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