src/arm/code-stubs-arm.h

   1 // Copyright 2012 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_ARM_CODE_STUBS_ARM_H_
   6 #define V8_ARM_CODE_STUBS_ARM_H_
   7
   8 #include "src/arm/frames-arm.h"
   9
  10 namespace v8 {
  11 namespace internal {
  12
  13
  14 void ArrayNativeCode(MacroAssembler* masm, Label* call_generic_code);
  15
  16
  17 class StringHelper : public AllStatic {
  18  public:
  19   // Generate code for copying a large number of characters. This function
  20   // is allowed to spend extra time setting up conditions to make copying
  21   // faster. Copying of overlapping regions is not supported.
  22   // Dest register ends at the position after the last character written.
  23   static void GenerateCopyCharacters(MacroAssembler* masm,
  24                                      Register dest,
  25                                      Register src,
  26                                      Register count,
  27                                      Register scratch,
  28                                      String::Encoding encoding);
  29
  30   // Compares two flat one-byte strings and returns result in r0.
  31   static void GenerateCompareFlatOneByteStrings(
  32       MacroAssembler* masm, Register left, Register right, Register scratch1,
  33       Register scratch2, Register scratch3, Register scratch4);
  34
  35   // Compares two flat one-byte strings for equality and returns result in r0.
  36   static void GenerateFlatOneByteStringEquals(MacroAssembler* masm,
  37                                               Register left, Register right,
  38                                               Register scratch1,
  39                                               Register scratch2,
  40                                               Register scratch3);
  41
  42  private:
  43   static void GenerateOneByteCharsCompareLoop(
  44       MacroAssembler* masm, Register left, Register right, Register length,
  45       Register scratch1, Register scratch2, Label* chars_not_equal);
  46
  47   DISALLOW_IMPLICIT_CONSTRUCTORS(StringHelper);
  48 };
  49
  50
  51 class RecordWriteStub: public PlatformCodeStub {
  52  public:
  53   RecordWriteStub(Isolate* isolate,
  54                   Register object,
  55                   Register value,
  56                   Register address,
  57                   RememberedSetAction remembered_set_action,
  58                   SaveFPRegsMode fp_mode)
  59       : PlatformCodeStub(isolate),
  60         regs_(object,   // An input reg.
  61               address,  // An input reg.
  62               value) {  // One scratch reg.
  63     minor_key_ = ObjectBits::encode(object.code()) |
  64                  ValueBits::encode(value.code()) |
  65                  AddressBits::encode(address.code()) |
  66                  RememberedSetActionBits::encode(remembered_set_action) |
  67                  SaveFPRegsModeBits::encode(fp_mode);
  68   }
  69
  70   RecordWriteStub(uint32_t key, Isolate* isolate)
  71       : PlatformCodeStub(key, isolate), regs_(object(), address(), value()) {}
  72
  73   enum Mode {
  74     STORE_BUFFER_ONLY,
  75     INCREMENTAL,
  76     INCREMENTAL_COMPACTION
  77   };
  78
  79   bool SometimesSetsUpAFrame() override { return false; }
  80
  81   static void PatchBranchIntoNop(MacroAssembler* masm, int pos) {
  82     masm->instr_at_put(pos, (masm->instr_at(pos) & ~B27) | (B24 | B20));
  83     DCHECK(Assembler::IsTstImmediate(masm->instr_at(pos)));
  84   }
  85
  86   static void PatchNopIntoBranch(MacroAssembler* masm, int pos) {
  87     masm->instr_at_put(pos, (masm->instr_at(pos) & ~(B24 | B20)) | B27);
  88     DCHECK(Assembler::IsBranch(masm->instr_at(pos)));
  89   }
  90
  91   static Mode GetMode(Code* stub) {
  92     Instr first_instruction = Assembler::instr_at(stub->instruction_start());
  93     Instr second_instruction = Assembler::instr_at(stub->instruction_start() +
  94                                                    Assembler::kInstrSize);
  95
  96     if (Assembler::IsBranch(first_instruction)) {
  97       return INCREMENTAL;
  98     }
  99
 100     DCHECK(Assembler::IsTstImmediate(first_instruction));
 101
 102     if (Assembler::IsBranch(second_instruction)) {
 103       return INCREMENTAL_COMPACTION;
 104     }
 105
 106     DCHECK(Assembler::IsTstImmediate(second_instruction));
 107
 108     return STORE_BUFFER_ONLY;
 109   }
 110
 111   static void Patch(Code* stub, Mode mode) {
 112     MacroAssembler masm(NULL,
 113                         stub->instruction_start(),
 114                         stub->instruction_size());
 115     switch (mode) {
 116       case STORE_BUFFER_ONLY:
 117         DCHECK(GetMode(stub) == INCREMENTAL ||
 118                GetMode(stub) == INCREMENTAL_COMPACTION);
 119         PatchBranchIntoNop(&masm, 0);
 120         PatchBranchIntoNop(&masm, Assembler::kInstrSize);
 121         break;
 122       case INCREMENTAL:
 123         DCHECK(GetMode(stub) == STORE_BUFFER_ONLY);
 124         PatchNopIntoBranch(&masm, 0);
 125         break;
 126       case INCREMENTAL_COMPACTION:
 127         DCHECK(GetMode(stub) == STORE_BUFFER_ONLY);
 128         PatchNopIntoBranch(&masm, Assembler::kInstrSize);
 129         break;
 130     }
 131     DCHECK(GetMode(stub) == mode);
 132     Assembler::FlushICache(stub->GetIsolate(), stub->instruction_start(),
 133                            2 * Assembler::kInstrSize);
 134   }
 135
 136   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
 137
 138  private:
 139   // This is a helper class for freeing up 3 scratch registers.  The input is
 140   // two registers that must be preserved and one scratch register provided by
 141   // the caller.
 142   class RegisterAllocation {
 143    public:
 144     RegisterAllocation(Register object,
 145                        Register address,
 146                        Register scratch0)
 147         : object_(object),
 148           address_(address),
 149           scratch0_(scratch0) {
 150       DCHECK(!AreAliased(scratch0, object, address, no_reg));
 151       scratch1_ = GetRegisterThatIsNotOneOf(object_, address_, scratch0_);
 152     }
 153
 154     void Save(MacroAssembler* masm) {
 155       DCHECK(!AreAliased(object_, address_, scratch1_, scratch0_));
 156       // We don't have to save scratch0_ because it was given to us as
 157       // a scratch register.
 158       masm->push(scratch1_);
 159     }
 160
 161     void Restore(MacroAssembler* masm) {
 162       masm->pop(scratch1_);
 163     }
 164
 165     // If we have to call into C then we need to save and restore all caller-
 166     // saved registers that were not already preserved.  The scratch registers
 167     // will be restored by other means so we don't bother pushing them here.
 168     void SaveCallerSaveRegisters(MacroAssembler* masm, SaveFPRegsMode mode) {
 169       masm->stm(db_w, sp, (kCallerSaved | lr.bit()) & ~scratch1_.bit());
 170       if (mode == kSaveFPRegs) {
 171         masm->SaveFPRegs(sp, scratch0_);
 172       }
 173     }
 174
 175     inline void RestoreCallerSaveRegisters(MacroAssembler*masm,
 176                                            SaveFPRegsMode mode) {
 177       if (mode == kSaveFPRegs) {
 178         masm->RestoreFPRegs(sp, scratch0_);
 179       }
 180       masm->ldm(ia_w, sp, (kCallerSaved | lr.bit()) & ~scratch1_.bit());
 181     }
 182
 183     inline Register object() { return object_; }
 184     inline Register address() { return address_; }
 185     inline Register scratch0() { return scratch0_; }
 186     inline Register scratch1() { return scratch1_; }
 187
 188    private:
 189     Register object_;
 190     Register address_;
 191     Register scratch0_;
 192     Register scratch1_;
 193
 194     friend class RecordWriteStub;
 195   };
 196
 197   enum OnNoNeedToInformIncrementalMarker {
 198     kReturnOnNoNeedToInformIncrementalMarker,
 199     kUpdateRememberedSetOnNoNeedToInformIncrementalMarker
 200   };
 201
 202   inline Major MajorKey() const final { return RecordWrite; }
 203
 204   void Generate(MacroAssembler* masm) override;
 205   void GenerateIncremental(MacroAssembler* masm, Mode mode);
 206   void CheckNeedsToInformIncrementalMarker(
 207       MacroAssembler* masm,
 208       OnNoNeedToInformIncrementalMarker on_no_need,
 209       Mode mode);
 210   void InformIncrementalMarker(MacroAssembler* masm);
 211
 212   void Activate(Code* code) override {
 213     code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code);
 214   }
 215
 216   Register object() const {
 217     return Register::from_code(ObjectBits::decode(minor_key_));
 218   }
 219
 220   Register value() const {
 221     return Register::from_code(ValueBits::decode(minor_key_));
 222   }
 223
 224   Register address() const {
 225     return Register::from_code(AddressBits::decode(minor_key_));
 226   }
 227
 228   RememberedSetAction remembered_set_action() const {
 229     return RememberedSetActionBits::decode(minor_key_);
 230   }
 231
 232   SaveFPRegsMode save_fp_regs_mode() const {
 233     return SaveFPRegsModeBits::decode(minor_key_);
 234   }
 235
 236   class ObjectBits: public BitField<int, 0, 4> {};
 237   class ValueBits: public BitField<int, 4, 4> {};
 238   class AddressBits: public BitField<int, 8, 4> {};
 239   class RememberedSetActionBits: public BitField<RememberedSetAction, 12, 1> {};
 240   class SaveFPRegsModeBits: public BitField<SaveFPRegsMode, 13, 1> {};
 241
 242   Label slow_;
 243   RegisterAllocation regs_;
 244
 245   DISALLOW_COPY_AND_ASSIGN(RecordWriteStub);
 246 };
 247
 248
 249 // Trampoline stub to call into native code. To call safely into native code
 250 // in the presence of compacting GC (which can move code objects) we need to
 251 // keep the code which called into native pinned in the memory. Currently the
 252 // simplest approach is to generate such stub early enough so it can never be
 253 // moved by GC
 254 class DirectCEntryStub: public PlatformCodeStub {
 255  public:
 256   explicit DirectCEntryStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
 257   void GenerateCall(MacroAssembler* masm, Register target);
 258
 259  private:
 260   bool NeedsImmovableCode() override { return true; }
 261
 262   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
 263   DEFINE_PLATFORM_CODE_STUB(DirectCEntry, PlatformCodeStub);
 264 };
 265
 266
 267 class NameDictionaryLookupStub: public PlatformCodeStub {
 268  public:
 269   enum LookupMode { POSITIVE_LOOKUP, NEGATIVE_LOOKUP };
 270
 271   NameDictionaryLookupStub(Isolate* isolate, LookupMode mode)
 272       : PlatformCodeStub(isolate) {
 273     minor_key_ = LookupModeBits::encode(mode);
 274   }
 275
 276   static void GenerateNegativeLookup(MacroAssembler* masm,
 277                                      Label* miss,
 278                                      Label* done,
 279                                      Register receiver,
 280                                      Register properties,
 281                                      Handle<Name> name,
 282                                      Register scratch0);
 283
 284   static void GeneratePositiveLookup(MacroAssembler* masm,
 285                                      Label* miss,
 286                                      Label* done,
 287                                      Register elements,
 288                                      Register name,
 289                                      Register r0,
 290                                      Register r1);
 291
 292   bool SometimesSetsUpAFrame() override { return false; }
 293
 294  private:
 295   static const int kInlinedProbes = 4;
 296   static const int kTotalProbes = 20;
 297
 298   static const int kCapacityOffset =
 299       NameDictionary::kHeaderSize +
 300       NameDictionary::kCapacityIndex * kPointerSize;
 301
 302   static const int kElementsStartOffset =
 303       NameDictionary::kHeaderSize +
 304       NameDictionary::kElementsStartIndex * kPointerSize;
 305
 306   LookupMode mode() const { return LookupModeBits::decode(minor_key_); }
 307
 308   class LookupModeBits: public BitField<LookupMode, 0, 1> {};
 309
 310   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
 311   DEFINE_PLATFORM_CODE_STUB(NameDictionaryLookup, PlatformCodeStub);
 312 };
 313
 314 } }  // namespace v8::internal
 315
 316 #endif  // V8_ARM_CODE_STUBS_ARM_H_