mro.c

   1 /*    mro.c
   2  *
   3  *    Copyright (c) 2007 Brandon L Black
   4  *    Copyright (c) 2007, 2008 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 void
 118 Perl_mro_register(pTHX_ const struct mro_alg *mro) {
 119     SV *wrapper = newSVuv(PTR2UV(mro));
 120
 121     PERL_ARGS_ASSERT_MRO_REGISTER;
 122
 123
 124     if (!Perl_hv_common(aTHX_ PL_registered_mros, NULL,
 125                         mro->name, mro->length, mro->kflags,
 126                         HV_FETCH_ISSTORE, wrapper, mro->hash)) {
 127         SvREFCNT_dec(wrapper);
 128         Perl_croak(aTHX_ "panic: hv_store() failed in mro_register() "
 129                    "for '%.*s' %d", (int) mro->length, mro->name, mro->kflags);
 130     }
 131 }
 132
 133 struct mro_meta*
 134 Perl_mro_meta_init(pTHX_ HV* stash)
 135 {
 136     struct mro_meta* newmeta;
 137
 138     PERL_ARGS_ASSERT_MRO_META_INIT;
 139     assert(HvAUX(stash));
 140     assert(!(HvAUX(stash)->xhv_mro_meta));
 141     Newxz(newmeta, 1, struct mro_meta);
 142     HvAUX(stash)->xhv_mro_meta = newmeta;
 143     newmeta->cache_gen = 1;
 144     newmeta->pkg_gen = 1;
 145     newmeta->mro_which = &dfs_alg;
 146
 147     return newmeta;
 148 }
 149
 150 #if defined(USE_ITHREADS)
 151
 152 /* for sv_dup on new threads */
 153 struct mro_meta*
 154 Perl_mro_meta_dup(pTHX_ struct mro_meta* smeta, CLONE_PARAMS* param)
 155 {
 156     struct mro_meta* newmeta;
 157
 158     PERL_ARGS_ASSERT_MRO_META_DUP;
 159
 160     Newx(newmeta, 1, struct mro_meta);
 161     Copy(smeta, newmeta, 1, struct mro_meta);
 162
 163     if (newmeta->mro_linear_all) {
 164         newmeta->mro_linear_all
 165             = MUTABLE_HV(sv_dup_inc((const SV *)newmeta->mro_linear_all, param));
 166         /* This is just acting as a shortcut pointer, and will be automatically
 167            updated on the first get.  */
 168         newmeta->mro_linear_current = NULL;
 169     } else if (newmeta->mro_linear_current) {
 170         /* Only the current MRO is stored, so this owns the data.  */
 171         newmeta->mro_linear_current
 172             = sv_dup_inc((const SV *)newmeta->mro_linear_current, param);
 173     }
 174
 175     if (newmeta->mro_nextmethod)
 176         newmeta->mro_nextmethod
 177             = MUTABLE_HV(sv_dup_inc((const SV *)newmeta->mro_nextmethod, param));
 178     if (newmeta->isa)
 179         newmeta->isa
 180             = MUTABLE_HV(sv_dup_inc((const SV *)newmeta->isa, param));
 181
 182     return newmeta;
 183 }
 184
 185 #endif /* USE_ITHREADS */
 186
 187 /*
 188 =for apidoc mro_get_linear_isa_dfs
 189
 190 Returns the Depth-First Search linearization of @ISA
 191 the given stash.  The return value is a read-only AV*.
 192 C<level> should be 0 (it is used internally in this
 193 function's recursion).
 194
 195 You are responsible for C<SvREFCNT_inc()> on the
 196 return value if you plan to store it anywhere
 197 semi-permanently (otherwise it might be deleted
 198 out from under you the next time the cache is
 199 invalidated).
 200
 201 =cut
 202 */
 203 static AV*
 204 S_mro_get_linear_isa_dfs(pTHX_ HV *stash, U32 level)
 205 {
 206     AV* retval;
 207     GV** gvp;
 208     GV* gv;
 209     AV* av;
 210     const HEK* stashhek;
 211     struct mro_meta* meta;
 212     SV *our_name;
 213     HV *stored = NULL;
 214
 215     PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS;
 216     assert(HvAUX(stash));
 217
 218     stashhek
 219      = HvAUX(stash)->xhv_name && HvENAME_HEK_NN(stash)
 220         ? HvENAME_HEK_NN(stash)
 221         : HvNAME_HEK(stash);
 222
 223     if (!stashhek)
 224       Perl_croak(aTHX_ "Can't linearize anonymous symbol table");
 225
 226     if (level > 100)
 227         Perl_croak(aTHX_ "Recursive inheritance detected in package '%s'",
 228                    HEK_KEY(stashhek));
 229
 230     meta = HvMROMETA(stash);
 231
 232     /* return cache if valid */
 233     if((retval = MUTABLE_AV(MRO_GET_PRIVATE_DATA(meta, &dfs_alg)))) {
 234         return retval;
 235     }
 236
 237     /* not in cache, make a new one */
 238
 239     retval = MUTABLE_AV(sv_2mortal(MUTABLE_SV(newAV())));
 240     /* We use this later in this function, but don't need a reference to it
 241        beyond the end of this function, so reference count is fine.  */
 242     our_name = newSVhek(stashhek);
 243     av_push(retval, our_name); /* add ourselves at the top */
 244
 245     /* fetch our @ISA */
 246     gvp = (GV**)hv_fetchs(stash, "ISA", FALSE);
 247     av = (gvp && (gv = *gvp) && isGV_with_GP(gv)) ? GvAV(gv) : NULL;
 248
 249     /* "stored" is used to keep track of all of the classnames we have added to
 250        the MRO so far, so we can do a quick exists check and avoid adding
 251        duplicate classnames to the MRO as we go.
 252        It's then retained to be re-used as a fast lookup for ->isa(), by adding
 253        our own name and "UNIVERSAL" to it.  */
 254
 255     if(av && AvFILLp(av) >= 0) {
 256
 257         SV **svp = AvARRAY(av);
 258         I32 items = AvFILLp(av) + 1;
 259
 260         /* foreach(@ISA) */
 261         while (items--) {
 262             SV* const sv = *svp++;
 263             HV* const basestash = gv_stashsv(sv, 0);
 264             SV *const *subrv_p;
 265             I32 subrv_items;
 266
 267             if (!basestash) {
 268                 /* if no stash exists for this @ISA member,
 269                    simply add it to the MRO and move on */
 270                 subrv_p = &sv;
 271                 subrv_items = 1;
 272             }
 273             else {
 274                 /* otherwise, recurse into ourselves for the MRO
 275                    of this @ISA member, and append their MRO to ours.
 276                    The recursive call could throw an exception, which
 277                    has memory management implications here, hence the use of
 278                    the mortal.  */
 279                 const AV *const subrv
 280                     = mro_get_linear_isa_dfs(basestash, level + 1);
 281
 282                 subrv_p = AvARRAY(subrv);
 283                 subrv_items = AvFILLp(subrv) + 1;
 284             }
 285             if (stored) {
 286                 while(subrv_items--) {
 287                     SV *const subsv = *subrv_p++;
 288                     /* LVALUE fetch will create a new undefined SV if necessary
 289                      */
 290                     HE *const he = hv_fetch_ent(stored, subsv, 1, 0);
 291                     assert(he);
 292                     if(HeVAL(he) != &PL_sv_undef) {
 293                         /* It was newly created.  Steal it for our new SV, and
 294                            replace it in the hash with the "real" thing.  */
 295                         SV *const val = HeVAL(he);
 296                         HEK *const key = HeKEY_hek(he);
 297
 298                         HeVAL(he) = &PL_sv_undef;
 299                         /* Save copying by making a shared hash key scalar. We
 300                            inline this here rather than calling
 301                            Perl_newSVpvn_share because we already have the
 302                            scalar, and we already have the hash key.  */
 303                         assert(SvTYPE(val) == SVt_NULL);
 304                         sv_upgrade(val, SVt_PV);
 305                         SvPV_set(val, HEK_KEY(share_hek_hek(key)));
 306                         SvCUR_set(val, HEK_LEN(key));
 307                         SvREADONLY_on(val);
 308                         SvFAKE_on(val);
 309                         SvPOK_on(val);
 310                         if (HEK_UTF8(key))
 311                             SvUTF8_on(val);
 312
 313                         av_push(retval, val);
 314                     }
 315                 }
 316             } else {
 317                 /* We are the first (or only) parent. We can short cut the
 318                    complexity above, because our @ISA is simply us prepended
 319                    to our parent's @ISA, and our ->isa cache is simply our
 320                    parent's, with our name added.  */
 321                 /* newSVsv() is slow. This code is only faster if we can avoid
 322                    it by ensuring that SVs in the arrays are shared hash key
 323                    scalar SVs, because we can "copy" them very efficiently.
 324                    Although to be fair, we can't *ensure* this, as a reference
 325                    to the internal array is returned by mro::get_linear_isa(),
 326                    so we'll have to be defensive just in case someone faffed
 327                    with it.  */
 328                 if (basestash) {
 329                     SV **svp;
 330                     stored = MUTABLE_HV(sv_2mortal((SV*)newHVhv(HvMROMETA(basestash)->isa)));
 331                     av_extend(retval, subrv_items);
 332                     AvFILLp(retval) = subrv_items;
 333                     svp = AvARRAY(retval);
 334                     while(subrv_items--) {
 335                         SV *const val = *subrv_p++;
 336                         *++svp = SvIsCOW_shared_hash(val)
 337                             ? newSVhek(SvSHARED_HEK_FROM_PV(SvPVX(val)))
 338                             : newSVsv(val);
 339                     }
 340                 } else {
 341                     /* They have no stash.  So create ourselves an ->isa cache
 342                        as if we'd copied it from what theirs should be.  */
 343                     stored = MUTABLE_HV(sv_2mortal(MUTABLE_SV(newHV())));
 344                     (void) hv_store(stored, "UNIVERSAL", 9, &PL_sv_undef, 0);
 345                     av_push(retval,
 346                             newSVhek(HeKEY_hek(hv_store_ent(stored, sv,
 347                                                             &PL_sv_undef, 0))));
 348                 }
 349             }
 350         }
 351     } else {
 352         /* We have no parents.  */
 353         stored = MUTABLE_HV(sv_2mortal(MUTABLE_SV(newHV())));
 354         (void) hv_store(stored, "UNIVERSAL", 9, &PL_sv_undef, 0);
 355     }
 356
 357     (void) hv_store_ent(stored, our_name, &PL_sv_undef, 0);
 358
 359     SvREFCNT_inc_simple_void_NN(stored);
 360     SvTEMP_off(stored);
 361     SvREADONLY_on(stored);
 362
 363     meta->isa = stored;
 364
 365     /* now that we're past the exception dangers, grab our own reference to
 366        the AV we're about to use for the result. The reference owned by the
 367        mortals' stack will be released soon, so everything will balance.  */
 368     SvREFCNT_inc_simple_void_NN(retval);
 369     SvTEMP_off(retval);
 370
 371     /* we don't want anyone modifying the cache entry but us,
 372        and we do so by replacing it completely */
 373     SvREADONLY_on(retval);
 374
 375     return MUTABLE_AV(Perl_mro_set_private_data(aTHX_ meta, &dfs_alg,
 376                                                 MUTABLE_SV(retval)));
 377 }
 378
 379 /*
 380 =for apidoc mro_get_linear_isa
 381
 382 Returns either C<mro_get_linear_isa_c3> or
 383 C<mro_get_linear_isa_dfs> for the given stash,
 384 dependant upon which MRO is in effect
 385 for that stash.  The return value is a
 386 read-only AV*.
 387
 388 You are responsible for C<SvREFCNT_inc()> on the
 389 return value if you plan to store it anywhere
 390 semi-permanently (otherwise it might be deleted
 391 out from under you the next time the cache is
 392 invalidated).
 393
 394 =cut
 395 */
 396 AV*
 397 Perl_mro_get_linear_isa(pTHX_ HV *stash)
 398 {
 399     struct mro_meta* meta;
 400     AV *isa;
 401
 402     PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA;
 403     if(!SvOOK(stash))
 404         Perl_croak(aTHX_ "Can't linearize anonymous symbol table");
 405
 406     meta = HvMROMETA(stash);
 407     if (!meta->mro_which)
 408         Perl_croak(aTHX_ "panic: invalid MRO!");
 409     isa = meta->mro_which->resolve(aTHX_ stash, 0);
 410
 411     if (!meta->isa) {
 412             HV *const isa_hash = newHV();
 413             /* Linearisation didn't build it for us, so do it here.  */
 414             SV *const *svp = AvARRAY(isa);
 415             SV *const *const svp_end = svp + AvFILLp(isa) + 1;
 416             const HEK *canon_name = HvENAME_HEK(stash);
 417             if (!canon_name) canon_name = HvNAME_HEK(stash);
 418
 419             while (svp < svp_end) {
 420                 (void) hv_store_ent(isa_hash, *svp++, &PL_sv_undef, 0);
 421             }
 422
 423             (void) hv_common(isa_hash, NULL, HEK_KEY(canon_name),
 424                              HEK_LEN(canon_name), HEK_FLAGS(canon_name),
 425                              HV_FETCH_ISSTORE, &PL_sv_undef,
 426                              HEK_HASH(canon_name));
 427             (void) hv_store(isa_hash, "UNIVERSAL", 9, &PL_sv_undef, 0);
 428
 429             SvREADONLY_on(isa_hash);
 430
 431             meta->isa = isa_hash;
 432     }
 433
 434     return isa;
 435 }
 436
 437 /*
 438 =for apidoc mro_isa_changed_in
 439
 440 Takes the necessary steps (cache invalidations, mostly)
 441 when the @ISA of the given package has changed.  Invoked
 442 by the C<setisa> magic, should not need to invoke directly.
 443
 444 =cut
 445 */
 446 void
 447 Perl_mro_isa_changed_in(pTHX_ HV* stash)
 448 {
 449     dVAR;
 450     HV* isarev;
 451     AV* linear_mro;
 452     HE* iter;
 453     SV** svp;
 454     I32 items;
 455     bool is_universal;
 456     struct mro_meta * meta;
 457     HV *isa = NULL;
 458
 459     const char * const stashname = HvENAME_get(stash);
 460     const STRLEN stashname_len = HvENAMELEN_get(stash);
 461
 462     PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN;
 463
 464     if(!stashname)
 465         Perl_croak(aTHX_ "Can't call mro_isa_changed_in() on anonymous symbol table");
 466
 467
 468     /* wipe out the cached linearizations for this stash */
 469     meta = HvMROMETA(stash);
 470     if (meta->mro_linear_all) {
 471         SvREFCNT_dec(MUTABLE_SV(meta->mro_linear_all));
 472         meta->mro_linear_all = NULL;
 473         /* This is just acting as a shortcut pointer.  */
 474         meta->mro_linear_current = NULL;
 475     } else if (meta->mro_linear_current) {
 476         /* Only the current MRO is stored, so this owns the data.  */
 477         SvREFCNT_dec(meta->mro_linear_current);
 478         meta->mro_linear_current = NULL;
 479     }
 480     if (meta->isa) {
 481         /* Steal it for our own purposes. */
 482         isa = (HV *)sv_2mortal((SV *)meta->isa);
 483         meta->isa = NULL;
 484     }
 485
 486     /* Inc the package generation, since our @ISA changed */
 487     meta->pkg_gen++;
 488
 489     /* Wipe the global method cache if this package
 490        is UNIVERSAL or one of its parents */
 491
 492     svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
 493     isarev = svp ? MUTABLE_HV(*svp) : NULL;
 494
 495     if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
 496         || (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
 497         PL_sub_generation++;
 498         is_universal = TRUE;
 499     }
 500     else { /* Wipe the local method cache otherwise */
 501         meta->cache_gen++;
 502         is_universal = FALSE;
 503     }
 504
 505     /* wipe next::method cache too */
 506     if(meta->mro_nextmethod) hv_clear(meta->mro_nextmethod);
 507
 508     /* Iterate the isarev (classes that are our children),
 509        wiping out their linearization, method and isa caches
 510        and upating PL_isarev. */
 511     if(isarev) {
 512         HV *isa_hashes = NULL;
 513
 514        /* We have to iterate through isarev twice to avoid a chicken and
 515         * egg problem: if A inherits from B and both are in isarev, A might
 516         * be processed before B and use B’s previous linearisation.
 517         */
 518
 519        /* First iteration: Wipe everything, but stash away the isa hashes
 520         * since we still need them for updating PL_isarev.
 521         */
 522
 523         if(hv_iterinit(isarev)) {
 524             /* Only create the hash if we need it; i.e., if isarev has
 525                any elements. */
 526             isa_hashes = (HV *)sv_2mortal((SV *)newHV());
 527         }
 528         while((iter = hv_iternext(isarev))) {
 529             I32 len;
 530             const char* const revkey = hv_iterkey(iter, &len);
 531             HV* revstash = gv_stashpvn(revkey, len, 0);
 532             struct mro_meta* revmeta;
 533
 534             if(!revstash) continue;
 535             revmeta = HvMROMETA(revstash);
 536             if (revmeta->mro_linear_all) {
 537                 SvREFCNT_dec(MUTABLE_SV(revmeta->mro_linear_all));
 538                 revmeta->mro_linear_all = NULL;
 539                 /* This is just acting as a shortcut pointer.  */
 540                 revmeta->mro_linear_current = NULL;
 541             } else if (revmeta->mro_linear_current) {
 542                 /* Only the current MRO is stored, so this owns the data.  */
 543                 SvREFCNT_dec(revmeta->mro_linear_current);
 544                 revmeta->mro_linear_current = NULL;
 545             }
 546             if(!is_universal)
 547                 revmeta->cache_gen++;
 548             if(revmeta->mro_nextmethod)
 549                 hv_clear(revmeta->mro_nextmethod);
 550
 551             (void)
 552               hv_store(
 553                isa_hashes, (const char*)&revstash, sizeof(HV *),
 554                revmeta->isa ? (SV *)revmeta->isa : &PL_sv_undef, 0
 555               );
 556             revmeta->isa = NULL;
 557         }
 558
 559        /* Second pass: Update PL_isarev. We can just use isa_hashes to
 560         * avoid another round of stash lookups. */
 561
 562        /* isarev might be deleted from PL_isarev during this loop, so hang
 563         * on to it. */
 564         SvREFCNT_inc_simple_void_NN(sv_2mortal((SV *)isarev));
 565
 566         if(isa_hashes) {
 567             hv_iterinit(isa_hashes);
 568             while((iter = hv_iternext(isa_hashes))) {
 569                 HV* const revstash = *(HV **)HEK_KEY(HeKEY_hek(iter));
 570                 HV * const isa = (HV *)HeVAL(iter);
 571                 const HEK *namehek;
 572
 573                 /* Re-calculate the linearisation, unless a previous iter-
 574                    ation was for a subclass of this class. */
 575                 if(!HvMROMETA(revstash)->isa)
 576                     (void)mro_get_linear_isa(revstash);
 577
 578                 /* We're starting at the 2nd element, skipping revstash */
 579                 linear_mro = mro_get_linear_isa(revstash);
 580                 svp = AvARRAY(linear_mro) + 1;
 581                 items = AvFILLp(linear_mro);
 582
 583                 namehek = HvENAME_HEK(revstash);
 584                 if (!namehek) namehek = HvNAME_HEK(revstash);
 585
 586                 while (items--) {
 587                     SV* const sv = *svp++;
 588                     HV* mroisarev;
 589
 590                     HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
 591
 592                     /* That fetch should not fail.  But if it had to create
 593                        a new SV for us, then will need to upgrade it to an
 594                        HV (which sv_upgrade() can now do for us). */
 595
 596                     mroisarev = MUTABLE_HV(HeVAL(he));
 597
 598                     SvUPGRADE(MUTABLE_SV(mroisarev), SVt_PVHV);
 599
 600                     /* This hash only ever contains PL_sv_yes. Storing it
 601                        over itself is almost as cheap as calling hv_exists,
 602                        so on aggregate we expect to save time by not making
 603                        two calls to the common HV code for the case where
 604                        it doesn't exist.  */
 605
 606                     (void)
 607                       hv_store(
 608                        mroisarev, HEK_KEY(namehek), HEK_LEN(namehek),
 609                        &PL_sv_yes, 0
 610                       );
 611                 }
 612
 613                 if((SV *)isa != &PL_sv_undef)
 614                     mro_clean_isarev(
 615                      isa, HEK_KEY(namehek), HEK_LEN(namehek),
 616                      HvMROMETA(revstash)->isa
 617                     );
 618             }
 619         }
 620     }
 621
 622     /* Now iterate our MRO (parents), adding ourselves and everything from
 623        our isarev to their isarev.
 624     */
 625
 626     /* We're starting at the 2nd element, skipping ourselves here */
 627     linear_mro = mro_get_linear_isa(stash);
 628     svp = AvARRAY(linear_mro) + 1;
 629     items = AvFILLp(linear_mro);
 630
 631     while (items--) {
 632         SV* const sv = *svp++;
 633         HV* mroisarev;
 634
 635         HE *he = hv_fetch_ent(PL_isarev, sv, TRUE, 0);
 636
 637         /* That fetch should not fail.  But if it had to create a new SV for
 638            us, then will need to upgrade it to an HV (which sv_upgrade() can
 639            now do for us. */
 640
 641         mroisarev = MUTABLE_HV(HeVAL(he));
 642
 643         SvUPGRADE(MUTABLE_SV(mroisarev), SVt_PVHV);
 644
 645         /* This hash only ever contains PL_sv_yes. Storing it over itself is
 646            almost as cheap as calling hv_exists, so on aggregate we expect to
 647            save time by not making two calls to the common HV code for the
 648            case where it doesn't exist.  */
 649
 650         (void)hv_store(mroisarev, stashname, stashname_len, &PL_sv_yes, 0);
 651     }
 652
 653     /* Delete our name from our former parents’ isarevs. */
 654     if(isa && HvARRAY(isa))
 655         mro_clean_isarev(isa, stashname, stashname_len, meta->isa);
 656 }
 657
 658 /* Deletes name from all the isarev entries listed in isa */
 659 STATIC void
 660 S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name,
 661                          const STRLEN len, HV * const exceptions)
 662 {
 663     HE* iter;
 664
 665     PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV;
 666
 667     /* Delete our name from our former parents’ isarevs. */
 668     if(isa && HvARRAY(isa) && hv_iterinit(isa)) {
 669         SV **svp;
 670         while((iter = hv_iternext(isa))) {
 671             I32 klen;
 672             const char * const key = hv_iterkey(iter, &klen);
 673             if(exceptions && hv_exists(exceptions, key, klen)) continue;
 674             svp = hv_fetch(PL_isarev, key, klen, 0);
 675             if(svp) {
 676                 HV * const isarev = (HV *)*svp;
 677                 (void)hv_delete(isarev, name, len, G_DISCARD);
 678                 if(!HvARRAY(isarev) || !HvKEYS(isarev))
 679                     (void)hv_delete(PL_isarev, key, klen, G_DISCARD);
 680             }
 681         }
 682     }
 683 }
 684
 685 /*
 686 =for apidoc mro_package_moved
 687
 688 Call this function to signal to a stash that it has been assigned to
 689 another spot in the stash hierarchy. C<stash> is the stash that has been
 690 assigned. C<oldstash> is the stash it replaces, if any. C<gv> is the glob
 691 that is actually being assigned to. C<newname> and C<newname_len> are the
 692 full name of the GV. If these last two arguments are omitted, they can be
 693 inferred from C<gv>. C<gv> can be omitted if C<newname> is given.
 694
 695 This can also be called with a null first argument to
 696 indicate that C<oldstash> has been deleted.
 697
 698 This function invalidates isa caches on the old stash, on all subpackages
 699 nested inside it, and on the subclasses of all those, including
 700 non-existent packages that have corresponding entries in C<stash>.
 701
 702 It also sets the effective names (C<HvENAME>) on all the stashes as
 703 appropriate.
 704
 705 =cut
 706 */
 707 void
 708 Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash,
 709                        const GV *gv, const char *newname,
 710                        I32 newname_len)
 711 {
 712     HV *stashes;
 713     HE* iter;
 714
 715     assert(stash || oldstash);
 716     assert(gv || newname);
 717
 718     /* Determine the name of the location that stash was assigned to
 719      * or from which oldstash was removed.
 720      *
 721      * We cannot reliably use the name in oldstash, because it may have
 722      * been deleted from the location in the symbol table that its name
 723      * suggests, as in this case:
 724      *
 725      *   $globref = \*foo::bar::;
 726      *   Symbol::delete_package("foo");
 727      *   *$globref = \%baz::;
 728      *   *$globref = *frelp::;
 729      *      # calls mro_package_moved(%frelp::, %baz::, *$globref, NULL, 0)
 730      *
 731      * If newname is not null, then we trust that the caller gave us the
 732      * right name. Otherwise, we get it from the gv. But if the gv is not
 733      * in the symbol table, then we just return.
 734      */
 735     if(!newname && gv) {
 736         SV * const namesv = sv_newmortal();
 737         STRLEN len;
 738         gv_fullname4(namesv, gv, NULL, 0);
 739         if(gv_fetchsv(namesv, GV_NOADD_NOINIT, SVt_PVGV) != gv) return;
 740         newname = SvPV_const(namesv, len);
 741         newname_len = len - 2; /* skip trailing :: */
 742     }
 743     if(newname_len < 0) newname_len = -newname_len;
 744
 745     /* Get a list of all the affected classes. */
 746     /* We cannot simply pass them all to mro_isa_changed_in to avoid
 747        the list, as that function assumes that only one package has
 748        changed. It does not work with:
 749
 750           @foo::ISA = qw( B B::B );
 751           *B:: = delete $::{"A::"};
 752
 753        as neither B nor B::B can be updated before the other, since they
 754        will reset caches on foo, which will see either B or B::B with the
 755        wrong name. The names must be set on *all* affected stashes before
 756        we do anything else.
 757      */
 758     stashes = (HV *) sv_2mortal((SV *)newHV());
 759     mro_gather_and_rename(
 760      stashes, (HV *) sv_2mortal((SV *)newHV()),
 761      stash, oldstash, newname, newname_len
 762     );
 763
 764     /* Iterate through the stashes, wiping isa linearisations, but leaving
 765        the isa hash (which mro_isa_changed_in needs for adjusting the
 766        isarev hashes belonging to parent classes). */
 767     hv_iterinit(stashes);
 768     while((iter = hv_iternext(stashes))) {
 769         HV * const stash = *(HV **)HEK_KEY(HeKEY_hek(iter));
 770         if(HvENAME(stash)) {
 771             struct mro_meta* meta;
 772             meta = HvMROMETA(stash);
 773             if (meta->mro_linear_all) {
 774                 SvREFCNT_dec(MUTABLE_SV(meta->mro_linear_all));
 775                 meta->mro_linear_all = NULL;
 776                 /* This is just acting as a shortcut pointer.  */
 777                 meta->mro_linear_current = NULL;
 778             } else if (meta->mro_linear_current) {
 779                 /* Only the current MRO is stored, so this owns the data.  */
 780                 SvREFCNT_dec(meta->mro_linear_current);
 781                 meta->mro_linear_current = NULL;
 782             }
 783         }
 784     }
 785
 786     /* Once the caches have been wiped on all the classes, call
 787        mro_isa_changed_in on each. */
 788     hv_iterinit(stashes);
 789     while((iter = hv_iternext(stashes))) {
 790         HV * const stash = *(HV **)HEK_KEY(HeKEY_hek(iter));
 791         if(HvENAME(stash)) {
 792             /* We have to restore the original meta->isa (that
 793                mro_gather_and_rename set aside for us) this way, in case
 794                one class in this list is a superclass of a another class
 795                that we have already encountered. In such a case, meta->isa
 796                will have been overwritten without old entries being deleted
 797                from PL_isarev. */
 798             struct mro_meta * const meta = HvMROMETA(stash);
 799             if(meta->isa != (HV *)HeVAL(iter)){
 800                 SvREFCNT_dec(meta->isa);
 801                 meta->isa
 802                  = HeVAL(iter) == &PL_sv_yes
 803                     ? NULL
 804                     : (HV *)HeVAL(iter);
 805                 HeVAL(iter) = NULL; /* We donated our reference count. */
 806             }
 807             mro_isa_changed_in(stash);
 808         }
 809     }
 810 }
 811
 812 void
 813 S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes,
 814                               HV *stash, HV *oldstash, const char *name,
 815                               I32 namlen)
 816 {
 817     register XPVHV* xhv;
 818     register HE *entry;
 819     I32 riter = -1;
 820     const bool stash_had_name = stash && HvENAME(stash);
 821     HV *seen = NULL;
 822     HV *isarev = NULL;
 823     SV **svp;
 824
 825     PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME;
 826
 827     /* We use the seen_stashes hash to keep track of which packages have
 828        been encountered so far. This must be separate from the main list of
 829        stashes, as we need to distinguish between stashes being assigned
 830        and stashes being replaced/deleted. (A nested stash can be on both
 831        sides of an assignment. We cannot simply skip iterating through a
 832        stash on the right if we have seen it on the left, as it will not
 833        get its ename assigned to it.)
 834
 835        To avoid allocating extra SVs, instead of a bitfield we can make
 836        bizarre use of immortals:
 837
 838         &PL_sv_undef:  seen on the left  (oldstash)
 839         &PL_sv_no   :  seen on the right (stash)
 840         &PL_sv_yes  :  seen on both sides
 841
 842      */
 843
 844     if(oldstash) {
 845         /* Add to the big list. */
 846         struct mro_meta * meta;
 847         HE * const entry
 848          = (HE *)
 849              hv_common(
 850               seen_stashes, NULL, (const char *)&oldstash, sizeof(HV *), 0,
 851               HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
 852              );
 853         if(HeVAL(entry) == &PL_sv_undef || HeVAL(entry) == &PL_sv_yes) {
 854             oldstash = NULL;
 855             goto check_stash;
 856         }
 857         HeVAL(entry)
 858          = HeVAL(entry) == &PL_sv_no ? &PL_sv_yes : &PL_sv_undef;
 859         meta = HvMROMETA(oldstash);
 860         (void)
 861           hv_store(
 862            stashes, (const char *)&oldstash, sizeof(HV *),
 863            meta->isa
 864             ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
 865             : &PL_sv_yes,
 866            0
 867           );
 868
 869         /* Update the effective name. */
 870         if(HvENAME_get(oldstash)) {
 871           const HEK * const enamehek = HvENAME_HEK(oldstash);
 872           if(PL_stashcache)
 873             (void)
 874              hv_delete(PL_stashcache, name, namlen, G_DISCARD);
 875           hv_ename_delete(oldstash, name, namlen);
 876
 877          /* If the name deletion caused a name change, then we are not
 878           * going to call mro_isa_changed_in with this name (and not at all
 879           * if it has become anonymous) so we need to delete old isarev
 880           * entries here, both those in the superclasses and this class’s
 881           * own list of subclasses. We simply delete the latter from
 882           * from PL_isarev, since we still need it. hv_delete mortifies it
 883           * for us, so sv_2mortal is not necessary. */
 884           if(HvENAME_HEK(oldstash) != enamehek) {
 885             if(meta->isa && HvARRAY(meta->isa))
 886                 mro_clean_isarev(meta->isa, name, namlen, NULL);
 887             isarev = (HV *)hv_delete(PL_isarev, name, namlen, 0);
 888           }
 889         }
 890     }
 891    check_stash:
 892     if(stash) {
 893         hv_ename_add(stash, name, namlen);
 894
 895        /* Add it to the big list if it needs
 896         * mro_isa_changed_in called on it. That happens if it was
 897         * detached from the symbol table (so it had no HvENAME) before
 898         * being assigned to the spot named by the ‘name’ variable, because
 899         * its cached isa linerisation is now stale (the effective name
 900         * having changed), and subclasses will then use that cache when
 901         * mro_package_moved calls mro_isa_changed_in. (See
 902         * [perl #77358].)
 903         *
 904         * If it did have a name, then its previous name is still
 905         * used in isa caches, and there is no need for
 906         * mro_package_moved to call mro_isa_changed_in.
 907         */
 908
 909         entry
 910          = (HE *)
 911              hv_common(
 912               seen_stashes, NULL, (const char *)&stash, sizeof(HV *), 0,
 913               HV_FETCH_LVALUE|HV_FETCH_EMPTY_HE, NULL, 0
 914              );
 915         if(HeVAL(entry) == &PL_sv_yes || HeVAL(entry) == &PL_sv_no)
 916             stash = NULL;
 917         else {
 918             HeVAL(entry)
 919              = HeVAL(entry) == &PL_sv_undef ? &PL_sv_yes : &PL_sv_no;
 920             if(!stash_had_name)
 921             {
 922                 struct mro_meta * const meta = HvMROMETA(stash);
 923                 (void)
 924                   hv_store(
 925                    stashes, (const char *)&stash, sizeof(HV *),
 926                    meta->isa
 927                     ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
 928                     : &PL_sv_yes,
 929                    0
 930                   );
 931             }
 932         }
 933     }
 934
 935     if(!stash && !oldstash)
 936         /* Both stashes have been encountered already. */
 937         return;
 938
 939     /* Add all the subclasses to the big list. */
 940     if(
 941         isarev
 942      || (
 943            (svp = hv_fetch(PL_isarev, name, namlen, 0))
 944         && (isarev = MUTABLE_HV(*svp))
 945         )
 946     ) {
 947         HE *iter;
 948         hv_iterinit(isarev);
 949         while((iter = hv_iternext(isarev))) {
 950             I32 len;
 951             const char* const revkey = hv_iterkey(iter, &len);
 952             HV* revstash = gv_stashpvn(revkey, len, 0);
 953             struct mro_meta * meta;
 954
 955             if(!revstash) continue;
 956             meta = HvMROMETA(revstash);
 957             (void)
 958               hv_store(
 959                stashes, (const char *)&revstash, sizeof(HV *),
 960                meta->isa
 961                 ? SvREFCNT_inc_simple_NN((SV *)meta->isa)
 962                 : &PL_sv_yes,
 963                0
 964               );
 965         }
 966     }
 967
 968     if(
 969      (!stash || !HvARRAY(stash)) && (!oldstash || !HvARRAY(oldstash))
 970     ) return;
 971
 972     /* This is partly based on code in hv_iternext_flags. We are not call-
 973        ing that here, as we want to avoid resetting the hash iterator. */
 974
 975     /* Skip the entire loop if the hash is empty.   */
 976     if(oldstash && HvUSEDKEYS(oldstash)) {
 977         xhv = (XPVHV*)SvANY(oldstash);
 978         seen = (HV *) sv_2mortal((SV *)newHV());
 979
 980         /* Iterate through entries in the oldstash, adding them to the
 981            list, meanwhile doing the equivalent of $seen{$key} = 1.
 982          */
 983
 984         while (++riter <= (I32)xhv->xhv_max) {
 985             entry = (HvARRAY(oldstash))[riter];
 986
 987             /* Iterate through the entries in this list */
 988             for(; entry; entry = HeNEXT(entry)) {
 989                 const char* key;
 990                 I32 len;
 991
 992                 /* If this entry is not a glob, ignore it.
 993                    Try the next.  */
 994                 if (!isGV(HeVAL(entry))) continue;
 995
 996                 key = hv_iterkey(entry, &len);
 997                 if(len > 1 && key[len-2] == ':' && key[len-1] == ':') {
 998                     HV * const oldsubstash = GvHV(HeVAL(entry));
 999                     SV ** const stashentry
1000                      = stash ? hv_fetch(stash, key, len, 0) : NULL;
1001                     HV *substash = NULL;
1002
1003                     /* Avoid main::main::main::... */
1004                     if(oldsubstash == oldstash) continue;
1005
1006                     if(
1007                         (
1008                             stashentry && *stashentry
1009                          && (substash = GvHV(*stashentry))
1010                         )
1011                      || (oldsubstash && HvENAME_get(oldsubstash))
1012                     )
1013                     {
1014                         /* Add :: and the key (minus the trailing ::)
1015                            to newname. */
1016                         SV *namesv
1017                          = newSVpvn_flags(name, namlen, SVs_TEMP);
1018                         {
1019                             const char *name;
1020                             STRLEN namlen;
1021                             sv_catpvs(namesv, "::");
1022                             sv_catpvn(namesv, key, len-2);
1023                             name = SvPV_const(namesv, namlen);
1024                             mro_gather_and_rename(
1025                              stashes, seen_stashes,
1026                              substash, oldsubstash, name, namlen
1027                             );
1028                         }
1029                     }
1030
1031                     (void)hv_store(seen, key, len, &PL_sv_yes, 0);
1032                 }
1033             }
1034         }
1035     }
1036
1037     /* Skip the entire loop if the hash is empty.   */
1038     if (stash && HvUSEDKEYS(stash)) {
1039         xhv = (XPVHV*)SvANY(stash);
1040         riter = -1;
1041
1042         /* Iterate through the new stash, skipping $seen{$key} items,
1043            calling mro_gather_and_rename(stashes,seen,entry,NULL, ...). */
1044         while (++riter <= (I32)xhv->xhv_max) {
1045             entry = (HvARRAY(stash))[riter];
1046
1047             /* Iterate through the entries in this list */
1048             for(; entry; entry = HeNEXT(entry)) {
1049                 const char* key;
1050                 I32 len;
1051
1052                 /* If this entry is not a glob, ignore it.
1053                    Try the next.  */
1054                 if (!isGV(HeVAL(entry))) continue;
1055
1056                 key = hv_iterkey(entry, &len);
1057                 if(len > 1 && key[len-2] == ':' && key[len-1] == ':') {
1058                     HV *substash;
1059
1060                     /* If this entry was seen when we iterated through the
1061                        oldstash, skip it. */
1062                     if(seen && hv_exists(seen, key, len)) continue;
1063
1064                     /* We get here only if this stash has no corresponding
1065                        entry in the stash being replaced. */
1066
1067                     substash = GvHV(HeVAL(entry));
1068                     if(substash) {
1069                         SV *namesv;
1070                         const char *subname;
1071                         STRLEN subnamlen;
1072
1073                         /* Avoid checking main::main::main::... */
1074                         if(substash == stash) continue;
1075
1076                         /* Add :: and the key (minus the trailing ::)
1077                            to newname. */
1078                         namesv
1079                          = newSVpvn_flags(name, namlen, SVs_TEMP);
1080                         sv_catpvs(namesv, "::");
1081                         sv_catpvn(namesv, key, len-2);
1082                         subname = SvPV_const(namesv, subnamlen);
1083                         mro_gather_and_rename(
1084                           stashes, seen_stashes,
1085                           substash, NULL, subname, subnamlen
1086                         );
1087                     }
1088                 }
1089             }
1090         }
1091     }
1092 }
1093
1094 /*
1095 =for apidoc mro_method_changed_in
1096
1097 Invalidates method caching on any child classes
1098 of the given stash, so that they might notice
1099 the changes in this one.
1100
1101 Ideally, all instances of C<PL_sub_generation++> in
1102 perl source outside of C<mro.c> should be
1103 replaced by calls to this.
1104
1105 Perl automatically handles most of the common
1106 ways a method might be redefined.  However, there
1107 are a few ways you could change a method in a stash
1108 without the cache code noticing, in which case you
1109 need to call this method afterwards:
1110
1111 1) Directly manipulating the stash HV entries from
1112 XS code.
1113
1114 2) Assigning a reference to a readonly scalar
1115 constant into a stash entry in order to create
1116 a constant subroutine (like constant.pm
1117 does).
1118
1119 This same method is available from pure perl
1120 via, C<mro::method_changed_in(classname)>.
1121
1122 =cut
1123 */
1124 void
1125 Perl_mro_method_changed_in(pTHX_ HV *stash)
1126 {
1127     const char * const stashname = HvENAME_get(stash);
1128     const STRLEN stashname_len = HvENAMELEN_get(stash);
1129
1130     SV ** const svp = hv_fetch(PL_isarev, stashname, stashname_len, 0);
1131     HV * const isarev = svp ? MUTABLE_HV(*svp) : NULL;
1132
1133     PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN;
1134
1135     if(!stashname)
1136         Perl_croak(aTHX_ "Can't call mro_method_changed_in() on anonymous symbol table");
1137
1138     /* Inc the package generation, since a local method changed */
1139     HvMROMETA(stash)->pkg_gen++;
1140
1141     /* If stash is UNIVERSAL, or one of UNIVERSAL's parents,
1142        invalidate all method caches globally */
1143     if((stashname_len == 9 && strEQ(stashname, "UNIVERSAL"))
1144         || (isarev && hv_exists(isarev, "UNIVERSAL", 9))) {
1145         PL_sub_generation++;
1146         return;
1147     }
1148
1149     /* else, invalidate the method caches of all child classes,
1150        but not itself */
1151     if(isarev) {
1152         HE* iter;
1153
1154         hv_iterinit(isarev);
1155         while((iter = hv_iternext(isarev))) {
1156             I32 len;
1157             const char* const revkey = hv_iterkey(iter, &len);
1158             HV* const revstash = gv_stashpvn(revkey, len, 0);
1159             struct mro_meta* mrometa;
1160
1161             if(!revstash) continue;
1162             mrometa = HvMROMETA(revstash);
1163             mrometa->cache_gen++;
1164             if(mrometa->mro_nextmethod)
1165                 hv_clear(mrometa->mro_nextmethod);
1166         }
1167     }
1168 }
1169
1170 void
1171 Perl_mro_set_mro(pTHX_ struct mro_meta *const meta, SV *const name)
1172 {
1173     const struct mro_alg *const which = Perl_mro_get_from_name(aTHX_ name);
1174
1175     PERL_ARGS_ASSERT_MRO_SET_MRO;
1176
1177     if (!which)
1178         Perl_croak(aTHX_ "Invalid mro name: '%"SVf"'", name);
1179
1180     if(meta->mro_which != which) {
1181         if (meta->mro_linear_current && !meta->mro_linear_all) {
1182             /* If we were storing something directly, put it in the hash before
1183                we lose it. */
1184             Perl_mro_set_private_data(aTHX_ meta, meta->mro_which,
1185                                       MUTABLE_SV(meta->mro_linear_current));
1186         }
1187         meta->mro_which = which;
1188         /* Scrub our cached pointer to the private data.  */
1189         meta->mro_linear_current = NULL;
1190         /* Only affects local method cache, not
1191            even child classes */
1192         meta->cache_gen++;
1193         if(meta->mro_nextmethod)
1194             hv_clear(meta->mro_nextmethod);
1195     }
1196 }
1197
1198 #include "XSUB.h"
1199
1200 XS(XS_mro_method_changed_in);
1201
1202 void
1203 Perl_boot_core_mro(pTHX)
1204 {
1205     dVAR;
1206     static const char file[] = __FILE__;
1207
1208     Perl_mro_register(aTHX_ &dfs_alg);
1209
1210     newXSproto("mro::method_changed_in", XS_mro_method_changed_in, file, "$");
1211 }
1212
1213 XS(XS_mro_method_changed_in)
1214 {
1215     dVAR;
1216     dXSARGS;
1217     SV* classname;
1218     HV* class_stash;
1219
1220     if(items != 1)
1221         croak_xs_usage(cv, "classname");
1222
1223     classname = ST(0);
1224
1225     class_stash = gv_stashsv(classname, 0);
1226     if(!class_stash) Perl_croak(aTHX_ "No such class: '%"SVf"'!", SVfARG(classname));
1227
1228     mro_method_changed_in(class_stash);
1229
1230     XSRETURN_EMPTY;
1231 }
1232
1233 /*
1234  * Local variables:
1235  * c-indentation-style: bsd
1236  * c-basic-offset: 4
1237  * indent-tabs-mode: t
1238  * End:
1239  *
1240  * ex: set ts=8 sts=4 sw=4 noet:
1241  */