Removed useless implementations of GetName and Print for code stubs, the common

src/code-stubs.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 171 matching lines @@
     return UNINITIALIZED;
   }
 
   // Returns a name for logging/debugging purposes.
   virtual const char* GetName() { return MajorName(MajorKey(), false); }
 
   // Returns whether the code generated for this stub needs to be allocated as
   // a fixed (non-moveable) code object.
   virtual bool NeedsImmovableCode() { return false; }
 
-  #ifdef DEBUG
+#ifdef DEBUG
   virtual void Print() { PrintF("%s\n", GetName()); }
 #endif
 
   // Computes the key based on major and minor.
   uint32_t GetKey() {
     ASSERT(static_cast<int>(MajorKey()) < NUMBER_OF_IDS);
     return MinorKeyBits::encode(MinorKey()) |
            MajorKeyBits::encode(MajorKey());
   }
 
@@ skipping 64 matching lines @@
 };
 
 
 class StackCheckStub : public CodeStub {
  public:
   StackCheckStub() { }
 
   void Generate(MacroAssembler* masm);
 
  private:
-  const char* GetName() { return "StackCheckStub"; }
-
   Major MajorKey() { return StackCheck; }
   int MinorKey() { return 0; }
 };
 
 
 class ToNumberStub: public CodeStub {
  public:
   ToNumberStub() { }
 
   void Generate(MacroAssembler* masm);
 
  private:
   Major MajorKey() { return ToNumber; }
   int MinorKey() { return 0; }
-  const char* GetName() { return "ToNumberStub"; }
 };
 
 
 class FastNewClosureStub : public CodeStub {
  public:
   explicit FastNewClosureStub(StrictModeFlag strict_mode)
     : strict_mode_(strict_mode) { }
 
   void Generate(MacroAssembler* masm);
 
  private:
-  const char* GetName() { return "FastNewClosureStub"; }
   Major MajorKey() { return FastNewClosure; }
   int MinorKey() { return strict_mode_; }
 
   StrictModeFlag strict_mode_;
 };
 
 
 class FastNewContextStub : public CodeStub {
  public:
   static const int kMaximumSlots = 64;
 
   explicit FastNewContextStub(int slots) : slots_(slots) {
     ASSERT(slots_ > 0 && slots <= kMaximumSlots);
   }
 
   void Generate(MacroAssembler* masm);
 
  private:
   int slots_;
 
-  const char* GetName() { return "FastNewContextStub"; }
   Major MajorKey() { return FastNewContext; }
   int MinorKey() { return slots_; }
 };
 
 
 class FastCloneShallowArrayStub : public CodeStub {
  public:
   // Maximum length of copied elements array.
   static const int kMaximumClonedLength = 8;
 
   enum Mode {
     CLONE_ELEMENTS,
     COPY_ON_WRITE_ELEMENTS
   };
 
   FastCloneShallowArrayStub(Mode mode, int length)
       : mode_(mode),
         length_((mode == COPY_ON_WRITE_ELEMENTS) ? 0 : length) {
     ASSERT(length_ >= 0);
     ASSERT(length_ <= kMaximumClonedLength);
   }
 
   void Generate(MacroAssembler* masm);
 
  private:
   Mode mode_;
   int length_;
 
-  const char* GetName() { return "FastCloneShallowArrayStub"; }
   Major MajorKey() { return FastCloneShallowArray; }
   int MinorKey() {
     ASSERT(mode_ == 0 || mode_ == 1);
     return (length_ << 1) | mode_;
   }
 };
 
 
 class InstanceofStub: public CodeStub {
  public:
@@ skipping 20 matching lines @@
   }
 
   bool HasCallSiteInlineCheck() const {
     return (flags_ & kCallSiteInlineCheck) != 0;
   }
 
   bool ReturnTrueFalseObject() const {
     return (flags_ & kReturnTrueFalseObject) != 0;
   }
 
-  const char* GetName();
+  virtual const char* GetName();
 
   Flags flags_;
   char* name_;
 };
 
 
 class MathPowStub: public CodeStub {
  public:
   MathPowStub() {}
   virtual void Generate(MacroAssembler* masm);
 
  private:
   virtual CodeStub::Major MajorKey() { return MathPow; }
   virtual int MinorKey() { return 0; }
-
-  const char* GetName() { return "MathPowStub"; }
 };
 
 
 class ICCompareStub: public CodeStub {
  public:
   ICCompareStub(Token::Value op, CompareIC::State state)
       : op_(op), state_(state) {
     ASSERT(Token::IsCompareOp(op));
   }
 
@@ skipping 114 matching lines @@
 
   // Branch to the label if the given object isn't a symbol.
   void BranchIfNonSymbol(MacroAssembler* masm,
                          Label* label,
                          Register object,
                          Register scratch);
 
   // Unfortunately you have to run without snapshots to see most of these
   // names in the profile since most compare stubs end up in the snapshot.
   char* name_;
-  const char* GetName();
+  virtual const char* GetName();
 #ifdef DEBUG
   void Print() {
     PrintF("CompareStub (minor %d) (cc %d), (strict %s), "
            "(never_nan_nan %s), (smi_compare %s) (number_compare %s) ",
            MinorKey(),
            static_cast<int>(cc_),
            strict_ ? "true" : "false",
            never_nan_nan_ ? "true" : "false",
            include_smi_compare_ ? "inluded" : "not included",
            include_number_compare_ ? "included" : "not included");
@@ skipping 28 matching lines @@
                                 UncatchableExceptionType type);
 
   // Number of pointers/values returned.
   const int result_size_;
   bool save_doubles_;
 
   Major MajorKey() { return CEntry; }
   int MinorKey();
 
   bool NeedsImmovableCode();
-
-  const char* GetName() { return "CEntryStub"; }
 };
 
 
 class JSEntryStub : public CodeStub {
  public:
   JSEntryStub() { }
 
   void Generate(MacroAssembler* masm) { GenerateBody(masm, false); }
 
  protected:
   void GenerateBody(MacroAssembler* masm, bool is_construct);
 
  private:
   Major MajorKey() { return JSEntry; }
   int MinorKey() { return 0; }
-
-  const char* GetName() { return "JSEntryStub"; }
 };
 
 
 class JSConstructEntryStub : public JSEntryStub {
  public:
   JSConstructEntryStub() { }
 
   void Generate(MacroAssembler* masm) { GenerateBody(masm, true); }
 
  private:
   int MinorKey() { return 1; }
 
-  const char* GetName() { return "JSConstructEntryStub"; }
+  virtual const char* GetName() { return "JSConstructEntryStub"; }
 };
 
 
 class ArgumentsAccessStub: public CodeStub {
  public:
   enum Type {
     READ_ELEMENT,
     NEW_NON_STRICT_FAST,
     NEW_NON_STRICT_SLOW,
     NEW_STRICT
   };
 
   explicit ArgumentsAccessStub(Type type) : type_(type) { }
 
  private:
   Type type_;
 
   Major MajorKey() { return ArgumentsAccess; }
   int MinorKey() { return type_; }
 
   void Generate(MacroAssembler* masm);
   void GenerateReadElement(MacroAssembler* masm);
   void GenerateNewStrict(MacroAssembler* masm);
   void GenerateNewNonStrictFast(MacroAssembler* masm);
   void GenerateNewNonStrictSlow(MacroAssembler* masm);
 
-  const char* GetName() { return "ArgumentsAccessStub"; }
-
 #ifdef DEBUG
   void Print() {
     PrintF("ArgumentsAccessStub (type %d)\n", type_);
   }
 #endif
 };
 
 
 class RegExpExecStub: public CodeStub {
  public:
   RegExpExecStub() { }
 
  private:
   Major MajorKey() { return RegExpExec; }
   int MinorKey() { return 0; }
 
   void Generate(MacroAssembler* masm);
-
-  const char* GetName() { return "RegExpExecStub"; }
-
-#ifdef DEBUG
-  void Print() {
-    PrintF("RegExpExecStub\n");
-  }
-#endif
 };
 
 
 class RegExpConstructResultStub: public CodeStub {
  public:
   RegExpConstructResultStub() { }
 
  private:
   Major MajorKey() { return RegExpConstructResult; }
   int MinorKey() { return 0; }
 
   void Generate(MacroAssembler* masm);
-
-  const char* GetName() { return "RegExpConstructResultStub"; }
-
-#ifdef DEBUG
-  void Print() {
-    PrintF("RegExpConstructResultStub\n");
-  }
-#endif
 };
 
 
 class CallFunctionStub: public CodeStub {
  public:
   CallFunctionStub(int argc, InLoopFlag in_loop, CallFunctionFlags flags)
       : argc_(argc), in_loop_(in_loop), flags_(flags) { }
 
   void Generate(MacroAssembler* masm);
 
@@ skipping 203 matching lines @@
     masm_->set_allow_stub_calls(previous_allow_);
   }
 
  private:
   MacroAssembler* masm_;
   bool previous_allow_;
 
   DISALLOW_COPY_AND_ASSIGN(AllowStubCallsScope);
 };
 
-#ifdef DEBUG
-#define DECLARE_ARRAY_STUB_PRINT(name) void Print() { PrintF(#name); }
-#else
-#define DECLARE_ARRAY_STUB_PRINT(name)
-#endif
-
 
 class KeyedLoadFastElementStub : public CodeStub {
  public:
   explicit KeyedLoadFastElementStub() {
   }
 
   Major MajorKey() { return KeyedLoadFastElement; }
   int MinorKey() { return 0; }
 
   void Generate(MacroAssembler* masm);
-
-  const char* GetName() { return "KeyedLoadFastElementStub"; }
-
-  DECLARE_ARRAY_STUB_PRINT(KeyedLoadFastElementStub)
 };
 
 
 class KeyedStoreFastElementStub : public CodeStub {
  public:
   explicit KeyedStoreFastElementStub(bool is_js_array)
       : is_js_array_(is_js_array) { }
 
   Major MajorKey() { return KeyedStoreFastElement; }
   int MinorKey() { return is_js_array_ ? 1 : 0; }
 
   void Generate(MacroAssembler* masm);
 
-  const char* GetName() { return "KeyedStoreFastElementStub"; }
-
-  DECLARE_ARRAY_STUB_PRINT(KeyedStoreFastElementStub)
-
  private:
   bool is_js_array_;
 };
 
 
 class KeyedLoadExternalArrayStub : public CodeStub {
  public:
   explicit KeyedLoadExternalArrayStub(JSObject::ElementsKind elements_kind)
       : elements_kind_(elements_kind) { }
 
   Major MajorKey() { return KeyedLoadExternalArray; }
   int MinorKey() { return elements_kind_; }
 
   void Generate(MacroAssembler* masm);
 
-  const char* GetName() { return "KeyedLoadExternalArrayStub"; }
-
-  DECLARE_ARRAY_STUB_PRINT(KeyedLoadExternalArrayStub)
-
  protected:
   JSObject::ElementsKind elements_kind_;
 };
 
 
 class KeyedStoreExternalArrayStub : public CodeStub {
  public:
   explicit KeyedStoreExternalArrayStub(JSObject::ElementsKind elements_kind)
       : elements_kind_(elements_kind) { }
 
   Major MajorKey() { return KeyedStoreExternalArray; }
   int MinorKey() { return elements_kind_; }
 
   void Generate(MacroAssembler* masm);
 
-  const char* GetName() { return "KeyedStoreExternalArrayStub"; }
-
-  DECLARE_ARRAY_STUB_PRINT(KeyedStoreExternalArrayStub)
-
  protected:
   JSObject::ElementsKind elements_kind_;
 };
 
 
 class ToBooleanStub: public CodeStub {
  public:
   explicit ToBooleanStub(Register tos) : tos_(tos) { }
 
   void Generate(MacroAssembler* masm);
 
  private:
   Register tos_;
   Major MajorKey() { return ToBoolean; }
   int MinorKey() { return tos_.code(); }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_