OLD | NEW |
1 // Copyright 2011 the V8 project authors. All rights reserved. | 1 // Copyright 2011 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef V8_MIPS_CODE_STUBS_ARM_H_ | 5 #ifndef V8_MIPS_CODE_STUBS_ARM_H_ |
6 #define V8_MIPS_CODE_STUBS_ARM_H_ | 6 #define V8_MIPS_CODE_STUBS_ARM_H_ |
7 | 7 |
8 #include "src/code-stubs.h" | 8 #include "src/code-stubs.h" |
9 | 9 |
10 | 10 |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
97 | 97 |
98 void Generate(MacroAssembler* masm); | 98 void Generate(MacroAssembler* masm); |
99 }; | 99 }; |
100 | 100 |
101 | 101 |
102 // This stub can convert a signed int32 to a heap number (double). It does | 102 // This stub can convert a signed int32 to a heap number (double). It does |
103 // not work for int32s that are in Smi range! No GC occurs during this stub | 103 // not work for int32s that are in Smi range! No GC occurs during this stub |
104 // so you don't have to set up the frame. | 104 // so you don't have to set up the frame. |
105 class WriteInt32ToHeapNumberStub : public PlatformCodeStub { | 105 class WriteInt32ToHeapNumberStub : public PlatformCodeStub { |
106 public: | 106 public: |
107 WriteInt32ToHeapNumberStub(Isolate* isolate, | 107 WriteInt32ToHeapNumberStub(Isolate* isolate, Register the_int, |
108 Register the_int, | 108 Register the_heap_number, Register scratch, |
109 Register the_heap_number, | |
110 Register scratch, | |
111 Register scratch2) | 109 Register scratch2) |
112 : PlatformCodeStub(isolate), | 110 : PlatformCodeStub(isolate) { |
113 the_int_(the_int), | 111 minor_key_ = IntRegisterBits::encode(the_int.code()) | |
114 the_heap_number_(the_heap_number), | 112 HeapNumberRegisterBits::encode(the_heap_number.code()) | |
115 scratch_(scratch), | 113 ScratchRegisterBits::encode(scratch.code()) | |
116 sign_(scratch2) { | 114 SignRegisterBits::encode(scratch2.code()); |
117 DCHECK(IntRegisterBits::is_valid(the_int_.code())); | 115 DCHECK(IntRegisterBits::is_valid(the_int.code())); |
118 DCHECK(HeapNumberRegisterBits::is_valid(the_heap_number_.code())); | 116 DCHECK(HeapNumberRegisterBits::is_valid(the_heap_number.code())); |
119 DCHECK(ScratchRegisterBits::is_valid(scratch_.code())); | 117 DCHECK(ScratchRegisterBits::is_valid(scratch.code())); |
120 DCHECK(SignRegisterBits::is_valid(sign_.code())); | 118 DCHECK(SignRegisterBits::is_valid(scratch2.code())); |
121 } | 119 } |
122 | 120 |
123 static void GenerateFixedRegStubsAheadOfTime(Isolate* isolate); | 121 static void GenerateFixedRegStubsAheadOfTime(Isolate* isolate); |
124 | 122 |
125 private: | 123 private: |
126 Register the_int_; | 124 Major MajorKey() const { return WriteInt32ToHeapNumber; } |
127 Register the_heap_number_; | 125 |
128 Register scratch_; | 126 void Generate(MacroAssembler* masm); |
129 Register sign_; | 127 |
| 128 Register the_int() const { |
| 129 return Register::from_code(IntRegisterBits::decode(minor_key_)); |
| 130 } |
| 131 |
| 132 Register the_heap_number() const { |
| 133 return Register::from_code(HeapNumberRegisterBits::decode(minor_key_)); |
| 134 } |
| 135 |
| 136 Register scratch() const { |
| 137 return Register::from_code(ScratchRegisterBits::decode(minor_key_)); |
| 138 } |
| 139 |
| 140 Register sign() const { |
| 141 return Register::from_code(SignRegisterBits::decode(minor_key_)); |
| 142 } |
130 | 143 |
131 // Minor key encoding in 16 bits. | 144 // Minor key encoding in 16 bits. |
132 class IntRegisterBits: public BitField<int, 0, 4> {}; | 145 class IntRegisterBits: public BitField<int, 0, 4> {}; |
133 class HeapNumberRegisterBits: public BitField<int, 4, 4> {}; | 146 class HeapNumberRegisterBits: public BitField<int, 4, 4> {}; |
134 class ScratchRegisterBits: public BitField<int, 8, 4> {}; | 147 class ScratchRegisterBits: public BitField<int, 8, 4> {}; |
135 class SignRegisterBits: public BitField<int, 12, 4> {}; | 148 class SignRegisterBits: public BitField<int, 12, 4> {}; |
136 | 149 |
137 Major MajorKey() const { return WriteInt32ToHeapNumber; } | 150 DISALLOW_COPY_AND_ASSIGN(WriteInt32ToHeapNumberStub); |
138 uint32_t MinorKey() const { | |
139 // Encode the parameters in a unique 16 bit value. | |
140 return IntRegisterBits::encode(the_int_.code()) | |
141 | HeapNumberRegisterBits::encode(the_heap_number_.code()) | |
142 | ScratchRegisterBits::encode(scratch_.code()) | |
143 | SignRegisterBits::encode(sign_.code()); | |
144 } | |
145 | |
146 void Generate(MacroAssembler* masm); | |
147 }; | 151 }; |
148 | 152 |
149 | 153 |
150 class RecordWriteStub: public PlatformCodeStub { | 154 class RecordWriteStub: public PlatformCodeStub { |
151 public: | 155 public: |
152 RecordWriteStub(Isolate* isolate, | 156 RecordWriteStub(Isolate* isolate, |
153 Register object, | 157 Register object, |
154 Register value, | 158 Register value, |
155 Register address, | 159 Register address, |
156 RememberedSetAction remembered_set_action, | 160 RememberedSetAction remembered_set_action, |
157 SaveFPRegsMode fp_mode) | 161 SaveFPRegsMode fp_mode) |
158 : PlatformCodeStub(isolate), | 162 : PlatformCodeStub(isolate), |
159 object_(object), | |
160 value_(value), | |
161 address_(address), | |
162 remembered_set_action_(remembered_set_action), | |
163 save_fp_regs_mode_(fp_mode), | |
164 regs_(object, // An input reg. | 163 regs_(object, // An input reg. |
165 address, // An input reg. | 164 address, // An input reg. |
166 value) { // One scratch reg. | 165 value) { // One scratch reg. |
| 166 minor_key_ = ObjectBits::encode(object.code()) | |
| 167 ValueBits::encode(value.code()) | |
| 168 AddressBits::encode(address.code()) | |
| 169 RememberedSetActionBits::encode(remembered_set_action) | |
| 170 SaveFPRegsModeBits::encode(fp_mode); |
167 } | 171 } |
168 | 172 |
169 enum Mode { | 173 enum Mode { |
170 STORE_BUFFER_ONLY, | 174 STORE_BUFFER_ONLY, |
171 INCREMENTAL, | 175 INCREMENTAL, |
172 INCREMENTAL_COMPACTION | 176 INCREMENTAL_COMPACTION |
173 }; | 177 }; |
174 | 178 |
175 virtual bool SometimesSetsUpAFrame() { return false; } | 179 virtual bool SometimesSetsUpAFrame() { return false; } |
176 | 180 |
(...skipping 113 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
290 Register scratch1_; | 294 Register scratch1_; |
291 | 295 |
292 friend class RecordWriteStub; | 296 friend class RecordWriteStub; |
293 }; | 297 }; |
294 | 298 |
295 enum OnNoNeedToInformIncrementalMarker { | 299 enum OnNoNeedToInformIncrementalMarker { |
296 kReturnOnNoNeedToInformIncrementalMarker, | 300 kReturnOnNoNeedToInformIncrementalMarker, |
297 kUpdateRememberedSetOnNoNeedToInformIncrementalMarker | 301 kUpdateRememberedSetOnNoNeedToInformIncrementalMarker |
298 }; | 302 }; |
299 | 303 |
| 304 Major MajorKey() const { return RecordWrite; } |
| 305 |
300 void Generate(MacroAssembler* masm); | 306 void Generate(MacroAssembler* masm); |
301 void GenerateIncremental(MacroAssembler* masm, Mode mode); | 307 void GenerateIncremental(MacroAssembler* masm, Mode mode); |
302 void CheckNeedsToInformIncrementalMarker( | 308 void CheckNeedsToInformIncrementalMarker( |
303 MacroAssembler* masm, | 309 MacroAssembler* masm, |
304 OnNoNeedToInformIncrementalMarker on_no_need, | 310 OnNoNeedToInformIncrementalMarker on_no_need, |
305 Mode mode); | 311 Mode mode); |
306 void InformIncrementalMarker(MacroAssembler* masm); | 312 void InformIncrementalMarker(MacroAssembler* masm); |
307 | 313 |
308 Major MajorKey() const { return RecordWrite; } | |
309 | |
310 uint32_t MinorKey() const { | |
311 return ObjectBits::encode(object_.code()) | | |
312 ValueBits::encode(value_.code()) | | |
313 AddressBits::encode(address_.code()) | | |
314 RememberedSetActionBits::encode(remembered_set_action_) | | |
315 SaveFPRegsModeBits::encode(save_fp_regs_mode_); | |
316 } | |
317 | |
318 void Activate(Code* code) { | 314 void Activate(Code* code) { |
319 code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code); | 315 code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code); |
320 } | 316 } |
321 | 317 |
| 318 Register object() const { |
| 319 return Register::from_code(ObjectBits::decode(minor_key_)); |
| 320 } |
| 321 |
| 322 Register value() const { |
| 323 return Register::from_code(ValueBits::decode(minor_key_)); |
| 324 } |
| 325 |
| 326 Register address() const { |
| 327 return Register::from_code(AddressBits::decode(minor_key_)); |
| 328 } |
| 329 |
| 330 RememberedSetAction remembered_set_action() const { |
| 331 return RememberedSetActionBits::decode(minor_key_); |
| 332 } |
| 333 |
| 334 SaveFPRegsMode save_fp_regs_mode() const { |
| 335 return SaveFPRegsModeBits::decode(minor_key_); |
| 336 } |
| 337 |
322 class ObjectBits: public BitField<int, 0, 5> {}; | 338 class ObjectBits: public BitField<int, 0, 5> {}; |
323 class ValueBits: public BitField<int, 5, 5> {}; | 339 class ValueBits: public BitField<int, 5, 5> {}; |
324 class AddressBits: public BitField<int, 10, 5> {}; | 340 class AddressBits: public BitField<int, 10, 5> {}; |
325 class RememberedSetActionBits: public BitField<RememberedSetAction, 15, 1> {}; | 341 class RememberedSetActionBits: public BitField<RememberedSetAction, 15, 1> {}; |
326 class SaveFPRegsModeBits: public BitField<SaveFPRegsMode, 16, 1> {}; | 342 class SaveFPRegsModeBits: public BitField<SaveFPRegsMode, 16, 1> {}; |
327 | 343 |
328 Register object_; | |
329 Register value_; | |
330 Register address_; | |
331 RememberedSetAction remembered_set_action_; | |
332 SaveFPRegsMode save_fp_regs_mode_; | |
333 Label slow_; | 344 Label slow_; |
334 RegisterAllocation regs_; | 345 RegisterAllocation regs_; |
| 346 |
| 347 DISALLOW_COPY_AND_ASSIGN(RecordWriteStub); |
335 }; | 348 }; |
336 | 349 |
337 | 350 |
338 // Trampoline stub to call into native code. To call safely into native code | 351 // Trampoline stub to call into native code. To call safely into native code |
339 // in the presence of compacting GC (which can move code objects) we need to | 352 // in the presence of compacting GC (which can move code objects) we need to |
340 // keep the code which called into native pinned in the memory. Currently the | 353 // keep the code which called into native pinned in the memory. Currently the |
341 // simplest approach is to generate such stub early enough so it can never be | 354 // simplest approach is to generate such stub early enough so it can never be |
342 // moved by GC | 355 // moved by GC |
343 class DirectCEntryStub: public PlatformCodeStub { | 356 class DirectCEntryStub: public PlatformCodeStub { |
344 public: | 357 public: |
345 explicit DirectCEntryStub(Isolate* isolate) : PlatformCodeStub(isolate) {} | 358 explicit DirectCEntryStub(Isolate* isolate) : PlatformCodeStub(isolate) {} |
346 void Generate(MacroAssembler* masm); | 359 void Generate(MacroAssembler* masm); |
347 void GenerateCall(MacroAssembler* masm, Register target); | 360 void GenerateCall(MacroAssembler* masm, Register target); |
348 | 361 |
349 private: | 362 private: |
350 Major MajorKey() const { return DirectCEntry; } | 363 Major MajorKey() const { return DirectCEntry; } |
351 uint32_t MinorKey() const { return 0; } | |
352 | 364 |
353 bool NeedsImmovableCode() { return true; } | 365 bool NeedsImmovableCode() { return true; } |
| 366 |
| 367 DISALLOW_COPY_AND_ASSIGN(DirectCEntryStub); |
354 }; | 368 }; |
355 | 369 |
356 | 370 |
357 class NameDictionaryLookupStub: public PlatformCodeStub { | 371 class NameDictionaryLookupStub: public PlatformCodeStub { |
358 public: | 372 public: |
359 enum LookupMode { POSITIVE_LOOKUP, NEGATIVE_LOOKUP }; | 373 enum LookupMode { POSITIVE_LOOKUP, NEGATIVE_LOOKUP }; |
360 | 374 |
361 NameDictionaryLookupStub(Isolate* isolate, LookupMode mode) | 375 NameDictionaryLookupStub(Isolate* isolate, LookupMode mode) |
362 : PlatformCodeStub(isolate), mode_(mode) { } | 376 : PlatformCodeStub(isolate) { |
| 377 minor_key_ = LookupModeBits::encode(mode); |
| 378 } |
363 | 379 |
364 void Generate(MacroAssembler* masm); | 380 void Generate(MacroAssembler* masm); |
365 | 381 |
366 static void GenerateNegativeLookup(MacroAssembler* masm, | 382 static void GenerateNegativeLookup(MacroAssembler* masm, |
367 Label* miss, | 383 Label* miss, |
368 Label* done, | 384 Label* done, |
369 Register receiver, | 385 Register receiver, |
370 Register properties, | 386 Register properties, |
371 Handle<Name> name, | 387 Handle<Name> name, |
372 Register scratch0); | 388 Register scratch0); |
(...skipping 15 matching lines...) Expand all Loading... |
388 static const int kCapacityOffset = | 404 static const int kCapacityOffset = |
389 NameDictionary::kHeaderSize + | 405 NameDictionary::kHeaderSize + |
390 NameDictionary::kCapacityIndex * kPointerSize; | 406 NameDictionary::kCapacityIndex * kPointerSize; |
391 | 407 |
392 static const int kElementsStartOffset = | 408 static const int kElementsStartOffset = |
393 NameDictionary::kHeaderSize + | 409 NameDictionary::kHeaderSize + |
394 NameDictionary::kElementsStartIndex * kPointerSize; | 410 NameDictionary::kElementsStartIndex * kPointerSize; |
395 | 411 |
396 Major MajorKey() const { return NameDictionaryLookup; } | 412 Major MajorKey() const { return NameDictionaryLookup; } |
397 | 413 |
398 uint32_t MinorKey() const { return LookupModeBits::encode(mode_); } | 414 LookupMode mode() const { return LookupModeBits::decode(minor_key_); } |
399 | 415 |
400 class LookupModeBits: public BitField<LookupMode, 0, 1> {}; | 416 class LookupModeBits: public BitField<LookupMode, 0, 1> {}; |
401 | 417 |
402 LookupMode mode_; | 418 DISALLOW_COPY_AND_ASSIGN(NameDictionaryLookupStub); |
403 }; | 419 }; |
404 | 420 |
405 | 421 |
406 } } // namespace v8::internal | 422 } } // namespace v8::internal |
407 | 423 |
408 #endif // V8_MIPS_CODE_STUBS_ARM_H_ | 424 #endif // V8_MIPS_CODE_STUBS_ARM_H_ |
OLD | NEW |