mro.c

   1 /*    mro.c
   2  *
   3  *    Copyright (c) 2007 Brandon L Black
   4  *    Copyright (c) 2007, 2008, 2009, 2010, 2011 Larry Wall and others
   5  *
   6  *    You may distribute under the terms of either the GNU General Public
   7  *    License or the Artistic License, as specified in the README file.
   8  *
   9  */
  10
  11 /*
  12  * 'Which order shall we go in?' said Frodo.  'Eldest first, or quickest first?
  13  *  You'll be last either way, Master Peregrin.'
  14  *
  15  *     [p.101 of _The Lord of the Rings_, I/iii: "A Conspiracy Unmasked"]
  16  */
  17
  18 /*
  19 =head1 MRO Functions
  20
  21 These functions are related to the method resolution order of perl classes
  22
  23 =cut
  24 */
  25
  26 #include "EXTERN.h"
  27 #define PERL_IN_MRO_C
  28 #include "perl.h"
  29
  30 static const struct mro_alg dfs_alg =
  31     {S_mro_get_linear_isa_dfs, "dfs", 3, 0, 0};
  32
  33 SV *
  34 Perl_mro_get_private_data(pTHX_ struct mro_meta *const smeta,
  35                           const struct mro_alg *const which)
  36 {
  37     SV **data;
  38     PERL_ARGS_ASSERT_MRO_GET_PRIVATE_DATA;
  39
  40     data = (SV **)Perl_hv_common(aTHX_ smeta->mro_linear_all, NULL,
  41                                  which->name, which->length, which->kflags,
  42                                  HV_FETCH_JUST_SV, NULL, which->hash);
  43     if (!data)
  44         return NULL;
  45
  46     /* If we've been asked to look up the private data for the current MRO, then
  47        cache it.  */
  48     if (smeta->mro_which == which)
  49         smeta->mro_linear_current = *data;
  50
  51     return *data;
  52 }
  53
  54 SV *
  55 Perl_mro_set_private_data(pTHX_ struct mro_meta *const smeta,
  56                           const struct mro_alg *const which, SV *const data)
  57 {
  58     PERL_ARGS_ASSERT_MRO_SET_PRIVATE_DATA;
  59
  60     if (!smeta->mro_linear_all) {
  61         if (smeta->mro_which == which) {
  62             /* If all we need to store is the current MRO's data, then don't use
  63                memory on a hash with 1 element - store it direct, and signal
  64                this by leaving the would-be-hash NULL.  */
  65             smeta->mro_linear_current = data;
  66             return data;
  67         } else {
  68             HV *const hv = newHV();
  69             /* Start with 2 buckets. It's unlikely we'll need more. */
  70             HvMAX(hv) = 1;
  71             smeta->mro_linear_all = hv;
  72
  73             if (smeta->mro_linear_current) {
  74                 /* If we were storing something directly, put it in the hash
  75                    before we lose it. */
  76                 Perl_mro_set_private_data(aTHX_ smeta, smeta->mro_which,
  77                                           smeta->mro_linear_current);
  78             }
  79         }
  80     }
  81
  82     /* We get here if we're storing more than one linearisation for this stash,
  83        or the linearisation we are storing is not that if its current MRO.  */
  84
  85     if (smeta->mro_which == which) {
  86         /* If we've been asked to store the private data for the current MRO,
  87            then cache it.  */
  88         smeta->mro_linear_current = data;
  89     }
  90
  91     if (!Perl_hv_common(aTHX_ smeta->mro_linear_all, NULL,
  92                         which->name, which->length, which->kflags,
  93                         HV_FETCH_ISSTORE, data, which->hash)) {
  94         Perl_croak(aTHX_ "panic: hv_store() failed in set_mro_private_data() "
  95                    "for '%.*s' %d", (int) which->length, which->name,
  96                    which->kflags);
  97     }
  98
  99     return data;
 100 }
 101
 102 const struct mro_alg *
 103 Perl_mro_get_from_name(pTHX_ SV *name) {
 104     SV **data;
 105
 106     PERL_ARGS_ASSERT_MRO_GET_FROM_NAME;
 107
 108     data = (SV **)Perl_hv_common(aTHX_ PL_registered_mros, name, NULL, 0, 0,
 109                                  HV_FETCH_JUST_SV, NULL, 0);
 110     if (!data)
 111         return NULL;
 112     assert(SvTYPE(*data) == SVt_IV);
 113     assert(SvIOK(*data));
 114     return INT2PTR(const struct mro_alg *, SvUVX(*data));
 115 }
 116
 117 /*
 118 =for apidoc mro_register
 119 Registers a custom mro plugin.  See L<perlmroapi> for details.
 120
 121 =cut
 122 */
 123
 124 void
 125 Perl_mro_register(pTHX_ const struct mro_alg *mro) {
 126     SV *wrapper = newSVuv(PTR2UV(mro));
 127
 128     PERL_ARGS_ASSERT_MRO_REGISTER;
 129
 130
 131     if (!Perl_hv_common(aTHX_ PL_registered_mros, NULL,
 132                         mro->name, mro->length, mro->kflags,
 133                         HV_FETCH_ISSTORE, wrapper, mro->hash)) {
 134         SvREFCNT_dec_NN(wrapper);
 135         Perl_croak(aTHX_ "panic: hv_store() failed in mro_register() "
 136                    "for '%.*s' %d", (int) mro->length, mro->name, mro->kflags);
 137     }
 138 }
 139
 140 struct mro_meta*
 141 Perl_mro_meta_init(pTHX_ HV* stash)
 142 {
 143     struct mro_meta* newmeta;
 144
 145     PERL_ARGS_ASSERT_MRO_META_INIT;
 146     assert(HvAUX(stash));
 147     assert(!(HvAUX(stash)->xhv_mro_meta));
 148     Newxz(newmeta, 1, struct mro_meta);
 149     HvAUX(stash)->xhv_mro_meta = newmeta;
 150     newmeta->cache_gen = 1;
 151     newmeta->pkg_gen = 1;
 152     newmeta->mro_which = &dfs_alg;
 153
 154     return newmeta;
 155 }
 156
 157 #if defined(USE_ITHREADS)
 158
 159 /* for sv_dup on new threads */
 160 struct mro_meta*
 161 Perl_mro_meta_dup(pTHX_ struct mro_meta* smeta, CLONE_PARAMS* param)
 162 {
 163     struct mro_meta* newmeta;
 164
 165     PERL_ARGS_ASSERT_MRO_META_DUP;
 166
 167     Newx(newmeta, 1, struct mro_meta);
 168     Copy(smeta, newmeta, 1, struct mro_meta);
 169
 170     if (newmeta->mro_linear_all) {
 171         newmeta->mro_linear_all
 172             = MUTABLE_HV(sv_dup_inc((const SV *)newmeta->mro_linear_all, param));
 173         /* This is just acting as a shortcut pointer, and will be automatically
 174            updated on the first get.  */
 175         newmeta->mro_linear_current = NULL;
 176     } else if (newmeta->mro_linear_current) {
 177         /* Only the current MRO is stored, so this owns the data.  */
 178         newmeta->mro_linear_current
 179             = sv_dup_inc((const SV *)newmeta->mro_linear_current, param);
 180     }
 181
 182     if (newmeta->mro_nextmethod)
 183         newmeta->mro_nextmethod
 184             = MUTABLE_HV(sv_dup_inc((const SV *)newmeta->mro_nextmethod, param));
 185     if (newmeta->isa)
 186         newmeta->isa
 187             = MUTABLE_HV(sv_dup_inc((const SV *)newmeta->isa, param));
 188
 189     newmeta->super = NULL;
 190
 191     return newmeta;
 192 }
 193
 194 #endif /* USE_ITHREADS */
 195
 196 /*
 197 =for apidoc mro_get_linear_isa_dfs
 198
 199 Returns the Depth-First Search linearization of @ISA
 200 the given stash.  The return value is a read-only AV*.
 201 C<level> should be 0 (it is used internally in this
 202 function's recursion).
 203
 204 You are responsible for C<SvREFCNT_inc()> on the
 205 return value if you plan to store it anywhere
 206 semi-permanently (otherwise it might be deleted
 207 out from under you the next time the cache is
 208 invalidated).
 209
 210 =cut
 211 */
 212 static AV*
 213 S_mro_get_linear_isa_dfs(pTHX_ HV *stash, U32 level)
 214 {
 215     AV* retval;
 216     GV** gvp;
 217     GV* gv;
 218     AV* av;
 219     const HEK* stashhek;
 220     struct mro_meta* meta;
 221     SV *our_name;
 222     HV *stored = NULL;
 223
 224     PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS;
 225     assert(HvAUX(stash));
 226
 227     stashhek
 228      = HvAUX(stash)->xhv_name_u.xhvnameu_name && HvENAME_HEK_NN(stash)
 229         ? HvENAME_HEK_NN(stash)
 230         : HvNAME_HEK(stash);
 231
 232     if (!stashhek)
 233       Perl_croak(aTHX_ "Can't linearize anonymous symbol table");
 234
 235     if (level > 100)
 236         Perl_croak(aTHX_
 237                   "Recursive inheritance detected in package '%"HEKf"'",
 238                    HEKfARG(stashhek));
 239
 240     meta = HvMROMETA(stash);
 241
 242     /* return cache if valid */
 243     if((retval = MUTABLE_AV(MRO_GET_PRIVATE_DATA(meta, &dfs_alg)))) {
 244         return retval;
 245     }
 246
 247     /* not in cache, make a new one */
 248
 249     retval = MUTABLE_AV(sv_2mortal(MUTABLE_SV(newAV())));
 250     /* We use this later in this function, but don't need a reference to it
 251        beyond the end of this function, so reference count is fine.  */
 252     our_name = newSVhek(stashhek);
 253     av_push(retval, our_name); /* add ourselves at the top */
 254
 255     /* fetch our @ISA */
 256     gvp = (GV**)hv_fetchs(stash, "ISA", FALSE);
 257     av = (gvp && (gv = *gvp) && isGV_with_GP(gv)) ? GvAV(gv) : NULL;
 258
 259     /* "stored" is used to keep track of all of the classnames we have added to
 260        the MRO so far, so we can do a quick exists check and avoid adding
 261        duplicate classnames to the MRO as we go.
 262        It's then retained to be re-used as a fast lookup for ->isa(), by adding
 263        our own name and "UNIVERSAL" to it.  */
 264
 265     if(av && AvFILLp(av) >= 0) {
 266
 267         SV **svp = AvARRAY(av);
 268         I32 items = AvFILLp(av) + 1;
 269
 270         /* foreach(@ISA) */
 271         while (items--) {
 272             SV* const sv = *svp ? *svp : &PL_sv_undef;
 273             HV* const basestash = gv_stashsv(sv, 0);
 274             SV *const *subrv_p;
 275             I32 subrv_items;
 276             svp++;
 277
 278             if (!basestash) {
 279                 /* if no stash exists for this @ISA member,
 280                    simply add it to the MRO and move on */
 281                 subrv_p = &sv;
 282                 subrv_items = 1;
 283             }
 284             else {
 285                 /* otherwise, recurse into ourselves for the MRO
 286                    of this @ISA member, and append their MRO to ours.
 287                    The recursive call could throw an exception, which
 288                    has memory management implications here, hence the use of
 289                    the mortal.  */
 290                 const AV *const subrv
 291                     = mro_get_linear_isa_dfs(basestash, level + 1);
 292
 293                 subrv_p = AvARRAY(subrv);
 294                 subrv_items = AvFILLp(subrv) + 1;
 295             }
 296             if (stored) {
 297                 while(subrv_items--) {
 298                     SV *const subsv = *subrv_p++;
 299                     /* LVALUE fetch will create a new undefined SV if necessary
 300                      */
 301                     HE *const he = hv_fetch_ent(stored, subsv, 1, 0);
 302                     assert(he);
 303                     if(HeVAL(he) != &PL_sv_undef) {
 304                         /* It was newly created.  Steal it for our new SV, and
 305                            replace it in the hash with the "real" thing.  */
 306                         SV *const val = HeVAL(he);
 307                         HEK *const key = HeKEY_hek(he);
 308
 309                         HeVAL(he) = &PL_sv_undef;
 310                         /* Save copying by making a shared hash key scalar. We
 311                            inline this here rather than calling
 312                            Perl_newSVpvn_share because we already have the
 313                            scalar, and we already have the hash key.  */
 314                         assert(SvTYPE(val) == SVt_NULL);
 315                         sv_upgrade(val, SVt_PV);
 316                         SvPV_set(val, HEK_KEY(share_hek_hek(key)));
 317                         SvCUR_set(val, HEK_LEN(key));
 318                         SvIsCOW_on(val);
 319                         SvPOK_on(val);
 320                         if (HEK_UTF8(key))
 321                             SvUTF8_on(val);
 322
 323                         av_push(retval, val);
 324                     }
 325                 }
 326             } else {
 327                 /* We are the first (or only) parent. We can short cut the
 328                    complexity above, because our @ISA is simply us prepended
 329                    to our parent's @ISA, and our ->isa cache is simply our
 330                    parent's, with our name added.  */
 331                 /* newSVsv() is slow. This code is only faster if we can avoid
 332                    it by ensuring that SVs in the arrays are shared hash key
 333                    scalar SVs, because we can "copy" them very efficiently.
 334                    Although to be fair, we can't *ensure* this, as a reference
 335                    to the internal array is returned by mro::get_linear_isa(),
 336                    so we'll have to be defensive just in case someone faffed
 337                    with it.  */
 338                 if (basestash) {
 339                     SV **svp;
 340                     stored = MUTABLE_HV(sv_2mortal((SV*)newHVhv(HvMROMETA(basestash)->isa)));
 341                     av_extend(retval, subrv_items);
 342                     AvFILLp(retval) = subrv_items;
 343                     svp = AvARRAY(retval);
 344                     while(subrv_items--) {
 345                         SV *const val = *subrv_p++;
 346                         *++svp = SvIsCOW_shared_hash(val)
 347                             ? newSVhek(SvSHARED_HEK_FROM_PV(SvPVX(val)))
 348                             : newSVsv(val);
 349                     }
 350                 } else {
 351                     /* They have no stash.  So create ourselves an ->isa cache
 352                        as if we'd copied it from what theirs should be.  */
 353                     stored = MUTABLE_HV(sv_2mortal(MUTABLE_SV(newHV())));
 354                     (void) hv_store(stored, "UNIVERSAL", 9, &PL_sv_undef, 0);
 355                     av_push(retval,
 356                             newSVhek(HeKEY_hek(hv_store_ent(stored, sv,
 357                                                             &PL_sv_undef, 0))));
 358                 }
 359             }
 360         }
 361     } else {
 362         /* We have no parents.  */
 363         stored = MUTABLE_HV(sv_2mortal(MUTABLE_SV(newHV())));
 364         (void) hv_store(stored, "UNIVERSAL", 9, &PL_sv_undef, 0);
 365     }
 366
 367     (void) hv_store_ent(stored, our_name, &PL_sv_undef, 0);
 368
 369     SvREFCNT_inc_simple_void_NN(stored);
 370     SvTEMP_off(stored);
 371     SvREADONLY_on(stored);
 372
 373     meta->isa = stored;
 374
 375     /* now that we're past the exception dangers, grab our own reference to
 376        the AV we're about to use for the result. The reference owned by the
 377        mortals' stack will be released soon, so everything will balance.  */
 378     SvREFCNT_inc_simple_void_NN(retval);
 379     SvTEMP_off(retval);
 380
 381     /* we don't want anyone modifying the cache entry but us,
 382        and we do so by replacing it completely */
 383     SvREADONLY_on(retval);
 384
 385     return MUTABLE_AV(Perl_mro_set_private_data(aTHX_ meta, &dfs_alg,
 386                                                 MUTABLE_SV(retval)));
 387 }
 388
 389 /*
 390 =for apidoc mro_get_linear_isa
 391
 392 Returns the mro linearisation for the given stash.  By default, this
 393 will be whatever C<mro_get_linear_isa_dfs> returns unless some
 394 other MRO is in effect for the stash.  The return value is a
 395 read-only AV*.
 396
 397 You are responsible for C<SvREFCNT_inc()> on the
 398 return value if you plan to store it anywhere
 399 semi-permanently (otherwise it might be deleted
 400 out from under you the next time the cache is
 401 invalidated).
 402
 403 =cut
 404 */
 405 AV*
 406 Perl_mro_get_linear_isa(pTHX_ HV *stash)
 407 {
 408     struct mro_meta* meta;
 409     AV *isa;
 410
 411     PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA;
 412     if(!SvOOK(stash))
 413         Perl_croak(aTHX_ "Can't linearize anonymous symbol table");
 414
 415     meta = HvMROMETA(stash);
 416     if (!meta->mro_which)
 417         Perl_croak(aTHX_ "panic: invalid MRO!");
 418     isa = meta->mro_which->resolve(aTHX_ stash, 0);
 419
 420     if (meta->mro_which != &dfs_alg) { /* skip for dfs, for speed */
 421         SV * const namesv =
 422             (HvENAME(stash)||HvNAME(stash))
 423               ? newSVhek(HvENAME_HEK(stash)
 424                           ? HvENAME_HEK(stash)
 425                           : HvNAME_HEK(stash))
 426               : NULL;
 427
 428         if(namesv && (AvFILLp(isa) == -1 || !sv_eq(*AvARRAY(isa), namesv)))
 429         {
 430             AV * const old = isa;
 431             SV **svp;
 432             SV **ovp = AvARRAY(old);
 433             SV * const * const oend = ovp + AvFILLp(old) + 1;
 434             isa = (AV *)sv_2mortal((SV *)newAV());
 435             av_extend(isa, AvFILLp(isa) = AvFILLp(old)+1);
 436             *AvARRAY(isa) = namesv;
 437             svp = AvARRAY(isa)+1;
 438             while (ovp < oend) *svp++ = SvREFCNT_inc(*ovp++);
 439         }
 440         else SvREFCNT_dec(namesv);
 441     }
 442
 443     if (!meta->isa) {
 444             HV *const isa_hash = newHV();
 445             /* Linearisation didn't build it for us, so do it here.  */
 446             SV *const *svp = AvARRAY(isa);
 447             SV *const *const svp_end = svp + AvFILLp(isa) + 1;
 448             const HEK *canon_name = HvENAME_HEK(stash);
 449             if (!canon_name) canon_name = HvNAME_HEK(stash);
 450
 451             while (svp < svp_end) {
 452                 (void) hv_store_ent(isa_hash, *svp++, &PL_sv_undef, 0);
 453             }
 454
 455             (void) hv_common(isa_hash, NULL, HEK_KEY(canon_name),
 456                              HEK_LEN(canon_name), HEK_FLAGS(canon_name),
 457                              HV_FETCH_ISSTORE, &PL_sv_undef,
 458                              HEK_HASH(canon_name));
 459             (void) hv_store(isa_hash, "UNIVERSAL", 9, &PL_sv_undef, 0);
 460
 461             SvREADONLY_on(isa_hash);
 462
 463             meta->isa = isa_hash;
 464     }
 465
 466     return isa;
 467 }
 468
 469 /*
 470 =for apidoc mro_isa_changed_in
 471
 472 Takes the necessary steps (cache invalidations, mostly)
 473 when the @ISA of the given package has changed.  Invoked
 474 by the C<setisa> magic, should not need to invoke directly.
 475
 476 =cut
 477 */
 478
 479 /* Macro to avoid repeating the code five times. */
 480 #define CLEAR_LINEAR(mEta)                                     \
 481     if (mEta->mro_linear_all) {                                 \
 482         SvREFCNT_dec(MUTABLE_SV(mEta->mro_linear_all));          \
 483         mEta->mro_linear_all = NULL;                              \
 484         /* This is just acting as a shortcut pointer.  */          \
 485         mEta->mro_linear_current = NULL;                            \
 486     } else if (mEta->mro_linear_current) {                           \
 487         /* Only the current MRO is stored, so this owns the data.  */ \
 488         SvREFCNT_dec(mEta->mro_linear_current);                        \
 489         mEta->mro_linear_current = NULL;                                \
 490     }
 491
 492 void
 493 Perl_mro_isa_changed_in(pTHX_ HV* stash)
 494 {
 495     dVAR;
 496     HV* isarev;
 497     AV* linear_mro;
 498     HE* iter;
 499     SV** svp;
 500     I32 items;
 501     bool is_universal;
 502     struct mro_meta * meta;
 503     HV *isa = NULL;
 504
 505     const HEK * const stashhek = HvENAME_HEK(stash);
 506     const char * const stashname = HvENAME_get(stash);
 507     const STRLEN stashname_len = HvENAMELEN_get(stash);
 508
 509     PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN;
 510
 511     if(!stashname)
 512         Perl_croak(aTHX_ "Can't call mro_isa_changed_in() on anonymous symbol table");
 513
 514
 515     /* wipe out the cached linearizations for this stash */
 516     meta = HvMROMETA(stash);
 517     CLEAR_LINEAR(meta);
 518     if (meta->isa) {
 519         /* Steal it for our own purposes. */
 520         isa = (HV *)sv_2mortal((SV *)meta->isa);
 521         meta->isa = NULL;
 522     }
 523
 524     /* Inc the package generation, since our @ISA changed */
 525     meta->pkg_gen++;
 526
 527     /* Wipe the global method cache if this package
 528        is UNIVERSAL or one of its parents */
 529
 530     svp = hv_fetchhek(PL_isarev, stashhek, 0);
 531     isarev = svp ? MUTABLE_HV(*svp) : NULL;
 532
 533     if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
 534         || (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
 535         PL_sub_generation++;
 536         is_universal = TRUE;
 537     }
 538     else { /* Wipe the local method cache otherwise */
 539         meta->cache_gen++;
 540         is_universal = FALSE;
 541     }
 542
 543     /* wipe next::method cache too */
 544     if(meta->mro_nextmethod) hv_clear(meta->mro_nextmethod);
 545
 546     /* Changes to @ISA might turn overloading on */
 547     HvAMAGIC_on(stash);
 548     /* pessimise derefs for now. Will get recalculated by Gv_AMupdate() */
 549     HvAUX(stash)->xhv_aux_flags &= ~HvAUXf_NO_DEREF;
 550
 551     /* DESTROY can be cached in SvSTASH. */
 552     if (!SvOBJECT(stash)) SvSTASH(stash) = NULL;
 553
 554     /* Iterate the isarev (classes that are our children),
 555        wiping out their linearization, method and isa caches
 556        and upating PL_isarev. */
 557     if(isarev) {
 558         HV *isa_hashes = NULL;
 559
 560        /* We have to iterate through isarev twice to avoid a chicken and
 561         * egg problem: if A inherits from B and both are in isarev, A might
 562         * be processed before B and use B's previous linearisation.
 563         */
 564
 565        /* First iteration: Wipe everything, but stash away the isa hashes
 566         * since we still need them for updating PL_isarev.
 567         */
 568
 569         if(hv_iterinit(isarev)) {
 570             /* Only create the hash if we need it; i.e., if isarev has
 571                any elements. */
 572             isa_hashes = (HV *)sv_2mortal((SV *)newHV());
 573         }
 574         while((iter = hv_iternext(isarev))) {
 575             HV* revstash = gv_stashsv(hv_iterkeysv(iter), 0);
 576             struct mro_meta* revmeta;
 577
 578             if(!revstash) continue;
 579             revmeta = HvMROMETA(revstash);
 580             CLEAR_LINEAR(revmeta);
 581             if(!is_universal)
 582                 revmeta->cache_gen++;
 583             if(revmeta->mro_nextmethod)
 584                 hv_clear(revmeta->mro_nextmethod);
 585             if (!SvOBJECT(revstash)) SvSTASH(revstash) = NULL;
 586
 587             (void)
 588               hv_store(
 589                isa_hashes, (const char*)&revstash, sizeof(HV *),
 590                revmeta->isa ? (SV *)revmeta->isa : &PL_sv_undef, 0
 591               );
 592             revmeta->isa = NULL;
 593         }
 594
 595        /* Second pass: Update PL_isarev. We can just use isa_hashes to
 596         * avoid another round of stash lookups. */
 597
 598        /* isarev might be deleted from PL_isarev during this loop, so hang
 599         * on to it. */
 600         SvREFCNT_inc_simple_void_NN(sv_2mortal((SV *)isarev));
 601
 602         if(isa_hashes) {
 603             hv_iterinit(isa_hashes);
 604             while((iter = hv_iternext(isa_hashes))) {
 605                 HV* const revstash = *(HV **)HEK_KEY(HeKEY_hek(iter));
 606                 HV * const isa = (HV *)HeVAL(iter);
 607                 const HEK *namehek;
 608
 609                 /* We're starting at the 2nd element, skipping revstash */
 610                 linear_mro = mro_get_linear_isa(revstash);
 611                 svp = AvARRAY(linear_mro) + 1;
 612                 items = AvFILLp(linear_mro);
 613
 614                 namehek = HvENAME_HEK(revstash);
 615                 if (!namehek) namehek = HvNAME_HEK(revstash);
 616
 617                 while (items--) {
 618                     SV* const sv = *svp++;
 619                     HV* mroisarev;
 620
 621                     HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
 622
 623                     /* That fetch should not fail.  But if it had to create
 624                        a new SV for us, then will need to upgrade it to an
 625                        HV (which sv_upgrade() can now do for us). */
 626
 627                     mroisarev = MUTABLE_HV(HeVAL(he));
 628
 629                     SvUPGRADE(MUTABLE_SV(mroisarev), SVt_PVHV);
 630
 631                     /* This hash only ever contains PL_sv_yes. Storing it
 632                        over itself is almost as cheap as calling hv_exists,
 633                        so on aggregate we expect to save time by not making
 634                        two calls to the common HV code for the case where
 635                        it doesn't exist.  */
 636
 637                     (void)
 638                       hv_storehek(mroisarev, namehek, &PL_sv_yes);
 639                 }
 640
 641                 if((SV *)isa != &PL_sv_undef)
 642                     mro_clean_isarev(
 643                      isa, HEK_KEY(namehek), HEK_LEN(namehek),
 644                      HvMROMETA(revstash)->isa, HEK_HASH(namehek),
 645                      HEK_UTF8(namehek)
 646                     );
 647             }
 648         }
 649     }
 650
 651     /* Now iterate our MRO (parents), adding ourselves and everything from
 652        our isarev to their isarev.
 653     */
 654
 655     /* We're starting at the 2nd element, skipping ourselves here */
 656     linear_mro = mro_get_linear_isa(stash);
 657     svp = AvARRAY(linear_mro) + 1;
 658     items = AvFILLp(linear_mro);
 659
 660     while (items--) {
 661         SV* const sv = *svp++;
 662         HV* mroisarev;
 663
 664         HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
 665
 666         /* That fetch should not fail.  But if it had to create a new SV for
 667            us, then will need to upgrade it to an HV (which sv_upgrade() can
 668            now do for us. */
 669
 670         mroisarev = MUTABLE_HV(HeVAL(he));
 671
 672         SvUPGRADE(MUTABLE_SV(mroisarev), SVt_PVHV);
 673
 674         /* This hash only ever contains PL_sv_yes. Storing it over itself is
 675            almost as cheap as calling hv_exists, so on aggregate we expect to
 676            save time by not making two calls to the common HV code for the
 677            case where it doesn't exist.  */
 678
 679         (void)hv_storehek(mroisarev, stashhek, &PL_sv_yes);
 680     }
 681
 682     /* Delete our name from our former parents' isarevs. */
 683     if(isa && HvARRAY(isa))
 684         mro_clean_isarev(isa, stashname, stashname_len, meta->isa,
 685                          HEK_HASH(stashhek), HEK_UTF8(stashhek));
 686 }
 687
 688 /* Deletes name from all the isarev entries listed in isa */
 689 STATIC void
 690 S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name,
 691                          const STRLEN len, HV * const exceptions, U32 hash,
 692                          U32 flags)
 693 {
 694     HE* iter;
 695
 696     PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV;
 697
 698     /* Delete our name from our former parents' isarevs. */
 699     if(isa && HvARRAY(isa) && hv_iterinit(isa)) {
 700         SV **svp;
 701         while((iter = hv_iternext(isa))) {
 702             I32 klen;
 703             const char * const key = hv_iterkey(iter, &klen);
 704             if(exceptions && hv_exists(exceptions, key, HeKUTF8(iter) ? -klen : klen))
 705                 continue;
 706             svp = hv_fetch(PL_isarev, key, HeKUTF8(iter) ? -klen : klen, 0);
 707             if(svp) {
 708                 HV * const isarev = (HV *)*svp;
 709                 (void)hv_common(isarev, NULL, name, len, flags,
 710                                 G_DISCARD|HV_DELETE, NULL, hash);
 711                 if(!HvARRAY(isarev) || !HvUSEDKEYS(isarev))
 712                     (void)hv_delete(PL_isarev, key,
 713                                         HeKUTF8(iter) ? -klen : klen, G_DISCARD);
 714             }
 715         }
 716     }
 717 }
 718
 719 /*
 720 =for apidoc mro_package_moved
 721
 722 Call this function to signal to a stash that it has been assigned to
 723 another spot in the stash hierarchy.  C<stash> is the stash that has been
 724 assigned.  C<oldstash> is the stash it replaces, if any.  C<gv> is the glob
 725 that is actually being assigned to.
 726
 727 This can also be called with a null first argument to
 728 indicate that C<oldstash> has been deleted.
 729
 730 This function invalidates isa caches on the old stash, on all subpackages
 731 nested inside it, and on the subclasses of all those, including
 732 non-existent packages that have corresponding entries in C<stash>.
 733
 734 It also sets the effective names (C<HvENAME>) on all the stashes as
 735 appropriate.
 736
 737 If the C<gv> is present and is not in the symbol table, then this function
 738 simply returns.  This checked will be skipped if C<flags & 1>.
 739
 740 =cut
 741 */
 742 void
 743 Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash,
 744                        const GV * const gv, U32 flags)
 745 {
 746     SV *namesv;
 747     HEK **namep;
 748     I32 name_count;
 749     HV *stashes;
 750     HE* iter;
 751
 752     PERL_ARGS_ASSERT_MRO_PACKAGE_MOVED;
 753     assert(stash || oldstash);
 754
 755     /* Determine the name(s) of the location that stash was assigned to
 756      * or from which oldstash was removed.
 757      *
 758      * We cannot reliably use the name in oldstash, because it may have
 759      * been deleted from the location in the symbol table that its name
 760      * suggests, as in this case:
 761      *
 762      *   $globref = \*foo::bar::;
 763      *   Symbol::delete_package("foo");
 764      *   *$globref = \%baz::;
 765      *   *$globref = *frelp::;
 766      *      # calls mro_package_moved(%frelp::, %baz::, *$globref, NULL, 0)
 767      *
 768      * So we get it from the gv. But, since the gv may no longer be in the
 769      * symbol table, we check that first. The only reliable way to tell is
 770      * to see whether its stash has an effective name and whether the gv
 771      * resides in that stash under its name. That effective name may be
 772      * different from what gv_fullname4 would use.
 773      * If flags & 1, the caller has asked us to skip the check.
 774      */
 775     if(!(flags & 1)) {
 776         SV **svp;
 777         if(
 778          !GvSTASH(gv) || !HvENAME(GvSTASH(gv)) ||
 779          !(svp = hv_fetchhek(GvSTASH(gv), GvNAME_HEK(gv), 0)) ||
 780          *svp != (SV *)gv
 781         ) return;
 782     }
 783     assert(SvOOK(GvSTASH(gv)));
 784     assert(GvNAMELEN(gv));
 785     assert(GvNAME(gv)[GvNAMELEN(gv) - 1] == ':');
 786     assert(GvNAMELEN(gv) == 1 || GvNAME(gv)[GvNAMELEN(gv) - 2] == ':');
 787     name_count = HvAUX(GvSTASH(gv))->xhv_name_count;
 788     if (!name_count) {
 789         name_count = 1;
 790         namep = &HvAUX(GvSTASH(gv))->xhv_name_u.xhvnameu_name;
 791     }
 792     else {
 793         namep = HvAUX(GvSTASH(gv))->xhv_name_u.xhvnameu_names;
 794         if (name_count < 0) ++namep, name_count = -name_count - 1;
 795     }
 796     if (name_count == 1) {
 797         if (HEK_LEN(*namep) == 4 && strnEQ(HEK_KEY(*namep), "main", 4)) {
 798             namesv = GvNAMELEN(gv) == 1
 799                 ? newSVpvs_flags(":", SVs_TEMP)
 800                 : newSVpvs_flags("",  SVs_TEMP);
 801         }
 802         else {
 803             namesv = sv_2mortal(newSVhek(*namep));
 804             if (GvNAMELEN(gv) == 1) sv_catpvs(namesv, ":");
 805             else                    sv_catpvs(namesv, "::");
 806         }
 807         if (GvNAMELEN(gv) != 1) {
 808             sv_catpvn_flags(
 809                 namesv, GvNAME(gv), GvNAMELEN(gv) - 2,
 810                                           /* skip trailing :: */
 811                 GvNAMEUTF8(gv) ? SV_CATUTF8 : SV_CATBYTES
 812             );
 813         }
 814     }
 815     else {
 816         SV *aname;
 817         namesv = sv_2mortal((SV *)newAV());
 818         while (name_count--) {
 819             if(HEK_LEN(*namep) == 4 && strnEQ(HEK_KEY(*namep), "main", 4)){
 820                 aname = GvNAMELEN(gv) == 1
 821                          ? newSVpvs(":")
 822                          : newSVpvs("");
 823                 namep++;
 824             }
 825             else {
 826                 aname = newSVhek(*namep++);
 827                 if (GvNAMELEN(gv) == 1) sv_catpvs(aname, ":");
 828                 else                    sv_catpvs(aname, "::");
 829             }
 830             if (GvNAMELEN(gv) != 1) {
 831                 sv_catpvn_flags(
 832                     aname, GvNAME(gv), GvNAMELEN(gv) - 2,
 833                                           /* skip trailing :: */
 834                     GvNAMEUTF8(gv) ? SV_CATUTF8 : SV_CATBYTES
 835                 );
 836             }
 837             av_push((AV *)namesv, aname);
 838         }
 839     }
 840
 841     /* Get a list of all the affected classes. */
 842     /* We cannot simply pass them all to mro_isa_changed_in to avoid
 843        the list, as that function assumes that only one package has
 844        changed. It does not work with:
 845
 846           @foo::ISA = qw( B B::B );
 847           *B:: = delete $::{"A::"};
 848
 849        as neither B nor B::B can be updated before the other, since they
 850        will reset caches on foo, which will see either B or B::B with the
 851        wrong name. The names must be set on *all* affected stashes before
 852        we do anything else. (And linearisations must be cleared, too.)
 853      */
 854     stashes = (HV *) sv_2mortal((SV *)newHV());
 855     mro_gather_and_rename(
 856      stashes, (HV *) sv_2mortal((SV *)newHV()),
 857      stash, oldstash, namesv
 858     );
 859
 860     /* Once the caches have been wiped on all the classes, call
 861        mro_isa_changed_in on each. */
 862     hv_iterinit(stashes);
 863     while((iter = hv_iternext(stashes))) {
 864         HV * const stash = *(HV **)HEK_KEY(HeKEY_hek(iter));
 865         if(HvENAME(stash)) {
 866             /* We have to restore the original meta->isa (that
 867                mro_gather_and_rename set aside for us) this way, in case
 868                one class in this list is a superclass of a another class
 869                that we have already encountered. In such a case, meta->isa
 870                will have been overwritten without old entries being deleted
 871                from PL_isarev. */
 872             struct mro_meta * const meta = HvMROMETA(stash);
 873             if(meta->isa != (HV *)HeVAL(iter)){
 874                 SvREFCNT_dec(meta->isa);
 875                 meta->isa
 876                  = HeVAL(iter) == &PL_sv_yes
 877                     ? NULL
 878                     : (HV *)HeVAL(iter);
 879                 HeVAL(iter) = NULL; /* We donated our reference count. */
 880             }
 881             mro_isa_changed_in(stash);
 882         }
 883     }
 884 }
 885
 886 STATIC void
 887 S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes,
 888                               HV *stash, HV *oldstash, SV *namesv)
 889 {
 890     XPVHV* xhv;
 891     HE *entry;
 892     I32 riter = -1;
 893     I32 items = 0;
 894     const bool stash_had_name = stash && HvENAME(stash);
 895     bool fetched_isarev = FALSE;
 896     HV *seen = NULL;
 897     HV *isarev = NULL;
 898     SV **svp = NULL;
 899
 900     PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME;
 901
 902     /* We use the seen_stashes hash to keep track of which packages have
 903        been encountered so far. This must be separate from the main list of
 904        stashes, as we need to distinguish between stashes being assigned
 905        and stashes being replaced/deleted. (A nested stash can be on both
 906        sides of an assignment. We cannot simply skip iterating through a
 907        stash on the right if we have seen it on the left, as it will not
 908        get its ename assigned to it.)
 909
 910        To avoid allocating extra SVs, instead of a bitfield we can make
 911        bizarre use of immortals:
 912
 913         &PL_sv_undef:  seen on the left  (oldstash)
 914         &PL_sv_no   :  seen on the right (stash)
 915         &PL_sv_yes  :  seen on both sides
 916
 917      */
 918
 919     if(oldstash) {
 920         /* Add to the big list. */
 921         struct mro_meta * meta;
 922         HE * const entry
 923          = (HE *)
 924              hv_common(
 925               seen_stashes, NULL, (const char *)&oldstash, sizeof(HV *), 0,
 926               HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
 927              );
 928         if(HeVAL(entry) == &PL_sv_undef || HeVAL(entry) == &PL_sv_yes) {
 929             oldstash = NULL;
 930             goto check_stash;
 931         }
 932         HeVAL(entry)
 933          = HeVAL(entry) == &PL_sv_no ? &PL_sv_yes : &PL_sv_undef;
 934         meta = HvMROMETA(oldstash);
 935         (void)
 936           hv_store(
 937            stashes, (const char *)&oldstash, sizeof(HV *),
 938            meta->isa
 939             ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
 940             : &PL_sv_yes,
 941            0
 942           );
 943         CLEAR_LINEAR(meta);
 944
 945         /* Update the effective name. */
 946         if(HvENAME_get(oldstash)) {
 947             const HEK * const enamehek = HvENAME_HEK(oldstash);
 948             if(SvTYPE(namesv) == SVt_PVAV) {
 949                 items = AvFILLp((AV *)namesv) + 1;
 950                 svp = AvARRAY((AV *)namesv);
 951             }
 952             else {
 953                 items = 1;
 954                 svp = &namesv;
 955             }
 956             while (items--) {
 957                 const U32 name_utf8 = SvUTF8(*svp);
 958                 STRLEN len;
 959                 const char *name = SvPVx_const(*svp, len);
 960                 if(PL_stashcache) {
 961                     DEBUG_o(Perl_deb(aTHX_ "mro_gather_and_rename clearing PL_stashcache for '%"SVf"'\n",
 962                                      *svp));
 963                    (void)hv_delete(PL_stashcache, name, name_utf8 ? -(I32)len : (I32)len, G_DISCARD);
 964                 }
 965                 ++svp;
 966                 hv_ename_delete(oldstash, name, len, name_utf8);
 967
 968                 if (!fetched_isarev) {
 969                     /* If the name deletion caused a name change, then we
 970                      * are not going to call mro_isa_changed_in with this
 971                      * name (and not at all if it has become anonymous) so
 972                      * we need to delete old isarev entries here, both
 973                      * those in the superclasses and this class's own list
 974                      * of subclasses. We simply delete the latter from
 975                      * PL_isarev, since we still need it. hv_delete morti-
 976                      * fies it for us, so sv_2mortal is not necessary. */
 977                     if(HvENAME_HEK(oldstash) != enamehek) {
 978                         if(meta->isa && HvARRAY(meta->isa))
 979                             mro_clean_isarev(meta->isa, name, len, 0, 0,
 980                                              name_utf8 ? HVhek_UTF8 : 0);
 981                         isarev = (HV *)hv_delete(PL_isarev, name,
 982                                                     name_utf8 ? -(I32)len : (I32)len, 0);
 983                         fetched_isarev=TRUE;
 984                     }
 985                 }
 986             }
 987         }
 988     }
 989    check_stash:
 990     if(stash) {
 991         if(SvTYPE(namesv) == SVt_PVAV) {
 992             items = AvFILLp((AV *)namesv) + 1;
 993             svp = AvARRAY((AV *)namesv);
 994         }
 995         else {
 996             items = 1;
 997             svp = &namesv;
 998         }
 999         while (items--) {
1000             const U32 name_utf8 = SvUTF8(*svp);
1001             STRLEN len;
1002             const char *name = SvPVx_const(*svp++, len);
1003             hv_ename_add(stash, name, len, name_utf8);
1004         }
1005
1006        /* Add it to the big list if it needs
1007         * mro_isa_changed_in called on it. That happens if it was
1008         * detached from the symbol table (so it had no HvENAME) before
1009         * being assigned to the spot named by the 'name' variable, because
1010         * its cached isa linearisation is now stale (the effective name
1011         * having changed), and subclasses will then use that cache when
1012         * mro_package_moved calls mro_isa_changed_in. (See
1013         * [perl #77358].)
1014         *
1015         * If it did have a name, then its previous name is still
1016         * used in isa caches, and there is no need for
1017         * mro_package_moved to call mro_isa_changed_in.
1018         */
1019
1020         entry
1021          = (HE *)
1022              hv_common(
1023               seen_stashes, NULL, (const char *)&stash, sizeof(HV *), 0,
1024               HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
1025              );
1026         if(HeVAL(entry) == &PL_sv_yes || HeVAL(entry) == &PL_sv_no)
1027             stash = NULL;
1028         else {
1029             HeVAL(entry)
1030              = HeVAL(entry) == &PL_sv_undef ? &PL_sv_yes : &PL_sv_no;
1031             if(!stash_had_name)
1032             {
1033                 struct mro_meta * const meta = HvMROMETA(stash);
1034                 (void)
1035                   hv_store(
1036                    stashes, (const char *)&stash, sizeof(HV *),
1037                    meta->isa
1038                     ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
1039                     : &PL_sv_yes,
1040                    0
1041                   );
1042                 CLEAR_LINEAR(meta);
1043             }
1044         }
1045     }
1046
1047     if(!stash && !oldstash)
1048         /* Both stashes have been encountered already. */
1049         return;
1050
1051     /* Add all the subclasses to the big list. */
1052     if(!fetched_isarev) {
1053         /* If oldstash is not null, then we can use its HvENAME to look up
1054            the isarev hash, since all its subclasses will be listed there.
1055            It will always have an HvENAME. It the HvENAME was removed
1056            above, then fetch_isarev will be true, and this code will not be
1057            reached.
1058
1059            If oldstash is null, then this is an empty spot with no stash in
1060            it, so subclasses could be listed in isarev hashes belonging to
1061            any of the names, so we have to check all of them.
1062          */
1063         assert(!oldstash || HvENAME(oldstash));
1064         if (oldstash) {
1065             /* Extra variable to avoid a compiler warning */
1066             const HEK * const hvename = HvENAME_HEK(oldstash);
1067             fetched_isarev = TRUE;
1068             svp = hv_fetchhek(PL_isarev, hvename, 0);
1069             if (svp) isarev = MUTABLE_HV(*svp);
1070         }
1071         else if(SvTYPE(namesv) == SVt_PVAV) {
1072             items = AvFILLp((AV *)namesv) + 1;
1073             svp = AvARRAY((AV *)namesv);
1074         }
1075         else {
1076             items = 1;
1077             svp = &namesv;
1078         }
1079     }
1080     if(
1081         isarev || !fetched_isarev
1082     ) {
1083       while (fetched_isarev || items--) {
1084         HE *iter;
1085
1086         if (!fetched_isarev) {
1087             HE * const he = hv_fetch_ent(PL_isarev, *svp++, 0, 0);
1088             if (!he || !(isarev = MUTABLE_HV(HeVAL(he)))) continue;
1089         }
1090
1091         hv_iterinit(isarev);
1092         while((iter = hv_iternext(isarev))) {
1093             HV* revstash = gv_stashsv(hv_iterkeysv(iter), 0);
1094             struct mro_meta * meta;
1095
1096             if(!revstash) continue;
1097             meta = HvMROMETA(revstash);
1098             (void)
1099               hv_store(
1100                stashes, (const char *)&revstash, sizeof(HV *),
1101                meta->isa
1102                 ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
1103                 : &PL_sv_yes,
1104                0
1105               );
1106             CLEAR_LINEAR(meta);
1107         }
1108
1109         if (fetched_isarev) break;
1110       }
1111     }
1112
1113     /* This is partly based on code in hv_iternext_flags. We are not call-
1114        ing that here, as we want to avoid resetting the hash iterator. */
1115
1116     /* Skip the entire loop if the hash is empty.   */
1117     if(oldstash && HvUSEDKEYS(oldstash)) {
1118         xhv = (XPVHV*)SvANY(oldstash);
1119         seen = (HV *) sv_2mortal((SV *)newHV());
1120
1121         /* Iterate through entries in the oldstash, adding them to the
1122            list, meanwhile doing the equivalent of $seen{$key} = 1.
1123          */
1124
1125         while (++riter <= (I32)xhv->xhv_max) {
1126             entry = (HvARRAY(oldstash))[riter];
1127
1128             /* Iterate through the entries in this list */
1129             for(; entry; entry = HeNEXT(entry)) {
1130                 const char* key;
1131                 I32 len;
1132
1133                 /* If this entry is not a glob, ignore it.
1134                    Try the next.  */
1135                 if (!isGV(HeVAL(entry))) continue;
1136
1137                 key = hv_iterkey(entry, &len);
1138                 if ((len > 1 && key[len-2] == ':' && key[len-1] == ':')
1139                  || (len == 1 && key[0] == ':')) {
1140                     HV * const oldsubstash = GvHV(HeVAL(entry));
1141                     SV ** const stashentry
1142                      = stash ? hv_fetch(stash, key, HeUTF8(entry) ? -(I32)len : (I32)len, 0) : NULL;
1143                     HV *substash = NULL;
1144
1145                     /* Avoid main::main::main::... */
1146                     if(oldsubstash == oldstash) continue;
1147
1148                     if(
1149                         (
1150                             stashentry && *stashentry && isGV(*stashentry)
1151                          && (substash = GvHV(*stashentry))
1152                         )
1153                      || (oldsubstash && HvENAME_get(oldsubstash))
1154                     )
1155                     {
1156                         /* Add :: and the key (minus the trailing ::)
1157                            to each name. */
1158                         SV *subname;
1159                         if(SvTYPE(namesv) == SVt_PVAV) {
1160                             SV *aname;
1161                             items = AvFILLp((AV *)namesv) + 1;
1162                             svp = AvARRAY((AV *)namesv);
1163                             subname = sv_2mortal((SV *)newAV());
1164                             while (items--) {
1165                                 aname = newSVsv(*svp++);
1166                                 if (len == 1)
1167                                     sv_catpvs(aname, ":");
1168                                 else {
1169                                     sv_catpvs(aname, "::");
1170                                     sv_catpvn_flags(
1171                                         aname, key, len-2,
1172                                         HeUTF8(entry)
1173                                            ? SV_CATUTF8 : SV_CATBYTES
1174                                     );
1175                                 }
1176                                 av_push((AV *)subname, aname);
1177                             }
1178                         }
1179                         else {
1180                             subname = sv_2mortal(newSVsv(namesv));
1181                             if (len == 1) sv_catpvs(subname, ":");
1182                             else {
1183                                 sv_catpvs(subname, "::");
1184                                 sv_catpvn_flags(
1185                                    subname, key, len-2,
1186                                    HeUTF8(entry) ? SV_CATUTF8 : SV_CATBYTES
1187                                 );
1188                             }
1189                         }
1190                         mro_gather_and_rename(
1191                              stashes, seen_stashes,
1192                              substash, oldsubstash, subname
1193                         );
1194                     }
1195
1196                     (void)hv_store(seen, key, HeUTF8(entry) ? -(I32)len : (I32)len, &PL_sv_yes, 0);
1197                 }
1198             }
1199         }
1200     }
1201
1202     /* Skip the entire loop if the hash is empty.   */
1203     if (stash && HvUSEDKEYS(stash)) {
1204         xhv = (XPVHV*)SvANY(stash);
1205         riter = -1;
1206
1207         /* Iterate through the new stash, skipping $seen{$key} items,
1208            calling mro_gather_and_rename(stashes,seen,entry,NULL, ...). */
1209         while (++riter <= (I32)xhv->xhv_max) {
1210             entry = (HvARRAY(stash))[riter];
1211
1212             /* Iterate through the entries in this list */
1213             for(; entry; entry = HeNEXT(entry)) {
1214                 const char* key;
1215                 I32 len;
1216
1217                 /* If this entry is not a glob, ignore it.
1218                    Try the next.  */
1219                 if (!isGV(HeVAL(entry))) continue;
1220
1221                 key = hv_iterkey(entry, &len);
1222                 if ((len > 1 && key[len-2] == ':' && key[len-1] == ':')
1223                  || (len == 1 && key[0] == ':')) {
1224                     HV *substash;
1225
1226                     /* If this entry was seen when we iterated through the
1227                        oldstash, skip it. */
1228                     if(seen && hv_exists(seen, key, HeUTF8(entry) ? -(I32)len : (I32)len)) continue;
1229
1230                     /* We get here only if this stash has no corresponding
1231                        entry in the stash being replaced. */
1232
1233                     substash = GvHV(HeVAL(entry));
1234                     if(substash) {
1235                         SV *subname;
1236
1237                         /* Avoid checking main::main::main::... */
1238                         if(substash == stash) continue;
1239
1240                         /* Add :: and the key (minus the trailing ::)
1241                            to each name. */
1242                         if(SvTYPE(namesv) == SVt_PVAV) {
1243                             SV *aname;
1244                             items = AvFILLp((AV *)namesv) + 1;
1245                             svp = AvARRAY((AV *)namesv);
1246                             subname = sv_2mortal((SV *)newAV());
1247                             while (items--) {
1248                                 aname = newSVsv(*svp++);
1249                                 if (len == 1)
1250                                     sv_catpvs(aname, ":");
1251                                 else {
1252                                     sv_catpvs(aname, "::");
1253                                     sv_catpvn_flags(
1254                                         aname, key, len-2,
1255                                         HeUTF8(entry)
1256                                            ? SV_CATUTF8 : SV_CATBYTES
1257                                     );
1258                                 }
1259                                 av_push((AV *)subname, aname);
1260                             }
1261                         }
1262                         else {
1263                             subname = sv_2mortal(newSVsv(namesv));
1264                             if (len == 1) sv_catpvs(subname, ":");
1265                             else {
1266                                 sv_catpvs(subname, "::");
1267                                 sv_catpvn_flags(
1268                                    subname, key, len-2,
1269                                    HeUTF8(entry) ? SV_CATUTF8 : SV_CATBYTES
1270                                 );
1271                             }
1272                         }
1273                         mro_gather_and_rename(
1274                           stashes, seen_stashes,
1275                           substash, NULL, subname
1276                         );
1277                     }
1278                 }
1279             }
1280         }
1281     }
1282 }
1283
1284 /*
1285 =for apidoc mro_method_changed_in
1286
1287 Invalidates method caching on any child classes
1288 of the given stash, so that they might notice
1289 the changes in this one.
1290
1291 Ideally, all instances of C<PL_sub_generation++> in
1292 perl source outside of F<mro.c> should be
1293 replaced by calls to this.
1294
1295 Perl automatically handles most of the common
1296 ways a method might be redefined.  However, there
1297 are a few ways you could change a method in a stash
1298 without the cache code noticing, in which case you
1299 need to call this method afterwards:
1300
1301 1) Directly manipulating the stash HV entries from
1302 XS code.
1303
1304 2) Assigning a reference to a readonly scalar
1305 constant into a stash entry in order to create
1306 a constant subroutine (like constant.pm
1307 does).
1308
1309 This same method is available from pure perl
1310 via, C<mro::method_changed_in(classname)>.
1311
1312 =cut
1313 */
1314 void
1315 Perl_mro_method_changed_in(pTHX_ HV *stash)
1316 {
1317     const char * const stashname = HvENAME_get(stash);
1318     const STRLEN stashname_len = HvENAMELEN_get(stash);
1319
1320     SV ** const svp = hv_fetchhek(PL_isarev, HvENAME_HEK(stash), 0);
1321     HV * const isarev = svp ? MUTABLE_HV(*svp) : NULL;
1322
1323     PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN;
1324
1325     if(!stashname)
1326         Perl_croak(aTHX_ "Can't call mro_method_changed_in() on anonymous symbol table");
1327
1328     /* Inc the package generation, since a local method changed */
1329     HvMROMETA(stash)->pkg_gen++;
1330
1331     /* DESTROY can be cached in SvSTASH. */
1332     if (!SvOBJECT(stash)) SvSTASH(stash) = NULL;
1333
1334     /* If stash is UNIVERSAL, or one of UNIVERSAL's parents,
1335        invalidate all method caches globally */
1336     if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
1337         || (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
1338         PL_sub_generation++;
1339         return;
1340     }
1341
1342     /* else, invalidate the method caches of all child classes,
1343        but not itself */
1344     if(isarev) {
1345         HE* iter;
1346
1347         hv_iterinit(isarev);
1348         while((iter = hv_iternext(isarev))) {
1349             HV* const revstash = gv_stashsv(hv_iterkeysv(iter), 0);
1350             struct mro_meta* mrometa;
1351
1352             if(!revstash) continue;
1353             mrometa = HvMROMETA(revstash);
1354             mrometa->cache_gen++;
1355             if(mrometa->mro_nextmethod)
1356                 hv_clear(mrometa->mro_nextmethod);
1357             if (!SvOBJECT(revstash)) SvSTASH(revstash) = NULL;
1358         }
1359     }
1360
1361     /* The method change may be due to *{$package . "::()"} = \&nil; in
1362        overload.pm. */
1363     HvAMAGIC_on(stash);
1364     /* pessimise derefs for now. Will get recalculated by Gv_AMupdate() */
1365     HvAUX(stash)->xhv_aux_flags &= ~HvAUXf_NO_DEREF;
1366 }
1367
1368 void
1369 Perl_mro_set_mro(pTHX_ struct mro_meta *const meta, SV *const name)
1370 {
1371     const struct mro_alg *const which = Perl_mro_get_from_name(aTHX_ name);
1372
1373     PERL_ARGS_ASSERT_MRO_SET_MRO;
1374
1375     if (!which)
1376         Perl_croak(aTHX_ "Invalid mro name: '%"SVf"'", name);
1377
1378     if(meta->mro_which != which) {
1379         if (meta->mro_linear_current && !meta->mro_linear_all) {
1380             /* If we were storing something directly, put it in the hash before
1381                we lose it. */
1382             Perl_mro_set_private_data(aTHX_ meta, meta->mro_which,
1383                                       MUTABLE_SV(meta->mro_linear_current));
1384         }
1385         meta->mro_which = which;
1386         /* Scrub our cached pointer to the private data.  */
1387         meta->mro_linear_current = NULL;
1388         /* Only affects local method cache, not
1389            even child classes */
1390         meta->cache_gen++;
1391         if(meta->mro_nextmethod)
1392             hv_clear(meta->mro_nextmethod);
1393     }
1394 }
1395
1396 #include "XSUB.h"
1397
1398 XS(XS_mro_method_changed_in);
1399
1400 void
1401 Perl_boot_core_mro(pTHX)
1402 {
1403     dVAR;
1404     static const char file[] = __FILE__;
1405
1406     Perl_mro_register(aTHX_ &dfs_alg);
1407
1408     newXSproto("mro::method_changed_in", XS_mro_method_changed_in, file, "$");
1409 }
1410
1411 XS(XS_mro_method_changed_in)
1412 {
1413     dVAR;
1414     dXSARGS;
1415     SV* classname;
1416     HV* class_stash;
1417
1418     if(items != 1)
1419         croak_xs_usage(cv, "classname");
1420
1421     classname = ST(0);
1422
1423     class_stash = gv_stashsv(classname, 0);
1424     if(!class_stash) Perl_croak(aTHX_ "No such class: '%"SVf"'!", SVfARG(classname));
1425
1426     mro_method_changed_in(class_stash);
1427
1428     XSRETURN_EMPTY;
1429 }
1430
1431 /*
1432  * Local variables:
1433  * c-indentation-style: bsd
1434  * c-basic-offset: 4
1435  * indent-tabs-mode: nil
1436  * End:
1437  *
1438  * ex: set ts=8 sts=4 sw=4 et:
1439  */