CSE2410 Fall 2014 Bounce

#define INSTANCE_TYPE_LIST(V)                                                  \

  V(CONSTANT_POOL_ARRAY_TYPE)                                                  \

  CONSTANT_POOL_ARRAY_TYPE,

class AllocationSite;

class AllocationSiteContext;

  V(ConstantPoolArray)                         \

  V(ObjectHashTable)                           \

  V(WeakHashTable)

  V(kNativeFunctionLiteral, "Native function literal")                        \

                                            Representation representation);

  // TODO(yangguo): this should eventually replace the non-handlified version.

  static Handle<Object> GetPropertyWithReceiver(Handle<Object> object,

                                                Handle<Object> receiver,

                                                Handle<Name> name,

                                                PropertyAttributes* attributes);

  // Implementation of [[Put]], ECMA-262 5th edition, section 8.12.5.

                                    StrictModeFlag strict_mode,

                                    StoreFromKeyed store_mode =

                                        MAY_BE_STORE_FROM_KEYED);

  // Implementation of [[HasProperty]], ECMA-262 5th edition, section 8.12.6.

  static inline bool HasProperty(Handle<JSReceiver> object, Handle<Name> name);

  static inline bool HasLocalProperty(Handle<JSReceiver>, Handle<Name> name);

  static inline bool HasElement(Handle<JSReceiver> object, uint32_t index);

  static inline bool HasLocalElement(Handle<JSReceiver> object, uint32_t index);

  // Implementation of [[Delete]], ECMA-262 5th edition, section 8.12.7.

  static Handle<Object> SetPropertyWithDefinedSetter(Handle<JSReceiver> object,

                                                     Handle<JSReceiver> setter,

                                                     Handle<Object> value);

  static Handle<Object> SetProperty(Handle<JSReceiver> receiver,

                                    LookupResult* result,

                                    Handle<Name> key,

                                    Handle<Object> value,

                                    PropertyAttributes attributes,

                                    StrictModeFlag strict_mode,

                                    StoreFromKeyed store_from_keyed);

  static Handle<FixedArray> EnsureWritableFastElements(

      Handle<JSObject> object);

  static Handle<Object> PrepareElementsForSort(Handle<JSObject> object,

                                               uint32_t limit);

  static Handle<Object> PrepareSlowElementsForSort(Handle<JSObject> object,

                                                   uint32_t limit);

  static Handle<Object> GetPropertyWithCallback(Handle<JSObject> object,

                                                Handle<Object> receiver,

                                                Handle<Object> structure,

                                                Handle<Name> name);

  static Handle<Object> SetPropertyWithCallback(

      Handle<JSObject> object,

      Handle<Object> structure,

      Handle<Name> name,

      Handle<Object> value,

      Handle<JSObject> holder,

  static Handle<Object> SetPropertyWithInterceptor(

      Handle<JSObject> object,

      Handle<Name> name,

      Handle<Object> value,

  static Handle<Object> SetPropertyForResult(

      Handle<JSObject> object,

      LookupResult* result,

      Handle<Name> name,

      Handle<Object> value,

      StoreFromKeyed store_mode = MAY_BE_STORE_FROM_KEYED);

  // Migrates the given object to a map whose field representations are the

  // lowest upper bound of all known representations for that field.

  // Migrates the given object only if the target map is already available,

  // or returns an empty handle if such a map is not yet available.

  static void SetNormalizedProperty(Handle<JSObject> object,

                                    LookupResult* result,

                                    Handle<Object> value);

  static void SetNormalizedProperty(Handle<JSObject> object,

                                    Handle<Name> key,

                                    Handle<Object> value,

                                    PropertyDetails details);

  // Retrieves an AccessorPair property from the given object. Might return

  // undefined if the property doesn't exist or is of a different kind.

  static Handle<Object> GetAccessor(Handle<JSObject> object,

                                    Handle<Name> name,

                                    AccessorComponent component);

  // Defines an AccessorPair property on the given object.

  // TODO(mstarzinger): Rename to SetAccessor() and return empty handle on

  // exception instead of letting callers check for scheduled exception.

  // Defines an AccessorInfo property on the given object.

  static Handle<Object> GetPropertyWithInterceptor(

      Handle<JSObject> object,

      Handle<Object> receiver,

      Handle<Name> name,

  static Handle<Object> GetPropertyPostInterceptor(

      Handle<JSObject> object,

      Handle<Object> receiver,

      Handle<Name> name,

  static bool HasRealNamedProperty(Handle<JSObject> object,

                                   Handle<Name> key);

  static bool HasRealElementProperty(Handle<JSObject> object, uint32_t index);

  static bool HasRealNamedCallbackProperty(Handle<JSObject> object,

                                           Handle<Name> key);

  static void TransitionElementsKind(Handle<JSObject> object,

                                     ElementsKind to_kind);

  // TODO(mstarzinger): Both public because of ConvertAnsSetLocalProperty().

  static void MigrateToMap(Handle<JSObject> object, Handle<Map> new_map);

  static void GeneralizeFieldRepresentation(Handle<JSObject> object,

                                            int modify_index,

                                            Representation new_representation,

                                            StoreMode store_mode);

  static Handle<Object> Freeze(Handle<JSObject> object);

  static void SetObserved(Handle<JSObject> object);

  // Copy object.

  static Handle<JSObject> Copy(Handle<JSObject> object,

                               Handle<AllocationSite> site);

  static Handle<JSObject> Copy(Handle<JSObject> object);

  static Handle<JSObject> DeepCopy(Handle<JSObject> object,

                                   AllocationSiteContext* site_context);

  static Handle<JSObject> DeepWalk(Handle<JSObject> object,

                                   AllocationSiteContext* site_context);

  // Casting.

  static inline JSObject* cast(Object* obj);

#ifdef VERIFY_HEAP

  // If a GC was caused while constructing this object, the elements pointer

  // may point to a one pointer filler map. The object won't be rooted, but

  // our heap verification code could stumble across it.

  bool ElementsAreSafeToExamine();

#endif

  friend class Object;

  // Used from Object::GetProperty().

  static Handle<Object> GetPropertyWithFailedAccessCheck(

      Handle<JSObject> object,

      Handle<Object> receiver,

      LookupResult* result,

      Handle<Name> name,

      PropertyAttributes* attributes);

  static Handle<Object> SetElementWithCallback(

      Handle<JSObject> object,

      Handle<Object> structure,

      Handle<Object> value,

      Handle<JSObject> holder,

  MUST_USE_RESULT MaybeObject* SetElementWithCallbackSetterInPrototypes(

      uint32_t index,

      Object* value,

      bool* found,

      StrictModeFlag strict_mode);

  // false. Can throw and return an empty handle with '*done==true'.

  static Handle<Object> SetPropertyViaPrototypes(

      Handle<JSObject> object,

      Handle<Name> name,

      Handle<Object> value,

  static Handle<Object> SetPropertyPostInterceptor(

      Handle<JSObject> object,

      Handle<Name> name,

      Handle<Object> value,

      PropertyAttributes attributes,

      StrictModeFlag strict_mode);

  static Handle<Object> SetPropertyUsingTransition(

      Handle<JSObject> object,

      LookupResult* lookup,

      Handle<Name> name,

      Handle<Object> value,

      PropertyAttributes attributes);

  static Handle<Object> SetPropertyWithFailedAccessCheck(

      Handle<JSObject> object,

      LookupResult* result,

      Handle<Name> name,

      Handle<Object> value,

      bool check_prototype,

      StrictModeFlag strict_mode);

  // Add a property to an object.

  static Handle<Object> AddProperty(

      Handle<JSObject> object,

      Handle<Name> name,

      Handle<Object> value,

      PropertyAttributes attributes,

      StrictModeFlag strict_mode,

      StoreFromKeyed store_mode = MAY_BE_STORE_FROM_KEYED,

      ExtensibilityCheck extensibility_check = PERFORM_EXTENSIBILITY_CHECK,

      ValueType value_type = OPTIMAL_REPRESENTATION,

      StoreMode mode = ALLOW_AS_CONSTANT,

      TransitionFlag flag = INSERT_TRANSITION);

  // Add a constant function property to a fast-case object.

  // This leaves a CONSTANT_TRANSITION in the old map, and

  // if it is called on a second object with this map, a

  // normal property is added instead, with a map transition.

  // This avoids the creation of many maps with the same constant

  // function, all orphaned.

  static void AddConstantProperty(Handle<JSObject> object,

                                  Handle<Name> name,

                                  Handle<Object> constant,

                                  PropertyAttributes attributes,

                                  TransitionFlag flag);

  // Add a property to a fast-case object.

  static void AddFastProperty(Handle<JSObject> object,

                              Handle<Name> name,

                              Handle<Object> value,

                              PropertyAttributes attributes,

                              StoreFromKeyed store_mode,

                              ValueType value_type,

                              TransitionFlag flag);

  // Add a property to a fast-case object using a map transition to

  // new_map.

  static void AddFastPropertyUsingMap(Handle<JSObject> object,

                                      Handle<Map> new_map,

                                      Handle<Name> name,

                                      Handle<Object> value,

                                      int field_index,

                                      Representation representation);

  // Add a property to a slow-case object.

  static void AddSlowProperty(Handle<JSObject> object,

                              Handle<Name> name,

                              Handle<Object> value,

                              PropertyAttributes attributes);

  MUST_USE_RESULT MaybeObject* CopySize(int new_length,

                                        PretenureFlag pretenure = NOT_TENURED);

// ConstantPoolArray describes a fixed-sized array containing constant pool

// entires.

// The format of the pool is:

//   [0]: Field holding the first index which is a pointer entry

//   [1]: Field holding the first index which is a int32 entry

//   [2] ... [first_ptr_index() - 1]: 64 bit entries

//   [first_ptr_index()] ... [first_int32_index() - 1]: pointer entries

//   [first_int32_index()] ... [length - 1]: 32 bit entries

class ConstantPoolArray: public FixedArrayBase {

 public:

  // Getters for the field storing the first index for different type entries.

  inline int first_ptr_index();

  inline int first_int64_index();

  inline int first_int32_index();

  // Getters for counts of different type entries.

  inline int count_of_ptr_entries();

  inline int count_of_int64_entries();

  inline int count_of_int32_entries();

  // Setter and getter for pool elements.

  inline Object* get_ptr_entry(int index);

  inline int64_t get_int64_entry(int index);

  inline int32_t get_int32_entry(int index);

  inline double get_int64_entry_as_double(int index);

  inline void set(int index, Object* value);

  inline void set(int index, int64_t value);

  inline void set(int index, double value);

  inline void set(int index, int32_t value);

  // Set up initial state.

  inline void SetEntryCounts(int number_of_int64_entries,

                             int number_of_ptr_entries,

                             int number_of_int32_entries);

  // Copy operations

  MUST_USE_RESULT inline MaybeObject* Copy();

  // Garbage collection support.

  inline static int SizeFor(int number_of_int64_entries,

                            int number_of_ptr_entries,

                            int number_of_int32_entries) {

    return RoundUp(OffsetAt(number_of_int64_entries,

                            number_of_ptr_entries,

                            number_of_int32_entries),

                   kPointerSize);

  }

  // Code Generation support.

  inline int OffsetOfElementAt(int index) {

    ASSERT(index < length());

    if (index >= first_int32_index()) {

      return OffsetAt(count_of_int64_entries(), count_of_ptr_entries(),

                      index - first_int32_index());

    } else if (index >= first_ptr_index()) {

      return OffsetAt(count_of_int64_entries(), index - first_ptr_index(), 0);

    } else {

      return OffsetAt(index, 0, 0);

    }

  }

  // Casting.

  static inline ConstantPoolArray* cast(Object* obj);

  // Layout description.

  static const int kFirstPointerIndexOffset = FixedArray::kHeaderSize;

  static const int kFirstInt32IndexOffset =

      kFirstPointerIndexOffset + kPointerSize;

  static const int kFirstOffset = kFirstInt32IndexOffset + kPointerSize;

  // Dispatched behavior.

  void ConstantPoolIterateBody(ObjectVisitor* v);

  DECLARE_PRINTER(ConstantPoolArray)

  DECLARE_VERIFIER(ConstantPoolArray)

 private:

  inline void set_first_ptr_index(int value);

  inline void set_first_int32_index(int value);

  inline static int OffsetAt(int number_of_int64_entries,

                             int number_of_ptr_entries,

                             int number_of_int32_entries) {

    return kFirstOffset

        + (number_of_int64_entries * kInt64Size)

        + (number_of_ptr_entries * kPointerSize)

        + (number_of_int32_entries * kInt32Size);

  }

  DISALLOW_IMPLICIT_CONSTRUCTORS(ConstantPoolArray);

};

  static Handle<DescriptorArray> Merge(Handle<DescriptorArray> desc,

                                       int verbatim,

                                       int valid,

                                       int new_size,

                                       int modify_index,

                                       StoreMode store_mode,

                                       Handle<DescriptorArray> other);

  static Handle<DescriptorArray> CopyUpToAddAttributes(

      Handle<DescriptorArray> desc,

      int enumeration_index,

      PropertyAttributes attributes);

  MUST_USE_RESULT MaybeObject* EnsureCapacity(

      int n,

      Key key,

      PretenureFlag pretenure = NOT_TENURED);

template <int entrysize>

class WeakHashTableShape : public BaseShape<Object*> {

 public:

  static inline bool IsMatch(Object* key, Object* other);

  static inline uint32_t Hash(Object* key);

  static inline uint32_t HashForObject(Object* key, Object* object);

  MUST_USE_RESULT static inline MaybeObject* AsObject(Heap* heap,

                                                      Object* key);

  static const int kPrefixSize = 0;

  static const int kEntrySize = entrysize;

};

// WeakHashTable maps keys that are arbitrary objects to object values.

// It is used for the global weak hash table that maps objects

// embedded in optimized code to dependent code lists.

class WeakHashTable: public HashTable<WeakHashTableShape<2>, Object*> {

 public:

  static inline WeakHashTable* cast(Object* obj) {

    ASSERT(obj->IsHashTable());

    return reinterpret_cast<WeakHashTable*>(obj);

  }

  // Looks up the value associated with the given key. The hole value is

  // returned in case the key is not present.

  Object* Lookup(Object* key);

  // Adds (or overwrites) the value associated with the given key. Mapping a

  // key to the hole value causes removal of the whole entry.

  MUST_USE_RESULT MaybeObject* Put(Object* key, Object* value);

  // This function is called when heap verification is turned on.

  void Zap(Object* value) {

    int capacity = Capacity();

    for (int i = 0; i < capacity; i++) {

      set(EntryToIndex(i), value);

      set(EntryToValueIndex(i), value);

    }

  }

 private:

  friend class MarkCompactCollector;

  void AddEntry(int entry, Object* key, Object* value);

  // Returns the index to the value of an entry.

  static inline int EntryToValueIndex(int entry) {

    return EntryToIndex(entry) + 1;

  }

};

  static bool CopyContextLocalsToScopeObject(Handle<ScopeInfo> scope_info,

                                             Handle<Context> context,

                                             Handle<JSObject> scope_object);

  static Handle<Map> Get(Handle<NormalizedMapCache> cache,

                         Handle<JSObject> object,

                         PropertyNormalizationMode mode);

  V(HANDLER)                \

    TRANSITION,

  static const int kPrologueOffsetNotSet = -1;

  inline Kind handler_kind() {

    return static_cast<Kind>(arguments_count());

  }

    return kind == COMPARE_NIL_IC || kind == TO_BOOLEAN_IC ||

           kind == BINARY_OP_IC;

  inline bool is_handler() { return kind() == HANDLER; }

  inline bool is_keyed_stub();

  // Find the first handler in an IC stub.

  Code* FindFirstHandler();

  // Find |length| handlers and put them into |code_list|. Returns false if not

  // enough handlers can be found.

  bool FindHandlers(CodeHandleList* code_list, int length = -1);

    kNotExecutedCodeAge = -2,

    kExecutedOnceCodeAge = -1,

    kNoAgeCodeAge = 0,

    kCodeAgeCount = kAfterLastCodeAge - 1,

    kIsOldCodeAge = kSexagenarianCodeAge,

    kPreAgedCodeAge = kIsOldCodeAge - 1

  static void MakeCodeAgeSequenceYoung(byte* sequence, Isolate* isolate);

  static void MarkCodeAsExecuted(byte* sequence, Isolate* isolate);

  Age GetAge();

  static inline Code* GetPreAgedCodeAgeStub(Isolate* isolate) {

    return GetCodeAgeStub(isolate, kNotExecutedCodeAge, NO_MARKING_PARITY);

  }

  void VerifyEmbeddedObjectsDependency();

  static bool IsWeakEmbeddedObject(Kind kind, Object* object);

  static Code* GetCodeAgeStub(Isolate* isolate, Age age, MarkingParity parity);

  static void PatchPlatformCodeAge(Isolate* isolate,

                                   byte* sequence, Age age,

  static Handle<TransitionArray> AddTransition(Handle<Map> map,

                                               Handle<Name> key,

                                               Handle<Map> target,

                                               SimpleTransitionFlag flag);

  static Handle<Map> GeneralizeAllFieldRepresentations(

      Handle<Map> map,

      Representation new_representation);

  static Handle<Map> CopyGeneralizeAllRepresentations(

      Handle<Map> map,

  static Handle<Map> RawCopy(Handle<Map> map, int instance_size);

  static Handle<Map> CopyReplaceDescriptors(Handle<Map> map,

                                            Handle<DescriptorArray> descriptors,

                                            TransitionFlag flag,

                                            Handle<Name> name);

  static Handle<Map> CopyInstallDescriptors(

      Handle<Map> map,

      Handle<DescriptorArray> descriptors);

  static Handle<Map> CopyForObserved(Handle<Map> map);

  kMathPowHalf

  // nested_site threads a list of sites that represent nested literals

  // walked in a particular order. So [[1, 2], 1, 2] will have one

  // nested_site, but [[1, 2], 3, [4]] will have a list of two.

  DECL_ACCESSORS(nested_site, Object)

  DECL_ACCESSORS(dependent_code, DependentCode)

  inline void Initialize();

  bool HasNestedSites() {

    return nested_site()->IsAllocationSite();

  // This method is expensive, it should only be called for reporting.

  bool IsNestedSite();

    ASSERT(!SitePointsToLiteral());

  bool SitePointsToLiteral() {

    // for an object or array literal.

    return transition_info()->IsJSArray() || transition_info()->IsJSObject();

  static const int kNestedSiteOffset = kTransitionInfoOffset + kPointerSize;

  static const int kDependentCodeOffset = kNestedSiteOffset + kPointerSize;

  static const int kWeakNextOffset = kDependentCodeOffset + kPointerSize;

                              kDependentCodeOffset + kPointerSize,

  static AllocationMemento* FindForJSObject(JSObject* object,

                                            bool in_GC = false);

  static void SetValueInferType(Handle<PropertyCell> cell,

                                Handle<Object> value);

  // Computes the new type of the cell's contents for the given value, but

  // without actually modifying the 'type' field.

  static Handle<Type> UpdatedType(Handle<PropertyCell> cell,

                                  Handle<Object> value);

  void AddDependentCompilationInfo(CompilationInfo* info);

  void AddDependentCode(Handle<Code> code);

  static Handle<Object> SetPropertyViaPrototypesWithHandler(

      Handle<JSProxy> proxy,

      Handle<JSReceiver> receiver,

      Handle<Name> name,

      Handle<Object> value,

  static Handle<Object> SetPropertyWithHandler(Handle<JSProxy> proxy,

                                               Handle<JSReceiver> receiver,

                                               Handle<Name> name,

                                               Handle<Object> value,

                                               PropertyAttributes attributes,

                                               StrictModeFlag strict_mode);

  static bool HasPropertyWithHandler(Handle<JSProxy> proxy, Handle<Name> name);

  static bool HasElementWithHandler(Handle<JSProxy> proxy, uint32_t index);

  // Handy shorthand for visiting a single pointer.

  virtual void VisitPointer(Object** p) { VisitPointers(p, p + 1); }

  // Visits an external reference embedded into a code object.

  // Visits an external reference. The value may be modified on return.

  virtual void VisitExternalReference(Address* p) {}