+ av_push((AV *)namesv, aname);
+ }
+ }
+
+ /* Get a list of all the affected classes. */
+ /* We cannot simply pass them all to mro_isa_changed_in to avoid
+ the list, as that function assumes that only one package has
+ changed. It does not work with:
+
+ @foo::ISA = qw( B B::B );
+ *B:: = delete $::{"A::"};
+
+ as neither B nor B::B can be updated before the other, since they
+ will reset caches on foo, which will see either B or B::B with the
+ wrong name. The names must be set on *all* affected stashes before
+ we do anything else. (And linearisations must be cleared, too.)
+ */
+ stashes = (HV *) sv_2mortal((SV *)newHV());
+ mro_gather_and_rename(
+ stashes, (HV *) sv_2mortal((SV *)newHV()),
+ stash, oldstash, namesv
+ );
+
+ /* Once the caches have been wiped on all the classes, call
+ mro_isa_changed_in on each. */
+ hv_iterinit(stashes);
+ while((iter = hv_iternext(stashes))) {
+ HV * const stash = *(HV **)HEK_KEY(HeKEY_hek(iter));
+ if(HvENAME(stash)) {
+ /* We have to restore the original meta->isa (that
+ mro_gather_and_rename set aside for us) this way, in case
+ one class in this list is a superclass of a another class
+ that we have already encountered. In such a case, meta->isa
+ will have been overwritten without old entries being deleted
+ from PL_isarev. */
+ struct mro_meta * const meta = HvMROMETA(stash);
+ if(meta->isa != (HV *)HeVAL(iter)){
+ SvREFCNT_dec(meta->isa);
+ meta->isa
+ = HeVAL(iter) == &PL_sv_yes
+ ? NULL
+ : (HV *)HeVAL(iter);
+ HeVAL(iter) = NULL; /* We donated our reference count. */
+ }
+ mro_isa_changed_in(stash);
+ }
+ }
+}
+
+STATIC void
+S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes,
+ HV *stash, HV *oldstash, SV *namesv)
+{
+ XPVHV* xhv;
+ HE *entry;
+ I32 riter = -1;
+ I32 items = 0;
+ const bool stash_had_name = stash && HvENAME(stash);
+ bool fetched_isarev = FALSE;
+ HV *seen = NULL;
+ HV *isarev = NULL;
+ SV **svp = NULL;
+
+ PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME;
+
+ /* We use the seen_stashes hash to keep track of which packages have
+ been encountered so far. This must be separate from the main list of
+ stashes, as we need to distinguish between stashes being assigned
+ and stashes being replaced/deleted. (A nested stash can be on both
+ sides of an assignment. We cannot simply skip iterating through a
+ stash on the right if we have seen it on the left, as it will not
+ get its ename assigned to it.)
+
+ To avoid allocating extra SVs, instead of a bitfield we can make
+ bizarre use of immortals:
+
+ &PL_sv_undef: seen on the left (oldstash)
+ &PL_sv_no : seen on the right (stash)
+ &PL_sv_yes : seen on both sides
+
+ */
+
+ if(oldstash) {
+ /* Add to the big list. */
+ struct mro_meta * meta;
+ HE * const entry
+ = (HE *)
+ hv_common(
+ seen_stashes, NULL, (const char *)&oldstash, sizeof(HV *), 0,
+ HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
+ );
+ if(HeVAL(entry) == &PL_sv_undef || HeVAL(entry) == &PL_sv_yes) {
+ oldstash = NULL;
+ goto check_stash;
+ }
+ HeVAL(entry)
+ = HeVAL(entry) == &PL_sv_no ? &PL_sv_yes : &PL_sv_undef;
+ meta = HvMROMETA(oldstash);
+ (void)
+ hv_store(
+ stashes, (const char *)&oldstash, sizeof(HV *),
+ meta->isa
+ ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
+ : &PL_sv_yes,
+ 0
+ );
+ CLEAR_LINEAR(meta);
+
+ /* Update the effective name. */
+ if(HvENAME_get(oldstash)) {
+ const HEK * const enamehek = HvENAME_HEK(oldstash);
+ if(SvTYPE(namesv) == SVt_PVAV) {
+ items = AvFILLp((AV *)namesv) + 1;
+ svp = AvARRAY((AV *)namesv);
+ }
+ else {
+ items = 1;
+ svp = &namesv;
+ }
+ while (items--) {
+ const U32 name_utf8 = SvUTF8(*svp);
+ STRLEN len;
+ const char *name = SvPVx_const(*svp, len);
+ if(PL_stashcache) {
+ DEBUG_o(Perl_deb(aTHX_ "mro_gather_and_rename clearing PL_stashcache for '%"SVf"'\n",
+ *svp));
+ (void)hv_delete(PL_stashcache, name, name_utf8 ? -(I32)len : (I32)len, G_DISCARD);
+ }
+ ++svp;
+ hv_ename_delete(oldstash, name, len, name_utf8);
+
+ if (!fetched_isarev) {
+ /* If the name deletion caused a name change, then we
+ * are not going to call mro_isa_changed_in with this
+ * name (and not at all if it has become anonymous) so
+ * we need to delete old isarev entries here, both
+ * those in the superclasses and this class's own list
+ * of subclasses. We simply delete the latter from
+ * PL_isarev, since we still need it. hv_delete morti-
+ * fies it for us, so sv_2mortal is not necessary. */
+ if(HvENAME_HEK(oldstash) != enamehek) {
+ if(meta->isa && HvARRAY(meta->isa))
+ mro_clean_isarev(meta->isa, name, len, 0, name_utf8);
+ isarev = (HV *)hv_delete(PL_isarev, name,
+ name_utf8 ? -(I32)len : (I32)len, 0);
+ fetched_isarev=TRUE;
+ }
+ }
+ }
+ }
+ }
+ check_stash:
+ if(stash) {
+ if(SvTYPE(namesv) == SVt_PVAV) {
+ items = AvFILLp((AV *)namesv) + 1;
+ svp = AvARRAY((AV *)namesv);
+ }
+ else {
+ items = 1;
+ svp = &namesv;
+ }
+ while (items--) {
+ const U32 name_utf8 = SvUTF8(*svp);
+ STRLEN len;
+ const char *name = SvPVx_const(*svp++, len);
+ hv_ename_add(stash, name, len, name_utf8);
+ }
+
+ /* Add it to the big list if it needs
+ * mro_isa_changed_in called on it. That happens if it was
+ * detached from the symbol table (so it had no HvENAME) before
+ * being assigned to the spot named by the 'name' variable, because
+ * its cached isa linearisation is now stale (the effective name
+ * having changed), and subclasses will then use that cache when
+ * mro_package_moved calls mro_isa_changed_in. (See
+ * [perl #77358].)
+ *
+ * If it did have a name, then its previous name is still
+ * used in isa caches, and there is no need for
+ * mro_package_moved to call mro_isa_changed_in.
+ */
+
+ entry
+ = (HE *)
+ hv_common(
+ seen_stashes, NULL, (const char *)&stash, sizeof(HV *), 0,
+ HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
+ );
+ if(HeVAL(entry) == &PL_sv_yes || HeVAL(entry) == &PL_sv_no)
+ stash = NULL;
+ else {
+ HeVAL(entry)
+ = HeVAL(entry) == &PL_sv_undef ? &PL_sv_yes : &PL_sv_no;
+ if(!stash_had_name)
+ {
+ struct mro_meta * const meta = HvMROMETA(stash);
+ (void)
+ hv_store(
+ stashes, (const char *)&stash, sizeof(HV *),
+ meta->isa
+ ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
+ : &PL_sv_yes,
+ 0
+ );
+ CLEAR_LINEAR(meta);
+ }
+ }
+ }
+
+ if(!stash && !oldstash)
+ /* Both stashes have been encountered already. */
+ return;
+
+ /* Add all the subclasses to the big list. */
+ if(!fetched_isarev) {
+ /* If oldstash is not null, then we can use its HvENAME to look up
+ the isarev hash, since all its subclasses will be listed there.
+ It will always have an HvENAME. It the HvENAME was removed
+ above, then fetch_isarev will be true, and this code will not be
+ reached.
+
+ If oldstash is null, then this is an empty spot with no stash in
+ it, so subclasses could be listed in isarev hashes belonging to
+ any of the names, so we have to check all of them.
+ */
+ assert(!oldstash || HvENAME(oldstash));
+ if (oldstash) {
+ /* Extra variable to avoid a compiler warning */
+ char * const hvename = HvENAME(oldstash);
+ fetched_isarev = TRUE;
+ svp = hv_fetch(PL_isarev, hvename,
+ HvENAMEUTF8(oldstash)
+ ? -HvENAMELEN_get(oldstash)
+ : HvENAMELEN_get(oldstash), 0);
+ if (svp) isarev = MUTABLE_HV(*svp);
+ }
+ else if(SvTYPE(namesv) == SVt_PVAV) {
+ items = AvFILLp((AV *)namesv) + 1;
+ svp = AvARRAY((AV *)namesv);
+ }
+ else {
+ items = 1;
+ svp = &namesv;
+ }
+ }
+ if(
+ isarev || !fetched_isarev
+ ) {
+ while (fetched_isarev || items--) {
+ HE *iter;
+
+ if (!fetched_isarev) {
+ HE * const he = hv_fetch_ent(PL_isarev, *svp++, 0, 0);
+ if (!he || !(isarev = MUTABLE_HV(HeVAL(he)))) continue;
+ }
+
+ hv_iterinit(isarev);
+ while((iter = hv_iternext(isarev))) {
+ HV* revstash = gv_stashsv(hv_iterkeysv(iter), 0);
+ struct mro_meta * meta;
+
+ if(!revstash) continue;
+ meta = HvMROMETA(revstash);
+ (void)
+ hv_store(
+ stashes, (const char *)&revstash, sizeof(HV *),
+ meta->isa
+ ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
+ : &PL_sv_yes,
+ 0
+ );
+ CLEAR_LINEAR(meta);