A64: Synchronize with r17441.

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 12 matching lines @@
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_CODE_STUBS_H_
 #define V8_CODE_STUBS_H_
 
 #include "allocation.h"
 #include "assembler.h"
+#include "codegen.h"
 #include "globals.h"
-#include "codegen.h"
+#include "macro-assembler.h"
 
 namespace v8 {
 namespace internal {
 
 // List of code stubs used on all platforms.
 #define CODE_STUB_LIST_ALL_PLATFORMS(V)  \
   V(CallFunction)                        \
   V(CallConstruct)                       \
   V(BinaryOp)                            \
   V(StringAdd)                           \
@@ skipping 163 matching lines @@
 
   // Returns a name for logging/debugging purposes.
   SmartArrayPointer<const char> GetName();
 
  protected:
   static bool CanUseFPRegisters();
 
   // Generates the assembler code for the stub.
   virtual Handle<Code> GenerateCode(Isolate* isolate) = 0;
 
+  virtual void VerifyPlatformFeatures(Isolate* isolate);
 
   // Returns whether the code generated for this stub needs to be allocated as
   // a fixed (non-moveable) code object.
   virtual bool NeedsImmovableCode() { return false; }
 
   virtual void PrintBaseName(StringStream* stream);
   virtual void PrintState(StringStream* stream) { }
 
  private:
   // Perform bookkeeping required after code generation when stub code is
@@ skipping 50 matching lines @@
   virtual void Generate(MacroAssembler* masm) = 0;
 };
 
 
 enum StubFunctionMode { NOT_JS_FUNCTION_STUB_MODE, JS_FUNCTION_STUB_MODE };
 
 
 struct CodeStubInterfaceDescriptor {
   CodeStubInterfaceDescriptor();
   int register_param_count_;
-  const Register* stack_parameter_count_;
+  Register stack_parameter_count_;
   // if hint_stack_parameter_count_ > 0, the code stub can optimize the
   // return sequence. Default value is -1, which means it is ignored.
   int hint_stack_parameter_count_;
   StubFunctionMode function_mode_;
   Register* register_params_;
   Address deoptimization_handler_;
 
   int environment_length() const {
-    if (stack_parameter_count_ != NULL) {
+    if (stack_parameter_count_.is_valid()) {
       return register_param_count_ + 1;
     }
     return register_param_count_;
   }
 
   bool initialized() const { return register_param_count_ >= 0; }
 
   void SetMissHandler(ExternalReference handler) {
     miss_handler_ = handler;
     has_miss_handler_ = true;
@@ skipping 10 matching lines @@
 
  private:
   ExternalReference miss_handler_;
   bool has_miss_handler_;
 };
 
 // A helper to make up for the fact that type Register is not fully
 // defined outside of the platform directories
 #define DESCRIPTOR_GET_PARAMETER_REGISTER(descriptor, index) \
   ((index) == (descriptor)->register_param_count_)           \
-      ? *((descriptor)->stack_parameter_count_)              \
+      ? (descriptor)->stack_parameter_count_                 \
       : (descriptor)->register_params_[(index)]
 
 
 class HydrogenCodeStub : public CodeStub {
  public:
   enum InitializationState {
     UNINITIALIZED,
     INITIALIZED
   };
 
@@ skipping 63 matching lines @@
 // TODO(bmeurer): Move to the StringAddStub declaration once we're
 // done with the translation to a hydrogen code stub.
 enum StringAddFlags {
   // Omit both parameter checks.
   STRING_ADD_CHECK_NONE = 0,
   // Check left parameter.
   STRING_ADD_CHECK_LEFT = 1 << 0,
   // Check right parameter.
   STRING_ADD_CHECK_RIGHT = 1 << 1,
   // Check both parameters.
-  STRING_ADD_CHECK_BOTH = STRING_ADD_CHECK_LEFT | STRING_ADD_CHECK_RIGHT,
-  // Stub needs a frame before calling the runtime
-  STRING_ADD_ERECT_FRAME = 1 << 2
+  STRING_ADD_CHECK_BOTH = STRING_ADD_CHECK_LEFT | STRING_ADD_CHECK_RIGHT
 };
 
 } }  // 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"
@@ skipping 51 matching lines @@
 class NumberToStringStub V8_FINAL : public HydrogenCodeStub {
  public:
   NumberToStringStub() {}
 
   virtual Handle<Code> GenerateCode(Isolate* isolate) V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       Isolate* isolate,
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
+  static void InstallDescriptors(Isolate* isolate);
+
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kNumber = 0;
 
  private:
   virtual Major MajorKey() V8_OVERRIDE { return NumberToString; }
   virtual int NotMissMinorKey() V8_OVERRIDE { return 0; }
 };
 
 
 class FastNewClosureStub : public HydrogenCodeStub {
@@ skipping 548 matching lines @@
 
   virtual Code::Kind GetCodeKind() const { return Code::BINARY_OP_IC; }
   virtual InlineCacheState GetICState() {
     if (Max(left_state_, right_state_) == NONE) {
       return ::v8::internal::UNINITIALIZED;
     }
     if (Max(left_state_, right_state_) == GENERIC) return MEGAMORPHIC;
     return MONOMORPHIC;
   }
 
+  virtual void VerifyPlatformFeatures(Isolate* isolate) V8_OVERRIDE {
+    ASSERT(CpuFeatures::VerifyCrossCompiling(SSE2));
+  }
+
   virtual Code::ExtraICState GetExtraICState() {
     bool sse_field = Max(result_state_, Max(left_state_, right_state_)) > SMI &&
                      CpuFeatures::IsSafeForSnapshot(SSE2);
 
     return OpBits::encode(encode_token(op_))
          | LeftStateField::encode(left_state_)
          | RightStateField::encode(fixed_right_arg_.has_value
                                        ? NONE : right_state_)
          | ResultStateField::encode(result_state_)
          | HasFixedRightArgBits::encode(fixed_right_arg_.has_value)
@@ skipping 285 matching lines @@
 
   void Generate(MacroAssembler* masm);
 
   // The version of this stub that doesn't save doubles is generated ahead of
   // time, so it's OK to call it from other stubs that can't cope with GC during
   // their code generation.  On machines that always have gp registers (x64) we
   // can generate both variants ahead of time.
   virtual bool IsPregenerated(Isolate* isolate) V8_OVERRIDE;
   static void GenerateAheadOfTime(Isolate* isolate);
 
+ protected:
+  virtual void VerifyPlatformFeatures(Isolate* isolate) V8_OVERRIDE {
+    ASSERT(CpuFeatures::VerifyCrossCompiling(SSE2));
+  };
+
  private:
   void GenerateCore(MacroAssembler* masm,
                     Label* throw_normal_exception,
                     Label* throw_termination_exception,
                     Label* throw_out_of_memory_exception,
                     bool do_gc,
                     bool always_allocate_scope);
 
   // Number of pointers/values returned.
   Isolate* isolate_;
@@ skipping 422 matching lines @@
   }
 
   int offset() {
     return OffsetBits::decode(bit_field_);
   }
 
   void Generate(MacroAssembler* masm);
 
   virtual bool SometimesSetsUpAFrame() { return false; }
 
+ protected:
+  virtual void VerifyPlatformFeatures(Isolate* isolate) V8_OVERRIDE {
+    ASSERT(CpuFeatures::VerifyCrossCompiling(SSE2));
+  }
+
  private:
   static const int kBitsPerRegisterNumber = 6;
   STATIC_ASSERT((1L << kBitsPerRegisterNumber) >= Register::kNumRegisters);
   class SourceRegisterBits:
       public BitField<int, 0, kBitsPerRegisterNumber> {};  // NOLINT
   class DestinationRegisterBits:
       public BitField<int, kBitsPerRegisterNumber,
         kBitsPerRegisterNumber> {};  // NOLINT
   class IsTruncatingBits:
       public BitField<bool, 2 * kBitsPerRegisterNumber, 1> {};  // NOLINT
@@ skipping 562 matching lines @@
   int MinorKey() { return 0; }
 
   void Generate(MacroAssembler* masm);
 
   DISALLOW_COPY_AND_ASSIGN(ProfileEntryHookStub);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_