Implement Object.prototype.hasOwnProperty in generated code.

src/ia32/code-stubs-ia32.h

 // Copyright 2010 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 359 matching lines @@
                                               Register scratch3);
 
   // Compares two flat ASCII strings for equality and returns result
   // in eax.
   static void GenerateFlatAsciiStringEquals(MacroAssembler* masm,
                                             Register left,
                                             Register right,
                                             Register scratch1,
                                             Register scratch2);
 
+  static void GenerateFlatAsciiStringEquals(MacroAssembler* masm,
+                                            Register left,
+                                            Register right,
+                                            Register scratch1,
+                                            Register scratch2,
+                                            Label* strings_not_equal);
+
  private:
   virtual Major MajorKey() { return StringCompare; }
   virtual int MinorKey() { return 0; }
   virtual void Generate(MacroAssembler* masm);
 
   static void GenerateAsciiCharsCompareLoop(
       MacroAssembler* masm,
       Register left,
       Register right,
       Register length,
@@ skipping 49 matching lines @@
       Register r0);
 
   static void GeneratePositiveLookup(MacroAssembler* masm,
                                      Label* miss,
                                      Label* done,
                                      Register elements,
                                      Register name,
                                      Register r0,
                                      Register r1);
 
+  static void GenerateLookupWithComparisons(MacroAssembler* masm,
+                                            Register dictionary,
+                                            Register name,
+                                            Register scratch1,
+                                            Register scratch2,
+                                            Register scratch3,
+                                            Label* found_in_dictionary,
+                                            Label* not_found_in_dictionary,
+                                            Label* call_runtime);
+
  private:
   static const int kInlinedProbes = 4;
   static const int kTotalProbes = 20;
 
   static const int kCapacityOffset =
       StringDictionary::kHeaderSize +
       StringDictionary::kCapacityIndex * kPointerSize;
 
   static const int kElementsStartOffset =
       StringDictionary::kHeaderSize +
       StringDictionary::kElementsStartIndex * kPointerSize;
 
+  enum NameType {
+    NAME_IS_ASCII_STRING_WITH_HASH,
+    NAME_IS_ASCII_SYMBOL
+  };
+
   Major MajorKey() { return StringDictionaryNegativeLookup; }
 
   int MinorKey() {
     return DictionaryBits::encode(dictionary_.code()) |
         ResultBits::encode(result_.code()) |
         IndexBits::encode(index_.code()) |
         LookupModeBits::encode(mode_);
   }
 
+  static void GenerateUnrolledComparisons(MacroAssembler* masm,
+                                          NameType name_type,
+                                          Register dictionary,
+                                          Register name,
+                                          Register scratch1,
+                                          Register scratch2,
+                                          Register scratch3,
+                                          Label* found_in_dictionary,
+                                          Label* not_found_in_dictionary,
+                                          Label* call_runtime);
+
   class DictionaryBits: public BitField<int, 0, 3> {};
   class ResultBits: public BitField<int, 3, 3> {};
   class IndexBits: public BitField<int, 6, 3> {};
   class LookupModeBits: public BitField<LookupMode, 9, 1> {};
 
   Register dictionary_;
   Register result_;
   Register index_;
   LookupMode mode_;
 };
 
 
+class HasOwnPropertyStub: public CodeStub {
+ public:
+  HasOwnPropertyStub() {}
+
+  virtual void Generate(MacroAssembler* masm);
+  virtual Major MajorKey() { return HasOwnProperty; }
+  virtual int MinorKey() { return 0; }
+
+ private:
+  enum NameType {
+    NAME_IS_SYMBOL,
+    NAME_IS_SEQUENTIAL_ASCII
+  };
+
+  void GenerateFastPropertiesCase(MacroAssembler* masm,
+                                  Register map,
+                                  Register name,
+                                  Register scratch1,
+                                  Register scratch2,
+                                  Register scratch3,
+                                  Label* call_runtime);
+
+  void GenerateSlowPropertiesCase(MacroAssembler* masm,
+                                  Register object,
+                                  Register name,
+                                  Register scratch1,
+                                  Register scratch2,
+                                  Register scratch3,
+                                  Label* call_runtime);
+
+  // Generates a lookup in the descriptor array. Generated code
+  // returns true if the property is found, jumps to the given label

[Mads Ager (chromium), 2011/07/15 09:04:45]

the given label -> the not_found_in_descriptors label?

+  // otherwise.
+  void GenerateDescriptorArrayLookup(MacroAssembler* masm,
+                                     NameType name_type,
+                                     Register descriptor_array,
+                                     Register name,
+                                     Register scratch1,
+                                     Register scratch2,
+                                     Register scratch3,
+                                     Label* not_found_in_descriptors,
+                                     Label* call_runtime);
+
+  DISALLOW_COPY_AND_ASSIGN(HasOwnPropertyStub);
+};
+
 } }  // namespace v8::internal
 
 #endif  // V8_IA32_CODE_STUBS_IA32_H_