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