Home | History | Annotate | Download | only in mips64 
      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
      3 // found in the LICENSE file.
      4 
      5 #ifndef V8_MIPS_CODE_STUBS_ARM_H_
      6 #define V8_MIPS_CODE_STUBS_ARM_H_
      7 
      8 namespace v8 {
      9 namespace internal {
     10 
     11 
     12 void ArrayNativeCode(MacroAssembler* masm, Label* call_generic_code);
     13 
     14 
     15 class StringHelper : public AllStatic {
     16  public:
     17   // Generate code for copying a large number of characters. This function
     18   // is allowed to spend extra time setting up conditions to make copying
     19   // faster. Copying of overlapping regions is not supported.
     20   // Dest register ends at the position after the last character written.
     21   static void GenerateCopyCharacters(MacroAssembler* masm,
     22                                      Register dest,
     23                                      Register src,
     24                                      Register count,
     25                                      Register scratch,
     26                                      String::Encoding encoding);
     27 
     28   // Compares two flat one-byte strings and returns result in v0.
     29   static void GenerateCompareFlatOneByteStrings(
     30       MacroAssembler* masm, Register left, Register right, Register scratch1,
     31       Register scratch2, Register scratch3, Register scratch4);
     32 
     33   // Compares two flat one-byte strings for equality and returns result in v0.
     34   static void GenerateFlatOneByteStringEquals(MacroAssembler* masm,
     35                                               Register left, Register right,
     36                                               Register scratch1,
     37                                               Register scratch2,
     38                                               Register scratch3);
     39 
     40  private:
     41   static void GenerateOneByteCharsCompareLoop(
     42       MacroAssembler* masm, Register left, Register right, Register length,
     43       Register scratch1, Register scratch2, Register scratch3,
     44       Label* chars_not_equal);
     45 
     46  private:
     47   DISALLOW_IMPLICIT_CONSTRUCTORS(StringHelper);
     48 };
     49 
     50 
     51 class StoreRegistersStateStub: public PlatformCodeStub {
     52  public:
     53   explicit StoreRegistersStateStub(Isolate* isolate)
     54       : PlatformCodeStub(isolate) {}
     55 
     56   static void GenerateAheadOfTime(Isolate* isolate);
     57 
     58  private:
     59   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
     60   DEFINE_PLATFORM_CODE_STUB(StoreRegistersState, PlatformCodeStub);
     61 };
     62 
     63 
     64 class RestoreRegistersStateStub: public PlatformCodeStub {
     65  public:
     66   explicit RestoreRegistersStateStub(Isolate* isolate)
     67       : PlatformCodeStub(isolate) {}
     68 
     69   static void GenerateAheadOfTime(Isolate* isolate);
     70 
     71  private:
     72   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
     73   DEFINE_PLATFORM_CODE_STUB(RestoreRegistersState, PlatformCodeStub);
     74 };
     75 
     76 // This stub can convert a signed int32 to a heap number (double).  It does
     77 // not work for int32s that are in Smi range!  No GC occurs during this stub
     78 // so you don't have to set up the frame.
     79 class WriteInt32ToHeapNumberStub : public PlatformCodeStub {
     80  public:
     81   WriteInt32ToHeapNumberStub(Isolate* isolate, Register the_int,
     82                              Register the_heap_number, Register scratch,
     83                              Register scratch2)
     84       : PlatformCodeStub(isolate) {
     85     minor_key_ = IntRegisterBits::encode(the_int.code()) |
     86                  HeapNumberRegisterBits::encode(the_heap_number.code()) |
     87                  ScratchRegisterBits::encode(scratch.code()) |
     88                  SignRegisterBits::encode(scratch2.code());
     89     DCHECK(IntRegisterBits::is_valid(the_int.code()));
     90     DCHECK(HeapNumberRegisterBits::is_valid(the_heap_number.code()));
     91     DCHECK(ScratchRegisterBits::is_valid(scratch.code()));
     92     DCHECK(SignRegisterBits::is_valid(scratch2.code()));
     93   }
     94 
     95   static void GenerateFixedRegStubsAheadOfTime(Isolate* isolate);
     96 
     97  private:
     98   void Generate(MacroAssembler* masm);
     99 
    100   Register the_int() const {
    101     return Register::from_code(IntRegisterBits::decode(minor_key_));
    102   }
    103 
    104   Register the_heap_number() const {
    105     return Register::from_code(HeapNumberRegisterBits::decode(minor_key_));
    106   }
    107 
    108   Register scratch() const {
    109     return Register::from_code(ScratchRegisterBits::decode(minor_key_));
    110   }
    111 
    112   Register sign() const {
    113     return Register::from_code(SignRegisterBits::decode(minor_key_));
    114   }
    115 
    116   // Minor key encoding in 16 bits.
    117   class IntRegisterBits: public BitField<int, 0, 4> {};
    118   class HeapNumberRegisterBits: public BitField<int, 4, 4> {};
    119   class ScratchRegisterBits: public BitField<int, 8, 4> {};
    120   class SignRegisterBits: public BitField<int, 12, 4> {};
    121 
    122   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
    123   DEFINE_CODE_STUB(WriteInt32ToHeapNumber, PlatformCodeStub);
    124 };
    125 
    126 
    127 class RecordWriteStub: public PlatformCodeStub {
    128  public:
    129   RecordWriteStub(Isolate* isolate,
    130                   Register object,
    131                   Register value,
    132                   Register address,
    133                   RememberedSetAction remembered_set_action,
    134                   SaveFPRegsMode fp_mode)
    135       : PlatformCodeStub(isolate),
    136         regs_(object,   // An input reg.
    137               address,  // An input reg.
    138               value) {  // One scratch reg.
    139     minor_key_ = ObjectBits::encode(object.code()) |
    140                  ValueBits::encode(value.code()) |
    141                  AddressBits::encode(address.code()) |
    142                  RememberedSetActionBits::encode(remembered_set_action) |
    143                  SaveFPRegsModeBits::encode(fp_mode);
    144   }
    145 
    146   RecordWriteStub(uint32_t key, Isolate* isolate)
    147       : PlatformCodeStub(key, isolate), regs_(object(), address(), value()) {}
    148 
    149   enum Mode {
    150     STORE_BUFFER_ONLY,
    151     INCREMENTAL,
    152     INCREMENTAL_COMPACTION
    153   };
    154 
    155   virtual bool SometimesSetsUpAFrame() { return false; }
    156 
    157   static void PatchBranchIntoNop(MacroAssembler* masm, int pos) {
    158     const unsigned offset = masm->instr_at(pos) & kImm16Mask;
    159     masm->instr_at_put(pos, BNE | (zero_reg.code() << kRsShift) |
    160         (zero_reg.code() << kRtShift) | (offset & kImm16Mask));
    161     DCHECK(Assembler::IsBne(masm->instr_at(pos)));
    162   }
    163 
    164   static void PatchNopIntoBranch(MacroAssembler* masm, int pos) {
    165     const unsigned offset = masm->instr_at(pos) & kImm16Mask;
    166     masm->instr_at_put(pos, BEQ | (zero_reg.code() << kRsShift) |
    167         (zero_reg.code() << kRtShift) | (offset & kImm16Mask));
    168     DCHECK(Assembler::IsBeq(masm->instr_at(pos)));
    169   }
    170 
    171   static Mode GetMode(Code* stub) {
    172     Instr first_instruction = Assembler::instr_at(stub->instruction_start());
    173     Instr second_instruction = Assembler::instr_at(stub->instruction_start() +
    174                                                    2 * Assembler::kInstrSize);
    175 
    176     if (Assembler::IsBeq(first_instruction)) {
    177       return INCREMENTAL;
    178     }
    179 
    180     DCHECK(Assembler::IsBne(first_instruction));
    181 
    182     if (Assembler::IsBeq(second_instruction)) {
    183       return INCREMENTAL_COMPACTION;
    184     }
    185 
    186     DCHECK(Assembler::IsBne(second_instruction));
    187 
    188     return STORE_BUFFER_ONLY;
    189   }
    190 
    191   static void Patch(Code* stub, Mode mode) {
    192     MacroAssembler masm(NULL,
    193                         stub->instruction_start(),
    194                         stub->instruction_size());
    195     switch (mode) {
    196       case STORE_BUFFER_ONLY:
    197         DCHECK(GetMode(stub) == INCREMENTAL ||
    198                GetMode(stub) == INCREMENTAL_COMPACTION);
    199         PatchBranchIntoNop(&masm, 0);
    200         PatchBranchIntoNop(&masm, 2 * Assembler::kInstrSize);
    201         break;
    202       case INCREMENTAL:
    203         DCHECK(GetMode(stub) == STORE_BUFFER_ONLY);
    204         PatchNopIntoBranch(&masm, 0);
    205         break;
    206       case INCREMENTAL_COMPACTION:
    207         DCHECK(GetMode(stub) == STORE_BUFFER_ONLY);
    208         PatchNopIntoBranch(&masm, 2 * Assembler::kInstrSize);
    209         break;
    210     }
    211     DCHECK(GetMode(stub) == mode);
    212     CpuFeatures::FlushICache(stub->instruction_start(),
    213                              4 * Assembler::kInstrSize);
    214   }
    215 
    216   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
    217 
    218  private:
    219   // This is a helper class for freeing up 3 scratch registers.  The input is
    220   // two registers that must be preserved and one scratch register provided by
    221   // the caller.
    222   class RegisterAllocation {
    223    public:
    224     RegisterAllocation(Register object,
    225                        Register address,
    226                        Register scratch0)
    227         : object_(object),
    228           address_(address),
    229           scratch0_(scratch0) {
    230       DCHECK(!AreAliased(scratch0, object, address, no_reg));
    231       scratch1_ = GetRegisterThatIsNotOneOf(object_, address_, scratch0_);
    232     }
    233 
    234     void Save(MacroAssembler* masm) {
    235       DCHECK(!AreAliased(object_, address_, scratch1_, scratch0_));
    236       // We don't have to save scratch0_ because it was given to us as
    237       // a scratch register.
    238       masm->push(scratch1_);
    239     }
    240 
    241     void Restore(MacroAssembler* masm) {
    242       masm->pop(scratch1_);
    243     }
    244 
    245     // If we have to call into C then we need to save and restore all caller-
    246     // saved registers that were not already preserved.  The scratch registers
    247     // will be restored by other means so we don't bother pushing them here.
    248     void SaveCallerSaveRegisters(MacroAssembler* masm, SaveFPRegsMode mode) {
    249       masm->MultiPush((kJSCallerSaved | ra.bit()) & ~scratch1_.bit());
    250       if (mode == kSaveFPRegs) {
    251         masm->MultiPushFPU(kCallerSavedFPU);
    252       }
    253     }
    254 
    255     inline void RestoreCallerSaveRegisters(MacroAssembler*masm,
    256                                            SaveFPRegsMode mode) {
    257       if (mode == kSaveFPRegs) {
    258         masm->MultiPopFPU(kCallerSavedFPU);
    259       }
    260       masm->MultiPop((kJSCallerSaved | ra.bit()) & ~scratch1_.bit());
    261     }
    262 
    263     inline Register object() { return object_; }
    264     inline Register address() { return address_; }
    265     inline Register scratch0() { return scratch0_; }
    266     inline Register scratch1() { return scratch1_; }
    267 
    268    private:
    269     Register object_;
    270     Register address_;
    271     Register scratch0_;
    272     Register scratch1_;
    273 
    274     friend class RecordWriteStub;
    275   };
    276 
    277   enum OnNoNeedToInformIncrementalMarker {
    278     kReturnOnNoNeedToInformIncrementalMarker,
    279     kUpdateRememberedSetOnNoNeedToInformIncrementalMarker
    280   };
    281 
    282   virtual inline Major MajorKey() const FINAL OVERRIDE { return RecordWrite; }
    283 
    284   virtual void Generate(MacroAssembler* masm) OVERRIDE;
    285   void GenerateIncremental(MacroAssembler* masm, Mode mode);
    286   void CheckNeedsToInformIncrementalMarker(
    287       MacroAssembler* masm,
    288       OnNoNeedToInformIncrementalMarker on_no_need,
    289       Mode mode);
    290   void InformIncrementalMarker(MacroAssembler* masm);
    291 
    292   void Activate(Code* code) {
    293     code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code);
    294   }
    295 
    296   Register object() const {
    297     return Register::from_code(ObjectBits::decode(minor_key_));
    298   }
    299 
    300   Register value() const {
    301     return Register::from_code(ValueBits::decode(minor_key_));
    302   }
    303 
    304   Register address() const {
    305     return Register::from_code(AddressBits::decode(minor_key_));
    306   }
    307 
    308   RememberedSetAction remembered_set_action() const {
    309     return RememberedSetActionBits::decode(minor_key_);
    310   }
    311 
    312   SaveFPRegsMode save_fp_regs_mode() const {
    313     return SaveFPRegsModeBits::decode(minor_key_);
    314   }
    315 
    316   class ObjectBits: public BitField<int, 0, 5> {};
    317   class ValueBits: public BitField<int, 5, 5> {};
    318   class AddressBits: public BitField<int, 10, 5> {};
    319   class RememberedSetActionBits: public BitField<RememberedSetAction, 15, 1> {};
    320   class SaveFPRegsModeBits: public BitField<SaveFPRegsMode, 16, 1> {};
    321 
    322   Label slow_;
    323   RegisterAllocation regs_;
    324 
    325   DISALLOW_COPY_AND_ASSIGN(RecordWriteStub);
    326 };
    327 
    328 
    329 // Trampoline stub to call into native code. To call safely into native code
    330 // in the presence of compacting GC (which can move code objects) we need to
    331 // keep the code which called into native pinned in the memory. Currently the
    332 // simplest approach is to generate such stub early enough so it can never be
    333 // moved by GC
    334 class DirectCEntryStub: public PlatformCodeStub {
    335  public:
    336   explicit DirectCEntryStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
    337   void GenerateCall(MacroAssembler* masm, Register target);
    338 
    339  private:
    340   bool NeedsImmovableCode() { return true; }
    341 
    342   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
    343   DEFINE_PLATFORM_CODE_STUB(DirectCEntry, PlatformCodeStub);
    344 };
    345 
    346 
    347 class NameDictionaryLookupStub: public PlatformCodeStub {
    348  public:
    349   enum LookupMode { POSITIVE_LOOKUP, NEGATIVE_LOOKUP };
    350 
    351   NameDictionaryLookupStub(Isolate* isolate, LookupMode mode)
    352       : PlatformCodeStub(isolate) {
    353     minor_key_ = LookupModeBits::encode(mode);
    354   }
    355 
    356   static void GenerateNegativeLookup(MacroAssembler* masm,
    357                                      Label* miss,
    358                                      Label* done,
    359                                      Register receiver,
    360                                      Register properties,
    361                                      Handle<Name> name,
    362                                      Register scratch0);
    363 
    364   static void GeneratePositiveLookup(MacroAssembler* masm,
    365                                      Label* miss,
    366                                      Label* done,
    367                                      Register elements,
    368                                      Register name,
    369                                      Register r0,
    370                                      Register r1);
    371 
    372   virtual bool SometimesSetsUpAFrame() { return false; }
    373 
    374  private:
    375   static const int kInlinedProbes = 4;
    376   static const int kTotalProbes = 20;
    377 
    378   static const int kCapacityOffset =
    379       NameDictionary::kHeaderSize +
    380       NameDictionary::kCapacityIndex * kPointerSize;
    381 
    382   static const int kElementsStartOffset =
    383       NameDictionary::kHeaderSize +
    384       NameDictionary::kElementsStartIndex * kPointerSize;
    385 
    386   LookupMode mode() const { return LookupModeBits::decode(minor_key_); }
    387 
    388   class LookupModeBits: public BitField<LookupMode, 0, 1> {};
    389 
    390   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
    391   DEFINE_PLATFORM_CODE_STUB(NameDictionaryLookup, PlatformCodeStub);
    392 };
    393 
    394 
    395 } }  // namespace v8::internal
    396 
    397 #endif  // V8_MIPS_CODE_STUBS_ARM_H_
    398