1 #define PERL_NO_GET_CONTEXT
8 /* Not yet in ppport.h */
10 # define CvISXSUB(cv) (CvXSUB(cv) ? TRUE : FALSE)
13 # define SvRV_const(rv) SvRV(rv)
17 /* "structured exception" handling is a Microsoft extension to C and C++.
18 It's *not* C++ exception handling - C++ exception handling can't capture
19 SEGVs and suchlike, whereas this can. There's no known analagous
20 functionality on other platforms. */
22 # define TRY_TO_CATCH_SEGV __try
23 # define CAUGHT_EXCEPTION __except(EXCEPTION EXCEPTION_EXECUTE_HANDLER)
25 # define TRY_TO_CATCH_SEGV if(1)
26 # define CAUGHT_EXCEPTION else
30 # define __attribute__(x)
33 #if 0 && defined(DEBUGGING)
34 #define dbg_printf(x) printf x
39 #define TAG /* printf( "# %s(%d)\n", __FILE__, __LINE__ ) */
42 /* The idea is to have a tree structure to store 1 bit per possible pointer
43 address. The lowest 16 bits are stored in a block of 8092 bytes.
44 The blocks are in a 256-way tree, indexed by the reset of the pointer.
45 This can cope with 32 and 64 bit pointers, and any address space layout,
46 without excessive memory needs. The assumption is that your CPU cache
47 works :-) (And that we're not going to bust it) */
49 #define ALIGN_BITS ( sizeof(void*) >> 1 )
51 #define LEAF_BITS (16 - BYTE_BITS)
52 #define LEAF_MASK 0x1FFF
60 /* My hunch (not measured) is that for most architectures pointers will
61 start with 0 bits, hence the start of this array will be hot, and the
62 end unused. So put the flags next to the hot end. */
67 Checks to see if thing is in the bitstring.
68 Returns true or false, and
69 notes thing in the segmented bitstring.
72 check_new(struct state *st, const void *const p) {
73 unsigned int bits = 8 * sizeof(void*);
74 const size_t raw_p = PTR2nat(p);
75 /* This effectively rotates the value right by the number of low always-0
76 bits in an aligned pointer. The assmption is that most (if not all)
77 pointers are aligned, and these will be in the same chain of nodes
78 (and hence hot in the cache) but we can still deal with any unaligned
81 = (raw_p >> ALIGN_BITS) | (raw_p << (bits - BYTE_BITS));
82 const U8 this_bit = 1 << (cooked_p & 0x7);
86 void **tv_p = (void **) (st->tracking);
88 if (NULL == p) return FALSE;
90 const char c = *(const char *)p;
94 warn( "Devel::Size: Encountered invalid pointer: %p\n", p );
100 /* bits now 24 (32 bit pointers) or 56 (64 bit pointers) */
102 /* First level is always present. */
104 i = (unsigned int)((cooked_p >> bits) & 0xFF);
106 Newxz(tv_p[i], 256, void *);
107 tv_p = (void **)(tv_p[i]);
109 } while (bits > LEAF_BITS + BYTE_BITS);
110 /* bits now 16 always */
111 #if !defined(MULTIPLICITY) || PERL_VERSION > 8 || (PERL_VERSION == 8 && PERL_SUBVERSION > 8)
112 /* 5.8.8 and early have an assert() macro that uses Perl_croak, hence needs
113 a my_perl under multiplicity */
116 leaf_p = (U8 **)tv_p;
117 i = (unsigned int)((cooked_p >> bits) & 0xFF);
119 Newxz(leaf_p[i], 1 << LEAF_BITS, U8);
124 i = (unsigned int)((cooked_p >> BYTE_BITS) & LEAF_MASK);
126 if(leaf[i] & this_bit)
134 free_tracking_at(void **tv, int level)
142 free_tracking_at(tv[i], level);
156 free_state(struct state *st)
158 const int top_level = (sizeof(void *) * 8 - LEAF_BITS - BYTE_BITS) / 8;
159 free_tracking_at((void **)st->tracking, top_level);
163 static bool sv_size(pTHX_ struct state *, const SV *const, bool recurse);
181 cc_opclass(const OP * const o)
187 return (o->op_flags & OPf_KIDS) ? OPc_UNOP : OPc_BASEOP;
189 if (o->op_type == OP_SASSIGN)
190 return ((o->op_private & OPpASSIGN_BACKWARDS) ? OPc_UNOP : OPc_BINOP);
193 if (o->op_type == OP_GV || o->op_type == OP_GVSV || o->op_type == OP_AELEMFAST)
197 if ((o->op_type == OP_TRANS)) {
201 switch (PL_opargs[o->op_type] & OA_CLASS_MASK) {
226 case OA_PVOP_OR_SVOP: TAG;
228 * Character translations (tr///) are usually a PVOP, keeping a
229 * pointer to a table of shorts used to look up translations.
230 * Under utf8, however, a simple table isn't practical; instead,
231 * the OP is an SVOP, and the SV is a reference to a swash
232 * (i.e., an RV pointing to an HV).
234 return (o->op_private & (OPpTRANS_TO_UTF|OPpTRANS_FROM_UTF))
235 ? OPc_SVOP : OPc_PVOP;
243 case OA_BASEOP_OR_UNOP: TAG;
245 * UNI(OP_foo) in toke.c returns token UNI or FUNC1 depending on
246 * whether parens were seen. perly.y uses OPf_SPECIAL to
247 * signal whether a BASEOP had empty parens or none.
248 * Some other UNOPs are created later, though, so the best
249 * test is OPf_KIDS, which is set in newUNOP.
251 return (o->op_flags & OPf_KIDS) ? OPc_UNOP : OPc_BASEOP;
253 case OA_FILESTATOP: TAG;
255 * The file stat OPs are created via UNI(OP_foo) in toke.c but use
256 * the OPf_REF flag to distinguish between OP types instead of the
257 * usual OPf_SPECIAL flag. As usual, if OPf_KIDS is set, then we
258 * return OPc_UNOP so that walkoptree can find our children. If
259 * OPf_KIDS is not set then we check OPf_REF. Without OPf_REF set
260 * (no argument to the operator) it's an OP; with OPf_REF set it's
261 * an SVOP (and op_sv is the GV for the filehandle argument).
263 return ((o->op_flags & OPf_KIDS) ? OPc_UNOP :
265 (o->op_flags & OPf_REF) ? OPc_PADOP : OPc_BASEOP);
267 (o->op_flags & OPf_REF) ? OPc_SVOP : OPc_BASEOP);
269 case OA_LOOPEXOP: TAG;
271 * next, last, redo, dump and goto use OPf_SPECIAL to indicate that a
272 * label was omitted (in which case it's a BASEOP) or else a term was
273 * seen. In this last case, all except goto are definitely PVOP but
274 * goto is either a PVOP (with an ordinary constant label), an UNOP
275 * with OPf_STACKED (with a non-constant non-sub) or an UNOP for
276 * OP_REFGEN (with goto &sub) in which case OPf_STACKED also seems to
279 if (o->op_flags & OPf_STACKED)
281 else if (o->op_flags & OPf_SPECIAL)
286 warn("Devel::Size: Can't determine class of operator %s, assuming BASEOP\n",
287 PL_op_name[o->op_type]);
298 /* Figure out how much magic is attached to the SV and return the
301 magic_size(const SV * const thing, struct state *st) {
302 MAGIC *magic_pointer;
305 if (!SvMAGIC(thing)) {
310 /* Get the base magic pointer */
311 magic_pointer = SvMAGIC(thing);
313 /* Have we seen the magic pointer? */
314 while (check_new(st, magic_pointer)) {
315 st->total_size += sizeof(MAGIC);
318 /* Have we seen the magic vtable? */
319 if (check_new(st, magic_pointer->mg_virtual)) {
320 st->total_size += sizeof(MGVTBL);
323 /* Get the next in the chain */
324 magic_pointer = magic_pointer->mg_moremagic;
327 if (st->dangle_whine)
328 warn( "Devel::Size: Encountered bad magic at: %p\n", magic_pointer );
334 check_new_and_strlen(struct state *st, const char *const p) {
336 st->total_size += 1 + strlen(p);
340 regex_size(const REGEXP * const baseregex, struct state *st) {
341 if(!check_new(st, baseregex))
343 st->total_size += sizeof(REGEXP);
344 #if (PERL_VERSION < 11)
345 /* Note the size of the paren offset thing */
346 st->total_size += sizeof(I32) * baseregex->nparens * 2;
347 st->total_size += strlen(baseregex->precomp);
349 st->total_size += sizeof(struct regexp);
350 st->total_size += sizeof(I32) * SvANY(baseregex)->nparens * 2;
351 /*st->total_size += strlen(SvANY(baseregex)->subbeg);*/
353 if (st->go_yell && !st->regex_whine) {
354 carp("Devel::Size: Calculated sizes for compiled regexes are incompatible, and probably always will be");
360 op_size(pTHX_ const OP * const baseop, struct state *st)
364 if(!check_new(st, baseop))
367 op_size(aTHX_ baseop->op_next, st);
369 switch (cc_opclass(baseop)) {
370 case OPc_BASEOP: TAG;
371 st->total_size += sizeof(struct op);
374 st->total_size += sizeof(struct unop);
375 op_size(aTHX_ cUNOPx(baseop)->op_first, st);
378 st->total_size += sizeof(struct binop);
379 op_size(aTHX_ cBINOPx(baseop)->op_first, st);
380 op_size(aTHX_ cBINOPx(baseop)->op_last, st);
383 st->total_size += sizeof(struct logop);
384 op_size(aTHX_ cBINOPx(baseop)->op_first, st);
385 op_size(aTHX_ cLOGOPx(baseop)->op_other, st);
387 case OPc_LISTOP: TAG;
388 st->total_size += sizeof(struct listop);
389 op_size(aTHX_ cLISTOPx(baseop)->op_first, st);
390 op_size(aTHX_ cLISTOPx(baseop)->op_last, st);
393 st->total_size += sizeof(struct pmop);
394 op_size(aTHX_ cPMOPx(baseop)->op_first, st);
395 op_size(aTHX_ cPMOPx(baseop)->op_last, st);
396 #if PERL_VERSION < 9 || (PERL_VERSION == 9 && PERL_SUBVERSION < 5)
397 op_size(aTHX_ cPMOPx(baseop)->op_pmreplroot, st);
398 op_size(aTHX_ cPMOPx(baseop)->op_pmreplstart, st);
399 op_size(aTHX_ (OP *)cPMOPx(baseop)->op_pmnext, st);
401 /* This is defined away in perl 5.8.x, but it is in there for
404 regex_size(PM_GETRE(cPMOPx(baseop)), st);
406 regex_size(cPMOPx(baseop)->op_pmregexp, st);
410 st->total_size += sizeof(struct pmop);
411 if (!(baseop->op_type == OP_AELEMFAST
412 && baseop->op_flags & OPf_SPECIAL)) {
413 /* not an OP_PADAV replacement */
414 sv_size(aTHX_ st, cSVOPx(baseop)->op_sv, TRUE);
418 st->total_size += sizeof(struct padop);
421 check_new_and_strlen(st, cPVOPx(baseop)->op_pv);
424 st->total_size += sizeof(struct loop);
425 op_size(aTHX_ cLOOPx(baseop)->op_first, st);
426 op_size(aTHX_ cLOOPx(baseop)->op_last, st);
427 op_size(aTHX_ cLOOPx(baseop)->op_redoop, st);
428 op_size(aTHX_ cLOOPx(baseop)->op_nextop, st);
429 op_size(aTHX_ cLOOPx(baseop)->op_lastop, st);
434 basecop = (COP *)baseop;
435 st->total_size += sizeof(struct cop);
437 /* Change 33656 by nicholas@mouse-mill on 2008/04/07 11:29:51
438 Eliminate cop_label from struct cop by storing a label as the first
439 entry in the hints hash. Most statements don't have labels, so this
440 will save memory. Not sure how much.
441 The check below will be incorrect fail on bleadperls
442 before 5.11 @33656, but later than 5.10, producing slightly too
443 small memory sizes on these Perls. */
444 #if (PERL_VERSION < 11)
445 check_new_and_strlen(st, basecop->cop_label);
448 check_new_and_strlen(st, basecop->cop_file);
449 check_new_and_strlen(st, basecop->cop_stashpv);
451 sv_size(aTHX_ st, (SV *)basecop->cop_stash, TRUE);
452 sv_size(aTHX_ st, (SV *)basecop->cop_filegv, TRUE);
462 if (st->dangle_whine)
463 warn( "Devel::Size: Encountered dangling pointer in opcode at: %p\n", baseop );
467 #if PERL_VERSION > 9 || (PERL_VERSION == 9 && PERL_SUBVERSION > 2)
468 # define NEW_HEAD_LAYOUT
472 sv_size(pTHX_ struct state *const st, const SV * const orig_thing,
473 const bool recurse) {
474 const SV *thing = orig_thing;
476 if(!check_new(st, thing))
479 st->total_size += sizeof(SV);
481 switch (SvTYPE(thing)) {
485 /* Just a plain integer. This will be differently sized depending
486 on whether purify's been compiled in */
488 #ifndef NEW_HEAD_LAYOUT
490 st->total_size += sizeof(sizeof(XPVIV));
492 st->total_size += sizeof(IV);
495 if(recurse && SvROK(thing))
496 sv_size(aTHX_ st, SvRV_const(thing), TRUE);
498 /* Is it a float? Like the int, it depends on purify */
501 st->total_size += sizeof(sizeof(XPVNV));
503 st->total_size += sizeof(NV);
506 #if (PERL_VERSION < 11)
507 /* Is it a reference? */
509 #ifndef NEW_HEAD_LAYOUT
510 st->total_size += sizeof(XRV);
512 if(recurse && SvROK(thing))
513 sv_size(aTHX_ st, SvRV_const(thing), TRUE);
516 /* How about a plain string? In which case we need to add in how
517 much has been allocated */
519 st->total_size += sizeof(XPV);
520 if(recurse && SvROK(thing))
521 sv_size(aTHX_ st, SvRV_const(thing), TRUE);
523 st->total_size += SvLEN(thing);
525 /* A string with an integer part? */
527 st->total_size += sizeof(XPVIV);
528 if(recurse && SvROK(thing))
529 sv_size(aTHX_ st, SvRV_const(thing), TRUE);
531 st->total_size += SvLEN(thing);
533 st->total_size += SvIVX(thing);
536 /* A scalar/string/reference with a float part? */
538 st->total_size += sizeof(XPVNV);
539 if(recurse && SvROK(thing))
540 sv_size(aTHX_ st, SvRV_const(thing), TRUE);
542 st->total_size += SvLEN(thing);
545 st->total_size += sizeof(XPVMG);
546 if(recurse && SvROK(thing))
547 sv_size(aTHX_ st, SvRV_const(thing), TRUE);
549 st->total_size += SvLEN(thing);
550 magic_size(thing, st);
552 #if PERL_VERSION <= 8
554 st->total_size += sizeof(XPVBM);
555 if(recurse && SvROK(thing))
556 sv_size(aTHX_ st, SvRV_const(thing), TRUE);
558 st->total_size += SvLEN(thing);
559 magic_size(thing, st);
563 st->total_size += sizeof(XPVLV);
564 if(recurse && SvROK(thing))
565 sv_size(aTHX_ st, SvRV_const(thing), TRUE);
567 st->total_size += SvLEN(thing);
568 magic_size(thing, st);
570 /* How much space is dedicated to the array? Not counting the
571 elements in the array, mind, just the array itself */
573 st->total_size += sizeof(XPVAV);
574 /* Is there anything in the array? */
575 if (AvMAX(thing) != -1) {
576 /* an array with 10 slots has AvMax() set to 9 - te 2007-04-22 */
577 st->total_size += sizeof(SV *) * (AvMAX(thing) + 1);
578 dbg_printf(("total_size: %li AvMAX: %li av_len: $i\n", st->total_size, AvMAX(thing), av_len((AV*)thing)));
580 /* Add in the bits on the other side of the beginning */
582 dbg_printf(("total_size %li, sizeof(SV *) %li, AvARRAY(thing) %li, AvALLOC(thing)%li , sizeof(ptr) %li \n",
583 st->total_size, sizeof(SV*), AvARRAY(thing), AvALLOC(thing), sizeof( thing )));
585 /* under Perl 5.8.8 64bit threading, AvARRAY(thing) was a pointer while AvALLOC was 0,
586 resulting in grossly overstated sized for arrays. Technically, this shouldn't happen... */
587 if (AvALLOC(thing) != 0) {
588 st->total_size += (sizeof(SV *) * (AvARRAY(thing) - AvALLOC(thing)));
590 #if (PERL_VERSION < 9)
591 /* Is there something hanging off the arylen element?
592 Post 5.9.something this is stored in magic, so will be found there,
593 and Perl_av_arylen_p() takes a non-const AV*, hence compilers rightly
594 complain about AvARYLEN() passing thing to it. */
595 sv_size(aTHX_ st, AvARYLEN(thing), TRUE);
597 magic_size(thing, st);
600 /* First the base struct */
601 st->total_size += sizeof(XPVHV);
602 /* Now the array of buckets */
603 st->total_size += (sizeof(HE *) * (HvMAX(thing) + 1));
604 /* Now walk the bucket chain */
605 if (HvARRAY(thing)) {
608 for (cur_bucket = 0; cur_bucket <= HvMAX(thing); cur_bucket++) {
609 cur_entry = *(HvARRAY(thing) + cur_bucket);
611 st->total_size += sizeof(HE);
612 if (cur_entry->hent_hek) {
613 /* Hash keys can be shared. Have we seen this before? */
614 if (check_new(st, cur_entry->hent_hek)) {
615 st->total_size += HEK_BASESIZE + cur_entry->hent_hek->hek_len + 2;
618 cur_entry = cur_entry->hent_next;
622 magic_size(thing, st);
625 st->total_size += sizeof(XPVCV);
626 magic_size(thing, st);
628 st->total_size += ((XPVIO *) SvANY(thing))->xpv_len;
629 sv_size(aTHX_ st, (SV *)CvSTASH(thing), TRUE);
630 sv_size(aTHX_ st, (SV *)SvSTASH(thing), TRUE);
631 sv_size(aTHX_ st, (SV *)CvGV(thing), TRUE);
632 sv_size(aTHX_ st, (SV *)CvPADLIST(thing), TRUE);
633 sv_size(aTHX_ st, (SV *)CvOUTSIDE(thing), TRUE);
634 if (CvISXSUB(thing)) {
635 sv_size(aTHX_ st, cv_const_sv((CV *)thing), TRUE);
637 op_size(aTHX_ CvSTART(thing), st);
638 op_size(aTHX_ CvROOT(thing), st);
643 magic_size(thing, st);
644 st->total_size += sizeof(XPVGV);
645 if(isGV_with_GP(thing)) {
646 st->total_size += GvNAMELEN(thing);
648 /* Is there a file? */
649 check_new_and_strlen(st, GvFILE(thing));
651 /* Is there something hanging off the glob? */
652 if (check_new(st, GvGP(thing))) {
653 st->total_size += sizeof(GP);
654 sv_size(aTHX_ st, (SV *)(GvGP(thing)->gp_sv), TRUE);
655 sv_size(aTHX_ st, (SV *)(GvGP(thing)->gp_form), TRUE);
656 sv_size(aTHX_ st, (SV *)(GvGP(thing)->gp_av), TRUE);
657 sv_size(aTHX_ st, (SV *)(GvGP(thing)->gp_hv), TRUE);
658 sv_size(aTHX_ st, (SV *)(GvGP(thing)->gp_egv), TRUE);
659 sv_size(aTHX_ st, (SV *)(GvGP(thing)->gp_cv), TRUE);
664 st->total_size += sizeof(XPVFM);
665 magic_size(thing, st);
666 st->total_size += ((XPVIO *) SvANY(thing))->xpv_len;
667 sv_size(aTHX_ st, (SV *)CvPADLIST(thing), TRUE);
668 sv_size(aTHX_ st, (SV *)CvOUTSIDE(thing), TRUE);
670 if (st->go_yell && !st->fm_whine) {
671 carp("Devel::Size: Calculated sizes for FMs are incomplete");
676 st->total_size += sizeof(XPVIO);
677 magic_size(thing, st);
678 if (check_new(st, (SvPVX_const(thing)))) {
679 st->total_size += ((XPVIO *) SvANY(thing))->xpv_cur;
681 /* Some embedded char pointers */
682 check_new_and_strlen(st, ((XPVIO *) SvANY(thing))->xio_top_name);
683 check_new_and_strlen(st, ((XPVIO *) SvANY(thing))->xio_fmt_name);
684 check_new_and_strlen(st, ((XPVIO *) SvANY(thing))->xio_bottom_name);
685 /* Throw the GVs on the list to be walked if they're not-null */
686 sv_size(aTHX_ st, (SV *)((XPVIO *) SvANY(thing))->xio_top_gv, TRUE);
687 sv_size(aTHX_ st, (SV *)((XPVIO *) SvANY(thing))->xio_bottom_gv, TRUE);
688 sv_size(aTHX_ st, (SV *)((XPVIO *) SvANY(thing))->xio_fmt_gv, TRUE);
690 /* Only go trotting through the IO structures if they're really
691 trottable. If USE_PERLIO is defined we can do this. If
692 not... we can't, so we don't even try */
694 /* Dig into xio_ifp and xio_ofp here */
695 warn("Devel::Size: Can't size up perlio layers yet\n");
699 warn("Devel::Size: Unknown variable type: %d encountered\n", SvTYPE(thing) );
704 static struct state *
709 Newxz(st, 1, struct state);
711 if (NULL != (warn_flag = perl_get_sv("Devel::Size::warn", FALSE))) {
712 st->dangle_whine = st->go_yell = SvIV(warn_flag) ? TRUE : FALSE;
714 if (NULL != (warn_flag = perl_get_sv("Devel::Size::dangle", FALSE))) {
715 st->dangle_whine = SvIV(warn_flag) ? TRUE : FALSE;
717 check_new(st, &PL_sv_undef);
718 check_new(st, &PL_sv_no);
719 check_new(st, &PL_sv_yes);
723 MODULE = Devel::Size PACKAGE = Devel::Size
732 SV *thing = orig_thing;
733 struct state *st = new_state(aTHX);
735 /* If they passed us a reference then dereference it. This is the
736 only way we can check the sizes of arrays and hashes */
737 #if (PERL_VERSION < 11)
738 if (SvOK(thing) && SvROK(thing)) {
747 sv_size(aTHX_ st, thing, FALSE);
748 RETVAL = st->total_size;
756 total_size(orig_thing)
760 SV *thing = orig_thing;
761 /* Array with things we still need to do */
764 struct state *st = new_state(aTHX);
766 /* Size starts at zero */
769 pending_array = newAV();
771 /* If they passed us a reference then dereference it.
772 This is the only way we can check the sizes of arrays and hashes. */
777 /* Put it on the pending array */
778 av_push(pending_array, thing);
780 /* Now just yank things off the end of the array until it's done */
781 while (av_len(pending_array) >= 0) {
782 thing = av_pop(pending_array);
783 /* Process it if we've not seen it */
784 if (sv_size(aTHX_ st, thing, TRUE)) {
785 dbg_printf(("# Found type %i at %p\n", SvTYPE(thing), thing));
786 switch (SvTYPE(thing)) {
787 /* fix for bug #24846 (Does not correctly recurse into references in a PVNV-type scalar) */
791 av_push(pending_array, SvRV(thing));
794 #if (PERL_VERSION < 11)
799 dbg_printf(("# Found RV\n"));
801 dbg_printf(("# Found RV\n"));
802 av_push(pending_array, SvRV(thing));
808 AV *tempAV = (AV *)thing;
811 dbg_printf(("# Found type AV\n"));
812 /* Quick alias to cut down on casting */
815 if (av_len(tempAV) != -1) {
817 /* Run through them all */
818 for (index = 0; index <= av_len(tempAV); index++) {
819 /* Did we get something? */
820 if ((tempSV = av_fetch(tempAV, index, 0))) {
822 if (*tempSV != &PL_sv_undef) {
823 /* Apparently not. Save it for later */
824 av_push(pending_array, *tempSV);
833 dbg_printf(("# Found type HV\n"));
834 /* Is there anything in here? */
835 if (hv_iterinit((HV *)thing)) {
837 while ((temp_he = hv_iternext((HV *)thing))) {
838 av_push(pending_array, hv_iterval((HV *)thing, temp_he));
844 dbg_printf(("# Found type GV\n"));
845 if(!isGV_with_GP(thing))
847 /* Run through all the pieces and push the ones with bits */
849 av_push(pending_array, (SV *)GvSV(thing));
852 av_push(pending_array, (SV *)GvFORM(thing));
855 av_push(pending_array, (SV *)GvAV(thing));
858 av_push(pending_array, (SV *)GvHV(thing));
861 av_push(pending_array, (SV *)GvCV(thing));
868 /* check_new() returned false: */
869 #ifdef DEVEL_SIZE_DEBUGGING
870 if (SvOK(sv)) printf("# Ignore ref copy 0x%x\n", sv);
871 else printf("# Ignore non-sv 0x%x\n", sv);
876 RETVAL = st->total_size;
878 SvREFCNT_dec(pending_array);