Lines Matching refs:Is
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
116 if (IsUndetectableObject()) return false; // Undetectable object is false.
396 // Getter is not a function.
412 // TODO(rossberg): adjust once there is a story for symbols vs proxies.
481 // Handle stepping into a getter if step into is active.
718 // TODO(mstarzinger): Temporary wrapper until target is handlified.
776 // If the object is fully fast case and has the same map it was
904 // Iterate up the prototype chain until an element is found or the null
905 // prototype is encountered.
929 // performance of fetching elements where checking the prototype chain is
966 // The object is either a number, a string, a boolean,
991 // The object is either a number, a name, an odd-ball,
1017 // The object is either a number, a name, an odd-ball,
1097 // Do not attempt to flatten in debug mode when allocation is not
1098 // allowed. This is to avoid an assertion failure when allocating.
1099 // Flattening strings is the only case where we always allow
1100 // allocation because no GC is performed if the allocation fails.
1112 // cons string is in old space. It can never get GCed until there is
1244 // reinitializing the fields. Use short version if space is limited.
1617 // During GC, the map pointer field is encoded.
1764 // buffer that is plenty big enough for any floating point number, then
1766 // there is no more space in the buffer).
1781 // If the constructor is not present, return "Object".
1797 // If the constructor is not present, return "Object".
1807 // This method is used to transition to a field. If we are transitioning to a
1860 // Normalize the object if the name is an actual name (not the
1861 // hidden strings) and is not a real identifier.
1908 // Note that Map::CopyAddDescriptor has side-effects, the new map is already
1963 // In case name is an orphaned property reuse the cell.
2271 // For now this trick is only applied to fixed arrays in new and paged space.
2327 // the map is sufficient.
2532 // Returns NULL if the updated map is incompatible.
2600 // the new type is deduced by merging the current type with any potential new
2612 // - If |updated| == |split_map|, |updated| is in the expected state. Return it.
2691 // This is shadowed by |updated_descriptors| being more general than
2717 // during GC. Its descriptor array is too large, but it will be
2926 // Handle stepping into a setter if step into is active.
2993 // We could not find a local property so let's check whether there is an
2994 // accessor that wants to handle the property, or whether the property is
3235 // Only remember the map transition if there is not an already existing
3277 // types because LocalLookupRealNamedProperty is used when setting
3369 // set is callbacks marked as ALL_CAN_WRITE on the prototype chain.
3419 // TODO(rossberg): adjust once there is a story for symbols vs proxies.
3443 // TODO(rossberg): adjust once there is a story for symbols vs proxies.
3468 // TODO(rossberg): adjust once there is a story for symbols vs proxies.
3560 // TODO(rossberg): adjust once there is a story for symbols vs proxies.
3601 // TODO(rossberg): adjust once there is a story for symbols vs proxies.
3844 // This is a real property that is not read-only, or it is a
3931 // If the same constant function is being added we can simply
3937 // even if the value is a constant function.
3971 // Set a real local property, even if it is READ_ONLY. If the property is not
3972 // present, add it with attributes NONE. This code is an exact clone of
3975 // result are also added. If one of the functions is changed, the other
3978 // because ConvertDescriptorToField() which is called in "case CALLBACKS:"
4136 // new map with a FIELD, even if the value is a function.
4295 // Check whether the name is an array index.
4491 // The global object is always normalized.
4784 // If the proxy is detached, return undefined.
4825 // If the proxy is detached, return undefined.
4835 // If there is no backing store yet, store the identity hash inline.
4846 // If it was found, check if the key is already in the dictionary.
4866 // If the proxy is detached, return immediately.
4902 // hidden strings hash code is zero (and no other name has hash
4969 // We can store the identity hash inline iff there is no backing store
4975 // hidden strings hash code is zero (and no other name has hash
5281 // Is the object the constructor for this object?
5286 // Is the object the prototype for this object?
5291 // Check if the object is among the named properties.
5297 // Check if the object is among the indexed properties.
5350 // Get the context and don't check if it is the native context.
5362 // If it is an arguments array check the content.
5449 // READ_ONLY is an invalid attribute for JS setters/getters.
5758 // it is no proxy, has no interceptors and needs no access checks).
5842 // Do not use inline caching if the object is a non-global object
5998 // successfully reusing a map transition for a getter. Nevertheless, this is
6016 // We could assert that the property is configurable here, but we would need
6042 // Check if there is an API defined callback object which prohibits
6044 // This mechanism is needed for instance in a browser setting, where
6116 // When running crankshaft, changing the map is not enough. We
6291 // If there is a transition, try to follow it.
6302 // If there is no transition yet, add a transition to the a new accessor pair
6385 // configurable (that is IsDontDelete in ES3 and v8), see 8.6.1 (Table 5).
6557 // Sanity check. This path is only to be taken if the map owns its descriptor
6598 // on a cache always being available once it is set. If the map has more
6656 // Since this method is used to rewrite an existing transition tree, it can
6726 // In case the map did not own its own descriptors, a split is forced by
6819 // Ensure the key is unique.
6860 // Ensure the key is unique.
6864 // We replace the key if it is already present.
6889 // READ_ONLY is an invalid attribute for JS setters/getters.
6914 // Ensure the key is unique.
6996 // No GC is supposed to happen between a call to IndexInCodeCache and
7004 // field of the contens array while it is running.
7042 // underlying array while it is running.
7099 // (1) The map of the map temporarily holds the parent, and is restored to the
7114 // Note that the child iterator is just a concatenation of two iterators: One
7197 // Make sure that a hash table is allocated for the normal load code cache.
7351 // deleted elements from unused elements. This distinction is used
7361 // code object. The actual match is on the name and the code flags. If a key
7362 // is created using the flags and not a code object it can only be used for
7517 // hash table; instead they're temporarily used for lookups. It is therefore
7538 // other_maps. This implementation is slow, but probably good enough for
7575 // both because the referenced MapList is short-lived, and because C++
7686 // We are taking the map from the old fixed array so the map is sure to
7771 // In case of incompatible types, the type and representation of |other| is
8243 // Loop until the string is found which contains the target offset.
8248 // Target offset is in the left branch.
8282 // Pop stack so next iteration is in correct place.
8317 // Pop stack so next iteration is in correct place.
8432 // Right hand side is longer. Recurse over left.
8443 // Left hand side is longer. Recurse over right.
8447 // is unbalanced to the left, a list, essentially. We inline the
8667 // Fast check: if hash code is computed for both strings
8805 // This is a ConsString, iterate across it.
8846 // Check the hash code is there.
8849 ASSERT(result != 0); // Ensure that the hash value of 0 is never computed.
8875 // Check that the new result is below the 32 bit limit.
8945 // (if there is one) to see if it's an AllocationMemento.
8951 // There is room in newspace for allocation info. Do we have some?
9040 // Must set length here so that hash computation is correct.
9177 // when the two pointers are close (which is fairly common).
9228 // No write barrier required, since the builtin is part of the root set.
9245 // No write barrier required, since the builtin is part of the root set.
9257 // No write barrier required, since the builtin is part of the root set.
9275 // No write barrier required, since the builtin is part of the root set.
9380 // If the next map link slot is already used then the function was
9418 // Always trim even when array is cleared because of heap verifier.
9431 // Always trim even when array is cleared because of heap verifier.
9548 // First some logic for the map of the prototype to make sure it is in fast
9559 // slack tracking that is in progress at this point because it is
9567 // If the function is used as the global Array function, cache the
9578 // Put the value in the initial map field until an initial map is
9579 // needed. At that point, a new initial map is created and the
9580 // prototype is put into the initial map where it belongs.
9592 // If the value is not a JSReceiver, store the value in the map's
9652 // The filter string is a pattern that matches functions in this way:
9739 // For some native functions there is no source.
9811 // is there because we flush non-optimized code thereby loosing the
9812 // non-optimizable information for the code. When the code is
9813 // regenerated and set on the shared function info it is marked as
9814 // non-optimizable if optimization is disabled for the shared
9856 // Nonzero counter is a leftover from the previous attempt interrupted
9880 // constructor is called. The countdown will continue and (possibly after
9888 // It is safe to clear the flag: it will be set again if the map is live.
10131 // Locate the source position which is closest to the address in the code. This
10132 // is using the source position information embedded in the relocation info.
10133 // The position returned is relative to the beginning of the script where the
10134 // source for this function is found.
10150 // If this position is closer than the current candidate or if it has the
10151 // same distance as the current candidate and the position is higher then
10152 // this position is the new candidate.
10801 // If there is no back edge table, the "table start" will be at or after
10968 // Returns false if the passed-in index is marked non-configurable,
11053 // if they were in fast mode, the below is slower than necessary
11141 // Don't cache prototype transition if this map is shared.
11247 // Do not append the compilation info if it is already in the array.
11248 // It is sufficient to just check only the last element because
11400 // Silently ignore the change if value is not a JSObject or null.
11406 // In addition, if [[Extensible]] is false the value of the [[Class]] and
11422 // It is sufficient to validate that the receiver is not in the new prototype
11439 // Find the first object in the chain whose prototype object is not
11452 // Nothing to do if prototype is already set.
11609 // Getter is not a function.
11713 // Adding n elements in fast case is O(n*n).
11724 // returning undefined. If there is a store to the initial prototype object,
11770 // If the array is growing, and it's not growth by a single element at the
11771 // end, make sure that the ElementsKind is HOLEY.
11782 // a transition to slow elements is necessary.
11889 // is read-only (a declared const that has not been initialized). If a
11890 // value is being defined we skip attribute checks completely.
11959 // Update the array length if this JSObject is an array.
12023 // If the value object is not a heap number, switch to fast elements and try
12051 // If the array is growing, and it's not growth by a single element at the
12052 // end, make sure that the ElementsKind is HOLEY.
12060 // Check whether there is extra space in the fixed array.
12402 // if kind is holey ensure that to_kind is as well.
12407 // If the array is huge, it's not likely to be defined in a local
12424 // if kind is holey ensure that to_kind is as well.
12462 // No change is needed to the elements() buffer, the transition
12482 // If length is undefined, then JSArray is being initialized and has no
12622 // Fall through if packing is not guaranteed.
12644 // Fall through if packing is not guaranteed.
12695 // An object requiring access checks is never allowed to have fast
13052 // While the current element at i is not at its correct position p,
13067 // purpose of this function is to provide reflection information for the object
13375 // stored value is stored where the key should be. IsMatch then
13387 // Plain hash maps, which is where regexp keys are used, don't
13422 ASSERT(result != 0); // Ensure that the hash value of 0 is never computed.
13456 ASSERT(result != 0); // Ensure that the hash value of 0 is never computed.
13502 ASSERT(result != 0); // Ensure that the hash value of 0 is never computed.
13632 // 1. Move the check if the key is unique out of the loop.
13634 // 3. Detect a case when a dictionary key is not unique but the key is.
13640 // EnsureCapacity will guarantee the hash table is never full.
13653 // Replace a key that is a non-internalized string by the equivalent
13705 // 50% is still free after adding n elements and
13734 // capacity is filled with elements.
13738 // there is extra room in the dictionary for additions. Don't go
13765 // EnsureCapacity will guarantee the hash table is never full.
13776 // Please note this list is compiler dependent.
13929 // Also bail out if the element is not supposed to be moved.
13934 // does not cause GC. This is the case because we made sure to allocate
13988 // If the object is in dictionary mode, it is converted to fast elements
13996 // Ordering is irrelevant, since we are going to sort anyway.
14392 // This class is used for looking up two character strings in the string table.
14420 // algorithm is different in that case.
14443 // The TwoCharHashTableKey is only used for looking in the string
14536 // If the string table grew as part of EnsureCapacity, obj is not
14550 // The key for the script compilation cache is dependent on the mode flags,
14685 // StringsKey used for HashTable where key is array of internalized strings.
14868 // If the entry is present set the value;
14895 // Valdate key is absent.
14943 // Check if this index is high enough that we should require slow
15239 // There is enough inobject space for all fields (including unused).
15260 // Ensure the key is a unique name before writing into the
15340 // Check whether key is already present.
15365 // Check whether key is actually present.
15408 // Key is already in table, just overwrite value.
15492 // Check if there is a break point at this code position.
15497 // If there is no break point info object or no break points in the break
15498 // point info object there is
15650 // If there is a single break point clear it if it is the same.
15689 // If the break point object is the same as before just ignore.
15762 // Since the stamp is not NaN, the value is also not NaN.
15924 if (new_type->Is(old_type)) {
15931 if (old_type->Is(Type::None()) || old_type->Is(Type::Undefined())) {
15942 if (!Type::Any()->Is(type())) {
