blob: 711e4595e7a6219ecec2e6dda854e070a87fab8f [file] [log] [blame]
sgjesse@chromium.orgc6c57182011-01-17 12:24:25 +00001// Copyright 2011 the V8 project authors. All rights reserved.
kasperl@chromium.orga5551262010-12-07 12:49:48 +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_LITHIUM_CODEGEN_ARM_H_
29#define V8_ARM_LITHIUM_CODEGEN_ARM_H_
30
31#include "arm/lithium-arm.h"
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +000032#include "arm/lithium-gap-resolver-arm.h"
kasperl@chromium.orga5551262010-12-07 12:49:48 +000033#include "deoptimizer.h"
34#include "safepoint-table.h"
35#include "scopes.h"
36
37namespace v8 {
38namespace internal {
39
40// Forward declarations.
41class LDeferredCode;
42class SafepointGenerator;
43
kasperl@chromium.orga5551262010-12-07 12:49:48 +000044class LCodeGen BASE_EMBEDDED {
45 public:
46 LCodeGen(LChunk* chunk, MacroAssembler* assembler, CompilationInfo* info)
47 : chunk_(chunk),
48 masm_(assembler),
49 info_(info),
50 current_block_(-1),
51 current_instruction_(-1),
52 instructions_(chunk->instructions()),
53 deoptimizations_(4),
danno@chromium.org40cb8782011-05-25 07:58:50 +000054 deopt_jump_table_(4),
kasperl@chromium.orga5551262010-12-07 12:49:48 +000055 deoptimization_literals_(8),
56 inlined_function_count_(0),
karlklose@chromium.org8f806e82011-03-07 14:06:08 +000057 scope_(info->scope()),
kasperl@chromium.orga5551262010-12-07 12:49:48 +000058 status_(UNUSED),
59 deferred_(8),
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +000060 osr_pc_offset_(-1),
karlklose@chromium.org44bc7082011-04-11 12:33:05 +000061 resolver_(this),
62 expected_safepoint_kind_(Safepoint::kSimple) {
kasperl@chromium.orga5551262010-12-07 12:49:48 +000063 PopulateDeoptimizationLiteralsWithInlinedFunctions();
64 }
65
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +000066
67 // Simple accessors.
68 MacroAssembler* masm() const { return masm_; }
karlklose@chromium.org8f806e82011-03-07 14:06:08 +000069 CompilationInfo* info() const { return info_; }
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +000070 Isolate* isolate() const { return info_->isolate(); }
71 Factory* factory() const { return isolate()->factory(); }
72 Heap* heap() const { return isolate()->heap(); }
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +000073
74 // Support for converting LOperands to assembler types.
75 // LOperand must be a register.
76 Register ToRegister(LOperand* op) const;
77
78 // LOperand is loaded into scratch, unless already a register.
79 Register EmitLoadRegister(LOperand* op, Register scratch);
80
81 // LOperand must be a double register.
82 DoubleRegister ToDoubleRegister(LOperand* op) const;
83
84 // LOperand is loaded into dbl_scratch, unless already a double register.
85 DoubleRegister EmitLoadDoubleRegister(LOperand* op,
86 SwVfpRegister flt_scratch,
87 DoubleRegister dbl_scratch);
88 int ToInteger32(LConstantOperand* op) const;
89 Operand ToOperand(LOperand* op);
90 MemOperand ToMemOperand(LOperand* op) const;
91 // Returns a MemOperand pointing to the high word of a DoubleStackSlot.
92 MemOperand ToHighMemOperand(LOperand* op) const;
93
kasperl@chromium.orga5551262010-12-07 12:49:48 +000094 // Try to generate code for the entire chunk, but it may fail if the
95 // chunk contains constructs we cannot handle. Returns true if the
96 // code generation attempt succeeded.
97 bool GenerateCode();
98
99 // Finish the code by setting stack height, safepoint, and bailout
100 // information on it.
101 void FinishCode(Handle<Code> code);
102
103 // Deferred code support.
vegorov@chromium.org0a4e9012011-01-24 12:33:13 +0000104 template<int T>
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +0000105 void DoDeferredBinaryOpStub(LTemplateInstruction<1, 2, T>* instr,
106 Token::Value op);
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000107 void DoDeferredNumberTagD(LNumberTagD* instr);
108 void DoDeferredNumberTagI(LNumberTagI* instr);
109 void DoDeferredTaggedToI(LTaggedToI* instr);
110 void DoDeferredMathAbsTaggedHeapNumber(LUnaryMathOperation* instr);
ager@chromium.org04921a82011-06-27 13:21:41 +0000111 void DoDeferredStackCheck(LStackCheck* instr);
vegorov@chromium.org0a4e9012011-01-24 12:33:13 +0000112 void DoDeferredStringCharCodeAt(LStringCharCodeAt* instr);
whesse@chromium.orgb08986c2011-03-14 16:13:42 +0000113 void DoDeferredStringCharFromCode(LStringCharFromCode* instr);
vegorov@chromium.org0a4e9012011-01-24 12:33:13 +0000114 void DoDeferredLInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr,
115 Label* map_check);
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000116
117 // Parallel move support.
118 void DoParallelMove(LParallelMove* move);
sgjesse@chromium.org8e8294a2011-05-02 14:30:53 +0000119 void DoGap(LGap* instr);
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000120
sgjesse@chromium.orgc6c57182011-01-17 12:24:25 +0000121 // Emit frame translation commands for an environment.
122 void WriteTranslation(LEnvironment* environment, Translation* translation);
123
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000124 // Declare methods that deal with the individual node types.
125#define DECLARE_DO(type) void Do##type(L##type* node);
126 LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_DO)
127#undef DECLARE_DO
128
129 private:
130 enum Status {
131 UNUSED,
132 GENERATING,
133 DONE,
134 ABORTED
135 };
136
137 bool is_unused() const { return status_ == UNUSED; }
138 bool is_generating() const { return status_ == GENERATING; }
139 bool is_done() const { return status_ == DONE; }
140 bool is_aborted() const { return status_ == ABORTED; }
141
kmillikin@chromium.org49edbdf2011-02-16 12:32:18 +0000142 int strict_mode_flag() const {
karlklose@chromium.org44bc7082011-04-11 12:33:05 +0000143 return info()->is_strict_mode() ? kStrictMode : kNonStrictMode;
kmillikin@chromium.org49edbdf2011-02-16 12:32:18 +0000144 }
145
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000146 LChunk* chunk() const { return chunk_; }
147 Scope* scope() const { return scope_; }
148 HGraph* graph() const { return chunk_->graph(); }
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000149
lrn@chromium.org5d00b602011-01-05 09:51:43 +0000150 Register scratch0() { return r9; }
vegorov@chromium.org3cf47312011-06-29 13:20:01 +0000151 DwVfpRegister double_scratch0() { return d15; }
lrn@chromium.org5d00b602011-01-05 09:51:43 +0000152
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000153 int GetNextEmittedBlock(int block);
154 LInstruction* GetNextInstruction();
155
156 void EmitClassOfTest(Label* if_true,
157 Label* if_false,
158 Handle<String> class_name,
159 Register input,
160 Register temporary,
161 Register temporary2);
162
danno@chromium.org160a7b02011-04-18 15:51:38 +0000163 int GetStackSlotCount() const { return chunk()->spill_slot_count(); }
164 int GetParameterCount() const { return scope()->num_parameters(); }
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000165
166 void Abort(const char* format, ...);
167 void Comment(const char* format, ...);
168
169 void AddDeferredCode(LDeferredCode* code) { deferred_.Add(code); }
170
171 // Code generation passes. Returns true if code generation should
172 // continue.
173 bool GeneratePrologue();
174 bool GenerateBody();
175 bool GenerateDeferredCode();
danno@chromium.org40cb8782011-05-25 07:58:50 +0000176 bool GenerateDeoptJumpTable();
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000177 bool GenerateSafepointTable();
178
karlklose@chromium.org44bc7082011-04-11 12:33:05 +0000179 enum SafepointMode {
180 RECORD_SIMPLE_SAFEPOINT,
181 RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
182 };
183
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000184 void CallCode(Handle<Code> code,
185 RelocInfo::Mode mode,
186 LInstruction* instr);
karlklose@chromium.org44bc7082011-04-11 12:33:05 +0000187
188 void CallCodeGeneric(Handle<Code> code,
189 RelocInfo::Mode mode,
190 LInstruction* instr,
191 SafepointMode safepoint_mode);
192
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000193 void CallRuntime(const Runtime::Function* function,
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000194 int num_arguments,
195 LInstruction* instr);
karlklose@chromium.org44bc7082011-04-11 12:33:05 +0000196
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000197 void CallRuntime(Runtime::FunctionId id,
198 int num_arguments,
199 LInstruction* instr) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000200 const Runtime::Function* function = Runtime::FunctionForId(id);
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000201 CallRuntime(function, num_arguments, instr);
202 }
203
karlklose@chromium.org44bc7082011-04-11 12:33:05 +0000204 void CallRuntimeFromDeferred(Runtime::FunctionId id,
205 int argc,
206 LInstruction* instr);
207
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000208 // Generate a direct call to a known function. Expects the function
209 // to be in edi.
210 void CallKnownFunction(Handle<JSFunction> function,
211 int arity,
danno@chromium.org40cb8782011-05-25 07:58:50 +0000212 LInstruction* instr,
213 CallKind call_kind);
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000214
sgjesse@chromium.orgc6c57182011-01-17 12:24:25 +0000215 void LoadHeapObject(Register result, Handle<HeapObject> object);
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000216
karlklose@chromium.org44bc7082011-04-11 12:33:05 +0000217 void RegisterLazyDeoptimization(LInstruction* instr,
218 SafepointMode safepoint_mode);
219
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000220 void RegisterEnvironmentForDeoptimization(LEnvironment* environment);
221 void DeoptimizeIf(Condition cc, LEnvironment* environment);
222
223 void AddToTranslation(Translation* translation,
224 LOperand* op,
225 bool is_tagged);
226 void PopulateDeoptimizationData(Handle<Code> code);
227 int DefineDeoptimizationLiteral(Handle<Object> literal);
228
229 void PopulateDeoptimizationLiteralsWithInlinedFunctions();
230
231 Register ToRegister(int index) const;
232 DoubleRegister ToDoubleRegister(int index) const;
233
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000234 // Specific math operations - used from DoUnaryMathOperation.
vegorov@chromium.org0a4e9012011-01-24 12:33:13 +0000235 void EmitIntegerMathAbs(LUnaryMathOperation* instr);
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000236 void DoMathAbs(LUnaryMathOperation* instr);
237 void DoMathFloor(LUnaryMathOperation* instr);
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +0000238 void DoMathRound(LUnaryMathOperation* instr);
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000239 void DoMathSqrt(LUnaryMathOperation* instr);
danno@chromium.org4d3fe4e2011-03-10 10:14:28 +0000240 void DoMathPowHalf(LUnaryMathOperation* instr);
karlklose@chromium.org8f806e82011-03-07 14:06:08 +0000241 void DoMathLog(LUnaryMathOperation* instr);
242 void DoMathCos(LUnaryMathOperation* instr);
243 void DoMathSin(LUnaryMathOperation* instr);
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000244
245 // Support for recording safepoint and position information.
ager@chromium.org378b34e2011-01-28 08:04:38 +0000246 void RecordSafepoint(LPointerMap* pointers,
247 Safepoint::Kind kind,
248 int arguments,
249 int deoptimization_index);
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000250 void RecordSafepoint(LPointerMap* pointers, int deoptimization_index);
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +0000251 void RecordSafepoint(int deoptimization_index);
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000252 void RecordSafepointWithRegisters(LPointerMap* pointers,
253 int arguments,
254 int deoptimization_index);
sgjesse@chromium.orgc6c57182011-01-17 12:24:25 +0000255 void RecordSafepointWithRegistersAndDoubles(LPointerMap* pointers,
256 int arguments,
257 int deoptimization_index);
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000258 void RecordPosition(int position);
whesse@chromium.orgb08986c2011-03-14 16:13:42 +0000259 int LastSafepointEnd() {
260 return static_cast<int>(safepoints_.GetPcAfterGap());
261 }
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000262
263 static Condition TokenToCondition(Token::Value op, bool is_unsigned);
ager@chromium.org04921a82011-06-27 13:21:41 +0000264 void EmitGoto(int block);
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000265 void EmitBranch(int left_block, int right_block, Condition cc);
266 void EmitCmpI(LOperand* left, LOperand* right);
267 void EmitNumberUntagD(Register input,
268 DoubleRegister result,
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +0000269 bool deoptimize_on_undefined,
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000270 LEnvironment* env);
271
272 // Emits optimized code for typeof x == "y". Modifies input register.
273 // Returns the condition on which a final split to
274 // true and false label should be made, to optimize fallthrough.
275 Condition EmitTypeofIs(Label* true_label, Label* false_label,
276 Register input, Handle<String> type_name);
277
ager@chromium.org5f0c45f2010-12-17 08:51:21 +0000278 // Emits optimized code for %_IsObject(x). Preserves input register.
279 // Returns the condition on which a final split to
280 // true and false label should be made, to optimize fallthrough.
281 Condition EmitIsObject(Register input,
282 Register temp1,
ager@chromium.org5f0c45f2010-12-17 08:51:21 +0000283 Label* is_not_object,
284 Label* is_object);
285
erik.corry@gmail.comd91075f2011-02-10 07:45:38 +0000286 // Emits optimized code for %_IsConstructCall().
287 // Caller should branch on equal condition.
288 void EmitIsConstructCall(Register temp1, Register temp2);
289
lrn@chromium.org1c092762011-05-09 09:42:16 +0000290 void EmitLoadFieldOrConstantFunction(Register result,
291 Register object,
292 Handle<Map> type,
293 Handle<String> name);
fschneider@chromium.org7979bbb2011-03-28 10:47:03 +0000294
danno@chromium.org40cb8782011-05-25 07:58:50 +0000295 struct JumpTableEntry {
296 explicit inline JumpTableEntry(Address entry)
297 : label(),
298 address(entry) { }
299 Label label;
300 Address address;
301 };
302
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000303 LChunk* const chunk_;
304 MacroAssembler* const masm_;
305 CompilationInfo* const info_;
306
307 int current_block_;
308 int current_instruction_;
309 const ZoneList<LInstruction*>* instructions_;
310 ZoneList<LEnvironment*> deoptimizations_;
danno@chromium.org40cb8782011-05-25 07:58:50 +0000311 ZoneList<JumpTableEntry> deopt_jump_table_;
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000312 ZoneList<Handle<Object> > deoptimization_literals_;
313 int inlined_function_count_;
314 Scope* const scope_;
315 Status status_;
316 TranslationBuffer translations_;
317 ZoneList<LDeferredCode*> deferred_;
318 int osr_pc_offset_;
319
320 // Builder that keeps track of safepoints in the code. The table
321 // itself is emitted at the end of the generated code.
322 SafepointTableBuilder safepoints_;
323
sgjesse@chromium.orgc6c57182011-01-17 12:24:25 +0000324 // Compiler from a set of parallel moves to a sequential list of moves.
325 LGapResolver resolver_;
326
karlklose@chromium.org44bc7082011-04-11 12:33:05 +0000327 Safepoint::Kind expected_safepoint_kind_;
328
329 class PushSafepointRegistersScope BASE_EMBEDDED {
330 public:
331 PushSafepointRegistersScope(LCodeGen* codegen,
332 Safepoint::Kind kind)
333 : codegen_(codegen) {
334 ASSERT(codegen_->expected_safepoint_kind_ == Safepoint::kSimple);
335 codegen_->expected_safepoint_kind_ = kind;
336
337 switch (codegen_->expected_safepoint_kind_) {
338 case Safepoint::kWithRegisters:
339 codegen_->masm_->PushSafepointRegisters();
340 break;
341 case Safepoint::kWithRegistersAndDoubles:
342 codegen_->masm_->PushSafepointRegistersAndDoubles();
343 break;
344 default:
345 UNREACHABLE();
346 }
347 }
348
349 ~PushSafepointRegistersScope() {
350 Safepoint::Kind kind = codegen_->expected_safepoint_kind_;
351 ASSERT((kind & Safepoint::kWithRegisters) != 0);
352 switch (kind) {
353 case Safepoint::kWithRegisters:
354 codegen_->masm_->PopSafepointRegisters();
355 break;
356 case Safepoint::kWithRegistersAndDoubles:
357 codegen_->masm_->PopSafepointRegistersAndDoubles();
358 break;
359 default:
360 UNREACHABLE();
361 }
362 codegen_->expected_safepoint_kind_ = Safepoint::kSimple;
363 }
364
365 private:
366 LCodeGen* codegen_;
367 };
368
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000369 friend class LDeferredCode;
370 friend class LEnvironment;
371 friend class SafepointGenerator;
372 DISALLOW_COPY_AND_ASSIGN(LCodeGen);
373};
374
375
376class LDeferredCode: public ZoneObject {
377 public:
378 explicit LDeferredCode(LCodeGen* codegen)
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000379 : codegen_(codegen),
380 external_exit_(NULL),
381 instruction_index_(codegen->current_instruction_) {
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000382 codegen->AddDeferredCode(this);
383 }
384
385 virtual ~LDeferredCode() { }
386 virtual void Generate() = 0;
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000387 virtual LInstruction* instr() = 0;
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000388
389 void SetExit(Label *exit) { external_exit_ = exit; }
390 Label* entry() { return &entry_; }
391 Label* exit() { return external_exit_ != NULL ? external_exit_ : &exit_; }
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000392 int instruction_index() const { return instruction_index_; }
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000393
394 protected:
395 LCodeGen* codegen() const { return codegen_; }
396 MacroAssembler* masm() const { return codegen_->masm(); }
397
398 private:
399 LCodeGen* codegen_;
400 Label entry_;
401 Label exit_;
402 Label* external_exit_;
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000403 int instruction_index_;
kasperl@chromium.orga5551262010-12-07 12:49:48 +0000404};
405
406} } // namespace v8::internal
407
408#endif // V8_ARM_LITHIUM_CODEGEN_ARM_H_