Lines Matching defs:that
2 // Use of this source code is governed by a BSD-style license that can be
170 AbstractElements* that = zone->New<AbstractElements>(zone);
178 that->elements_[that->next_index_++] = element2;
181 that->next_index_ %= arraysize(elements_);
182 return that;
189 AbstractElements const* that) const {
190 if (this == that) return true;
196 Element that_element = that->elements_[j];
205 Element that_element = that->elements_[i];
221 LoadElimination::AbstractElements::Merge(AbstractElements const* that,
223 if (this->Equals(that)) return this;
227 for (Element const that_element : that->elements_) {
294 // on all nodes that must alias with 'object'.
296 AbstractField* that = zone->New<AbstractField>(zone);
299 that->info_for_node_.insert(info2);
302 return that;
314 AbstractField* that = zone->New<AbstractField>(zone);
318 that->info_for_node_.insert(info2);
321 return that;
358 AbstractMaps* that = zone->New<AbstractMaps>(zone);
361 that->info_for_node_.insert(info2);
363 return that;
370 AbstractMaps const* that, Zone* zone) const {
371 if (this->Equals(that)) return this;
376 auto that_it = that->info_for_node_.find(this_object);
377 if (that_it != that->info_for_node_.end() && that_it->second == this_maps) {
386 AbstractMaps* that = zone->New<AbstractMaps>(zone);
387 that->info_for_node_ = this->info_for_node_;
389 that->info_for_node_[object] = maps;
390 return that;
421 bool LoadElimination::AbstractState::Equals(AbstractState const* that) const {
423 if (!that->elements_ || !that->elements_->Equals(this->elements_)) {
426 } else if (that->elements_) {
429 if (!FieldsEquals(this->fields_, that->fields_) ||
430 !FieldsEquals(this->const_fields_, that->const_fields_)) {
434 if (!that->maps_ || !that->maps_->Equals(this->maps_)) {
437 } else if (that->maps_) {
458 void LoadElimination::AbstractState::Merge(AbstractState const* that,
462 this->elements_ = that->elements_
463 ? that->elements_->Merge(this->elements_, zone)
468 FieldsMerge(&this->fields_, that->fields_, zone);
469 FieldsMerge(&this->const_fields_, that->const_fields_, zone);
473 this->maps_ = that->maps_ ? that->maps_->Merge(this->maps_, zone) : nullptr;
484 AbstractState* that = zone->New<AbstractState>(*this);
485 if (that->maps_) {
486 that->maps_ = that->maps_->Extend(object, maps, zone);
488 that->maps_ = zone->New<AbstractMaps>(object, maps, zone);
490 return that;
498 AbstractState* that = zone->New<AbstractState>(*this);
499 that->maps_ = that_maps;
500 return that;
525 AbstractState* that = zone->New<AbstractState>(*this);
526 if (that->elements_) {
527 that->elements_ =
528 that->elements_->Extend(object, index, value, representation, zone);
530 that->elements_ =
533 return that;
543 AbstractState* that = zone->New<AbstractState>(*this);
544 that->elements_ = that_elements;
545 return that;
554 AbstractState* that = zone->New<AbstractState>(*this);
556 info.const_field_info.IsConst() ? that->const_fields_ : that->fields_;
564 return that;
572 AbstractState* that = nullptr;
577 if (!that) that = zone->New<AbstractState>(*this);
578 that->const_fields_[index] = this_field;
582 return that ? that : this;
595 AbstractState* that = nullptr;
600 if (!that) that = zone->New<AbstractState>(*this);
601 that->fields_[index] = this_field;
605 return that ? that : this;
618 AbstractState* that = zone->New<AbstractState>(*this);
619 that->fields_[i] = that_field;
622 that->fields_[i] = this->fields_[i]->Kill(alias_info, name, zone);
625 return that;
636 AbstractState* that = zone->New<AbstractState>();
637 that->const_fields_ = const_fields_;
638 return that;
679 // an Allocate node instead of a FinishRegion node), we know that {other}
800 // We know that the resulting elements have the fixed array map.
820 // We know that the resulting elements have the fixed double array map.
824 // We know that the resulting elements have the fixed array map or the COW
937 // Make sure we don't reuse values that were recorded with a different
1009 // that should be marked mutable instead of const
1032 // We only kill const information when there is a chance that we
1041 // mutable world to guard against field accesses that should have
1061 // Only handle loads that do not require truncations.
1245 // Only signal that the {node} has Changed, if the information about {state}
1360 // to only invalidate information about nodes that can have the transition's
1361 // source map. The trouble is that an object can be transitioned by some other
1362 // transition to the source map. In that case, the other transition will
1369 // If we process the slow transition first on an object that has mapA, we will
1375 // Note that the slow-slow case is fine because either of the slow transition
1439 // We currently only track fields that are at least tagged pointer sized.