dump.c: add S_get_cv_from_op() function

The existing S_get_sv_from_pad() function does two things: it finds the
CV associated with the specified op, and then extracts something from
that CV's pad.

This commit splits the 'find the associated CV' part of the code out
into a separate function, which will be used elsewhere shortly.

Author: iabyn

dump.c

@@ -1099,13 +1099,13 @@ S_pm_description(pTHX_ const PMOP *pm)
 }
 
 
-/* S_get_sv_from_pad(): a helper function for op_dump().
+/* S_get_cv_from_op(): a helper function for op_dump().
+ *
+ * Find the CV which the OP o is contained within.
  *
- * On threaded builds, try to find the SV indexed by the OP o (e.g. via
- * op_targ or op_padix) at pad offset po.
  * Since an op can be dumped at any time, there is no guarantee that the
- * OP is associated with the current PL_curpad. So try to find the currently
- * running CV or eval, and see if it contains the OP. Or if it's
+ * OP is associated with the current PL_curpad. So try to find the
+ * currently running CV or eval, and see if it contains the OP. Or if it's
  * compile-time, see if the op is contained within one of the op subtrees
  * on the parser stack.
  *
@@ -1118,32 +1118,20 @@ S_pm_description(pTHX_ const PMOP *pm)
  * sane state, be conservative, and if in doubt, return NULL.
  */
 
-#ifdef USE_ITHREADS
-static SV *
-S_get_sv_from_pad(pTHX_ const OP *o, PADOFFSET po, CV *rootcv)
+static CV *
+S_get_cv_from_op(pTHX_ const OP *o, CV *rootcv)
 {
-    PADLIST *padlist; /* declare early to work round compiler quirks */
-
-    if (!po)
-        return NULL;
-
-    CV *cv = NULL;
-    int n;
-    OP *oproot;
-
-    if (rootcv) {
-        cv = rootcv;
-        goto got_cv;
-    }
+    if (rootcv)
+        return rootcv;
 
     /* Find the root of the optree this op is embedded in. For a compiled
      * sub, this root will typically be a leavesub or similar attached to
      * a CV. If compiling, this may be a small subtree on the parser
      * stack. Limit the number of hops, in case there is some sort of
      * loop or other weirdness.
      */
-    n = 100;
-    oproot = (OP*)o;
+    int n = 100;
+    OP *oproot = (OP*)o;
     while (1) {
         if (--n <= 0)
             return NULL;
@@ -1159,12 +1147,8 @@ S_get_sv_from_pad(pTHX_ const OP *o, PADOFFSET po, CV *rootcv)
         yy_stack_frame *ps;
 
         for (ps = PL_parser->ps; ps > PL_parser->stack; ps--) {
-            if (ps->val.opval == oproot) {
-                cv = ps->compcv;
-                if (!cv)
-                    return NULL; /* this shouldn't actually happen */
-                goto got_cv;
-            }
+            if (ps->val.opval == oproot)
+                return ps->compcv;
         }
     }
 
@@ -1174,6 +1158,7 @@ S_get_sv_from_pad(pTHX_ const OP *o, PADOFFSET po, CV *rootcv)
      */
     I32 i;
     for (i = cxstack_ix; i >= 0; i--) {
+        CV *cv;
         const PERL_CONTEXT * const cx = &cxstack[i];
         switch (CxTYPE(cx)) {
         default:
@@ -1187,7 +1172,7 @@ S_get_sv_from_pad(pTHX_ const OP *o, PADOFFSET po, CV *rootcv)
              * does instead */
             if (!cv || !CvEVAL(cv) || oproot != PL_eval_root)
                 continue;
-            goto got_cv;
+            return cv;
         case CXt_SUB:
             if (cx->cx_type & CXp_SUB_RE_FAKE)
                 continue;
@@ -1196,21 +1181,54 @@ S_get_sv_from_pad(pTHX_ const OP *o, PADOFFSET po, CV *rootcv)
             cv = cxstack[i].blk_sub.cv;
             if (!cv || CvISXSUB(cv) || oproot != CvROOT(cv))
                 continue;
-            goto got_cv;
+            return cv;
         }
     }
 
-    if (PL_main_cv && PL_main_root == oproot) {
-        cv = PL_main_cv;
-        goto got_cv;
-    }
+    if (PL_main_cv && PL_main_root == oproot)
+        return PL_main_cv;
+
     return NULL;
+}
+
+
+/* S_get_sv_from_pad(): a helper function for op_dump().
+ *
+ * On threaded builds, try to find the SV indexed by the OP o (e.g. via
+ * op_targ or op_padix) at pad offset po.
+ * Since an op can be dumped at any time, there is no guarantee that the
+ * OP is associated with the current PL_curpad. So try to find the currently
+ * running CV or eval, and see if it contains the OP. Or if it's
+ * compile-time, see if the op is contained within one of the op subtrees
+ * on the parser stack.
+ *
+ * Return NULL if it can't be found.
+ *
+ * Sometimes the caller *does* know what CV is being dumped; if so, it
+ * is passed as rootcv.
+ *
+ * Since this may be called during debugging and things may not be in a
+ * sane state, be conservative, and if in doubt, return NULL.
+ */
+
+#ifdef USE_ITHREADS
+static SV *
+S_get_sv_from_pad(pTHX_ const OP *o, PADOFFSET po, CV *rootcv)
+{
+    PADLIST *padlist; /* declare early to work round compiler quirks */
+
+    if (!po)
+        return NULL;
+
+    CV *cv = S_get_cv_from_op(aTHX_ o, rootcv);
+    if (!cv)
+        return NULL;
 
    /* Lookup the entry in the pad associated with this CV.
     * Note that for SVs moved into the pad, they are shared at all pad
     * depths, so we only have to look at depth 1 and not worry about
     * CvDEPTH(). */
-   got_cv:
+
     padlist = CvPADLIST(cv);
     if (!padlist)
         return NULL;