| // Copyright 2012 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "src/v8.h" |
| |
| #include "src/interface.h" |
| |
| #include "src/base/lazy-instance.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| // --------------------------------------------------------------------------- |
| // Initialization. |
| |
| struct Interface::Cache { |
| template<int flags> |
| struct Create { |
| static void Construct(Interface* ptr) { ::new (ptr) Interface(flags); } |
| }; |
| typedef Create<VALUE + FROZEN> ValueCreate; |
| typedef Create<VALUE + CONST + FROZEN> ConstCreate; |
| |
| static base::LazyInstance<Interface, ValueCreate>::type value_interface; |
| static base::LazyInstance<Interface, ConstCreate>::type const_interface; |
| }; |
| |
| |
| base::LazyInstance<Interface, Interface::Cache::ValueCreate>::type |
| Interface::Cache::value_interface = LAZY_INSTANCE_INITIALIZER; |
| |
| base::LazyInstance<Interface, Interface::Cache::ConstCreate>::type |
| Interface::Cache::const_interface = LAZY_INSTANCE_INITIALIZER; |
| |
| |
| Interface* Interface::NewValue() { |
| return Cache::value_interface.Pointer(); // Cached. |
| } |
| |
| |
| Interface* Interface::NewConst() { |
| return Cache::const_interface.Pointer(); // Cached. |
| } |
| |
| |
| // --------------------------------------------------------------------------- |
| // Lookup. |
| |
| Interface* Interface::Lookup(Handle<String> name, Zone* zone) { |
| DCHECK(IsModule()); |
| ZoneHashMap* map = Chase()->exports_; |
| if (map == nullptr) return nullptr; |
| ZoneAllocationPolicy allocator(zone); |
| ZoneHashMap::Entry* p = |
| map->Lookup(name.location(), name->Hash(), false, allocator); |
| if (p == nullptr) return nullptr; |
| DCHECK(*static_cast<String**>(p->key) == *name); |
| DCHECK(p->value != nullptr); |
| return static_cast<Interface*>(p->value); |
| } |
| |
| |
| // --------------------------------------------------------------------------- |
| // Addition. |
| |
| #ifdef DEBUG |
| // Current nesting depth for debug output. |
| class Nesting { |
| public: |
| Nesting() { current_ += 2; } |
| ~Nesting() { current_ -= 2; } |
| static int current() { return current_; } |
| private: |
| static int current_; |
| }; |
| |
| int Nesting::current_ = 0; |
| #endif |
| |
| |
| void Interface::DoAdd(const void* name, uint32_t hash, Interface* interface, |
| Zone* zone, bool* ok) { |
| MakeModule(ok); |
| if (!*ok) return; |
| |
| #ifdef DEBUG |
| if (FLAG_print_interface_details) { |
| PrintF("%*s# Adding...\n", Nesting::current(), ""); |
| PrintF("%*sthis = ", Nesting::current(), ""); |
| this->Print(Nesting::current()); |
| const AstRawString* raw = static_cast<const AstRawString*>(name); |
| PrintF("%*s%.*s : ", Nesting::current(), "", |
| raw->length(), raw->raw_data()); |
| interface->Print(Nesting::current()); |
| } |
| #endif |
| |
| ZoneHashMap** map = &Chase()->exports_; |
| ZoneAllocationPolicy allocator(zone); |
| |
| if (*map == nullptr) { |
| *map = new(zone->New(sizeof(ZoneHashMap))) |
| ZoneHashMap(ZoneHashMap::PointersMatch, |
| ZoneHashMap::kDefaultHashMapCapacity, allocator); |
| } |
| |
| ZoneHashMap::Entry* p = |
| (*map)->Lookup(const_cast<void*>(name), hash, !IsFrozen(), allocator); |
| if (p == nullptr) { |
| // This didn't have name but was frozen already, that's an error. |
| *ok = false; |
| } else if (p->value == nullptr) { |
| p->value = interface; |
| } else { |
| #ifdef DEBUG |
| Nesting nested; |
| #endif |
| static_cast<Interface*>(p->value)->Unify(interface, zone, ok); |
| } |
| |
| #ifdef DEBUG |
| if (FLAG_print_interface_details) { |
| PrintF("%*sthis' = ", Nesting::current(), ""); |
| this->Print(Nesting::current()); |
| PrintF("%*s# Added.\n", Nesting::current(), ""); |
| } |
| #endif |
| } |
| |
| |
| // --------------------------------------------------------------------------- |
| // Unification. |
| |
| void Interface::Unify(Interface* that, Zone* zone, bool* ok) { |
| if (this->forward_) return this->Chase()->Unify(that, zone, ok); |
| if (that->forward_) return this->Unify(that->Chase(), zone, ok); |
| DCHECK(this->forward_ == nullptr); |
| DCHECK(that->forward_ == nullptr); |
| |
| *ok = true; |
| if (this == that) return; |
| if (this->IsValue()) { |
| that->MakeValue(ok); |
| if (*ok && this->IsConst()) that->MakeConst(ok); |
| return; |
| } |
| if (that->IsValue()) { |
| this->MakeValue(ok); |
| if (*ok && that->IsConst()) this->MakeConst(ok); |
| return; |
| } |
| |
| #ifdef DEBUG |
| if (FLAG_print_interface_details) { |
| PrintF("%*s# Unifying...\n", Nesting::current(), ""); |
| PrintF("%*sthis = ", Nesting::current(), ""); |
| this->Print(Nesting::current()); |
| PrintF("%*sthat = ", Nesting::current(), ""); |
| that->Print(Nesting::current()); |
| } |
| #endif |
| |
| // Merge the smaller interface into the larger, for performance. |
| if (this->exports_ != nullptr && (that->exports_ == nullptr || |
| this->exports_->occupancy() >= that->exports_->occupancy())) { |
| this->DoUnify(that, ok, zone); |
| } else { |
| that->DoUnify(this, ok, zone); |
| } |
| |
| #ifdef DEBUG |
| if (FLAG_print_interface_details) { |
| PrintF("%*sthis' = ", Nesting::current(), ""); |
| this->Print(Nesting::current()); |
| PrintF("%*sthat' = ", Nesting::current(), ""); |
| that->Print(Nesting::current()); |
| PrintF("%*s# Unified.\n", Nesting::current(), ""); |
| } |
| #endif |
| } |
| |
| |
| void Interface::DoUnify(Interface* that, bool* ok, Zone* zone) { |
| DCHECK(this->forward_ == nullptr); |
| DCHECK(that->forward_ == nullptr); |
| DCHECK(!this->IsValue()); |
| DCHECK(!that->IsValue()); |
| DCHECK(this->index_ == -1); |
| DCHECK(that->index_ == -1); |
| DCHECK(*ok); |
| |
| #ifdef DEBUG |
| Nesting nested; |
| #endif |
| |
| // Try to merge all members from that into this. |
| ZoneHashMap* map = that->exports_; |
| if (map != nullptr) { |
| for (ZoneHashMap::Entry* p = map->Start(); p != nullptr; p = map->Next(p)) { |
| this->DoAdd(p->key, p->hash, static_cast<Interface*>(p->value), zone, ok); |
| if (!*ok) return; |
| } |
| } |
| |
| // If the new interface is larger than that's, then there were members in |
| // 'this' which 'that' didn't have. If 'that' was frozen that is an error. |
| int this_size = this->exports_ == nullptr ? 0 : this->exports_->occupancy(); |
| int that_size = map == nullptr ? 0 : map->occupancy(); |
| if (that->IsFrozen() && this_size > that_size) { |
| *ok = false; |
| return; |
| } |
| |
| // Merge interfaces. |
| this->flags_ |= that->flags_; |
| that->forward_ = this; |
| } |
| |
| |
| // --------------------------------------------------------------------------- |
| // Printing. |
| |
| #ifdef DEBUG |
| void Interface::Print(int n) { |
| int n0 = n > 0 ? n : 0; |
| |
| if (FLAG_print_interface_details) { |
| PrintF("%p", static_cast<void*>(this)); |
| for (Interface* link = this->forward_; link != nullptr; |
| link = link->forward_) { |
| PrintF("->%p", static_cast<void*>(link)); |
| } |
| PrintF(" "); |
| } |
| |
| if (IsUnknown()) { |
| PrintF("unknown\n"); |
| } else if (IsConst()) { |
| PrintF("const\n"); |
| } else if (IsValue()) { |
| PrintF("value\n"); |
| } else if (IsModule()) { |
| PrintF("module %d %s{", Index(), IsFrozen() ? "" : "(unresolved) "); |
| ZoneHashMap* map = Chase()->exports_; |
| if (map == nullptr || map->occupancy() == 0) { |
| PrintF("}\n"); |
| } else if (n < 0 || n0 >= 2 * FLAG_print_interface_depth) { |
| // Avoid infinite recursion on cyclic types. |
| PrintF("...}\n"); |
| } else { |
| PrintF("\n"); |
| for (ZoneHashMap::Entry* p = map->Start(); |
| p != nullptr; p = map->Next(p)) { |
| String* name = *static_cast<String**>(p->key); |
| Interface* interface = static_cast<Interface*>(p->value); |
| PrintF("%*s%s : ", n0 + 2, "", name->ToAsciiArray()); |
| interface->Print(n0 + 2); |
| } |
| PrintF("%*s}\n", n0, ""); |
| } |
| } |
| } |
| #endif |
| |
| } } // namespace v8::internal |