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);
89 if (NULL == p || NULL == st) return FALSE;
90 tv_p = (void **) (st->tracking);
92 const char c = *(const char *)p;
96 warn( "Devel::Size: Encountered invalid pointer: %p\n", p );
102 /* bits now 24 (32 bit pointers) or 56 (64 bit pointers) */
104 /* First level is always present. */
106 i = (unsigned int)((cooked_p >> bits) & 0xFF);
108 Newxz(tv_p[i], 256, void *);
109 tv_p = (void **)(tv_p[i]);
111 } while (bits > LEAF_BITS + BYTE_BITS);
112 /* bits now 16 always */
113 #if !defined(MULTIPLICITY) || PERL_VERSION > 8 || (PERL_VERSION == 8 && PERL_SUBVERSION > 8)
114 /* 5.8.8 and early have an assert() macro that uses Perl_croak, hence needs
115 a my_perl under multiplicity */
118 leaf_p = (U8 **)tv_p;
119 i = (unsigned int)((cooked_p >> bits) & 0xFF);
121 Newxz(leaf_p[i], 1 << LEAF_BITS, U8);
126 i = (unsigned int)((cooked_p >> BYTE_BITS) & LEAF_MASK);
128 if(leaf[i] & this_bit)
136 free_tracking_at(void **tv, int level)
144 free_tracking_at(tv[i], level);
158 free_state(struct state *st)
160 const int top_level = (sizeof(void *) * 8 - LEAF_BITS - BYTE_BITS) / 8;
161 free_tracking_at((void **)st->tracking, top_level);
165 static void thing_size(pTHX_ const SV *const, struct state *);
182 cc_opclass(const OP * const o)
188 return (o->op_flags & OPf_KIDS) ? OPc_UNOP : OPc_BASEOP;
190 if (o->op_type == OP_SASSIGN)
191 return ((o->op_private & OPpASSIGN_BACKWARDS) ? OPc_UNOP : OPc_BINOP);
194 if (o->op_type == OP_GV || o->op_type == OP_GVSV || o->op_type == OP_AELEMFAST)
198 if ((o->op_type == OP_TRANS)) {
202 switch (PL_opargs[o->op_type] & OA_CLASS_MASK) {
227 case OA_PVOP_OR_SVOP: TAG;
229 * Character translations (tr///) are usually a PVOP, keeping a
230 * pointer to a table of shorts used to look up translations.
231 * Under utf8, however, a simple table isn't practical; instead,
232 * the OP is an SVOP, and the SV is a reference to a swash
233 * (i.e., an RV pointing to an HV).
235 return (o->op_private & (OPpTRANS_TO_UTF|OPpTRANS_FROM_UTF))
236 ? OPc_SVOP : OPc_PVOP;
244 case OA_BASEOP_OR_UNOP: TAG;
246 * UNI(OP_foo) in toke.c returns token UNI or FUNC1 depending on
247 * whether parens were seen. perly.y uses OPf_SPECIAL to
248 * signal whether a BASEOP had empty parens or none.
249 * Some other UNOPs are created later, though, so the best
250 * test is OPf_KIDS, which is set in newUNOP.
252 return (o->op_flags & OPf_KIDS) ? OPc_UNOP : OPc_BASEOP;
254 case OA_FILESTATOP: TAG;
256 * The file stat OPs are created via UNI(OP_foo) in toke.c but use
257 * the OPf_REF flag to distinguish between OP types instead of the
258 * usual OPf_SPECIAL flag. As usual, if OPf_KIDS is set, then we
259 * return OPc_UNOP so that walkoptree can find our children. If
260 * OPf_KIDS is not set then we check OPf_REF. Without OPf_REF set
261 * (no argument to the operator) it's an OP; with OPf_REF set it's
262 * an SVOP (and op_sv is the GV for the filehandle argument).
264 return ((o->op_flags & OPf_KIDS) ? OPc_UNOP :
266 (o->op_flags & OPf_REF) ? OPc_PADOP : OPc_BASEOP);
268 (o->op_flags & OPf_REF) ? OPc_SVOP : OPc_BASEOP);
270 case OA_LOOPEXOP: TAG;
272 * next, last, redo, dump and goto use OPf_SPECIAL to indicate that a
273 * label was omitted (in which case it's a BASEOP) or else a term was
274 * seen. In this last case, all except goto are definitely PVOP but
275 * goto is either a PVOP (with an ordinary constant label), an UNOP
276 * with OPf_STACKED (with a non-constant non-sub) or an UNOP for
277 * OP_REFGEN (with goto &sub) in which case OPf_STACKED also seems to
280 if (o->op_flags & OPf_STACKED)
282 else if (o->op_flags & OPf_SPECIAL)
287 warn("Devel::Size: Can't determine class of operator %s, assuming BASEOP\n",
288 PL_op_name[o->op_type]);
299 /* Figure out how much magic is attached to the SV and return the
302 magic_size(const SV * const thing, struct state *st) {
303 MAGIC *magic_pointer;
306 if (!SvMAGIC(thing)) {
311 /* Get the base magic pointer */
312 magic_pointer = SvMAGIC(thing);
314 /* Have we seen the magic pointer? */
315 while (check_new(st, magic_pointer)) {
316 st->total_size += sizeof(MAGIC);
319 /* Have we seen the magic vtable? */
320 if (check_new(st, magic_pointer->mg_virtual)) {
321 st->total_size += sizeof(MGVTBL);
324 /* Get the next in the chain */
325 magic_pointer = magic_pointer->mg_moremagic;
328 if (st->dangle_whine)
329 warn( "Devel::Size: Encountered bad magic at: %p\n", magic_pointer );
335 check_new_and_strlen(struct state *st, const char *const p) {
337 st->total_size += strlen(p);
341 regex_size(const REGEXP * const baseregex, struct state *st) {
342 if(!check_new(st, baseregex))
344 st->total_size += sizeof(REGEXP);
345 #if (PERL_VERSION < 11)
346 /* Note the size of the paren offset thing */
347 st->total_size += sizeof(I32) * baseregex->nparens * 2;
348 st->total_size += strlen(baseregex->precomp);
350 st->total_size += sizeof(struct regexp);
351 st->total_size += sizeof(I32) * SvANY(baseregex)->nparens * 2;
352 /*st->total_size += strlen(SvANY(baseregex)->subbeg);*/
354 if (st->go_yell && !st->regex_whine) {
355 carp("Devel::Size: Calculated sizes for compiled regexes are incompatible, and probably always will be");
361 op_size(pTHX_ const OP * const baseop, struct state *st)
365 if(!check_new(st, baseop))
368 op_size(aTHX_ baseop->op_next, st);
370 switch (cc_opclass(baseop)) {
371 case OPc_BASEOP: TAG;
372 st->total_size += sizeof(struct op);
375 st->total_size += sizeof(struct unop);
376 op_size(aTHX_ cUNOPx(baseop)->op_first, st);
379 st->total_size += sizeof(struct binop);
380 op_size(aTHX_ cBINOPx(baseop)->op_first, st);
381 op_size(aTHX_ cBINOPx(baseop)->op_last, st);
384 st->total_size += sizeof(struct logop);
385 op_size(aTHX_ cBINOPx(baseop)->op_first, st);
386 op_size(aTHX_ cLOGOPx(baseop)->op_other, st);
388 case OPc_LISTOP: TAG;
389 st->total_size += sizeof(struct listop);
390 op_size(aTHX_ cLISTOPx(baseop)->op_first, st);
391 op_size(aTHX_ cLISTOPx(baseop)->op_last, st);
394 st->total_size += sizeof(struct pmop);
395 op_size(aTHX_ cPMOPx(baseop)->op_first, st);
396 op_size(aTHX_ cPMOPx(baseop)->op_last, st);
397 #if PERL_VERSION < 9 || (PERL_VERSION == 9 && PERL_SUBVERSION < 5)
398 op_size(aTHX_ cPMOPx(baseop)->op_pmreplroot, st);
399 op_size(aTHX_ cPMOPx(baseop)->op_pmreplstart, st);
400 op_size(aTHX_ (OP *)cPMOPx(baseop)->op_pmnext, st);
402 /* This is defined away in perl 5.8.x, but it is in there for
405 regex_size(PM_GETRE(cPMOPx(baseop)), st);
407 regex_size(cPMOPx(baseop)->op_pmregexp, st);
411 st->total_size += sizeof(struct pmop);
412 if (check_new(st, cSVOPx(baseop)->op_sv)) {
413 thing_size(aTHX_ cSVOPx(baseop)->op_sv, st);
417 st->total_size += sizeof(struct padop);
420 check_new_and_strlen(st, cPVOPx(baseop)->op_pv);
422 st->total_size += sizeof(struct loop);
423 op_size(aTHX_ cLOOPx(baseop)->op_first, st);
424 op_size(aTHX_ cLOOPx(baseop)->op_last, st);
425 op_size(aTHX_ cLOOPx(baseop)->op_redoop, st);
426 op_size(aTHX_ cLOOPx(baseop)->op_nextop, st);
427 op_size(aTHX_ cLOOPx(baseop)->op_lastop, st);
432 basecop = (COP *)baseop;
433 st->total_size += sizeof(struct cop);
435 /* Change 33656 by nicholas@mouse-mill on 2008/04/07 11:29:51
436 Eliminate cop_label from struct cop by storing a label as the first
437 entry in the hints hash. Most statements don't have labels, so this
438 will save memory. Not sure how much.
439 The check below will be incorrect fail on bleadperls
440 before 5.11 @33656, but later than 5.10, producing slightly too
441 small memory sizes on these Perls. */
442 #if (PERL_VERSION < 11)
443 check_new_and_strlen(st, basecop->cop_label);
446 check_new_and_strlen(st, basecop->cop_file);
447 check_new_and_strlen(st, basecop->cop_stashpv);
449 if (check_new(st, basecop->cop_stash)) {
450 thing_size(aTHX_ (SV *)basecop->cop_stash, st);
452 if (check_new(st, basecop->cop_filegv)) {
453 thing_size(aTHX_ (SV *)basecop->cop_filegv, st);
464 if (st->dangle_whine)
465 warn( "Devel::Size: Encountered dangling pointer in opcode at: %p\n", baseop );
469 #if PERL_VERSION > 9 || (PERL_VERSION == 9 && PERL_SUBVERSION > 2)
470 # define NEW_HEAD_LAYOUT
474 thing_size(pTHX_ const SV * const orig_thing, struct state *st) {
475 const SV *thing = orig_thing;
477 st->total_size += sizeof(SV);
479 switch (SvTYPE(thing)) {
483 /* Just a plain integer. This will be differently sized depending
484 on whether purify's been compiled in */
486 #ifndef NEW_HEAD_LAYOUT
488 st->total_size += sizeof(sizeof(XPVIV));
490 st->total_size += sizeof(IV);
494 /* Is it a float? Like the int, it depends on purify */
497 st->total_size += sizeof(sizeof(XPVNV));
499 st->total_size += sizeof(NV);
502 #if (PERL_VERSION < 11)
503 /* Is it a reference? */
505 #ifndef NEW_HEAD_LAYOUT
506 st->total_size += sizeof(XRV);
510 /* How about a plain string? In which case we need to add in how
511 much has been allocated */
513 st->total_size += sizeof(XPV);
515 thing_size(aTHX_ SvRV_const(thing), st);
517 st->total_size += SvLEN(thing);
519 /* A string with an integer part? */
521 st->total_size += sizeof(XPVIV);
523 thing_size(aTHX_ SvRV_const(thing), st);
525 st->total_size += SvLEN(thing);
527 st->total_size += SvIVX(thing);
530 /* A scalar/string/reference with a float part? */
532 st->total_size += sizeof(XPVNV);
534 thing_size(aTHX_ SvRV_const(thing), st);
536 st->total_size += SvLEN(thing);
539 st->total_size += sizeof(XPVMG);
541 thing_size(aTHX_ SvRV_const(thing), st);
543 st->total_size += SvLEN(thing);
544 magic_size(thing, st);
546 #if PERL_VERSION <= 8
548 st->total_size += sizeof(XPVBM);
550 thing_size(aTHX_ SvRV_const(thing), st);
552 st->total_size += SvLEN(thing);
553 magic_size(thing, st);
557 st->total_size += sizeof(XPVLV);
559 thing_size(aTHX_ SvRV_const(thing), st);
561 st->total_size += SvLEN(thing);
562 magic_size(thing, st);
564 /* How much space is dedicated to the array? Not counting the
565 elements in the array, mind, just the array itself */
567 st->total_size += sizeof(XPVAV);
568 /* Is there anything in the array? */
569 if (AvMAX(thing) != -1) {
570 /* an array with 10 slots has AvMax() set to 9 - te 2007-04-22 */
571 st->total_size += sizeof(SV *) * (AvMAX(thing) + 1);
572 dbg_printf(("total_size: %li AvMAX: %li av_len: $i\n", st->total_size, AvMAX(thing), av_len((AV*)thing)));
574 /* Add in the bits on the other side of the beginning */
576 dbg_printf(("total_size %li, sizeof(SV *) %li, AvARRAY(thing) %li, AvALLOC(thing)%li , sizeof(ptr) %li \n",
577 st->total_size, sizeof(SV*), AvARRAY(thing), AvALLOC(thing), sizeof( thing )));
579 /* under Perl 5.8.8 64bit threading, AvARRAY(thing) was a pointer while AvALLOC was 0,
580 resulting in grossly overstated sized for arrays. Technically, this shouldn't happen... */
581 if (AvALLOC(thing) != 0) {
582 st->total_size += (sizeof(SV *) * (AvARRAY(thing) - AvALLOC(thing)));
584 #if (PERL_VERSION < 9)
585 /* Is there something hanging off the arylen element?
586 Post 5.9.something this is stored in magic, so will be found there,
587 and Perl_av_arylen_p() takes a non-const AV*, hence compilers rightly
588 complain about AvARYLEN() passing thing to it. */
589 if (AvARYLEN(thing)) {
590 if (check_new(st, AvARYLEN(thing))) {
591 thing_size(aTHX_ AvARYLEN(thing), st);
595 magic_size(thing, st);
598 /* First the base struct */
599 st->total_size += sizeof(XPVHV);
600 /* Now the array of buckets */
601 st->total_size += (sizeof(HE *) * (HvMAX(thing) + 1));
602 /* Now walk the bucket chain */
603 if (HvARRAY(thing)) {
606 for (cur_bucket = 0; cur_bucket <= HvMAX(thing); cur_bucket++) {
607 cur_entry = *(HvARRAY(thing) + cur_bucket);
609 st->total_size += sizeof(HE);
610 if (cur_entry->hent_hek) {
611 /* Hash keys can be shared. Have we seen this before? */
612 if (check_new(st, cur_entry->hent_hek)) {
613 st->total_size += HEK_BASESIZE + cur_entry->hent_hek->hek_len + 2;
616 cur_entry = cur_entry->hent_next;
620 magic_size(thing, st);
623 st->total_size += sizeof(XPVCV);
624 magic_size(thing, st);
626 st->total_size += ((XPVIO *) SvANY(thing))->xpv_len;
627 if (check_new(st, CvSTASH(thing))) {
628 thing_size(aTHX_ (SV *)CvSTASH(thing), st);
630 if (check_new(st, SvSTASH(thing))) {
631 thing_size(aTHX_ (SV *)SvSTASH(thing), st);
633 if (check_new(st, CvGV(thing))) {
634 thing_size(aTHX_ (SV *)CvGV(thing), st);
636 if (check_new(st, CvPADLIST(thing))) {
637 thing_size(aTHX_ (SV *)CvPADLIST(thing), st);
639 if (check_new(st, CvOUTSIDE(thing))) {
640 thing_size(aTHX_ (SV *)CvOUTSIDE(thing), st);
642 if (CvISXSUB(thing)) {
643 SV *sv = cv_const_sv((CV *)thing);
645 thing_size(aTHX_ sv, st);
648 op_size(aTHX_ CvSTART(thing), st);
649 op_size(aTHX_ CvROOT(thing), st);
654 magic_size(thing, st);
655 st->total_size += sizeof(XPVGV);
656 st->total_size += GvNAMELEN(thing);
658 /* Is there a file? */
659 check_new_and_strlen(st, GvFILE(thing));
661 /* Is there something hanging off the glob? */
663 if (check_new(st, GvGP(thing))) {
664 st->total_size += sizeof(GP);
667 if ((generic_thing = (SV *)(GvGP(thing)->gp_sv))) {
668 thing_size(aTHX_ generic_thing, st);
670 if ((generic_thing = (SV *)(GvGP(thing)->gp_form))) {
671 thing_size(aTHX_ generic_thing, st);
673 if ((generic_thing = (SV *)(GvGP(thing)->gp_av))) {
674 thing_size(aTHX_ generic_thing, st);
676 if ((generic_thing = (SV *)(GvGP(thing)->gp_hv))) {
677 thing_size(aTHX_ generic_thing, st);
679 if ((generic_thing = (SV *)(GvGP(thing)->gp_egv))) {
680 thing_size(aTHX_ generic_thing, st);
682 if ((generic_thing = (SV *)(GvGP(thing)->gp_cv))) {
683 thing_size(aTHX_ generic_thing, st);
690 st->total_size += sizeof(XPVFM);
691 magic_size(thing, st);
692 st->total_size += ((XPVIO *) SvANY(thing))->xpv_len;
693 if (check_new(st, CvPADLIST(thing))) {
694 thing_size(aTHX_ (SV *)CvPADLIST(thing), st);
696 if (check_new(st, CvOUTSIDE(thing))) {
697 thing_size(aTHX_ (SV *)CvOUTSIDE(thing), st);
700 if (st->go_yell && !st->fm_whine) {
701 carp("Devel::Size: Calculated sizes for FMs are incomplete");
706 st->total_size += sizeof(XPVIO);
707 magic_size(thing, st);
708 if (check_new(st, (SvPVX_const(thing)))) {
709 st->total_size += ((XPVIO *) SvANY(thing))->xpv_cur;
711 /* Some embedded char pointers */
712 check_new_and_strlen(st, ((XPVIO *) SvANY(thing))->xio_top_name);
713 check_new_and_strlen(st, ((XPVIO *) SvANY(thing))->xio_fmt_name);
714 check_new_and_strlen(st, ((XPVIO *) SvANY(thing))->xio_bottom_name);
715 /* Throw the GVs on the list to be walked if they're not-null */
716 if (((XPVIO *) SvANY(thing))->xio_top_gv) {
717 thing_size(aTHX_ (SV *)((XPVIO *) SvANY(thing))->xio_top_gv, st);
719 if (((XPVIO *) SvANY(thing))->xio_bottom_gv) {
720 thing_size(aTHX_ (SV *)((XPVIO *) SvANY(thing))->xio_bottom_gv, st);
722 if (((XPVIO *) SvANY(thing))->xio_fmt_gv) {
723 thing_size(aTHX_ (SV *)((XPVIO *) SvANY(thing))->xio_fmt_gv, st);
726 /* Only go trotting through the IO structures if they're really
727 trottable. If USE_PERLIO is defined we can do this. If
728 not... we can't, so we don't even try */
730 /* Dig into xio_ifp and xio_ofp here */
731 warn("Devel::Size: Can't size up perlio layers yet\n");
735 warn("Devel::Size: Unknown variable type: %d encountered\n", SvTYPE(thing) );
739 static struct state *
744 Newxz(st, 1, struct state);
746 if (NULL != (warn_flag = perl_get_sv("Devel::Size::warn", FALSE))) {
747 st->dangle_whine = st->go_yell = SvIV(warn_flag) ? TRUE : FALSE;
749 if (NULL != (warn_flag = perl_get_sv("Devel::Size::dangle", FALSE))) {
750 st->dangle_whine = SvIV(warn_flag) ? TRUE : FALSE;
755 MODULE = Devel::Size PACKAGE = Devel::Size
764 SV *thing = orig_thing;
765 struct state *st = new_state(aTHX);
767 /* If they passed us a reference then dereference it. This is the
768 only way we can check the sizes of arrays and hashes */
769 #if (PERL_VERSION < 11)
770 if (SvOK(thing) && SvROK(thing)) {
779 thing_size(aTHX_ thing, st);
780 RETVAL = st->total_size;
788 total_size(orig_thing)
792 SV *thing = orig_thing;
793 /* Array with things we still need to do */
796 struct state *st = new_state(aTHX);
798 /* Size starts at zero */
801 pending_array = newAV();
803 /* If they passed us a reference then dereference it.
804 This is the only way we can check the sizes of arrays and hashes. */
809 /* Put it on the pending array */
810 av_push(pending_array, thing);
812 /* Now just yank things off the end of the array until it's done */
813 while (av_len(pending_array) >= 0) {
814 thing = av_pop(pending_array);
815 /* Process it if we've not seen it */
816 if (check_new(st, thing)) {
817 dbg_printf(("# Found type %i at %p\n", SvTYPE(thing), thing));
820 /* Yes, it is. So let's check the type */
821 switch (SvTYPE(thing)) {
822 /* fix for bug #24846 (Does not correctly recurse into references in a PVNV-type scalar) */
826 av_push(pending_array, SvRV(thing));
829 #if (PERL_VERSION < 11)
834 dbg_printf(("# Found RV\n"));
836 dbg_printf(("# Found RV\n"));
837 av_push(pending_array, SvRV(thing));
843 AV *tempAV = (AV *)thing;
846 dbg_printf(("# Found type AV\n"));
847 /* Quick alias to cut down on casting */
850 if (av_len(tempAV) != -1) {
852 /* Run through them all */
853 for (index = 0; index <= av_len(tempAV); index++) {
854 /* Did we get something? */
855 if ((tempSV = av_fetch(tempAV, index, 0))) {
857 if (*tempSV != &PL_sv_undef) {
858 /* Apparently not. Save it for later */
859 av_push(pending_array, *tempSV);
868 dbg_printf(("# Found type HV\n"));
869 /* Is there anything in here? */
870 if (hv_iterinit((HV *)thing)) {
872 while ((temp_he = hv_iternext((HV *)thing))) {
873 av_push(pending_array, hv_iterval((HV *)thing, temp_he));
879 dbg_printf(("# Found type GV\n"));
880 /* Run through all the pieces and push the ones with bits */
882 av_push(pending_array, (SV *)GvSV(thing));
885 av_push(pending_array, (SV *)GvFORM(thing));
888 av_push(pending_array, (SV *)GvAV(thing));
891 av_push(pending_array, (SV *)GvHV(thing));
894 av_push(pending_array, (SV *)GvCV(thing));
902 thing_size(aTHX_ thing, st);
904 /* check_new() returned false: */
905 #ifdef DEVEL_SIZE_DEBUGGING
906 if (SvOK(sv)) printf("# Ignore ref copy 0x%x\n", sv);
907 else printf("# Ignore non-sv 0x%x\n", sv);
912 RETVAL = st->total_size;
914 SvREFCNT_dec(pending_array);