Remove CALL_FPTR and CPERLscope.

These are left from PERL_OBJECT, which was an implementation of
multiplicity using C++ objects. PERL_OBJECT was removed in 5.8, but the
macros seem to have been cargo-culted all over the core (including in
places where they would have been inappropriate originally). Since they
now do exactly nothing, it's cleaner to remove them.

I have left the definitions in perl.h, under #ifndef PERL_CORE, since
some CPAN XS code uses them (also often incorrectly). I have also left
STATIC alone, since it seems potentially more useful and is much more
ingrained.

The only appearance of these macros this patch doesn't touch is in
Devel-PPPort, because that's a CPAN module.

15 files changed, 82 insertions, 75 deletions

diff --git a/dist/threads-shared/shared.xs b/dist/threads-shared/shared.xs
index 720e3b6749..549fe374b8 100644
--- a/dist/threads-shared/shared.xs
+++ b/dist/threads-shared/shared.xs
@@ -1181,7 +1181,7 @@ S_shared_signal_hook(pTHX) {
     MUTEX_UNLOCK(&PL_sharedsv_lock.mutex);
     if (us)
 	return; /* try again later */
-    CALL_FPTR(prev_signal_hook)(aTHX);
+    prev_signal_hook(aTHX);
 }
 #endif
 
diff --git a/dump.c b/dump.c
index 2acc7e1d4d..06ce87992a 100644
--- a/dump.c
+++ b/dump.c
@@ -2109,7 +2109,7 @@ Perl_runops_debug(pTHX)
 	    if (DEBUG_t_TEST_) debop(PL_op);
 	    if (DEBUG_P_TEST_) debprof(PL_op);
 	}
-    } while ((PL_op = CALL_FPTR(PL_op->op_ppaddr)(aTHX)));
+    } while ((PL_op = PL_op->op_ppaddr(aTHX)));
     DEBUG_l(Perl_deb(aTHX_ "leaving RUNOPS level\n"));
 
     TAINT_NOT;
diff --git a/mg.c b/mg.c
index 797b57e74a..a674e439fb 100644
--- a/mg.c
+++ b/mg.c
@@ -227,7 +227,7 @@ Perl_mg_get(pTHX_ SV *sv)
 	MAGIC * const nextmg = mg->mg_moremagic;	/* it may delete itself */
 
 	if (!(mg->mg_flags & MGf_GSKIP) && vtbl && vtbl->svt_get) {
-	    CALL_FPTR(vtbl->svt_get)(aTHX_ sv, mg);
+	    vtbl->svt_get(aTHX_ sv, mg);
 
 	    /* guard against magic having been deleted - eg FETCH calling
 	     * untie */
@@ -302,7 +302,7 @@ Perl_mg_set(pTHX_ SV *sv)
 	if (PL_localizing == 2 && !S_is_container_magic(mg))
 	    continue;
 	if (vtbl && vtbl->svt_set)
-	    CALL_FPTR(vtbl->svt_set)(aTHX_ sv, mg);
+	    vtbl->svt_set(aTHX_ sv, mg);
     }
 
     restore_magic(INT2PTR(void*, (IV)mgs_ix));
@@ -332,7 +332,7 @@ Perl_mg_length(pTHX_ SV *sv)
             const I32 mgs_ix = SSNEW(sizeof(MGS));
 	    save_magic(mgs_ix, sv);
 	    /* omit MGf_GSKIP -- not changed here */
-	    len = CALL_FPTR(vtbl->svt_len)(aTHX_ sv, mg);
+	    len = vtbl->svt_len(aTHX_ sv, mg);
 	    restore_magic(INT2PTR(void*, (IV)mgs_ix));
 	    return len;
 	}
@@ -364,7 +364,7 @@ Perl_mg_size(pTHX_ SV *sv)
             I32 len;
 	    save_magic(mgs_ix, sv);
 	    /* omit MGf_GSKIP -- not changed here */
-	    len = CALL_FPTR(vtbl->svt_len)(aTHX_ sv, mg);
+	    len = vtbl->svt_len(aTHX_ sv, mg);
 	    restore_magic(INT2PTR(void*, (IV)mgs_ix));
 	    return len;
 	}
@@ -408,7 +408,7 @@ Perl_mg_clear(pTHX_ SV *sv)
 	nextmg = mg->mg_moremagic; /* it may delete itself */
 
 	if (vtbl && vtbl->svt_clear)
-	    CALL_FPTR(vtbl->svt_clear)(aTHX_ sv, mg);
+	    vtbl->svt_clear(aTHX_ sv, mg);
     }
 
     restore_magic(INT2PTR(void*, (IV)mgs_ix));
@@ -456,7 +456,7 @@ Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen)
     for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
         const MGVTBL* const vtbl = mg->mg_virtual;
 	if ((mg->mg_flags & MGf_COPY) && vtbl->svt_copy){
-	    count += CALL_FPTR(vtbl->svt_copy)(aTHX_ sv, mg, nsv, key, klen);
+	    count += vtbl->svt_copy(aTHX_ sv, mg, nsv, key, klen);
 	}
 	else {
 	    const char type = mg->mg_type;
@@ -503,7 +503,7 @@ Perl_mg_localize(pTHX_ SV *sv, SV *nsv, bool setmagic)
 	    continue;
 		
 	if ((mg->mg_flags & MGf_LOCAL) && vtbl->svt_local)
-	    (void)CALL_FPTR(vtbl->svt_local)(aTHX_ nsv, mg);
+	    (void)vtbl->svt_local(aTHX_ nsv, mg);
 	else
 	    sv_magicext(nsv, mg->mg_obj, mg->mg_type, vtbl,
 			    mg->mg_ptr, mg->mg_len);
@@ -542,7 +542,7 @@ Perl_mg_free(pTHX_ SV *sv)
         const MGVTBL* const vtbl = mg->mg_virtual;
 	moremagic = mg->mg_moremagic;
 	if (vtbl && vtbl->svt_free)
-	    CALL_FPTR(vtbl->svt_free)(aTHX_ sv, mg);
+	    vtbl->svt_free(aTHX_ sv, mg);
 	if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) {
 	    if (mg->mg_len > 0 || mg->mg_type == PERL_MAGIC_utf8)
 		Safefree(mg->mg_ptr);
diff --git a/mg.h b/mg.h
index 33628546c9..848f735d6c 100644
--- a/mg.h
+++ b/mg.h
@@ -12,15 +12,15 @@
 STRUCT_MGVTBL_DEFINITION;
 #else
 struct mgvtbl {
-    int		(CPERLscope(*svt_get))	(pTHX_ SV *sv, MAGIC* mg);
-    int		(CPERLscope(*svt_set))	(pTHX_ SV *sv, MAGIC* mg);
-    U32		(CPERLscope(*svt_len))	(pTHX_ SV *sv, MAGIC* mg);
-    int		(CPERLscope(*svt_clear))(pTHX_ SV *sv, MAGIC* mg);
-    int		(CPERLscope(*svt_free))	(pTHX_ SV *sv, MAGIC* mg);
-    int		(CPERLscope(*svt_copy))	(pTHX_ SV *sv, MAGIC* mg,
+    int		(*svt_get)	(pTHX_ SV *sv, MAGIC* mg);
+    int		(*svt_set)	(pTHX_ SV *sv, MAGIC* mg);
+    U32		(*svt_len)	(pTHX_ SV *sv, MAGIC* mg);
+    int		(*svt_clear)(pTHX_ SV *sv, MAGIC* mg);
+    int		(*svt_free)	(pTHX_ SV *sv, MAGIC* mg);
+    int		(*svt_copy)	(pTHX_ SV *sv, MAGIC* mg,
     					SV *nsv, const char *name, I32 namlen);
-    int		(CPERLscope(*svt_dup))	(pTHX_ MAGIC *mg, CLONE_PARAMS *param);
-    int		(CPERLscope(*svt_local))(pTHX_ SV *nsv, MAGIC *mg);
+    int		(*svt_dup)	(pTHX_ MAGIC *mg, CLONE_PARAMS *param);
+    int		(*svt_local)(pTHX_ SV *nsv, MAGIC *mg);
 };
 #endif
 
diff --git a/op.c b/op.c
index 48b2a36fa1..764b32919e 100644
--- a/op.c
+++ b/op.c
@@ -103,8 +103,8 @@ recursive, but it's recursive on basic blocks, not on tree nodes.
 #include "perl.h"
 #include "keywords.h"
 
-#define CALL_PEEP(o) CALL_FPTR(PL_peepp)(aTHX_ o)
-#define CALL_OPFREEHOOK(o) if (PL_opfreehook) CALL_FPTR(PL_opfreehook)(aTHX_ o)
+#define CALL_PEEP(o) PL_peepp(aTHX_ o)
+#define CALL_OPFREEHOOK(o) if (PL_opfreehook) PL_opfreehook(aTHX_ o)
 
 #if defined(PL_OP_SLAB_ALLOC)
 
@@ -305,7 +305,7 @@ Perl_Slab_Free(pTHX_ void *op)
      ? ( op_free((OP*)o),					\
 	 Perl_croak(aTHX_ "'%s' trapped by operation mask", PL_op_desc[type]),	\
 	 (OP*)0 )						\
-     : CALL_FPTR(PL_check[type])(aTHX_ (OP*)o))
+     : PL_check[type](aTHX_ (OP*)o))
 
 #define RETURN_UNLIMITED_NUMBER (PERL_INT_MAX / 2)
 
diff --git a/op.h b/op.h
index 4241f02033..d537170289 100644
--- a/op.h
+++ b/op.h
@@ -54,7 +54,7 @@ typedef PERL_BITFIELD16 Optype;
 #define BASEOP				\
     OP*		op_next;		\
     OP*		op_sibling;		\
-    OP*		(CPERLscope(*op_ppaddr))(pTHX);		\
+    OP*		(*op_ppaddr)(pTHX);	\
     MADPROP_IN_BASEOP			\
     PADOFFSET	op_targ;		\
     PERL_BITFIELD16 op_type:9;		\
@@ -733,7 +733,7 @@ preprocessing token; the type of I<arg> depends on I<which>.
 		    hk = INT2PTR(BHK *, SvIVX(sv)); \
 		\
 		if (BhkENTRY(hk, which)) \
-		    CALL_FPTR(BhkENTRY(hk, which))(aTHX_ arg); \
+		    BhkENTRY(hk, which)(aTHX_ arg); \
 	    } \
 	} \
     } STMT_END
diff --git a/perl.c b/perl.c
index 7a1c54308a..57be5d2367 100644
--- a/perl.c
+++ b/perl.c
@@ -574,7 +574,7 @@ perl_destruct(pTHXx)
     /* Need to flush since END blocks can produce output */
     my_fflush_all();
 
-    if (CALL_FPTR(PL_threadhook)(aTHX)) {
+    if (PL_threadhook(aTHX)) {
         /* Threads hook has vetoed further cleanup */
 	PL_veto_cleanup = TRUE;
         return STATUS_EXIT;
diff --git a/perl.h b/perl.h
index 1def000bf7..d9b2228608 100644
--- a/perl.h
+++ b/perl.h
@@ -210,6 +210,13 @@
 #endif
 
 #define STATIC static
+
+#ifndef PERL_CORE
+/* Do not use these macros. They were part of PERL_OBJECT, which was an
+ * implementation of multiplicity using C++ objects. They have been left
+ * here solely for the sake of XS code which has incorrectly
+ * cargo-culted them.
+ */
 #define CPERLscope(x) x
 #define CPERLarg void
 #define CPERLarg_
@@ -218,76 +225,76 @@
 #define _PERL_OBJECT_THIS
 #define PERL_OBJECT_THIS_
 #define CALL_FPTR(fptr) (*fptr)
+#endif /* !PERL_CORE */
 
-#define CALLRUNOPS  CALL_FPTR(PL_runops)
+#define CALLRUNOPS  PL_runops
 
 #define CALLREGCOMP(sv, flags) Perl_pregcomp(aTHX_ (sv),(flags))
 
-#define CALLREGCOMP_ENG(prog, sv, flags) \
-    CALL_FPTR(((prog)->comp))(aTHX_ sv, flags)
+#define CALLREGCOMP_ENG(prog, sv, flags) (prog)->comp(aTHX_ sv, flags)
 #define CALLREGEXEC(prog,stringarg,strend,strbeg,minend,screamer,data,flags) \
-    CALL_FPTR(RX_ENGINE(prog)->exec)(aTHX_ (prog),(stringarg),(strend), \
+    RX_ENGINE(prog)->exec(aTHX_ (prog),(stringarg),(strend), \
         (strbeg),(minend),(screamer),(data),(flags))
 #define CALLREG_INTUIT_START(prog,sv,strpos,strend,flags,data) \
-    CALL_FPTR(RX_ENGINE(prog)->intuit)(aTHX_ (prog), (sv), (strpos), \
+    RX_ENGINE(prog)->intuit(aTHX_ (prog), (sv), (strpos), \
         (strend),(flags),(data))
 #define CALLREG_INTUIT_STRING(prog) \
-    CALL_FPTR(RX_ENGINE(prog)->checkstr)(aTHX_ (prog))
+    RX_ENGINE(prog)->checkstr(aTHX_ (prog))
 
 #define CALLREGFREE(prog) \
     Perl_pregfree(aTHX_ (prog))
 
 #define CALLREGFREE_PVT(prog) \
-    if(prog) CALL_FPTR(RX_ENGINE(prog)->free)(aTHX_ (prog))
+    if(prog) RX_ENGINE(prog)->free(aTHX_ (prog))
 
 #define CALLREG_NUMBUF_FETCH(rx,paren,usesv)                                \
-    CALL_FPTR(RX_ENGINE(rx)->numbered_buff_FETCH)(aTHX_ (rx),(paren),(usesv))
+    RX_ENGINE(rx)->numbered_buff_FETCH(aTHX_ (rx),(paren),(usesv))
 
 #define CALLREG_NUMBUF_STORE(rx,paren,value) \
-    CALL_FPTR(RX_ENGINE(rx)->numbered_buff_STORE)(aTHX_ (rx),(paren),(value))
+    RX_ENGINE(rx)->numbered_buff_STORE(aTHX_ (rx),(paren),(value))
 
 #define CALLREG_NUMBUF_LENGTH(rx,sv,paren)                              \
-    CALL_FPTR(RX_ENGINE(rx)->numbered_buff_LENGTH)(aTHX_ (rx),(sv),(paren))
+    RX_ENGINE(rx)->numbered_buff_LENGTH(aTHX_ (rx),(sv),(paren))
 
 #define CALLREG_NAMED_BUFF_FETCH(rx, key, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff)(aTHX_ (rx), (key), NULL, ((flags) | RXapif_FETCH))
+    RX_ENGINE(rx)->named_buff(aTHX_ (rx), (key), NULL, ((flags) | RXapif_FETCH))
 
 #define CALLREG_NAMED_BUFF_STORE(rx, key, value, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff)(aTHX_ (rx), (key), (value), ((flags) | RXapif_STORE))
+    RX_ENGINE(rx)->named_buff(aTHX_ (rx), (key), (value), ((flags) | RXapif_STORE))
 
 #define CALLREG_NAMED_BUFF_DELETE(rx, key, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff)(aTHX_ (rx),(key), NULL, ((flags) | RXapif_DELETE))
+    RX_ENGINE(rx)->named_buff(aTHX_ (rx),(key), NULL, ((flags) | RXapif_DELETE))
 
 #define CALLREG_NAMED_BUFF_CLEAR(rx, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff)(aTHX_ (rx), NULL, NULL, ((flags) | RXapif_CLEAR))
+    RX_ENGINE(rx)->named_buff(aTHX_ (rx), NULL, NULL, ((flags) | RXapif_CLEAR))
 
 #define CALLREG_NAMED_BUFF_EXISTS(rx, key, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff)(aTHX_ (rx), (key), NULL, ((flags) | RXapif_EXISTS))
+    RX_ENGINE(rx)->named_buff(aTHX_ (rx), (key), NULL, ((flags) | RXapif_EXISTS))
 
 #define CALLREG_NAMED_BUFF_FIRSTKEY(rx, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff_iter)(aTHX_ (rx), NULL, ((flags) | RXapif_FIRSTKEY))
+    RX_ENGINE(rx)->named_buff_iter(aTHX_ (rx), NULL, ((flags) | RXapif_FIRSTKEY))
 
 #define CALLREG_NAMED_BUFF_NEXTKEY(rx, lastkey, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff_iter)(aTHX_ (rx), (lastkey), ((flags) | RXapif_NEXTKEY))
+    RX_ENGINE(rx)->named_buff_iter(aTHX_ (rx), (lastkey), ((flags) | RXapif_NEXTKEY))
 
 #define CALLREG_NAMED_BUFF_SCALAR(rx, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff)(aTHX_ (rx), NULL, NULL, ((flags) | RXapif_SCALAR))
+    RX_ENGINE(rx)->named_buff(aTHX_ (rx), NULL, NULL, ((flags) | RXapif_SCALAR))
 
 #define CALLREG_NAMED_BUFF_COUNT(rx) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff)(aTHX_ (rx), NULL, NULL, RXapif_REGNAMES_COUNT)
+    RX_ENGINE(rx)->named_buff(aTHX_ (rx), NULL, NULL, RXapif_REGNAMES_COUNT)
 
 #define CALLREG_NAMED_BUFF_ALL(rx, flags) \
-    CALL_FPTR(RX_ENGINE(rx)->named_buff)(aTHX_ (rx), NULL, NULL, flags)
+    RX_ENGINE(rx)->named_buff(aTHX_ (rx), NULL, NULL, flags)
 
 #define CALLREG_PACKAGE(rx) \
-    CALL_FPTR(RX_ENGINE(rx)->qr_package)(aTHX_ (rx))
+    RX_ENGINE(rx)->qr_package(aTHX_ (rx))
 
 #if defined(USE_ITHREADS)
 #define CALLREGDUPE(prog,param) \
     Perl_re_dup(aTHX_ (prog),(param))
 
 #define CALLREGDUPE_PVT(prog,param) \
-    (prog ? CALL_FPTR(RX_ENGINE(prog)->dupe)(aTHX_ (prog),(param)) \
+    (prog ? RX_ENGINE(prog)->dupe(aTHX_ (prog),(param)) \
           : (REGEXP *)NULL)
 #endif
 
@@ -4210,12 +4217,12 @@ struct perl_memory_debug_header {
 #  endif
 #endif
 
-typedef int (CPERLscope(*runops_proc_t)) (pTHX);
-typedef void (CPERLscope(*share_proc_t)) (pTHX_ SV *sv);
-typedef int  (CPERLscope(*thrhook_proc_t)) (pTHX);
-typedef OP* (CPERLscope(*PPADDR_t)[]) (pTHX);
-typedef bool (CPERLscope(*destroyable_proc_t)) (pTHX_ SV *sv);
-typedef void (CPERLscope(*despatch_signals_proc_t)) (pTHX);
+typedef int (*runops_proc_t)(pTHX);
+typedef void (*share_proc_t) (pTHX_ SV *sv);
+typedef int  (*thrhook_proc_t) (pTHX);
+typedef OP* (*PPADDR_t[]) (pTHX);
+typedef bool (*destroyable_proc_t) (pTHX_ SV *sv);
+typedef void (*despatch_signals_proc_t) (pTHX);
 
 /* _ (for $_) must be first in the following list (DEFSV requires it) */
 #define THREADSV_NAMES "_123456789&`'+/.,\\\";^-%=|~:\001\005!@"
@@ -4841,18 +4848,18 @@ struct perl_debug_pad {
 	PERL_DEBUG_PAD(i))
 
 /* Enable variables which are pointers to functions */
-typedef void (CPERLscope(*peep_t))(pTHX_ OP* o);
-typedef regexp*(CPERLscope(*regcomp_t)) (pTHX_ char* exp, char* xend, PMOP* pm);
-typedef I32 (CPERLscope(*regexec_t)) (pTHX_ regexp* prog, char* stringarg,
+typedef void (*peep_t)(pTHX_ OP* o);
+typedef regexp* (*regcomp_t) (pTHX_ char* exp, char* xend, PMOP* pm);
+typedef I32     (*regexec_t) (pTHX_ regexp* prog, char* stringarg,
 				      char* strend, char* strbeg, I32 minend,
 				      SV* screamer, void* data, U32 flags);
-typedef char* (CPERLscope(*re_intuit_start_t)) (pTHX_ regexp *prog, SV *sv,
+typedef char*   (*re_intuit_start_t) (pTHX_ regexp *prog, SV *sv,
 						char *strpos, char *strend,
 						U32 flags,
 						re_scream_pos_data *d);
-typedef SV*	(CPERLscope(*re_intuit_string_t)) (pTHX_ regexp *prog);
-typedef void	(CPERLscope(*regfree_t)) (pTHX_ struct regexp* r);
-typedef regexp*(CPERLscope(*regdupe_t)) (pTHX_ const regexp* r, CLONE_PARAMS *param);
+typedef SV*	(*re_intuit_string_t) (pTHX_ regexp *prog);
+typedef void	(*regfree_t) (pTHX_ struct regexp* r);
+typedef regexp* (*regdupe_t) (pTHX_ const regexp* r, CLONE_PARAMS *param);
 
 typedef void (*DESTRUCTORFUNC_NOCONTEXT_t) (void*);
 typedef void (*DESTRUCTORFUNC_t) (pTHX_ void*);
@@ -4869,10 +4876,10 @@ typedef void (*XSUBADDR_t) (pTHX_ CV *);
 #define PERLVARIC(var,type,init) type var;
 #define PERLVARISC(var,init) const char var[sizeof(init)];
 
-typedef OP* (CPERLscope(*Perl_ppaddr_t))(pTHX);
-typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*);
-typedef void(CPERLscope(*Perl_ophook_t))(pTHX_ OP*);
-typedef int (CPERLscope(*Perl_keyword_plugin_t))(pTHX_ char*, STRLEN, OP**);
+typedef OP* (*Perl_ppaddr_t)(pTHX);
+typedef OP* (*Perl_check_t) (pTHX_ OP*);
+typedef void(*Perl_ophook_t)(pTHX_ OP*);
+typedef int (*Perl_keyword_plugin_t)(pTHX_ char*, STRLEN, OP**);
 
 #define KEYWORD_PLUGIN_DECLINE 0
 #define KEYWORD_PLUGIN_STMT    1
@@ -5721,7 +5728,7 @@ typedef struct am_table_short AMTS;
 
 #ifndef PERL_MICRO
 #	ifndef PERL_ASYNC_CHECK
-#		define PERL_ASYNC_CHECK() if (PL_sig_pending) CALL_FPTR(PL_signalhook)(aTHX)
+#		define PERL_ASYNC_CHECK() if (PL_sig_pending) PL_signalhook(aTHX)
 #	endif
 #endif
 
diff --git a/pod/perlhack.pod b/pod/perlhack.pod
index cce574d9e0..a0b35725e4 100644
--- a/pod/perlhack.pod
+++ b/pod/perlhack.pod
@@ -557,7 +557,7 @@ that's left to do is run it. The actual execution is done by the
 C<runops_standard> function in F<run.c>; more specifically, it's done by
 these three innocent looking lines:
 
-    while ((PL_op = CALL_FPTR(PL_op->op_ppaddr)(aTHX))) {
+    while ((PL_op = PL_op->op_ppaddr(aTHX))) {
         PERL_ASYNC_CHECK();
     }
 
diff --git a/pp_ctl.c b/pp_ctl.c
index 57118a4aa7..1e90894f16 100644
--- a/pp_ctl.c
+++ b/pp_ctl.c
@@ -2752,7 +2752,7 @@ PP(pp_goto)
 		 * for each op.  For now, we punt on the hard ones. */
 		if (PL_op->op_type == OP_ENTERITER)
 		    DIE(aTHX_ "Can't \"goto\" into the middle of a foreach loop");
-		CALL_FPTR(PL_op->op_ppaddr)(aTHX);
+		PL_op->op_ppaddr(aTHX);
 	    }
 	    PL_op = oldop;
 	}
diff --git a/pp_hot.c b/pp_hot.c
index e1f0fc9904..02f425aa41 100644
--- a/pp_hot.c
+++ b/pp_hot.c
@@ -2925,7 +2925,7 @@ try_autoload:
 
 	/* CvXSUB(cv) must not be NULL because newXS() refuses NULL xsub address */
 	assert(CvXSUB(cv));
-	CALL_FPTR(CvXSUB(cv))(aTHX_ cv);
+	CvXSUB(cv)(aTHX_ cv);
 
 	/* Enforce some sanity in scalar context. */
 	if (gimme == G_SCALAR && ++markix != PL_stack_sp - PL_stack_base ) {
diff --git a/run.c b/run.c
index eb465da57c..368ef0301d 100644
--- a/run.c
+++ b/run.c
@@ -38,7 +38,7 @@ Perl_runops_standard(pTHX)
 {
     dVAR;
     register OP *op = PL_op;
-    while ((PL_op = op = CALL_FPTR(op->op_ppaddr)(aTHX))) {
+    while ((PL_op = op = op->op_ppaddr(aTHX))) {
     }
 
     TAINT_NOT;
diff --git a/sv.c b/sv.c
index 9f2fde4c34..c9ab89e649 100644
--- a/sv.c
+++ b/sv.c
@@ -5184,7 +5184,7 @@ Perl_sv_unmagic(pTHX_ SV *const sv, const int type)
             const MGVTBL* const vtbl = mg->mg_virtual;
 	    *mgp = mg->mg_moremagic;
 	    if (vtbl && vtbl->svt_free)
-		CALL_FPTR(vtbl->svt_free)(aTHX_ sv, mg);
+		vtbl->svt_free(aTHX_ sv, mg);
 	    if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) {
 		if (mg->mg_len > 0)
 		    Safefree(mg->mg_ptr);
@@ -10867,7 +10867,7 @@ Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *const param)
 		nmg->mg_ptr = (char*)sv_dup_inc((const SV *)nmg->mg_ptr, param);
 	}
 	if ((nmg->mg_flags & MGf_DUP) && nmg->mg_virtual && nmg->mg_virtual->svt_dup) {
-	    CALL_FPTR(nmg->mg_virtual->svt_dup)(aTHX_ nmg, param);
+	    nmg->mg_virtual->svt_dup(aTHX_ nmg, param);
 	}
     }
     return mgret;
diff --git a/sv.h b/sv.h
index a49954ddba..5819ee42f5 100644
--- a/sv.h
+++ b/sv.h
@@ -1876,10 +1876,10 @@ Returns a pointer to the character buffer.
 =cut
 */
 
-#define SvSHARE(sv) CALL_FPTR(PL_sharehook)(aTHX_ sv)
-#define SvLOCK(sv) CALL_FPTR(PL_lockhook)(aTHX_ sv)
-#define SvUNLOCK(sv) CALL_FPTR(PL_unlockhook)(aTHX_ sv)
-#define SvDESTROYABLE(sv) CALL_FPTR(PL_destroyhook)(aTHX_ sv)
+#define SvSHARE(sv) PL_sharehook(aTHX_ sv)
+#define SvLOCK(sv) PL_lockhook(aTHX_ sv)
+#define SvUNLOCK(sv) PL_unlockhook(aTHX_ sv)
+#define SvDESTROYABLE(sv) PL_destroyhook(aTHX_ sv)
 
 #define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
 #define SvSETMAGIC(x) STMT_START { if (SvSMAGICAL(x)) mg_set(x); } STMT_END
diff --git a/toke.c b/toke.c
index 544cd1a754..b8eb11a6ae 100644
--- a/toke.c
+++ b/toke.c
@@ -6131,7 +6131,7 @@ Perl_yylex(pTHX)
 	    int result;
 	    char *saved_bufptr = PL_bufptr;
 	    PL_bufptr = s;
-	    result = CALL_FPTR(PL_keyword_plugin)(aTHX_ PL_tokenbuf, len, &o);
+	    result = PL_keyword_plugin(aTHX_ PL_tokenbuf, len, &o);
 	    s = PL_bufptr;
 	    if (result == KEYWORD_PLUGIN_DECLINE) {
 		/* not a plugged-in keyword */