Reset trunk to 3.24.35.4

src/code-stubs.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 83 matching lines @@
   V(InternalArrayConstructor)            \
   V(ProfileEntryHook)                    \
   V(StoreGlobal)                         \
   V(CallApiFunction)                     \
   V(CallApiGetter)                       \
   /* IC Handler stubs */                 \
   V(LoadField)                           \
   V(KeyedLoadField)
 
 // List of code stubs only used on ARM platforms.
-#if defined(V8_TARGET_ARCH_ARM) || defined(V8_TARGET_ARCH_A64)
+#if V8_TARGET_ARCH_ARM
 #define CODE_STUB_LIST_ARM(V)  \
   V(GetProperty)               \
   V(SetProperty)               \
   V(InvokeBuiltin)             \
   V(DirectCEntry)
 #else
 #define CODE_STUB_LIST_ARM(V)
 #endif
 
 // List of code stubs only used on MIPS platforms.
@@ skipping 66 matching lines @@
 
   virtual InlineCacheState GetICState() {
     return UNINITIALIZED;
   }
   virtual ExtraICState GetExtraICState() {
     return kNoExtraICState;
   }
   virtual Code::StubType GetStubType() {
     return Code::NORMAL;
   }
+  virtual int GetStubFlags() {
+    return -1;
+  }
 
   virtual void PrintName(StringStream* stream);
 
   // Returns a name for logging/debugging purposes.
   SmartArrayPointer<const char> GetName();
 
  protected:
   static bool CanUseFPRegisters();
 
   // Generates the assembler code for the stub.
@@ skipping 231 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(RuntimeCallHelper);
 };
 
 
 } }  // namespace v8::internal
 
 #if V8_TARGET_ARCH_IA32
 #include "ia32/code-stubs-ia32.h"
 #elif V8_TARGET_ARCH_X64
 #include "x64/code-stubs-x64.h"
-#elif V8_TARGET_ARCH_A64
-#include "a64/code-stubs-a64.h"
 #elif V8_TARGET_ARCH_ARM
 #include "arm/code-stubs-arm.h"
 #elif V8_TARGET_ARCH_MIPS
 #include "mips/code-stubs-mips.h"
 #else
 #error Unsupported target architecture.
 #endif
 
 namespace v8 {
 namespace internal {
@@ skipping 25 matching lines @@
 class ToNumberStub: public HydrogenCodeStub {
  public:
   ToNumberStub() { }
 
   virtual Handle<Code> GenerateCode(Isolate* isolate);
 
   virtual void InitializeInterfaceDescriptor(
       Isolate* isolate,
       CodeStubInterfaceDescriptor* descriptor);
 
-  static void InstallDescriptors(Isolate* isolate) {
-    ToNumberStub stub;
-    stub.InitializeInterfaceDescriptor(
-        isolate,
-        isolate->code_stub_interface_descriptor(CodeStub::ToNumber));
-  }
-
  private:
   Major MajorKey() { return ToNumber; }
   int NotMissMinorKey() { return 0; }
 };
 
 
 class NumberToStringStub V8_FINAL : public HydrogenCodeStub {
  public:
   NumberToStringStub() {}
 
@@ skipping 118 matching lines @@
     UNREACHABLE();
     return LAST_ELEMENTS_KIND;
   }
 
   virtual Handle<Code> GenerateCode(Isolate* isolate);
 
   virtual void InitializeInterfaceDescriptor(
       Isolate* isolate,
       CodeStubInterfaceDescriptor* descriptor);
 
-  static void InstallDescriptors(Isolate* isolate);
-
  private:
   Mode mode_;
   AllocationSiteMode allocation_site_mode_;
   int length_;
 
   class AllocationSiteModeBits: public BitField<AllocationSiteMode, 0, 1> {};
   class ModeBits: public BitField<Mode, 1, 4> {};
   class LengthBits: public BitField<int, 5, 4> {};
   // Ensure data fits within available bits.
   STATIC_ASSERT(LAST_ALLOCATION_SITE_MODE == 1);
@@ skipping 238 matching lines @@
 
  protected:
   class KindBits: public BitField<Code::Kind, 0, 4> {};
   virtual Code::Kind kind() const = 0;
 };
 
 
 class HandlerStub: public HICStub {
  public:
   virtual Code::Kind GetCodeKind() const { return Code::HANDLER; }
-  virtual ExtraICState GetExtraICState() { return kind(); }
+  virtual int GetStubFlags() { return kind(); }
 
  protected:
   HandlerStub() : HICStub() { }
   virtual int NotMissMinorKey() { return bit_field_; }
   int bit_field_;
 };
 
 
 class LoadFieldStub: public HandlerStub {
  public:
@@ skipping 75 matching lines @@
   }
 
   virtual Code::Kind kind() const { return Code::STORE_IC; }
 
   virtual Handle<Code> GenerateCode(Isolate* isolate);
 
   virtual void InitializeInterfaceDescriptor(
       Isolate* isolate,
       CodeStubInterfaceDescriptor* descriptor);
 
+  virtual ExtraICState GetExtraICState() { return bit_field_; }
+
   bool is_constant() {
     return IsConstantBits::decode(bit_field_);
   }
   void set_is_constant(bool value) {
     bit_field_ = IsConstantBits::update(bit_field_, value);
   }
 
   Representation representation() {
     return Representation::FromKind(RepresentationBits::decode(bit_field_));
   }
   void set_representation(Representation r) {
     bit_field_ = RepresentationBits::update(bit_field_, r.kind());
   }
 
  private:
+  virtual int NotMissMinorKey() { return GetExtraICState(); }
   Major MajorKey() { return StoreGlobal; }
 
   class IsConstantBits: public BitField<bool, 0, 1> {};
   class RepresentationBits: public BitField<Representation::Kind, 1, 8> {};
 
+  int bit_field_;
+
   DISALLOW_COPY_AND_ASSIGN(StoreGlobalStub);
 };
 
 
 class CallApiFunctionStub : public PlatformCodeStub {
  public:
-  CallApiFunctionStub(bool is_store,
+  CallApiFunctionStub(bool restore_context,
                       bool call_data_undefined,
                       int argc) {
     bit_field_ =
-        IsStoreBits::encode(is_store) |
+        RestoreContextBits::encode(restore_context) |
         CallDataUndefinedBits::encode(call_data_undefined) |
         ArgumentBits::encode(argc);
-    ASSERT(!is_store || argc == 1);
   }
 
  private:
   virtual void Generate(MacroAssembler* masm) V8_OVERRIDE;
   virtual Major MajorKey() V8_OVERRIDE { return CallApiFunction; }
   virtual int MinorKey() V8_OVERRIDE { return bit_field_; }
 
-  class IsStoreBits: public BitField<bool, 0, 1> {};
+  class RestoreContextBits: public BitField<bool, 0, 1> {};
   class CallDataUndefinedBits: public BitField<bool, 1, 1> {};
   class ArgumentBits: public BitField<int, 2, Code::kArgumentsBits> {};
 
   int bit_field_;
 
   DISALLOW_COPY_AND_ASSIGN(CallApiFunctionStub);
 };
 
 
 class CallApiGetterStub : public PlatformCodeStub {
@@ skipping 323 matching lines @@
 
   static Handle<Code> GetUninitialized(Isolate* isolate,
                                        NilValue nil) {
     return CompareNilICStub(nil, UNINITIALIZED).GetCode(isolate);
   }
 
   virtual void InitializeInterfaceDescriptor(
       Isolate* isolate,
       CodeStubInterfaceDescriptor* descriptor);
 
-  static void InstallDescriptors(Isolate* isolate) {
+  static void InitializeForIsolate(Isolate* isolate) {
     CompareNilICStub compare_stub(kNullValue, UNINITIALIZED);
     compare_stub.InitializeInterfaceDescriptor(
         isolate,
         isolate->code_stub_interface_descriptor(CodeStub::CompareNilIC));
   }
 
   virtual InlineCacheState GetICState() {
     if (state_.Contains(GENERIC)) {
       return MEGAMORPHIC;
     } else if (state_.Contains(MONOMORPHIC_MAP)) {
@@ skipping 477 matching lines @@
 };
 
 
 class DoubleToIStub : public PlatformCodeStub {
  public:
   DoubleToIStub(Register source,
                 Register destination,
                 int offset,
                 bool is_truncating,
                 bool skip_fastpath = false) : bit_field_(0) {
-    bit_field_ = SourceRegisterBits::encode(source.code()) |
-      DestinationRegisterBits::encode(destination.code()) |
+    bit_field_ = SourceRegisterBits::encode(source.code_) |
+      DestinationRegisterBits::encode(destination.code_) |
       OffsetBits::encode(offset) |
       IsTruncatingBits::encode(is_truncating) |
       SkipFastPathBits::encode(skip_fastpath) |
       SSEBits::encode(CpuFeatures::IsSafeForSnapshot(SSE2) ?
-                      CpuFeatures::IsSafeForSnapshot(SSE3) ? 2 : 1 : 0);
+                          CpuFeatures::IsSafeForSnapshot(SSE3) ? 2 : 1 : 0);
   }
 
   Register source() {
-    return Register::from_code(SourceRegisterBits::decode(bit_field_));
+    Register result = { SourceRegisterBits::decode(bit_field_) };
+    return result;
   }
 
   Register destination() {
-    return Register::from_code(DestinationRegisterBits::decode(bit_field_));
+    Register result = { DestinationRegisterBits::decode(bit_field_) };
+    return result;
   }
 
   bool is_truncating() {
     return IsTruncatingBits::decode(bit_field_);
   }
 
   bool skip_fastpath() {
     return SkipFastPathBits::decode(bit_field_);
   }
 
@@ skipping 424 matching lines @@
   virtual Handle<Code> GenerateCode(Isolate* isolate);
   virtual void InitializeInterfaceDescriptor(
       Isolate* isolate,
       CodeStubInterfaceDescriptor* descriptor);
 
   virtual Code::Kind GetCodeKind() const { return Code::TO_BOOLEAN_IC; }
   virtual void PrintState(StringStream* stream);
 
   virtual bool SometimesSetsUpAFrame() { return false; }
 
-  static void InstallDescriptors(Isolate* isolate) {
+  static void InitializeForIsolate(Isolate* isolate) {
     ToBooleanStub stub;
     stub.InitializeInterfaceDescriptor(
         isolate,
         isolate->code_stub_interface_descriptor(CodeStub::ToBoolean));
   }
 
   static Handle<Code> GetUninitialized(Isolate* isolate) {
     return ToBooleanStub(UNINITIALIZED).GetCode(isolate);
   }
 
@@ skipping 135 matching lines @@
 
 
 class CallDescriptors {
  public:
   static void InitializeForIsolate(Isolate* isolate);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_