Remove regexp caching.
[platform/upstream/v8.git] / src / arm / codegen-arm.h
1 // Copyright 2010 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 #ifndef V8_ARM_CODEGEN_ARM_H_
29 #define V8_ARM_CODEGEN_ARM_H_
30
31 #include "ast.h"
32 #include "code-stubs-arm.h"
33 #include "ic-inl.h"
34
35 namespace v8 {
36 namespace internal {
37
38 // Forward declarations
39 class CompilationInfo;
40 class DeferredCode;
41 class JumpTarget;
42 class RegisterAllocator;
43 class RegisterFile;
44
45 enum InitState { CONST_INIT, NOT_CONST_INIT };
46 enum TypeofState { INSIDE_TYPEOF, NOT_INSIDE_TYPEOF };
47 enum GenerateInlineSmi { DONT_GENERATE_INLINE_SMI, GENERATE_INLINE_SMI };
48 enum WriteBarrierCharacter { UNLIKELY_SMI, LIKELY_SMI, NEVER_NEWSPACE };
49
50
51 // -------------------------------------------------------------------------
52 // Reference support
53
54 // A reference is a C++ stack-allocated object that puts a
55 // reference on the virtual frame.  The reference may be consumed
56 // by GetValue, TakeValue, SetValue, and Codegen::UnloadReference.
57 // When the lifetime (scope) of a valid reference ends, it must have
58 // been consumed, and be in state UNLOADED.
59 class Reference BASE_EMBEDDED {
60  public:
61   // The values of the types is important, see size().
62   enum Type { UNLOADED = -2, ILLEGAL = -1, SLOT = 0, NAMED = 1, KEYED = 2 };
63   Reference(CodeGenerator* cgen,
64             Expression* expression,
65             bool persist_after_get = false);
66   ~Reference();
67
68   Expression* expression() const { return expression_; }
69   Type type() const { return type_; }
70   void set_type(Type value) {
71     ASSERT_EQ(ILLEGAL, type_);
72     type_ = value;
73   }
74
75   void set_unloaded() {
76     ASSERT_NE(ILLEGAL, type_);
77     ASSERT_NE(UNLOADED, type_);
78     type_ = UNLOADED;
79   }
80   // The size the reference takes up on the stack.
81   int size() const {
82     return (type_ < SLOT) ? 0 : type_;
83   }
84
85   bool is_illegal() const { return type_ == ILLEGAL; }
86   bool is_slot() const { return type_ == SLOT; }
87   bool is_property() const { return type_ == NAMED || type_ == KEYED; }
88   bool is_unloaded() const { return type_ == UNLOADED; }
89
90   // Return the name.  Only valid for named property references.
91   Handle<String> GetName();
92
93   // Generate code to push the value of the reference on top of the
94   // expression stack.  The reference is expected to be already on top of
95   // the expression stack, and it is consumed by the call unless the
96   // reference is for a compound assignment.
97   // If the reference is not consumed, it is left in place under its value.
98   void GetValue();
99
100   // Generate code to store the value on top of the expression stack in the
101   // reference.  The reference is expected to be immediately below the value
102   // on the expression stack.  The  value is stored in the location specified
103   // by the reference, and is left on top of the stack, after the reference
104   // is popped from beneath it (unloaded).
105   void SetValue(InitState init_state, WriteBarrierCharacter wb);
106
107   // This is in preparation for something that uses the reference on the stack.
108   // If we need this reference afterwards get then dup it now.  Otherwise mark
109   // it as used.
110   inline void DupIfPersist();
111
112  private:
113   CodeGenerator* cgen_;
114   Expression* expression_;
115   Type type_;
116   // Keep the reference on the stack after get, so it can be used by set later.
117   bool persist_after_get_;
118 };
119
120
121 // -------------------------------------------------------------------------
122 // Code generation state
123
124 // The state is passed down the AST by the code generator (and back up, in
125 // the form of the state of the label pair).  It is threaded through the
126 // call stack.  Constructing a state implicitly pushes it on the owning code
127 // generator's stack of states, and destroying one implicitly pops it.
128
129 class CodeGenState BASE_EMBEDDED {
130  public:
131   // Create an initial code generator state.  Destroying the initial state
132   // leaves the code generator with a NULL state.
133   explicit CodeGenState(CodeGenerator* owner);
134
135   // Destroy a code generator state and restore the owning code generator's
136   // previous state.
137   virtual ~CodeGenState();
138
139   virtual JumpTarget* true_target() const { return NULL; }
140   virtual JumpTarget* false_target() const { return NULL; }
141
142  protected:
143   inline CodeGenerator* owner() { return owner_; }
144   inline CodeGenState* previous() const { return previous_; }
145
146  private:
147   CodeGenerator* owner_;
148   CodeGenState* previous_;
149 };
150
151
152 class ConditionCodeGenState : public CodeGenState {
153  public:
154   // Create a code generator state based on a code generator's current
155   // state.  The new state has its own pair of branch labels.
156   ConditionCodeGenState(CodeGenerator* owner,
157                         JumpTarget* true_target,
158                         JumpTarget* false_target);
159
160   virtual JumpTarget* true_target() const { return true_target_; }
161   virtual JumpTarget* false_target() const { return false_target_; }
162
163  private:
164   JumpTarget* true_target_;
165   JumpTarget* false_target_;
166 };
167
168
169 class TypeInfoCodeGenState : public CodeGenState {
170  public:
171   TypeInfoCodeGenState(CodeGenerator* owner,
172                        Slot* slot_number,
173                        TypeInfo info);
174   ~TypeInfoCodeGenState();
175
176   virtual JumpTarget* true_target() const { return previous()->true_target(); }
177   virtual JumpTarget* false_target() const {
178     return previous()->false_target();
179   }
180
181  private:
182   Slot* slot_;
183   TypeInfo old_type_info_;
184 };
185
186
187 // -------------------------------------------------------------------------
188 // Arguments allocation mode
189
190 enum ArgumentsAllocationMode {
191   NO_ARGUMENTS_ALLOCATION,
192   EAGER_ARGUMENTS_ALLOCATION,
193   LAZY_ARGUMENTS_ALLOCATION
194 };
195
196
197 // Different nop operations are used by the code generator to detect certain
198 // states of the generated code.
199 enum NopMarkerTypes {
200   NON_MARKING_NOP = 0,
201   PROPERTY_ACCESS_INLINED
202 };
203
204
205 // -------------------------------------------------------------------------
206 // CodeGenerator
207
208 class CodeGenerator: public AstVisitor {
209  public:
210   static bool MakeCode(CompilationInfo* info);
211
212   // Printing of AST, etc. as requested by flags.
213   static void MakeCodePrologue(CompilationInfo* info);
214
215   // Allocate and install the code.
216   static Handle<Code> MakeCodeEpilogue(MacroAssembler* masm,
217                                        Code::Flags flags,
218                                        CompilationInfo* info);
219
220 #ifdef ENABLE_LOGGING_AND_PROFILING
221   static bool ShouldGenerateLog(Expression* type);
222 #endif
223
224   static void SetFunctionInfo(Handle<JSFunction> fun,
225                               FunctionLiteral* lit,
226                               bool is_toplevel,
227                               Handle<Script> script);
228
229   static bool RecordPositions(MacroAssembler* masm,
230                               int pos,
231                               bool right_here = false);
232
233   // Accessors
234   MacroAssembler* masm() { return masm_; }
235   VirtualFrame* frame() const { return frame_; }
236   inline Handle<Script> script();
237
238   bool has_valid_frame() const { return frame_ != NULL; }
239
240   // Set the virtual frame to be new_frame, with non-frame register
241   // reference counts given by non_frame_registers.  The non-frame
242   // register reference counts of the old frame are returned in
243   // non_frame_registers.
244   void SetFrame(VirtualFrame* new_frame, RegisterFile* non_frame_registers);
245
246   void DeleteFrame();
247
248   RegisterAllocator* allocator() const { return allocator_; }
249
250   CodeGenState* state() { return state_; }
251   void set_state(CodeGenState* state) { state_ = state; }
252
253   TypeInfo type_info(Slot* slot) {
254     int index = NumberOfSlot(slot);
255     if (index == kInvalidSlotNumber) return TypeInfo::Unknown();
256     return (*type_info_)[index];
257   }
258
259   TypeInfo set_type_info(Slot* slot, TypeInfo info) {
260     int index = NumberOfSlot(slot);
261     ASSERT(index >= kInvalidSlotNumber);
262     if (index != kInvalidSlotNumber) {
263       TypeInfo previous_value = (*type_info_)[index];
264       (*type_info_)[index] = info;
265       return previous_value;
266     }
267     return TypeInfo::Unknown();
268   }
269
270   void AddDeferred(DeferredCode* code) { deferred_.Add(code); }
271
272   // Constants related to patching of inlined load/store.
273   static int GetInlinedKeyedLoadInstructionsAfterPatch() {
274     return FLAG_debug_code ? 32 : 13;
275   }
276   static const int kInlinedKeyedStoreInstructionsAfterPatch = 5;
277   static int GetInlinedNamedStoreInstructionsAfterPatch() {
278     ASSERT(inlined_write_barrier_size_ != -1);
279     return inlined_write_barrier_size_ + 4;
280   }
281
282   static MemOperand ContextOperand(Register context, int index) {
283     return MemOperand(context, Context::SlotOffset(index));
284   }
285
286  private:
287   // Type of a member function that generates inline code for a native function.
288   typedef void (CodeGenerator::*InlineFunctionGenerator)
289       (ZoneList<Expression*>*);
290
291   static const InlineFunctionGenerator kInlineFunctionGenerators[];
292
293   // Construction/Destruction
294   explicit CodeGenerator(MacroAssembler* masm);
295
296   // Accessors
297   inline bool is_eval();
298   inline Scope* scope();
299
300   // Generating deferred code.
301   void ProcessDeferred();
302
303   static const int kInvalidSlotNumber = -1;
304
305   int NumberOfSlot(Slot* slot);
306
307   // State
308   bool has_cc() const { return cc_reg_ != al; }
309   JumpTarget* true_target() const { return state_->true_target(); }
310   JumpTarget* false_target() const { return state_->false_target(); }
311
312   // Track loop nesting level.
313   int loop_nesting() const { return loop_nesting_; }
314   void IncrementLoopNesting() { loop_nesting_++; }
315   void DecrementLoopNesting() { loop_nesting_--; }
316
317   // Node visitors.
318   void VisitStatements(ZoneList<Statement*>* statements);
319
320 #define DEF_VISIT(type) \
321   void Visit##type(type* node);
322   AST_NODE_LIST(DEF_VISIT)
323 #undef DEF_VISIT
324
325   // Main code generation function
326   void Generate(CompilationInfo* info);
327
328   // Generate the return sequence code.  Should be called no more than
329   // once per compiled function, immediately after binding the return
330   // target (which can not be done more than once).  The return value should
331   // be in r0.
332   void GenerateReturnSequence();
333
334   // Returns the arguments allocation mode.
335   ArgumentsAllocationMode ArgumentsMode();
336
337   // Store the arguments object and allocate it if necessary.
338   void StoreArgumentsObject(bool initial);
339
340   // The following are used by class Reference.
341   void LoadReference(Reference* ref);
342   void UnloadReference(Reference* ref);
343
344   MemOperand SlotOperand(Slot* slot, Register tmp);
345
346   MemOperand ContextSlotOperandCheckExtensions(Slot* slot,
347                                                Register tmp,
348                                                Register tmp2,
349                                                JumpTarget* slow);
350
351   // Expressions
352   static MemOperand GlobalObject()  {
353     return ContextOperand(cp, Context::GLOBAL_INDEX);
354   }
355
356   void LoadCondition(Expression* x,
357                      JumpTarget* true_target,
358                      JumpTarget* false_target,
359                      bool force_cc);
360   void Load(Expression* expr);
361   void LoadGlobal();
362   void LoadGlobalReceiver(Register scratch);
363
364   // Read a value from a slot and leave it on top of the expression stack.
365   void LoadFromSlot(Slot* slot, TypeofState typeof_state);
366   void LoadFromSlotCheckForArguments(Slot* slot, TypeofState state);
367
368   // Store the value on top of the stack to a slot.
369   void StoreToSlot(Slot* slot, InitState init_state);
370
371   // Support for compiling assignment expressions.
372   void EmitSlotAssignment(Assignment* node);
373   void EmitNamedPropertyAssignment(Assignment* node);
374   void EmitKeyedPropertyAssignment(Assignment* node);
375
376   // Load a named property, returning it in r0. The receiver is passed on the
377   // stack, and remains there.
378   void EmitNamedLoad(Handle<String> name, bool is_contextual);
379
380   // Store to a named property. If the store is contextual, value is passed on
381   // the frame and consumed. Otherwise, receiver and value are passed on the
382   // frame and consumed. The result is returned in r0.
383   void EmitNamedStore(Handle<String> name, bool is_contextual);
384
385   // Load a keyed property, leaving it in r0.  The receiver and key are
386   // passed on the stack, and remain there.
387   void EmitKeyedLoad();
388
389   // Store a keyed property. Key and receiver are on the stack and the value is
390   // in r0. Result is returned in r0.
391   void EmitKeyedStore(StaticType* key_type, WriteBarrierCharacter wb_info);
392
393   void LoadFromGlobalSlotCheckExtensions(Slot* slot,
394                                          TypeofState typeof_state,
395                                          JumpTarget* slow);
396
397   // Support for loading from local/global variables and arguments
398   // whose location is known unless they are shadowed by
399   // eval-introduced bindings. Generates no code for unsupported slot
400   // types and therefore expects to fall through to the slow jump target.
401   void EmitDynamicLoadFromSlotFastCase(Slot* slot,
402                                        TypeofState typeof_state,
403                                        JumpTarget* slow,
404                                        JumpTarget* done);
405
406   // Special code for typeof expressions: Unfortunately, we must
407   // be careful when loading the expression in 'typeof'
408   // expressions. We are not allowed to throw reference errors for
409   // non-existing properties of the global object, so we must make it
410   // look like an explicit property access, instead of an access
411   // through the context chain.
412   void LoadTypeofExpression(Expression* x);
413
414   void ToBoolean(JumpTarget* true_target, JumpTarget* false_target);
415
416   // Generate code that computes a shortcutting logical operation.
417   void GenerateLogicalBooleanOperation(BinaryOperation* node);
418
419   void GenericBinaryOperation(Token::Value op,
420                               OverwriteMode overwrite_mode,
421                               GenerateInlineSmi inline_smi,
422                               int known_rhs =
423                                   GenericBinaryOpStub::kUnknownIntValue);
424   void Comparison(Condition cc,
425                   Expression* left,
426                   Expression* right,
427                   bool strict = false);
428
429   void SmiOperation(Token::Value op,
430                     Handle<Object> value,
431                     bool reversed,
432                     OverwriteMode mode);
433
434   void CallWithArguments(ZoneList<Expression*>* arguments,
435                          CallFunctionFlags flags,
436                          int position);
437
438   // An optimized implementation of expressions of the form
439   // x.apply(y, arguments).  We call x the applicand and y the receiver.
440   // The optimization avoids allocating an arguments object if possible.
441   void CallApplyLazy(Expression* applicand,
442                      Expression* receiver,
443                      VariableProxy* arguments,
444                      int position);
445
446   // Control flow
447   void Branch(bool if_true, JumpTarget* target);
448   void CheckStack();
449
450   bool CheckForInlineRuntimeCall(CallRuntime* node);
451
452   static Handle<Code> ComputeLazyCompile(int argc);
453   void ProcessDeclarations(ZoneList<Declaration*>* declarations);
454
455   static Handle<Code> ComputeCallInitialize(int argc, InLoopFlag in_loop);
456
457   static Handle<Code> ComputeKeyedCallInitialize(int argc, InLoopFlag in_loop);
458
459   // Declare global variables and functions in the given array of
460   // name/value pairs.
461   void DeclareGlobals(Handle<FixedArray> pairs);
462
463   // Instantiate the function based on the shared function info.
464   void InstantiateFunction(Handle<SharedFunctionInfo> function_info);
465
466   // Support for type checks.
467   void GenerateIsSmi(ZoneList<Expression*>* args);
468   void GenerateIsNonNegativeSmi(ZoneList<Expression*>* args);
469   void GenerateIsArray(ZoneList<Expression*>* args);
470   void GenerateIsRegExp(ZoneList<Expression*>* args);
471   void GenerateIsObject(ZoneList<Expression*>* args);
472   void GenerateIsSpecObject(ZoneList<Expression*>* args);
473   void GenerateIsFunction(ZoneList<Expression*>* args);
474   void GenerateIsUndetectableObject(ZoneList<Expression*>* args);
475   void GenerateIsStringWrapperSafeForDefaultValueOf(
476       ZoneList<Expression*>* args);
477
478   // Support for construct call checks.
479   void GenerateIsConstructCall(ZoneList<Expression*>* args);
480
481   // Support for arguments.length and arguments[?].
482   void GenerateArgumentsLength(ZoneList<Expression*>* args);
483   void GenerateArguments(ZoneList<Expression*>* args);
484
485   // Support for accessing the class and value fields of an object.
486   void GenerateClassOf(ZoneList<Expression*>* args);
487   void GenerateValueOf(ZoneList<Expression*>* args);
488   void GenerateSetValueOf(ZoneList<Expression*>* args);
489
490   // Fast support for charCodeAt(n).
491   void GenerateStringCharCodeAt(ZoneList<Expression*>* args);
492
493   // Fast support for string.charAt(n) and string[n].
494   void GenerateStringCharFromCode(ZoneList<Expression*>* args);
495
496   // Fast support for string.charAt(n) and string[n].
497   void GenerateStringCharAt(ZoneList<Expression*>* args);
498
499   // Fast support for object equality testing.
500   void GenerateObjectEquals(ZoneList<Expression*>* args);
501
502   void GenerateLog(ZoneList<Expression*>* args);
503
504   // Fast support for Math.random().
505   void GenerateRandomHeapNumber(ZoneList<Expression*>* args);
506
507   // Fast support for StringAdd.
508   void GenerateStringAdd(ZoneList<Expression*>* args);
509
510   // Fast support for SubString.
511   void GenerateSubString(ZoneList<Expression*>* args);
512
513   // Fast support for StringCompare.
514   void GenerateStringCompare(ZoneList<Expression*>* args);
515
516   // Support for direct calls from JavaScript to native RegExp code.
517   void GenerateRegExpExec(ZoneList<Expression*>* args);
518
519   void GenerateRegExpConstructResult(ZoneList<Expression*>* args);
520
521   // Support for fast native caches.
522   void GenerateGetFromCache(ZoneList<Expression*>* args);
523
524   // Fast support for number to string.
525   void GenerateNumberToString(ZoneList<Expression*>* args);
526
527   // Fast swapping of elements.
528   void GenerateSwapElements(ZoneList<Expression*>* args);
529
530   // Fast call for custom callbacks.
531   void GenerateCallFunction(ZoneList<Expression*>* args);
532
533   // Fast call to math functions.
534   void GenerateMathPow(ZoneList<Expression*>* args);
535   void GenerateMathSin(ZoneList<Expression*>* args);
536   void GenerateMathCos(ZoneList<Expression*>* args);
537   void GenerateMathSqrt(ZoneList<Expression*>* args);
538
539   void GenerateIsRegExpEquivalent(ZoneList<Expression*>* args);
540
541   void GenerateHasCachedArrayIndex(ZoneList<Expression*>* args);
542   void GenerateGetCachedArrayIndex(ZoneList<Expression*>* args);
543
544   // Simple condition analysis.
545   enum ConditionAnalysis {
546     ALWAYS_TRUE,
547     ALWAYS_FALSE,
548     DONT_KNOW
549   };
550   ConditionAnalysis AnalyzeCondition(Expression* cond);
551
552   // Methods used to indicate which source code is generated for. Source
553   // positions are collected by the assembler and emitted with the relocation
554   // information.
555   void CodeForFunctionPosition(FunctionLiteral* fun);
556   void CodeForReturnPosition(FunctionLiteral* fun);
557   void CodeForStatementPosition(Statement* node);
558   void CodeForDoWhileConditionPosition(DoWhileStatement* stmt);
559   void CodeForSourcePosition(int pos);
560
561 #ifdef DEBUG
562   // True if the registers are valid for entry to a block.
563   bool HasValidEntryRegisters();
564 #endif
565
566   List<DeferredCode*> deferred_;
567
568   // Assembler
569   MacroAssembler* masm_;  // to generate code
570
571   CompilationInfo* info_;
572
573   // Code generation state
574   VirtualFrame* frame_;
575   RegisterAllocator* allocator_;
576   Condition cc_reg_;
577   CodeGenState* state_;
578   int loop_nesting_;
579
580   Vector<TypeInfo>* type_info_;
581
582   // Jump targets
583   BreakTarget function_return_;
584
585   // True if the function return is shadowed (ie, jumping to the target
586   // function_return_ does not jump to the true function return, but rather
587   // to some unlinking code).
588   bool function_return_is_shadowed_;
589
590   // Size of inlined write barriers generated by EmitNamedStore.
591   static int inlined_write_barrier_size_;
592
593   friend class VirtualFrame;
594   friend class JumpTarget;
595   friend class Reference;
596   friend class FastCodeGenerator;
597   friend class FullCodeGenerator;
598   friend class FullCodeGenSyntaxChecker;
599
600   DISALLOW_COPY_AND_ASSIGN(CodeGenerator);
601 };
602
603
604 } }  // namespace v8::internal
605
606 #endif  // V8_ARM_CODEGEN_ARM_H_