ARM: Optimisations for call, jump and untag.
[platform/upstream/v8.git] / src / arm / simulator-arm.h
1 // Copyright 2011 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 //     * Redistributions of source code must retain the above copyright
7 //       notice, this list of conditions and the following disclaimer.
8 //     * Redistributions in binary form must reproduce the above
9 //       copyright notice, this list of conditions and the following
10 //       disclaimer in the documentation and/or other materials provided
11 //       with the distribution.
12 //     * Neither the name of Google Inc. nor the names of its
13 //       contributors may be used to endorse or promote products derived
14 //       from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28
29 // Declares a Simulator for ARM instructions if we are not generating a native
30 // ARM binary. This Simulator allows us to run and debug ARM code generation on
31 // regular desktop machines.
32 // V8 calls into generated code by "calling" the CALL_GENERATED_CODE macro,
33 // which will start execution in the Simulator or forwards to the real entry
34 // on a ARM HW platform.
35
36 #ifndef V8_ARM_SIMULATOR_ARM_H_
37 #define V8_ARM_SIMULATOR_ARM_H_
38
39 #include "allocation.h"
40
41 #if !defined(USE_SIMULATOR)
42 // Running without a simulator on a native arm platform.
43
44 namespace v8 {
45 namespace internal {
46
47 // When running without a simulator we call the entry directly.
48 #define CALL_GENERATED_CODE(entry, p0, p1, p2, p3, p4) \
49   (entry(p0, p1, p2, p3, p4))
50
51 typedef int (*arm_regexp_matcher)(String*, int, const byte*, const byte*,
52                                   void*, int*, Address, int, Isolate*);
53
54
55 // Call the generated regexp code directly. The code at the entry address
56 // should act as a function matching the type arm_regexp_matcher.
57 // The fifth argument is a dummy that reserves the space used for
58 // the return address added by the ExitFrame in native calls.
59 #define CALL_GENERATED_REGEXP_CODE(entry, p0, p1, p2, p3, p4, p5, p6, p7) \
60   (FUNCTION_CAST<arm_regexp_matcher>(entry)(                              \
61       p0, p1, p2, p3, NULL, p4, p5, p6, p7))
62
63 #define TRY_CATCH_FROM_ADDRESS(try_catch_address) \
64   reinterpret_cast<TryCatch*>(try_catch_address)
65
66 // The stack limit beyond which we will throw stack overflow errors in
67 // generated code. Because generated code on arm uses the C stack, we
68 // just use the C stack limit.
69 class SimulatorStack : public v8::internal::AllStatic {
70  public:
71   static inline uintptr_t JsLimitFromCLimit(uintptr_t c_limit) {
72     return c_limit;
73   }
74
75   static inline uintptr_t RegisterCTryCatch(uintptr_t try_catch_address) {
76     return try_catch_address;
77   }
78
79   static inline void UnregisterCTryCatch() { }
80 };
81
82 } }  // namespace v8::internal
83
84 #else  // !defined(USE_SIMULATOR)
85 // Running with a simulator.
86
87 #include "constants-arm.h"
88 #include "hashmap.h"
89 #include "assembler.h"
90
91 namespace v8 {
92 namespace internal {
93
94 class CachePage {
95  public:
96   static const int LINE_VALID = 0;
97   static const int LINE_INVALID = 1;
98
99   static const int kPageShift = 12;
100   static const int kPageSize = 1 << kPageShift;
101   static const int kPageMask = kPageSize - 1;
102   static const int kLineShift = 2;  // The cache line is only 4 bytes right now.
103   static const int kLineLength = 1 << kLineShift;
104   static const int kLineMask = kLineLength - 1;
105
106   CachePage() {
107     memset(&validity_map_, LINE_INVALID, sizeof(validity_map_));
108   }
109
110   char* ValidityByte(int offset) {
111     return &validity_map_[offset >> kLineShift];
112   }
113
114   char* CachedData(int offset) {
115     return &data_[offset];
116   }
117
118  private:
119   char data_[kPageSize];   // The cached data.
120   static const int kValidityMapSize = kPageSize >> kLineShift;
121   char validity_map_[kValidityMapSize];  // One byte per line.
122 };
123
124
125 class Simulator {
126  public:
127   friend class ArmDebugger;
128   enum Register {
129     no_reg = -1,
130     r0 = 0, r1, r2, r3, r4, r5, r6, r7,
131     r8, r9, r10, r11, r12, r13, r14, r15,
132     num_registers,
133     sp = 13,
134     lr = 14,
135     pc = 15,
136     s0 = 0, s1, s2, s3, s4, s5, s6, s7,
137     s8, s9, s10, s11, s12, s13, s14, s15,
138     s16, s17, s18, s19, s20, s21, s22, s23,
139     s24, s25, s26, s27, s28, s29, s30, s31,
140     num_s_registers = 32,
141     d0 = 0, d1, d2, d3, d4, d5, d6, d7,
142     d8, d9, d10, d11, d12, d13, d14, d15,
143     num_d_registers = 16
144   };
145
146   Simulator();
147   ~Simulator();
148
149   // The currently executing Simulator instance. Potentially there can be one
150   // for each native thread.
151   static Simulator* current(v8::internal::Isolate* isolate);
152
153   // Accessors for register state. Reading the pc value adheres to the ARM
154   // architecture specification and is off by a 8 from the currently executing
155   // instruction.
156   void set_register(int reg, int32_t value);
157   int32_t get_register(int reg) const;
158   double get_double_from_register_pair(int reg);
159   void set_dw_register(int dreg, const int* dbl);
160
161   // Support for VFP.
162   void set_s_register(int reg, unsigned int value);
163   unsigned int get_s_register(int reg) const;
164   void set_d_register_from_double(int dreg, const double& dbl);
165   double get_double_from_d_register(int dreg);
166   void set_s_register_from_float(int sreg, const float dbl);
167   float get_float_from_s_register(int sreg);
168   void set_s_register_from_sinteger(int reg, const int value);
169   int get_sinteger_from_s_register(int reg);
170
171   // Special case of set_register and get_register to access the raw PC value.
172   void set_pc(int32_t value);
173   int32_t get_pc() const;
174
175   // Accessor to the internal simulator stack area.
176   uintptr_t StackLimit() const;
177
178   // Executes ARM instructions until the PC reaches end_sim_pc.
179   void Execute();
180
181   // Call on program start.
182   static void Initialize();
183
184   // V8 generally calls into generated JS code with 5 parameters and into
185   // generated RegExp code with 7 parameters. This is a convenience function,
186   // which sets up the simulator state and grabs the result on return.
187   int32_t Call(byte* entry, int argument_count, ...);
188
189   // Push an address onto the JS stack.
190   uintptr_t PushAddress(uintptr_t address);
191
192   // Pop an address from the JS stack.
193   uintptr_t PopAddress();
194
195   // ICache checking.
196   static void FlushICache(v8::internal::HashMap* i_cache, void* start,
197                           size_t size);
198
199   // Returns true if pc register contains one of the 'special_values' defined
200   // below (bad_lr, end_sim_pc).
201   bool has_bad_pc() const;
202
203  private:
204   enum special_values {
205     // Known bad pc value to ensure that the simulator does not execute
206     // without being properly setup.
207     bad_lr = -1,
208     // A pc value used to signal the simulator to stop execution.  Generally
209     // the lr is set to this value on transition from native C code to
210     // simulated execution, so that the simulator can "return" to the native
211     // C code.
212     end_sim_pc = -2
213   };
214
215   // Unsupported instructions use Format to print an error and stop execution.
216   void Format(Instruction* instr, const char* format);
217
218   // Checks if the current instruction should be executed based on its
219   // condition bits.
220   bool ConditionallyExecute(Instruction* instr);
221
222   // Helper functions to set the conditional flags in the architecture state.
223   void SetNZFlags(int32_t val);
224   void SetCFlag(bool val);
225   void SetVFlag(bool val);
226   bool CarryFrom(int32_t left, int32_t right, int32_t carry = 0);
227   bool BorrowFrom(int32_t left, int32_t right);
228   bool OverflowFrom(int32_t alu_out,
229                     int32_t left,
230                     int32_t right,
231                     bool addition);
232
233   inline int GetCarry() {
234     return c_flag_ ? 1 : 0;
235   };
236
237   // Support for VFP.
238   void Compute_FPSCR_Flags(double val1, double val2);
239   void Copy_FPSCR_to_APSR();
240
241   // Helper functions to decode common "addressing" modes
242   int32_t GetShiftRm(Instruction* instr, bool* carry_out);
243   int32_t GetImm(Instruction* instr, bool* carry_out);
244   void ProcessPUW(Instruction* instr,
245                   int num_regs,
246                   int operand_size,
247                   intptr_t* start_address,
248                   intptr_t* end_address);
249   void HandleRList(Instruction* instr, bool load);
250   void HandleVList(Instruction* inst);
251   void SoftwareInterrupt(Instruction* instr);
252
253   // Stop helper functions.
254   inline bool isStopInstruction(Instruction* instr);
255   inline bool isWatchedStop(uint32_t bkpt_code);
256   inline bool isEnabledStop(uint32_t bkpt_code);
257   inline void EnableStop(uint32_t bkpt_code);
258   inline void DisableStop(uint32_t bkpt_code);
259   inline void IncreaseStopCounter(uint32_t bkpt_code);
260   void PrintStopInfo(uint32_t code);
261
262   // Read and write memory.
263   inline uint8_t ReadBU(int32_t addr);
264   inline int8_t ReadB(int32_t addr);
265   inline void WriteB(int32_t addr, uint8_t value);
266   inline void WriteB(int32_t addr, int8_t value);
267
268   inline uint16_t ReadHU(int32_t addr, Instruction* instr);
269   inline int16_t ReadH(int32_t addr, Instruction* instr);
270   // Note: Overloaded on the sign of the value.
271   inline void WriteH(int32_t addr, uint16_t value, Instruction* instr);
272   inline void WriteH(int32_t addr, int16_t value, Instruction* instr);
273
274   inline int ReadW(int32_t addr, Instruction* instr);
275   inline void WriteW(int32_t addr, int value, Instruction* instr);
276
277   int32_t* ReadDW(int32_t addr);
278   void WriteDW(int32_t addr, int32_t value1, int32_t value2);
279
280   // Executing is handled based on the instruction type.
281   // Both type 0 and type 1 rolled into one.
282   void DecodeType01(Instruction* instr);
283   void DecodeType2(Instruction* instr);
284   void DecodeType3(Instruction* instr);
285   void DecodeType4(Instruction* instr);
286   void DecodeType5(Instruction* instr);
287   void DecodeType6(Instruction* instr);
288   void DecodeType7(Instruction* instr);
289
290   // Support for VFP.
291   void DecodeTypeVFP(Instruction* instr);
292   void DecodeType6CoprocessorIns(Instruction* instr);
293
294   void DecodeVMOVBetweenCoreAndSinglePrecisionRegisters(Instruction* instr);
295   void DecodeVCMP(Instruction* instr);
296   void DecodeVCVTBetweenDoubleAndSingle(Instruction* instr);
297   void DecodeVCVTBetweenFloatingPointAndInteger(Instruction* instr);
298
299   // Executes one instruction.
300   void InstructionDecode(Instruction* instr);
301
302   // ICache.
303   static void CheckICache(v8::internal::HashMap* i_cache, Instruction* instr);
304   static void FlushOnePage(v8::internal::HashMap* i_cache, intptr_t start,
305                            int size);
306   static CachePage* GetCachePage(v8::internal::HashMap* i_cache, void* page);
307
308   // Runtime call support.
309   static void* RedirectExternalReference(
310       void* external_function,
311       v8::internal::ExternalReference::Type type);
312
313   // For use in calls that take two double values, constructed from r0, r1, r2
314   // and r3.
315   void GetFpArgs(double* x, double* y);
316   void SetFpResult(const double& result);
317   void TrashCallerSaveRegisters();
318
319   // Architecture state.
320   // Saturating instructions require a Q flag to indicate saturation.
321   // There is currently no way to read the CPSR directly, and thus read the Q
322   // flag, so this is left unimplemented.
323   int32_t registers_[16];
324   bool n_flag_;
325   bool z_flag_;
326   bool c_flag_;
327   bool v_flag_;
328
329   // VFP architecture state.
330   unsigned int vfp_register[num_s_registers];
331   bool n_flag_FPSCR_;
332   bool z_flag_FPSCR_;
333   bool c_flag_FPSCR_;
334   bool v_flag_FPSCR_;
335
336   // VFP rounding mode. See ARM DDI 0406B Page A2-29.
337   VFPRoundingMode FPSCR_rounding_mode_;
338
339   // VFP FP exception flags architecture state.
340   bool inv_op_vfp_flag_;
341   bool div_zero_vfp_flag_;
342   bool overflow_vfp_flag_;
343   bool underflow_vfp_flag_;
344   bool inexact_vfp_flag_;
345
346   // Simulator support.
347   char* stack_;
348   bool pc_modified_;
349   int icount_;
350
351   // Icache simulation
352   v8::internal::HashMap* i_cache_;
353
354   // Registered breakpoints.
355   Instruction* break_pc_;
356   Instr break_instr_;
357
358   v8::internal::Isolate* isolate_;
359
360   // A stop is watched if its code is less than kNumOfWatchedStops.
361   // Only watched stops support enabling/disabling and the counter feature.
362   static const uint32_t kNumOfWatchedStops = 256;
363
364   // Breakpoint is disabled if bit 31 is set.
365   static const uint32_t kStopDisabledBit = 1 << 31;
366
367   // A stop is enabled, meaning the simulator will stop when meeting the
368   // instruction, if bit 31 of watched_stops[code].count is unset.
369   // The value watched_stops[code].count & ~(1 << 31) indicates how many times
370   // the breakpoint was hit or gone through.
371   struct StopCountAndDesc {
372     uint32_t count;
373     char* desc;
374   };
375   StopCountAndDesc watched_stops[kNumOfWatchedStops];
376 };
377
378
379 // When running with the simulator transition into simulated execution at this
380 // point.
381 #define CALL_GENERATED_CODE(entry, p0, p1, p2, p3, p4) \
382   reinterpret_cast<Object*>(Simulator::current(Isolate::Current())->Call( \
383       FUNCTION_ADDR(entry), 5, p0, p1, p2, p3, p4))
384
385 #define CALL_GENERATED_REGEXP_CODE(entry, p0, p1, p2, p3, p4, p5, p6, p7) \
386   Simulator::current(Isolate::Current())->Call( \
387       entry, 9, p0, p1, p2, p3, NULL, p4, p5, p6, p7)
388
389 #define TRY_CATCH_FROM_ADDRESS(try_catch_address)                              \
390   try_catch_address == NULL ?                                                  \
391       NULL : *(reinterpret_cast<TryCatch**>(try_catch_address))
392
393
394 // The simulator has its own stack. Thus it has a different stack limit from
395 // the C-based native code.  Setting the c_limit to indicate a very small
396 // stack cause stack overflow errors, since the simulator ignores the input.
397 // This is unlikely to be an issue in practice, though it might cause testing
398 // trouble down the line.
399 class SimulatorStack : public v8::internal::AllStatic {
400  public:
401   static inline uintptr_t JsLimitFromCLimit(uintptr_t c_limit) {
402     return Simulator::current(Isolate::Current())->StackLimit();
403   }
404
405   static inline uintptr_t RegisterCTryCatch(uintptr_t try_catch_address) {
406     Simulator* sim = Simulator::current(Isolate::Current());
407     return sim->PushAddress(try_catch_address);
408   }
409
410   static inline void UnregisterCTryCatch() {
411     Simulator::current(Isolate::Current())->PopAddress();
412   }
413 };
414
415 } }  // namespace v8::internal
416
417 #endif  // !defined(USE_SIMULATOR)
418 #endif  // V8_ARM_SIMULATOR_ARM_H_