[Isolates] Statics 7: ExternalReference*/Simulator/dtoa...

src/arm/simulator-arm.h

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 56 matching lines @@
   entry(p0, p1, p2, p3, p4, p5, p6)
 
 #define TRY_CATCH_FROM_ADDRESS(try_catch_address) \
   reinterpret_cast<TryCatch*>(try_catch_address)
 
 
 #else  // defined(__arm__)
 
 // When running with the simulator transition into simulated execution at this
 // point.
-#define CALL_GENERATED_CODE(entry, p0, p1, p2, p3, p4) \
-  reinterpret_cast<Object*>( \
-      assembler::arm::Simulator::current()->Call(FUNCTION_ADDR(entry), 5, \
-                                                 p0, p1, p2, p3, p4))
+#define CALL_GENERATED_CODE(entry, p0, p1, p2, p3, p4)                         \
+  reinterpret_cast<Object*>(                                                   \
+      assembler::arm::Simulator::current(Isolate::Current())->                 \
+          Call(FUNCTION_ADDR(entry), 5, p0, p1, p2, p3, p4))
 
-#define CALL_GENERATED_REGEXP_CODE(entry, p0, p1, p2, p3, p4, p5, p6) \
-  assembler::arm::Simulator::current()->Call( \
+#define CALL_GENERATED_REGEXP_CODE(entry, p0, p1, p2, p3, p4, p5, p6)          \
+  assembler::arm::Simulator::current(Isolate::Current())->Call(                \
     FUNCTION_ADDR(entry), 7, p0, p1, p2, p3, p4, p5, p6)
 
-#define TRY_CATCH_FROM_ADDRESS(try_catch_address) \
-  try_catch_address == NULL ? \
+#define TRY_CATCH_FROM_ADDRESS(try_catch_address)                              \
+  try_catch_address == NULL ?                                                  \
       NULL : *(reinterpret_cast<TryCatch**>(try_catch_address))
 
 
 #include "constants-arm.h"
 #include "hashmap.h"
 
 
 namespace assembler {
 namespace arm {
 
@@ skipping 47 matching lines @@
     d0 = 0, d1, d2, d3, d4, d5, d6, d7,
     d8, d9, d10, d11, d12, d13, d14, d15,
     num_d_registers = 16
   };
 
   Simulator();
   ~Simulator();
 
   // The currently executing Simulator instance. Potentially there can be one
   // for each native thread.
-  static Simulator* current();
+  static Simulator* current(v8::internal::Isolate* isolate);
 
   // Accessors for register state. Reading the pc value adheres to the ARM
   // architecture specification and is off by a 8 from the currently executing
   // instruction.
   void set_register(int reg, int32_t value);
   int32_t get_register(int reg) const;
   void set_dw_register(int dreg, const int* dbl);
 
   // Support for VFP.
   void set_s_register(int reg, unsigned int value);
@@ skipping 23 matching lines @@
   // which sets up the simulator state and grabs the result on return.
   int32_t Call(byte* entry, int argument_count, ...);
 
   // Push an address onto the JS stack.
   uintptr_t PushAddress(uintptr_t address);
 
   // Pop an address from the JS stack.
   uintptr_t PopAddress();
 
   // ICache checking.
-  static void FlushICache(void* start, size_t size);
+  static void FlushICache(v8::internal::HashMap* i_cache, void* start,
+                          size_t size);
 
  private:
   enum special_values {
     // Known bad pc value to ensure that the simulator does not execute
     // without being properly setup.
     bad_lr = -1,
     // A pc value used to signal the simulator to stop execution.  Generally
     // the lr is set to this value on transition from native C code to
     // simulated execution, so that the simulator can "return" to the native
     // C code.
@@ skipping 62 matching lines @@
 
   void DecodeVMOVBetweenCoreAndSinglePrecisionRegisters(Instr* instr);
   void DecodeVCMP(Instr* instr);
   void DecodeVCVTBetweenDoubleAndSingle(Instr* instr);
   void DecodeVCVTBetweenFloatingPointAndInteger(Instr* instr);
 
   // Executes one instruction.
   void InstructionDecode(Instr* instr);
 
   // ICache.
-  static void CheckICache(Instr* instr);
-  static void FlushOnePage(intptr_t start, int size);
-  static CachePage* GetCachePage(void* page);
+  static void CheckICache(v8::internal::HashMap* i_cache, Instr* instr);
+  static void FlushOnePage(v8::internal::HashMap* i_cache, intptr_t start,
+                           int size);
+  static CachePage* GetCachePage(v8::internal::HashMap* i_cache, void* page);
 
   // Runtime call support.
   static void* RedirectExternalReference(void* external_function,
                                          bool fp_return);
 
   // For use in calls that take two double values, constructed from r0, r1, r2
   // and r3.
   void GetFpArgs(double* x, double* y);
   void SetFpResult(const double& result);
   void TrashCallerSaveRegisters();
@@ skipping 16 matching lines @@
   bool inv_op_vfp_flag_;
   bool div_zero_vfp_flag_;
   bool overflow_vfp_flag_;
   bool underflow_vfp_flag_;
   bool inexact_vfp_flag_;
 
   // Simulator support.
   char* stack_;
   bool pc_modified_;
   int icount_;
-  static bool initialized_;
 
   // Icache simulation
-  static v8::internal::HashMap* i_cache_;
+  v8::internal::HashMap* i_cache_;
 
   // Registered breakpoints.
   Instr* break_pc_;
   instr_t break_instr_;
+
+  v8::internal::Isolate* isolate_;
 };
 
 } }  // namespace assembler::arm
 
 
 // The simulator has its own stack. Thus it has a different stack limit from
 // the C-based native code.  Setting the c_limit to indicate a very small
 // stack cause stack overflow errors, since the simulator ignores the input.
 // This is unlikely to be an issue in practice, though it might cause testing
 // trouble down the line.
 class SimulatorStack : public v8::internal::AllStatic {
  public:
   static inline uintptr_t JsLimitFromCLimit(uintptr_t c_limit) {
-    return assembler::arm::Simulator::current()->StackLimit();
+    return assembler::arm::Simulator::current(
+        v8::internal::Isolate::Current())->StackLimit();
   }
 
   static inline uintptr_t RegisterCTryCatch(uintptr_t try_catch_address) {
-    assembler::arm::Simulator* sim = assembler::arm::Simulator::current();
+    assembler::arm::Simulator* sim =
+        assembler::arm::Simulator::current(v8::internal::Isolate::Current());
     return sim->PushAddress(try_catch_address);
   }
 
   static inline void UnregisterCTryCatch() {
-    assembler::arm::Simulator::current()->PopAddress();
+    assembler::arm::Simulator::current(v8::internal::Isolate::Current())->
+        PopAddress();
   }
 };
 
 
 #endif  // defined(__arm__)
 
 #endif  // V8_ARM_SIMULATOR_ARM_H_