Enable stub generation using Hydrogen/Lithium (again)

src/ia32/code-stubs-ia32.h

 // Copyright 2011 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 20 matching lines @@
 #include "macro-assembler.h"
 #include "code-stubs.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,
     UNTAGGED = 1 << TranscendentalCache::kTranscendentalTypeBits
   };
 
   TranscendentalCacheStub(TranscendentalCache::Type type,
                           ArgumentType argument_type)
       : type_(type), argument_type_(argument_type) {}
   void Generate(MacroAssembler* masm);
   static void GenerateOperation(MacroAssembler* masm,
                                 TranscendentalCache::Type type);
  private:
   TranscendentalCache::Type type_;
   ArgumentType argument_type_;
 
   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() { return true; }
   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 53 matching lines @@
   virtual InlineCacheState GetICState() {
     return UnaryOpIC::ToState(operand_type_);
   }
 
   virtual void FinishCode(Handle<Code> code) {
     code->set_unary_op_type(operand_type_);
   }
 };
 
 
-class BinaryOpStub: public CodeStub {
+class BinaryOpStub: public PlatformCodeStub {
  public:
   BinaryOpStub(Token::Value op, OverwriteMode mode)
       : op_(op),
         mode_(mode),
         operands_type_(BinaryOpIC::UNINITIALIZED),
         result_type_(BinaryOpIC::UNINITIALIZED) {
     use_sse3_ = CpuFeatures::IsSupported(SSE3);
     ASSERT(OpBits::is_valid(Token::NUM_TOKENS));
   }
 
@@ skipping 140 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,
                                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 eax.
   static void GenerateCompareFlatAsciiStrings(MacroAssembler* masm,
                                               Register left,
                                               Register right,
                                               Register scratch1,
                                               Register scratch2,
                                               Register scratch3);
@@ skipping 15 matching lines @@
       MacroAssembler* masm,
       Register left,
       Register right,
       Register length,
       Register scratch,
       Label* chars_not_equal,
       Label::Distance chars_not_equal_near = Label::kFar);
 };
 
 
-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,
                                               bool object_is_smi,
                                               Label* not_found);
 
  private:
   Major MajorKey() { return NumberToString; }
   int MinorKey() { return 0; }
 
   void Generate(MacroAssembler* masm);
 };
 
 
-class StringDictionaryLookupStub: public CodeStub {
+class StringDictionaryLookupStub: public PlatformCodeStub {
  public:
   enum LookupMode { POSITIVE_LOOKUP, NEGATIVE_LOOKUP };
 
   StringDictionaryLookupStub(Register dictionary,
                              Register result,
                              Register index,
                              LookupMode mode)
       : dictionary_(dictionary), result_(result), index_(index), mode_(mode) { }
 
   void Generate(MacroAssembler* masm);
@@ skipping 41 matching lines @@
   class IndexBits: public BitField<int, 6, 3> {};
   class LookupModeBits: public BitField<LookupMode, 9, 1> {};
 
   Register dictionary_;
   Register result_;
   Register index_;
   LookupMode mode_;
 };
 
 
-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 182 matching lines @@
     Register scratch0_orig_;
     Register object_;
     Register address_;
     Register scratch0_;
     Register scratch1_;
     // Third scratch register is always ecx.
 
     Register GetRegThatIsNotEcxOr(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(ecx)) continue;
         if (candidate.is(r1)) continue;
         if (candidate.is(r2)) continue;
         if (candidate.is(r3)) continue;
         return candidate;
       }
       UNREACHABLE();
       return no_reg;
     }
@@ skipping 38 matching lines @@
   Register address_;
   RememberedSetAction remembered_set_action_;
   SaveFPRegsMode save_fp_regs_mode_;
   RegisterAllocation regs_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_IA32_CODE_STUBS_IA32_H_