blob: 589e704b5128ebf17664b2fbd69bd24f2d2097e1 [file] [log] [blame]
Leon Clarked91b9f72010-01-27 17:25:45 +00001// Copyright 2010 the V8 project authors. All rights reserved.
Steve Blocka7e24c12009-10-30 11:49:00 +00002// 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
Kristian Monsen25f61362010-05-21 11:50:48 +010031#include "ast.h"
Kristian Monsen80d68ea2010-09-08 11:05:35 +010032#include "code-stubs-arm.h"
33#include "ic-inl.h"
Steve Block6ded16b2010-05-10 14:33:55 +010034
Steve Blocka7e24c12009-10-30 11:49:00 +000035namespace v8 {
36namespace internal {
37
38// Forward declarations
Leon Clarke4515c472010-02-03 11:58:03 +000039class CompilationInfo;
Steve Blocka7e24c12009-10-30 11:49:00 +000040class DeferredCode;
Kristian Monsen25f61362010-05-21 11:50:48 +010041class JumpTarget;
Steve Blocka7e24c12009-10-30 11:49:00 +000042class RegisterAllocator;
43class RegisterFile;
44
45enum InitState { CONST_INIT, NOT_CONST_INIT };
46enum TypeofState { INSIDE_TYPEOF, NOT_INSIDE_TYPEOF };
Ben Murdoch7f4d5bd2010-06-15 11:15:29 +010047enum GenerateInlineSmi { DONT_GENERATE_INLINE_SMI, GENERATE_INLINE_SMI };
Steve Block8defd9f2010-07-08 12:39:36 +010048enum WriteBarrierCharacter { UNLIKELY_SMI, LIKELY_SMI, NEVER_NEWSPACE };
Steve Blocka7e24c12009-10-30 11:49:00 +000049
50
51// -------------------------------------------------------------------------
52// Reference support
53
Leon Clarked91b9f72010-01-27 17:25:45 +000054// 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.
Steve Blocka7e24c12009-10-30 11:49:00 +000059class Reference BASE_EMBEDDED {
60 public:
61 // The values of the types is important, see size().
Leon Clarked91b9f72010-01-27 17:25:45 +000062 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);
Steve Blocka7e24c12009-10-30 11:49:00 +000066 ~Reference();
67
68 Expression* expression() const { return expression_; }
69 Type type() const { return type_; }
70 void set_type(Type value) {
Leon Clarked91b9f72010-01-27 17:25:45 +000071 ASSERT_EQ(ILLEGAL, type_);
Steve Blocka7e24c12009-10-30 11:49:00 +000072 type_ = value;
73 }
74
Leon Clarked91b9f72010-01-27 17:25:45 +000075 void set_unloaded() {
76 ASSERT_NE(ILLEGAL, type_);
77 ASSERT_NE(UNLOADED, type_);
78 type_ = UNLOADED;
79 }
Steve Blocka7e24c12009-10-30 11:49:00 +000080 // The size the reference takes up on the stack.
Leon Clarked91b9f72010-01-27 17:25:45 +000081 int size() const {
82 return (type_ < SLOT) ? 0 : type_;
83 }
Steve Blocka7e24c12009-10-30 11:49:00 +000084
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; }
Leon Clarked91b9f72010-01-27 17:25:45 +000088 bool is_unloaded() const { return type_ == UNLOADED; }
Steve Blocka7e24c12009-10-30 11:49:00 +000089
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
Leon Clarked91b9f72010-01-27 17:25:45 +000095 // 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.
Steve Blockd0582a62009-12-15 09:54:21 +000098 void GetValue();
Steve Blocka7e24c12009-10-30 11:49:00 +000099
Steve Blocka7e24c12009-10-30 11:49:00 +0000100 // 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
Leon Clarked91b9f72010-01-27 17:25:45 +0000102 // 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).
Steve Block8defd9f2010-07-08 12:39:36 +0100105 void SetValue(InitState init_state, WriteBarrierCharacter wb);
Steve Blocka7e24c12009-10-30 11:49:00 +0000106
Ben Murdoch7f4d5bd2010-06-15 11:15:29 +0100107 // 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
Steve Blocka7e24c12009-10-30 11:49:00 +0000112 private:
113 CodeGenerator* cgen_;
114 Expression* expression_;
115 Type type_;
Leon Clarked91b9f72010-01-27 17:25:45 +0000116 // Keep the reference on the stack after get, so it can be used by set later.
117 bool persist_after_get_;
Steve Blocka7e24c12009-10-30 11:49:00 +0000118};
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
129class 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
Steve Blocka7e24c12009-10-30 11:49:00 +0000135 // Destroy a code generator state and restore the owning code generator's
136 // previous state.
Ben Murdoch7f4d5bd2010-06-15 11:15:29 +0100137 virtual ~CodeGenState();
Steve Blocka7e24c12009-10-30 11:49:00 +0000138
Ben Murdoch7f4d5bd2010-06-15 11:15:29 +0100139 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_; }
Steve Blocka7e24c12009-10-30 11:49:00 +0000145
146 private:
147 CodeGenerator* owner_;
Ben Murdoch7f4d5bd2010-06-15 11:15:29 +0100148 CodeGenState* previous_;
149};
150
151
152class 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:
Steve Blocka7e24c12009-10-30 11:49:00 +0000164 JumpTarget* true_target_;
165 JumpTarget* false_target_;
Ben Murdoch7f4d5bd2010-06-15 11:15:29 +0100166};
167
168
169class 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_;
Steve Blocka7e24c12009-10-30 11:49:00 +0000184};
185
186
187// -------------------------------------------------------------------------
Steve Block6ded16b2010-05-10 14:33:55 +0100188// Arguments allocation mode
189
190enum ArgumentsAllocationMode {
191 NO_ARGUMENTS_ALLOCATION,
192 EAGER_ARGUMENTS_ALLOCATION,
193 LAZY_ARGUMENTS_ALLOCATION
194};
195
196
Steve Block6ded16b2010-05-10 14:33:55 +0100197// -------------------------------------------------------------------------
Steve Blocka7e24c12009-10-30 11:49:00 +0000198// CodeGenerator
199
200class CodeGenerator: public AstVisitor {
201 public:
Ben Murdochf87a2032010-10-22 12:50:53 +0100202 static bool MakeCode(CompilationInfo* info);
Steve Blocka7e24c12009-10-30 11:49:00 +0000203
Steve Block3ce2e202009-11-05 08:53:23 +0000204 // Printing of AST, etc. as requested by flags.
Andrei Popescu31002712010-02-23 13:46:05 +0000205 static void MakeCodePrologue(CompilationInfo* info);
Steve Block3ce2e202009-11-05 08:53:23 +0000206
207 // Allocate and install the code.
Andrei Popescu31002712010-02-23 13:46:05 +0000208 static Handle<Code> MakeCodeEpilogue(MacroAssembler* masm,
Steve Block3ce2e202009-11-05 08:53:23 +0000209 Code::Flags flags,
Andrei Popescu31002712010-02-23 13:46:05 +0000210 CompilationInfo* info);
Steve Block3ce2e202009-11-05 08:53:23 +0000211
Ben Murdochb0fe1622011-05-05 13:52:32 +0100212 // Print the code after compiling it.
213 static void PrintCode(Handle<Code> code, CompilationInfo* info);
214
Steve Blocka7e24c12009-10-30 11:49:00 +0000215#ifdef ENABLE_LOGGING_AND_PROFILING
216 static bool ShouldGenerateLog(Expression* type);
217#endif
218
219 static void SetFunctionInfo(Handle<JSFunction> fun,
220 FunctionLiteral* lit,
221 bool is_toplevel,
222 Handle<Script> script);
223
Ben Murdoch7f4d5bd2010-06-15 11:15:29 +0100224 static bool RecordPositions(MacroAssembler* masm,
225 int pos,
226 bool right_here = false);
Steve Block3ce2e202009-11-05 08:53:23 +0000227
Steve Blocka7e24c12009-10-30 11:49:00 +0000228 // Accessors
229 MacroAssembler* masm() { return masm_; }
Steve Blocka7e24c12009-10-30 11:49:00 +0000230 VirtualFrame* frame() const { return frame_; }
Andrei Popescu31002712010-02-23 13:46:05 +0000231 inline Handle<Script> script();
Steve Blocka7e24c12009-10-30 11:49:00 +0000232
233 bool has_valid_frame() const { return frame_ != NULL; }
234
235 // Set the virtual frame to be new_frame, with non-frame register
236 // reference counts given by non_frame_registers. The non-frame
237 // register reference counts of the old frame are returned in
238 // non_frame_registers.
239 void SetFrame(VirtualFrame* new_frame, RegisterFile* non_frame_registers);
240
241 void DeleteFrame();
242
243 RegisterAllocator* allocator() const { return allocator_; }
244
245 CodeGenState* state() { return state_; }
246 void set_state(CodeGenState* state) { state_ = state; }
247
Ben Murdoch7f4d5bd2010-06-15 11:15:29 +0100248 TypeInfo type_info(Slot* slot) {
249 int index = NumberOfSlot(slot);
250 if (index == kInvalidSlotNumber) return TypeInfo::Unknown();
251 return (*type_info_)[index];
252 }
253
254 TypeInfo set_type_info(Slot* slot, TypeInfo info) {
255 int index = NumberOfSlot(slot);
256 ASSERT(index >= kInvalidSlotNumber);
257 if (index != kInvalidSlotNumber) {
258 TypeInfo previous_value = (*type_info_)[index];
259 (*type_info_)[index] = info;
260 return previous_value;
261 }
262 return TypeInfo::Unknown();
263 }
264
Steve Blocka7e24c12009-10-30 11:49:00 +0000265 void AddDeferred(DeferredCode* code) { deferred_.Add(code); }
266
Kristian Monsen25f61362010-05-21 11:50:48 +0100267 // Constants related to patching of inlined load/store.
Steve Block8defd9f2010-07-08 12:39:36 +0100268 static int GetInlinedKeyedLoadInstructionsAfterPatch() {
Iain Merrick75681382010-08-19 15:07:18 +0100269 return FLAG_debug_code ? 32 : 13;
Steve Block8defd9f2010-07-08 12:39:36 +0100270 }
Leon Clarkef7060e22010-06-03 12:02:55 +0100271 static const int kInlinedKeyedStoreInstructionsAfterPatch = 5;
Kristian Monsen50ef84f2010-07-29 15:18:00 +0100272 static int GetInlinedNamedStoreInstructionsAfterPatch() {
273 ASSERT(inlined_write_barrier_size_ != -1);
274 return inlined_write_barrier_size_ + 4;
275 }
Kristian Monsen25f61362010-05-21 11:50:48 +0100276
Steve Blocka7e24c12009-10-30 11:49:00 +0000277 private:
Kristian Monsen0d5e1162010-09-30 15:31:59 +0100278 // Type of a member function that generates inline code for a native function.
279 typedef void (CodeGenerator::*InlineFunctionGenerator)
280 (ZoneList<Expression*>*);
281
282 static const InlineFunctionGenerator kInlineFunctionGenerators[];
283
Steve Blocka7e24c12009-10-30 11:49:00 +0000284 // Construction/Destruction
Andrei Popescu31002712010-02-23 13:46:05 +0000285 explicit CodeGenerator(MacroAssembler* masm);
Steve Blocka7e24c12009-10-30 11:49:00 +0000286
287 // Accessors
Andrei Popescu31002712010-02-23 13:46:05 +0000288 inline bool is_eval();
Steve Block6ded16b2010-05-10 14:33:55 +0100289 inline Scope* scope();
Steve Blocka7e24c12009-10-30 11:49:00 +0000290
291 // Generating deferred code.
292 void ProcessDeferred();
293
Ben Murdoch7f4d5bd2010-06-15 11:15:29 +0100294 static const int kInvalidSlotNumber = -1;
295
296 int NumberOfSlot(Slot* slot);
297
Steve Blocka7e24c12009-10-30 11:49:00 +0000298 // State
Kristian Monsen0d5e1162010-09-30 15:31:59 +0100299 bool has_cc() const { return cc_reg_ != al; }
300 JumpTarget* true_target() const { return state_->true_target(); }
301 JumpTarget* false_target() const { return state_->false_target(); }
Steve Blocka7e24c12009-10-30 11:49:00 +0000302
Steve Block6ded16b2010-05-10 14:33:55 +0100303 // Track loop nesting level.
304 int loop_nesting() const { return loop_nesting_; }
305 void IncrementLoopNesting() { loop_nesting_++; }
306 void DecrementLoopNesting() { loop_nesting_--; }
Steve Blocka7e24c12009-10-30 11:49:00 +0000307
308 // Node visitors.
309 void VisitStatements(ZoneList<Statement*>* statements);
310
Ben Murdochb0fe1622011-05-05 13:52:32 +0100311 virtual void VisitSlot(Slot* node);
Steve Blocka7e24c12009-10-30 11:49:00 +0000312#define DEF_VISIT(type) \
Ben Murdochb0fe1622011-05-05 13:52:32 +0100313 virtual void Visit##type(type* node);
Steve Blocka7e24c12009-10-30 11:49:00 +0000314 AST_NODE_LIST(DEF_VISIT)
315#undef DEF_VISIT
316
Steve Blocka7e24c12009-10-30 11:49:00 +0000317 // Main code generation function
Andrei Popescu402d9372010-02-26 13:31:12 +0000318 void Generate(CompilationInfo* info);
Steve Blocka7e24c12009-10-30 11:49:00 +0000319
Kristian Monsen9dcf7e22010-06-28 14:14:28 +0100320 // Generate the return sequence code. Should be called no more than
321 // once per compiled function, immediately after binding the return
322 // target (which can not be done more than once). The return value should
323 // be in r0.
324 void GenerateReturnSequence();
325
Steve Block6ded16b2010-05-10 14:33:55 +0100326 // Returns the arguments allocation mode.
327 ArgumentsAllocationMode ArgumentsMode();
328
329 // Store the arguments object and allocate it if necessary.
330 void StoreArgumentsObject(bool initial);
331
Steve Blocka7e24c12009-10-30 11:49:00 +0000332 // The following are used by class Reference.
333 void LoadReference(Reference* ref);
334 void UnloadReference(Reference* ref);
335
Steve Blocka7e24c12009-10-30 11:49:00 +0000336 MemOperand SlotOperand(Slot* slot, Register tmp);
337
338 MemOperand ContextSlotOperandCheckExtensions(Slot* slot,
339 Register tmp,
340 Register tmp2,
341 JumpTarget* slow);
342
343 // Expressions
Steve Blocka7e24c12009-10-30 11:49:00 +0000344 void LoadCondition(Expression* x,
Steve Blocka7e24c12009-10-30 11:49:00 +0000345 JumpTarget* true_target,
346 JumpTarget* false_target,
347 bool force_cc);
Steve Blockd0582a62009-12-15 09:54:21 +0000348 void Load(Expression* expr);
Steve Blocka7e24c12009-10-30 11:49:00 +0000349 void LoadGlobal();
350 void LoadGlobalReceiver(Register scratch);
351
Steve Blocka7e24c12009-10-30 11:49:00 +0000352 // Read a value from a slot and leave it on top of the expression stack.
353 void LoadFromSlot(Slot* slot, TypeofState typeof_state);
Steve Block6ded16b2010-05-10 14:33:55 +0100354 void LoadFromSlotCheckForArguments(Slot* slot, TypeofState state);
Kristian Monsen25f61362010-05-21 11:50:48 +0100355
Leon Clarkee46be812010-01-19 14:06:41 +0000356 // Store the value on top of the stack to a slot.
357 void StoreToSlot(Slot* slot, InitState init_state);
Steve Block6ded16b2010-05-10 14:33:55 +0100358
359 // Support for compiling assignment expressions.
360 void EmitSlotAssignment(Assignment* node);
361 void EmitNamedPropertyAssignment(Assignment* node);
362 void EmitKeyedPropertyAssignment(Assignment* node);
363
364 // Load a named property, returning it in r0. The receiver is passed on the
365 // stack, and remains there.
366 void EmitNamedLoad(Handle<String> name, bool is_contextual);
367
368 // Store to a named property. If the store is contextual, value is passed on
369 // the frame and consumed. Otherwise, receiver and value are passed on the
370 // frame and consumed. The result is returned in r0.
371 void EmitNamedStore(Handle<String> name, bool is_contextual);
372
Leon Clarked91b9f72010-01-27 17:25:45 +0000373 // Load a keyed property, leaving it in r0. The receiver and key are
374 // passed on the stack, and remain there.
Steve Block6ded16b2010-05-10 14:33:55 +0100375 void EmitKeyedLoad();
376
377 // Store a keyed property. Key and receiver are on the stack and the value is
378 // in r0. Result is returned in r0.
Steve Block8defd9f2010-07-08 12:39:36 +0100379 void EmitKeyedStore(StaticType* key_type, WriteBarrierCharacter wb_info);
Leon Clarkee46be812010-01-19 14:06:41 +0000380
Steve Blocka7e24c12009-10-30 11:49:00 +0000381 void LoadFromGlobalSlotCheckExtensions(Slot* slot,
382 TypeofState typeof_state,
Steve Blocka7e24c12009-10-30 11:49:00 +0000383 JumpTarget* slow);
384
Kristian Monsen25f61362010-05-21 11:50:48 +0100385 // Support for loading from local/global variables and arguments
386 // whose location is known unless they are shadowed by
387 // eval-introduced bindings. Generates no code for unsupported slot
388 // types and therefore expects to fall through to the slow jump target.
389 void EmitDynamicLoadFromSlotFastCase(Slot* slot,
390 TypeofState typeof_state,
391 JumpTarget* slow,
392 JumpTarget* done);
393
Steve Blocka7e24c12009-10-30 11:49:00 +0000394 // Special code for typeof expressions: Unfortunately, we must
395 // be careful when loading the expression in 'typeof'
396 // expressions. We are not allowed to throw reference errors for
397 // non-existing properties of the global object, so we must make it
398 // look like an explicit property access, instead of an access
399 // through the context chain.
400 void LoadTypeofExpression(Expression* x);
401
402 void ToBoolean(JumpTarget* true_target, JumpTarget* false_target);
403
Steve Block6ded16b2010-05-10 14:33:55 +0100404 // Generate code that computes a shortcutting logical operation.
405 void GenerateLogicalBooleanOperation(BinaryOperation* node);
406
Steve Blocka7e24c12009-10-30 11:49:00 +0000407 void GenericBinaryOperation(Token::Value op,
408 OverwriteMode overwrite_mode,
Ben Murdoch7f4d5bd2010-06-15 11:15:29 +0100409 GenerateInlineSmi inline_smi,
Kristian Monsen80d68ea2010-09-08 11:05:35 +0100410 int known_rhs =
411 GenericBinaryOpStub::kUnknownIntValue);
Steve Blocka7e24c12009-10-30 11:49:00 +0000412 void Comparison(Condition cc,
413 Expression* left,
414 Expression* right,
415 bool strict = false);
416
417 void SmiOperation(Token::Value op,
418 Handle<Object> value,
419 bool reversed,
420 OverwriteMode mode);
421
Leon Clarkee46be812010-01-19 14:06:41 +0000422 void CallWithArguments(ZoneList<Expression*>* arguments,
423 CallFunctionFlags flags,
424 int position);
Steve Blocka7e24c12009-10-30 11:49:00 +0000425
Steve Block6ded16b2010-05-10 14:33:55 +0100426 // An optimized implementation of expressions of the form
427 // x.apply(y, arguments). We call x the applicand and y the receiver.
428 // The optimization avoids allocating an arguments object if possible.
429 void CallApplyLazy(Expression* applicand,
430 Expression* receiver,
431 VariableProxy* arguments,
432 int position);
433
Steve Blocka7e24c12009-10-30 11:49:00 +0000434 // Control flow
435 void Branch(bool if_true, JumpTarget* target);
436 void CheckStack();
437
Steve Blocka7e24c12009-10-30 11:49:00 +0000438 bool CheckForInlineRuntimeCall(CallRuntime* node);
Steve Blocka7e24c12009-10-30 11:49:00 +0000439
Steve Block3ce2e202009-11-05 08:53:23 +0000440 static Handle<Code> ComputeLazyCompile(int argc);
Steve Blocka7e24c12009-10-30 11:49:00 +0000441 void ProcessDeclarations(ZoneList<Declaration*>* declarations);
442
Steve Blocka7e24c12009-10-30 11:49:00 +0000443 // Declare global variables and functions in the given array of
444 // name/value pairs.
445 void DeclareGlobals(Handle<FixedArray> pairs);
446
Steve Block6ded16b2010-05-10 14:33:55 +0100447 // Instantiate the function based on the shared function info.
Shimeng (Simon) Wang8a31eba2010-12-06 19:01:33 -0800448 void InstantiateFunction(Handle<SharedFunctionInfo> function_info,
449 bool pretenure);
Steve Blocka7e24c12009-10-30 11:49:00 +0000450
451 // Support for type checks.
452 void GenerateIsSmi(ZoneList<Expression*>* args);
453 void GenerateIsNonNegativeSmi(ZoneList<Expression*>* args);
454 void GenerateIsArray(ZoneList<Expression*>* args);
Andrei Popescu402d9372010-02-26 13:31:12 +0000455 void GenerateIsRegExp(ZoneList<Expression*>* args);
Steve Blockd0582a62009-12-15 09:54:21 +0000456 void GenerateIsObject(ZoneList<Expression*>* args);
Ben Murdoch3bec4d22010-07-22 14:51:16 +0100457 void GenerateIsSpecObject(ZoneList<Expression*>* args);
Steve Blockd0582a62009-12-15 09:54:21 +0000458 void GenerateIsFunction(ZoneList<Expression*>* args);
Leon Clarked91b9f72010-01-27 17:25:45 +0000459 void GenerateIsUndetectableObject(ZoneList<Expression*>* args);
Iain Merrick75681382010-08-19 15:07:18 +0100460 void GenerateIsStringWrapperSafeForDefaultValueOf(
461 ZoneList<Expression*>* args);
Steve Blocka7e24c12009-10-30 11:49:00 +0000462
463 // Support for construct call checks.
464 void GenerateIsConstructCall(ZoneList<Expression*>* args);
465
466 // Support for arguments.length and arguments[?].
467 void GenerateArgumentsLength(ZoneList<Expression*>* args);
Steve Block6ded16b2010-05-10 14:33:55 +0100468 void GenerateArguments(ZoneList<Expression*>* args);
Steve Blocka7e24c12009-10-30 11:49:00 +0000469
470 // Support for accessing the class and value fields of an object.
471 void GenerateClassOf(ZoneList<Expression*>* args);
472 void GenerateValueOf(ZoneList<Expression*>* args);
473 void GenerateSetValueOf(ZoneList<Expression*>* args);
474
475 // Fast support for charCodeAt(n).
Ben Murdoch7f4d5bd2010-06-15 11:15:29 +0100476 void GenerateStringCharCodeAt(ZoneList<Expression*>* args);
Steve Blocka7e24c12009-10-30 11:49:00 +0000477
Steve Block6ded16b2010-05-10 14:33:55 +0100478 // Fast support for string.charAt(n) and string[n].
Ben Murdoch7f4d5bd2010-06-15 11:15:29 +0100479 void GenerateStringCharFromCode(ZoneList<Expression*>* args);
480
481 // Fast support for string.charAt(n) and string[n].
482 void GenerateStringCharAt(ZoneList<Expression*>* args);
Steve Block6ded16b2010-05-10 14:33:55 +0100483
Steve Blocka7e24c12009-10-30 11:49:00 +0000484 // Fast support for object equality testing.
485 void GenerateObjectEquals(ZoneList<Expression*>* args);
486
487 void GenerateLog(ZoneList<Expression*>* args);
488
489 // Fast support for Math.random().
Steve Block6ded16b2010-05-10 14:33:55 +0100490 void GenerateRandomHeapNumber(ZoneList<Expression*>* args);
Steve Blocka7e24c12009-10-30 11:49:00 +0000491
Steve Blockd0582a62009-12-15 09:54:21 +0000492 // Fast support for StringAdd.
493 void GenerateStringAdd(ZoneList<Expression*>* args);
494
Leon Clarkee46be812010-01-19 14:06:41 +0000495 // Fast support for SubString.
496 void GenerateSubString(ZoneList<Expression*>* args);
497
498 // Fast support for StringCompare.
499 void GenerateStringCompare(ZoneList<Expression*>* args);
500
501 // Support for direct calls from JavaScript to native RegExp code.
502 void GenerateRegExpExec(ZoneList<Expression*>* args);
503
Steve Block6ded16b2010-05-10 14:33:55 +0100504 void GenerateRegExpConstructResult(ZoneList<Expression*>* args);
505
506 // Support for fast native caches.
507 void GenerateGetFromCache(ZoneList<Expression*>* args);
508
Andrei Popescu402d9372010-02-26 13:31:12 +0000509 // Fast support for number to string.
510 void GenerateNumberToString(ZoneList<Expression*>* args);
511
Steve Block6ded16b2010-05-10 14:33:55 +0100512 // Fast swapping of elements.
513 void GenerateSwapElements(ZoneList<Expression*>* args);
514
515 // Fast call for custom callbacks.
516 void GenerateCallFunction(ZoneList<Expression*>* args);
517
518 // Fast call to math functions.
519 void GenerateMathPow(ZoneList<Expression*>* args);
Andrei Popescu402d9372010-02-26 13:31:12 +0000520 void GenerateMathSin(ZoneList<Expression*>* args);
521 void GenerateMathCos(ZoneList<Expression*>* args);
Steve Block6ded16b2010-05-10 14:33:55 +0100522 void GenerateMathSqrt(ZoneList<Expression*>* args);
Ben Murdochb0fe1622011-05-05 13:52:32 +0100523 void GenerateMathLog(ZoneList<Expression*>* args);
Andrei Popescu402d9372010-02-26 13:31:12 +0000524
Ben Murdochbb769b22010-08-11 14:56:33 +0100525 void GenerateIsRegExpEquivalent(ZoneList<Expression*>* args);
526
Kristian Monsen80d68ea2010-09-08 11:05:35 +0100527 void GenerateHasCachedArrayIndex(ZoneList<Expression*>* args);
528 void GenerateGetCachedArrayIndex(ZoneList<Expression*>* args);
Shimeng (Simon) Wang8a31eba2010-12-06 19:01:33 -0800529 void GenerateFastAsciiArrayJoin(ZoneList<Expression*>* args);
Kristian Monsen80d68ea2010-09-08 11:05:35 +0100530
Steve Block3ce2e202009-11-05 08:53:23 +0000531 // Simple condition analysis.
532 enum ConditionAnalysis {
533 ALWAYS_TRUE,
534 ALWAYS_FALSE,
535 DONT_KNOW
536 };
537 ConditionAnalysis AnalyzeCondition(Expression* cond);
538
Steve Blocka7e24c12009-10-30 11:49:00 +0000539 // Methods used to indicate which source code is generated for. Source
540 // positions are collected by the assembler and emitted with the relocation
541 // information.
542 void CodeForFunctionPosition(FunctionLiteral* fun);
543 void CodeForReturnPosition(FunctionLiteral* fun);
544 void CodeForStatementPosition(Statement* node);
Steve Blockd0582a62009-12-15 09:54:21 +0000545 void CodeForDoWhileConditionPosition(DoWhileStatement* stmt);
Steve Blocka7e24c12009-10-30 11:49:00 +0000546 void CodeForSourcePosition(int pos);
547
548#ifdef DEBUG
549 // True if the registers are valid for entry to a block.
550 bool HasValidEntryRegisters();
551#endif
552
Steve Blocka7e24c12009-10-30 11:49:00 +0000553 List<DeferredCode*> deferred_;
554
555 // Assembler
556 MacroAssembler* masm_; // to generate code
557
Andrei Popescu31002712010-02-23 13:46:05 +0000558 CompilationInfo* info_;
559
Steve Blocka7e24c12009-10-30 11:49:00 +0000560 // Code generation state
Steve Blocka7e24c12009-10-30 11:49:00 +0000561 VirtualFrame* frame_;
562 RegisterAllocator* allocator_;
563 Condition cc_reg_;
564 CodeGenState* state_;
Steve Block6ded16b2010-05-10 14:33:55 +0100565 int loop_nesting_;
Steve Blocka7e24c12009-10-30 11:49:00 +0000566
Ben Murdoch7f4d5bd2010-06-15 11:15:29 +0100567 Vector<TypeInfo>* type_info_;
568
Steve Blocka7e24c12009-10-30 11:49:00 +0000569 // Jump targets
570 BreakTarget function_return_;
571
572 // True if the function return is shadowed (ie, jumping to the target
573 // function_return_ does not jump to the true function return, but rather
574 // to some unlinking code).
575 bool function_return_is_shadowed_;
576
Kristian Monsen50ef84f2010-07-29 15:18:00 +0100577 // Size of inlined write barriers generated by EmitNamedStore.
578 static int inlined_write_barrier_size_;
579
Steve Blocka7e24c12009-10-30 11:49:00 +0000580 friend class VirtualFrame;
581 friend class JumpTarget;
582 friend class Reference;
Leon Clarke4515c472010-02-03 11:58:03 +0000583 friend class FastCodeGenerator;
Leon Clarked91b9f72010-01-27 17:25:45 +0000584 friend class FullCodeGenerator;
585 friend class FullCodeGenSyntaxChecker;
Ben Murdochb0fe1622011-05-05 13:52:32 +0100586 friend class LCodeGen;
Steve Blocka7e24c12009-10-30 11:49:00 +0000587
588 DISALLOW_COPY_AND_ASSIGN(CodeGenerator);
589};
590
591
Steve Blocka7e24c12009-10-30 11:49:00 +0000592} } // namespace v8::internal
593
594#endif // V8_ARM_CODEGEN_ARM_H_