Enable stub generation using Hydrogen/Lithium (again)

src/arm/code-stubs-arm.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 18 matching lines @@
 #define V8_ARM_CODE_STUBS_ARM_H_
 
 #include "ic-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
 // Compute a transcendental math function natively, or call the
 // TranscendentalCache runtime function.
-class TranscendentalCacheStub: public CodeStub {
+class TranscendentalCacheStub: public PlatformCodeStub {
  public:
   enum ArgumentType {
     TAGGED = 0 << TranscendentalCache::kTranscendentalTypeBits,
     UNTAGGED = 1 << TranscendentalCache::kTranscendentalTypeBits
   };
 
   TranscendentalCacheStub(TranscendentalCache::Type type,
                           ArgumentType argument_type)
       : type_(type), argument_type_(argument_type) { }
   void Generate(MacroAssembler* masm);
  private:
   TranscendentalCache::Type type_;
   ArgumentType argument_type_;
   void GenerateCallCFunction(MacroAssembler* masm, Register scratch);
 
   Major MajorKey() { return TranscendentalCache; }
   int MinorKey() { return type_ | argument_type_; }
   Runtime::FunctionId RuntimeFunction();
 };
 
 
-class StoreBufferOverflowStub: public CodeStub {
+class StoreBufferOverflowStub: public PlatformCodeStub {
  public:
   explicit StoreBufferOverflowStub(SaveFPRegsMode save_fp)
       : save_doubles_(save_fp) { }
 
   void Generate(MacroAssembler* masm);
 
   virtual bool IsPregenerated();
   static void GenerateFixedRegStubsAheadOfTime();
   virtual bool SometimesSetsUpAFrame() { return false; }
 
  private:
   SaveFPRegsMode save_doubles_;
 
   Major MajorKey() { return StoreBufferOverflow; }
   int MinorKey() { return (save_doubles_ == kSaveFPRegs) ? 1 : 0; }
 };
 
 
-class UnaryOpStub: public CodeStub {
+class UnaryOpStub: public PlatformCodeStub {
  public:
   UnaryOpStub(Token::Value op,
               UnaryOverwriteMode mode,
               UnaryOpIC::TypeInfo operand_type = UnaryOpIC::UNINITIALIZED)
       : op_(op),
         mode_(mode),
         operand_type_(operand_type) {
   }
 
  private:
@@ skipping 121 matching lines @@
   // Omit left string check in stub (left is definitely a string).
   NO_STRING_CHECK_LEFT_IN_STUB = 1 << 0,
   // Omit right string check in stub (right is definitely a string).
   NO_STRING_CHECK_RIGHT_IN_STUB = 1 << 1,
   // Omit both string checks in stub.
   NO_STRING_CHECK_IN_STUB =
       NO_STRING_CHECK_LEFT_IN_STUB | NO_STRING_CHECK_RIGHT_IN_STUB
 };
 
 
-class StringAddStub: public CodeStub {
+class StringAddStub: public PlatformCodeStub {
  public:
   explicit StringAddStub(StringAddFlags flags) : flags_(flags) {}
 
  private:
   Major MajorKey() { return StringAdd; }
   int MinorKey() { return flags_; }
 
   void Generate(MacroAssembler* masm);
 
   void GenerateConvertArgument(MacroAssembler* masm,
                                int stack_offset,
                                Register arg,
                                Register scratch1,
                                Register scratch2,
                                Register scratch3,
                                Register scratch4,
                                Label* slow);
 
   const StringAddFlags flags_;
 };
 
 
-class SubStringStub: public CodeStub {
+class SubStringStub: public PlatformCodeStub {
  public:
   SubStringStub() {}
 
  private:
   Major MajorKey() { return SubString; }
   int MinorKey() { return 0; }
 
   void Generate(MacroAssembler* masm);
 };
 
 
 
-class StringCompareStub: public CodeStub {
+class StringCompareStub: public PlatformCodeStub {
  public:
   StringCompareStub() { }
 
   // Compares two flat ASCII strings and returns result in r0.
   static void GenerateCompareFlatAsciiStrings(MacroAssembler* masm,
                                               Register left,
                                               Register right,
                                               Register scratch1,
                                               Register scratch2,
                                               Register scratch3,
@@ skipping 19 matching lines @@
                                             Register length,
                                             Register scratch1,
                                             Register scratch2,
                                             Label* chars_not_equal);
 };
 
 
 // This stub can convert a signed int32 to a heap number (double).  It does
 // not work for int32s that are in Smi range!  No GC occurs during this stub
 // so you don't have to set up the frame.
-class WriteInt32ToHeapNumberStub : public CodeStub {
+class WriteInt32ToHeapNumberStub : public PlatformCodeStub {
  public:
   WriteInt32ToHeapNumberStub(Register the_int,
                              Register the_heap_number,
                              Register scratch)
       : the_int_(the_int),
         the_heap_number_(the_heap_number),
         scratch_(scratch) { }
 
   bool IsPregenerated();
   static void GenerateFixedRegStubsAheadOfTime();
@@ skipping 13 matching lines @@
     // Encode the parameters in a unique 16 bit value.
     return IntRegisterBits::encode(the_int_.code())
            | HeapNumberRegisterBits::encode(the_heap_number_.code())
            | ScratchRegisterBits::encode(scratch_.code());
   }
 
   void Generate(MacroAssembler* masm);
 };
 
 
-class NumberToStringStub: public CodeStub {
+class NumberToStringStub: public PlatformCodeStub {
  public:
   NumberToStringStub() { }
 
   // Generate code to do a lookup in the number string cache. If the number in
   // the register object is found in the cache the generated code falls through
   // with the result in the result register. The object and the result register
   // can be the same. If the number is not found in the cache the code jumps to
   // the label not_found with only the content of register object unchanged.
   static void GenerateLookupNumberStringCache(MacroAssembler* masm,
                                               Register object,
                                               Register result,
                                               Register scratch1,
                                               Register scratch2,
                                               Register scratch3,
                                               bool object_is_smi,
                                               Label* not_found);
 
  private:
   Major MajorKey() { return NumberToString; }
   int MinorKey() { return 0; }
 
   void Generate(MacroAssembler* masm);
 };
 
 
-class RecordWriteStub: public CodeStub {
+class RecordWriteStub: public PlatformCodeStub {
  public:
   RecordWriteStub(Register object,
                   Register value,
                   Register address,
                   RememberedSetAction remembered_set_action,
                   SaveFPRegsMode fp_mode)
       : object_(object),
         value_(value),
         address_(address),
         remembered_set_action_(remembered_set_action),
@@ skipping 135 matching lines @@
 
    private:
     Register object_;
     Register address_;
     Register scratch0_;
     Register scratch1_;
 
     Register GetRegThatIsNotOneOf(Register r1,
                                   Register r2,
                                   Register r3) {
-      for (int i = 0; i < Register::kNumAllocatableRegisters; i++) {
+      for (int i = 0; i < Register::NumAllocatableRegisters(); i++) {
         Register candidate = Register::FromAllocationIndex(i);
         if (candidate.is(r1)) continue;
         if (candidate.is(r2)) continue;
         if (candidate.is(r3)) continue;
         return candidate;
       }
       UNREACHABLE();
       return no_reg;
     }
     friend class RecordWriteStub;
@@ skipping 38 matching lines @@
   RememberedSetAction remembered_set_action_;
   SaveFPRegsMode save_fp_regs_mode_;
   Label slow_;
   RegisterAllocation regs_;
 };
 
 
 // Enter C code from generated RegExp code in a way that allows
 // the C code to fix the return address in case of a GC.
 // Currently only needed on ARM.
-class RegExpCEntryStub: public CodeStub {
+class RegExpCEntryStub: public PlatformCodeStub {
  public:
   RegExpCEntryStub() {}
   virtual ~RegExpCEntryStub() {}
   void Generate(MacroAssembler* masm);
 
  private:
   Major MajorKey() { return RegExpCEntry; }
   int MinorKey() { return 0; }
 
   bool NeedsImmovableCode() { return true; }
 };
 
 
 // Trampoline stub to call into native code. To call safely into native code
 // in the presence of compacting GC (which can move code objects) we need to
 // keep the code which called into native pinned in the memory. Currently the
 // simplest approach is to generate such stub early enough so it can never be
 // moved by GC
-class DirectCEntryStub: public CodeStub {
+class DirectCEntryStub: public PlatformCodeStub {
  public:
   DirectCEntryStub() {}
   void Generate(MacroAssembler* masm);
   void GenerateCall(MacroAssembler* masm, ExternalReference function);
   void GenerateCall(MacroAssembler* masm, Register target);
 
  private:
   Major MajorKey() { return DirectCEntry; }
   int MinorKey() { return 0; }
 
@@ skipping 129 matching lines @@
                          DwVfpRegister dst,
                          Register dst1,
                          Register dst2,
                          Register heap_number_map,
                          Register scratch1,
                          Register scratch2,
                          Label* not_number);
 };
 
 
-class StringDictionaryLookupStub: public CodeStub {
+class StringDictionaryLookupStub: public PlatformCodeStub {
  public:
   enum LookupMode { POSITIVE_LOOKUP, NEGATIVE_LOOKUP };
 
   explicit StringDictionaryLookupStub(LookupMode mode) : mode_(mode) { }
 
   void Generate(MacroAssembler* masm);
 
   static void GenerateNegativeLookup(MacroAssembler* masm,
                                      Label* miss,
                                      Label* done,
@@ skipping 32 matching lines @@
 
   class LookupModeBits: public BitField<LookupMode, 0, 1> {};
 
   LookupMode mode_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM_CODE_STUBS_ARM_H_