summaryrefslogtreecommitdiff
path: root/pp_hot.c
Commit message (Collapse)AuthorAgeFilesLines
* Remove IN_ENCODING macro, and all code dependent on itFather Chrysostomos2016-07-131-11/+2
|
* pp_aelemfast: always extend stackDavid Mitchell2016-06-271-1/+2
| | | | | my previous commit split pp_aelemfast() into two branches; but the new branch wasn't extending the stack before pushing the result.
* pp_aelemfast: skip av_fetch() for simple casesDavid Mitchell2016-06-261-3/+19
| | | | | | | | Where the av is non magic and has a positive key, try fetching the array element directly rather than calling av_fetch(). This reduces the number of cycles required to run the nbody benchmark by about 5%.
* [perl #127877] Emit undef warning on sassign+concatAaron Crane2016-05-091-2/+5
| | | | | | | | | | | | | | | | | | | | | | | | Code like this: my $x; $x .= 'a'; is specifically exempted from "use of uninitialized value" warnings, according to the "Declarations" section of perlsyn, to allow the idiom of building up a value piecemeal. The same is true of the += and -= operators. However, breaking the combined assignment up into the underlying operator and a simple assignment, as in this code: my $x; $x = $x . 'a'; *should* produce a warning. That warning was correctly being emitted for addition and subtraction, but concatenation was behaving as the ".=" case, because "$x = $x . EXPR" is optimized to the equivalent of "$x .= EXPR". So we now explicitly detect this case, and emit the desired warning.
* Improve code comments for some ctx stuffDavid Mitchell2016-03-301-0/+2
| | | | | | | | | * in pp_return(), some comments were out of date about how leave_adjust_stacks() is called ; * add a comment to all the functions that pp_return() tail-calls to the effect that they can be tail-called; * make it clearer when/why OPf_SPECIAL is set on OP_LEAVE; * CXt_LOOP_PLAIN can be a while loop as well as a plain block.
* pp_subst(): rename local varDavid Mitchell2016-03-021-3/+5
| | | | | make it clear that is_cow represents the original COW state (which may not be the current state when checked later), by renaming it to was_cow.
* pp_subst: fix typoDavid Mitchell2016-03-021-1/+1
|
* use cBOOL() in pp_subst()David Mitchell2016-03-021-3/+1
| | | | Now that we have that macro, use it.
* [perl #127635] s///r with -DPERL_NO_COW attempts to modify source SVTony Cook2016-03-011-9/+11
| | | | | | | | | | | | | | | | | | | | | | | | | based on work done by bulk88, per his notes below: I found pp_subst with a -DPERL_NO_COW build on an experimental perl branch would die in ../dist/SelfLoader/t/03taint.t in this line "my $file = __FILE__ =~ s/[\w.]+\z/01SelfLoader.t/r;" with a attempt to modify since sv_force_normal_flags checks for readonlyness. The -DPERL_NO_COW exclusive logic seems faulty, since the COW branch right above stores the cow status and doesn't call sv_force_normal_flags until it actually wants to modify the source SV, and pp_subst wont modify the source SV if PMf_NONDESTRUCT is on. So fix the die by only de-COWing if !PMf_NONDESTRUCT. Do not deCOW the source SV if PMf_NONDESTRUCT. The "my $file = __FILE__ =~ s/[\w.]+\z/01SelfLoader.t/r;" fatal die can not be reproduced in blead perl with -DPERL_NO_COW, only in my experimental branch so I rewrote the test to use a const sub that is folded to a HEK COW RO SV * instead of the __FILE__ token which is not a HEK COW on blead perl. The subst.t test only fails if perl is compiled with -DPERL_NO_COW. To avoid an extra !(rpm->op_pmflags & PMf_NONDESTRUCT) check on a NO_COW build, restructure the logic so !(rpm->op_pmflags & PMf_NONDESTRUCT) is tested only once. Filed as [perl #127635].
* assert(cv) before doing CvROOT(cv)Jarkko Hietaniemi2016-02-071-0/+1
| | | | Coverity CID 29020 (an old one from 2014, wondering why it now resurfaced)
* Whitespace only: zap empty lines.Jarkko Hietaniemi2016-02-071-2/+0
|
* Lexical scoping in case statement is tricky.Jarkko Hietaniemi2016-02-071-7/+5
| | | | | | | | | | | | | | | | | | | Coverity CID 135142: Structurally dead code (UNREACHABLE) The case labels are just effectively goto labels, and therefore any variable initialization will not happen. That is not the case luckily here, the variables will be always overwritten as needed. But better not to introduce false lexical scopes to avoid future misery. In the general case, the only way to have lexically tighter scopes is to have dedicated blocks for each case, but that doesn't easily work here, with all the tricky jumping. We could switch() the second time on CxTYPE(), and have these variables scoped on an inner block, but since this is hot hot hot code, better not to mess with that, and just hoist the variables to an outer scope. Any deeper refactoring should be done with profilers at hand.
* assert() that itersvp is non-NULL.Jarkko Hietaniemi2016-02-071-0/+1
| | | | | | | | Coverity CID 135011 Explicit null derefenced In pp_iter() there are multiple derefers of *itersvp, but at the setting of itersvp the CxITERVAR() can return NULL, add an assert() to catch the badness in debug builds (as the Coverity builds are).
* pp_enter: calculate gimme earlier in XS branchDavid Mitchell2016-02-061-1/+6
| | | | | | | | | My commit 801bbf618dc make it so that pp_entersub only calculates gimme at the point its needed, to avoid wasting register resource. However in n the XS branch it was a bit over-enthusiatic: its possible for an XS sub to save PL_op and change its value. The old value will only get restored when pp_entersub soes LEAVE, which is *after* we cacluate gimme. So grab the value before the XS sub is called.
* leave_adjust_stacks() fix some code commentsDavid Mitchell2016-02-031-3/+1
| | | | One comment was obsolete; the other referred to the wrong pp function
* leave_adjust_stacks(): avoid accessing random tmpsDavid Mitchell2016-02-031-7/+19
| | | | | | | | | | | | | | | | | | | | | | | | | | There was some code in leave_adjust_stacks() that checked whether the current arg sv being processed was the same SV as the first SvTEMP above the 'cut' on the tmps stack. If there was nothing above the cut, it was actually comparing against whatever garbage was 1 slot above the current PL_tmps_ix. This was almost always harmless (but of course wrong); the only symptom was an occasional smoke failure in t/re/pat_re_eval_thr.t, due to this: local our $s = "abc"; my $qr = qr/^(?{1})$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s$s/; where a qr// with a code blocks acts like my $qr = sub : lvalue { .....; }->() to make closures happen correctly. The lvalue return from the anon sub was triggering this because the address of $s was in one of the unused slots above PL_tmp_ix. I couldn't get it to fail in a simple test case. At the same time, I moved a SvREFCNT_inc() inside a check for !SvIMMORTAL(sv) since there's no need to do it for PL_sv_undef etc.
* make gimme consistently U8David Mitchell2016-02-031-8/+8
| | | | | | | | | | | | | The value of gimme stored in the context stack is U8. Make all other uses in the main core consistent with this. My primary motivation on this was that the new function cx_pushblock(), which I gave a 'U8 gimme' parameter, was generating warnings where callers were passing I32 gimme vars to it. Rather than play whack-a-mole, it seemed simpler to just uniformly use U8 everywhere. Porting/bench.pl shows a consistent reduction of about 2 instructions on the loop and sub benchmarks, so this change isn't harming performance.
* fix -DPERL_GLOBAL_STRUCT_PRIVATEDavid Mitchell2016-02-031-0/+1
| | | | Perl_leave_adjust_stacks() needed a dVAR
* convert CX_PUSHSUB/POPSUB to inline fnsDavid Mitchell2016-02-031-5/+5
| | | | | | Replace CX_PUSHSUB() with cx_pushsub() etc. No functional changes.
* convert CX_PUSH/POP/TOPBLOCK to inline fnsDavid Mitchell2016-02-031-2/+2
| | | | | | Replace CX_PUSHBLOCK() with cx_pushblock() etc. No functional changes.
* rename PUSHBLOCK,PUSHSUB etc to CX_PUSHBLOCK etcDavid Mitchell2016-02-031-6/+6
| | | | | | | Earlier all the POPFOO macros were renamed to CX_POPFOO to reflect the changed API (like POPBLOCK no longer decremented cxstack_ix). Now rename the PUSH ones for consistency.
* PUSHSUB: make retop a parameterDavid Mitchell2016-02-031-2/+1
| | | | | | Rather than doing cx->blk_sub.retop = NULL in PUSHSUB, then relying on the caller to subsequently change it to something more useful, make it an arg to PUSHSUB.
* PUSHSUB: don't use implicit argsDavid Mitchell2016-02-031-1/+1
| | | | | Make cv and hasargs explicit parameters of PUSHSUB(), rather than just assuming that there are such vars in scope.
* PUSHBLOCK: don't use implicit argsDavid Mitchell2016-02-031-1/+1
| | | | | Make gimme a parameter of PUSHBLOCK() rather than just assuming that there's a 'gimme' var in scope.
* move PL_savestack_ix saving into PUSHBLOCKDavid Mitchell2016-02-031-2/+1
| | | | | | | | | | | | Currently blku_oldsaveix was being set by the various PUSHFOO macros, except for PUSHSUB and PUSHEVAL which expected their caller to do it manually. Now that all the main context state is stored on the context stack rather than than some on the save stack too, things are a lot simpler, and this messy transitional state can now be rationalised, whereby blku_oldsaveix is now always set by PUSHBLOCK; the exact value being specified by a new arg to PUSHBLOCK.
* eliminate PERL_STACK_OVERFLOW_CHECKDavid Mitchell2016-02-031-3/+1
| | | | | | | | This macro is defined as NOOP on all platforms except for MacOS classic, where it was added as a hook to allow for OSes that have a small CPU stack size. Since pp_entersub et al don't actually use the CPU stack, this hook looks misconceived from the beginning. So remove all uses of it in the core.
* rename POPFOO() to CX_POPFOO()David Mitchell2016-02-031-3/+3
| | | | | | | | | | | | | | | | Rename all the context-popping macros such as POPBLOCK and POPSUB, by giving them a CX_ prefix. (Do TOPBLOCK too). This is principally to deliberately break any existing non-core use of these non-API macros, as their behaviour has changed in this branch. In particular, POPBLOCK(cx) no longer decrements the cxt stack pointer nor sets cx; instead, cx is now expected to already point to the stack frame which POPBLOCK should process. At the same time, giving them a CX_ prefix makes it clearer that these are all part of a family of macros that manipulate the context stack. The PUSHFOO() macros will be renamed in a later commit.
* pp_iter: optimise integer setting in for (1..10) {}David Mitchell2016-02-031-1/+16
| | | | | If the target SV is a simple SVt_IV, which it is likely to be, just update it directly rather than calling sv_setiv()
* fix *_ = "" for 0 .. 1;David Mitchell2016-02-031-5/+9
| | | | | | | | | | | | | | | | | | | | | | | | RT #123994 pp_iter couldn't handle GvSv(gv) being NULL. In that ticket, Tony Cook suggested two possible fixes. First, always instantiate the GvSV slot at the start of pp_iter by using GvSVn rather than GvSV in the CxITERVAR() macro; Second, test for it being null within the two 'range' branches, (for(1..9), for('a'..'z')), and if so create it. One advantage of doing it there is that there's already code for (re)creating the SV if the reference count is != 1. It also means that the list and array cases (for(@a), for(1,3,5)) which always put the next iterated SV into the pad/GvSV slot don't waste time creating and then immediately discarding an SV if GvSV was NULL. I went for the second fix. It also means that's there's no longer any need in pp_enteriter to initially poulate GvSV is it was null, as this will be detected during the first pp_iter() anyway.
* replace leave_common() with leave_adjust_stacks()David Mitchell2016-02-031-2/+3
| | | | | | | | | | Make the remaining callers of S_leave_common() use leave_adjust_stacks() instead, then delete this static function. This brings the benefits of freeing TEMPS on all scope exists that has already been introduced on sub exits; uses the optimised code for creating mortal copies; and finally unifies all the different 'process return args on scope exit' implementations into single function.
* make pp_return() use leave_adjust_stacks()David Mitchell2016-02-031-13/+14
| | | | | | | It was using S_leave_common(), but that's shortly to be removed. It also required adding an extra arg to leave_adjust_stacks() to indicate where to shift the return args to. This will also be needed for when we replace the remaining uses of S_leave_common() with leave_adjust_stacks().
* make pp_leavesublv use S_leavesub_adjust_stacks()David Mitchell2016-02-031-47/+84
| | | | | | | | | | | | | | | | | | | | | | | Currently S_leavesub_adjust_stacks() is just used by pp_leavesub. Rename it to Perl_leave_adjust_stacks(), extend its functionality slightly, then make pp_leavesublv() use it too. This means that lvalue sub exit gains the benefit of FREETMPS being done, and (where mortal copying needs doing) the optimised copying code. It also means there is now one less version of the "process args on scope exit" code. pp_leavesublv() still does a scan of its return args looking for things to croak() on, but leaves everything else to leave_adjust_stacks(). leave_adjust_stacks() is intended shortly to be used in place of S_leave_common() too, thus unifying all args-on-scope-exit code. The changes to leave_adjust_stacks() in this commit (apart from the renaming and doc changes) are: * a new arg to indicate what condition to use to decide whether to pass or copy the arg; * a new branch to mortalise and ref count bump an arg
* pp_leavesublv(): croak on *all* PADTMPsDavid Mitchell2016-02-031-0/+29
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | pp_leavesublv() generally croaks on returned PADTMPs when called in lvalue context. However, an exception was made in scalar context if the PADTMP had set magic. This was to allow for things like sub :lvalue { $tied{foo} } and sub :lvalue { substr($foo,1,2) } However, it was later found that in places like pp_substr(), when returning a PVLV, it should return a new mortal rather than upgrading its pad target to PVLV, because the PVLV holds a reference to $foo which then gets delayed being freed indefinitely. Since places like pp_susbtr() no longer return lvalue PADTMPs, there's no longer any need to make a special exception in pp_leavesublv(). I've added an assertion to the effect that PADTMPs don't have set container magic, but I've added the assert to pp_leavesub() rather than pp_leavesublv(), since the former is much likely to be used in many weird situations and edge cases that would quickly flush out any false assumptions. If this assumption is wrong and the exception needs to be re-instated in pp_leavesublv(), then presumably it needs adding to the ARRAY context branch too - I'm assuming that its previous absence there was an oversight; i.e. sub foo :lvalue { $tied{foo}, substr($foo,1,2) } foo() = (1,2); should work too.
* pp_leavesub(): call FREETMPS and optimiseDavid Mitchell2016-02-031-57/+250
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Currently pp_leavesub() doesn't call FREETMPS. Presumably this is due to the danger of freeing temps that need to exist beyond the return, such as the mortal copies we make of return args, or return args that are already temps. The down side of this is that temps aren't freed until the next nextstate is executed following the function call. If the function isn't near a statement boundary, then it may be a while before temps are freed; e.g. in f(g()), when g() returns, its temps continue to exist during the call to f(). For recursive subs it gets worse, although there is a specific hack already in pp_leavesub() that says in scalar context if CvDEPTH > 1, then temporarily RC++ the single return value then do a FREETMPS. This can in theory leak if something dies during the FREETMPS. This commit provides a more general solution. During the course of processing (usually mortal copying) the return args, it divides the current temps stack frame into two halves, with the temps that need keeping migrating to the bottom half. It then does a FREETMPS equivalent only of the top half. This is actually more efficient than it sounds; but in addition, the code has been heavily optimised: in particular the call to sv_mortalcopy() has been unrolled and inlined, and within that code common cases (such as IV, RV) handled directly, and the mortal stack is only checked/extended once, rather than for every arg. Also, the arg adjust / freetmps code has been moved out of pp_leavesub() and into a separate static function.
* pp_leavesub: reset SP in void contextDavid Mitchell2016-02-031-0/+5
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | In void context, pp_leavesub() doesn't bother resetting SP to the base; either as an efficiency measure, or as an oversight (the other pp_leavefoo functions do reset). This is mostly harmless, as being void context, it's likely to immediately execute pp_nextstate or similar, which will reset the stack anyway. However with attributes, something like my @foo :attr = () causes attributes::import() to be called in void context, and whatever dross it leaves on the stack becomes part of the assign, i.e. that assign becomes the equivalent of: my (@foo, dross) = () which again is fairly harmless, if slightly inefficient. However, the next commit should make pp_leavesub() call FRETMPS, which means that 'dross' may now include freed SVs, which will make pp_aassign choke. This commit also requires ext/XS-APItest/t/call.t to be fixed. Some tests in there (added years ago by myself) test the statu quo; that is, it expects that calling call_sv(G_VOID) will leave return args on the stack. Now it doesn't.
* add CX_CUR() macroDavid Mitchell2016-02-031-4/+4
| | | | | | This is simply #define CX_CUR() (&cxstack[cxstack_ix])
* make POPSUB and POPFORMAT re-entrant safeDavid Mitchell2016-02-031-5/+7
| | | | | | | | | | | | | | | | | | | | | | | | | In code like sub DESTROY { exit } sub f { push @_, bless [] } f() While leaving f, POPSUB will attempt to clear @_. This triggers the destructor, which calls exit, which unwinds the context stack, calling POPSUB again on thr same context stack entry. Thus we need to to be careful that POPSUB can be called multiple times on the same CX stack entry. The general way of doing this is to NULL or update pointers *before* calling SvREFCNT_dec() on the old value. This commit also removes the old CxPOPSUB_DONE mechanism which was a poor bandaid added at the last minute to 5.22 to try and achieve the basics of what this commit does comprehensively (hopefully). Also, CxPOPSUB_DONE was mainly a protection against re-entrantly calling LEAVE_SCOPE(). Since that's now done before POPSUB rather than in the middle of it, it has become reentrant-safe by default.
* move and rename cx_old_savestack_ixDavid Mitchell2016-02-031-1/+1
| | | | | | | | | | | Earlier on in this branch I temporarily added cx_old_savestack_ix as the first element in the context struct. This commit moves it down 32 bits so it now follows type/gimme/u16 in the sbu and blku unions. This means that type is now back as the first item in the struct. I've also renamed it blku_oldsaveix to be more in keeping with similar field names.
* simplify two conditions in pp_iter:David Mitchell2016-02-031-1/+1
| | | | | | | | | | | | | | | | | | | | | | - if (UNLIKELY(SvMAGICAL(av) || AvREIFY(av))) { + if (UNLIKELY(SvRMAGICAL(av))) { This condition is deciding whether to call av_fetch or cheat and do sv = AvARRAY(av)[ix]. The magic test is too broad: av_fetch() only handles the specially on RMG, not all magic. The AvREIFY condition was originally added by 64138690 in 2001. It was an attempt to paper over the cracks if function args are deleted, then iterate over @_, which now contains freed elements. Since pp_iter now includes a 'freed sv' check itself, there's no need to call into av_fetch which has a similar check. This makes a slight functional change - previously if @_ contained a freed element, av_fetch would silently return NULL; now instead, pp_iter croaks with "Use of freed value in iteration", the same as it does with all other cases involving freed elements being iterated over.
* pp_iter(): optimise stack handlingDavid Mitchell2016-02-031-7/+18
| | | | | | | | | Make pp_enteriter() do EXTEND(SP,1); then there's no need for pp_iter() to check for space to push PL_sv_yes/no each time round the loop. Since the only stack manipulation in pp_iter is now just pushing a boolean at the end, remove dSP etc and just directly push to PL_stack_sp at the end.
* split CXt_LOOP_FOR into CXt_LOOP_LIST,CXt_LOOP_ARYDavid Mitchell2016-02-031-26/+31
| | | | | | | | | | | | | | | Create a new context type so that "for (1,2,3)" and "for (@ary)" are now two separate types. For the list type, we store the index of the base stack element in the state union rather than having an array pointer. Currently this is just the same as blk_resetsp, but this will shortly allow us to eliminate the resetsp field from the struct block_loop - which is currently the largest sub-struct within the block union. Having two separate types also allows the two cases to be handled directly in the main switch in the hot pp_iter code, rather than having extra conditionals.
* add CX_POP(cx) macro: glorified cxstack_ix--David Mitchell2016-02-031-2/+4
| | | | but with extra checking goodness on debugging builds.
* move blku_old_savestack_ix to base of cxt structDavid Mitchell2016-02-031-1/+1
| | | | | | The previous commit moved the "old savestack" field of substitution contexts into the shared root of the context union. This commit does the same for all other context types
* move CX_LEAVE_SCOPE outside the POPFOO'sDavid Mitchell2016-02-031-0/+1
| | | | | | | | | | Currently every POPFOO macro has CX_LEAVE_SCOPE(cx) as its first action. Since this is common code and not specific to a particular POPFOO type, remove it from each POPFOO macro and make each caller of POPFOO explicitly call CX_LEAVE_SCOPE() instead. This should make no functional difference (but will help if you're single-stepping the code in a debugger :-)
* remove newpm param from POPBLOCK() macro.David Mitchell2016-02-031-3/+1
| | | | | | | Since all core usage of POPBLOCK now immediately restores PL_curpm, there's no need to copy the old value to a temp var specified by the caller; just make POPBLOCK itself restore PL_curpm in the same way that it restores all the other PL_ vars.
* reverse the order of POPBLOCK; POPFOODavid Mitchell2016-02-031-3/+2
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Currently most pp_leavefoo subs have something along the lines of POPBLOCK(cx); POPFOO(cx); where POPBLOCK does cxstack_ix-- and sets cx to point to the top CX stack entry. It then restores a bunch of PL_ vars saved in the CX struct. Then POPFOO does any type-specific restoration, e.g. POPSUB decrements the ref count of the cv that was just executed. However, this is logically the wrong order. When we *enter* a scope, we do PUSHBLOCK; PUSHFOO; so undoing the PUSHBLOCK should be the last thing we do. As it happens, it doesn't really make any difference to the running, which is why we've never fixed it before. Reordering it has two advantages. First, it allows the steps for scope exit to be the exact logical reverse of scope exit, which makes understanding what's going on and debugging easier. It allows us to make the code cleaner. This commit also removes the cxstack_ix-- and setting cx steps from POPBLOCK; now we already expect cx to be set (which it usually already is) and we do the cxstack_ix-- ourselves. This also means we can remove a whole bunch of cxstack_ix++'s that were added immediately after the POPBLOCK in order to prevent the context being inadvertently overwritten before we've finished using it. So in full, POPBLOCK(cx); POPFOO(cx); is now implemented as: cx = &cxstack[cxstack_ix]; ... other stuff done with cx ... POPFOO(cx); POPBLOCK(cx); cxstack_ix--; Finally, this commit also tweaks PL_curcop in pp_leaveeval, since otherwise PL_curcop could temporarily be NULL when debugging code is called in the presence of 'use re Debug'. It also stops the debugging code crashing if PL_curcop is still NULL.
* eliminate LEAVESUB() macroDavid Mitchell2016-02-031-4/+2
| | | | | | | | | | Many years ago, POPSUB was split into two parts, with a final cleanup being done by the LEAVESUB() macro. After the previous commit, LEAVESUB now always immediately follows POPSUB, so roll its action into the last line of POPSUB and eliminate it. This also allows us to remove the 'sv' parameter from POPSUB(), which was needed purely to communicate to LEAVESUB() which var to process
* make LEAVESUB() always immediately follow POPSUB()David Mitchell2016-02-031-1/+1
| | | | | | | Many years ago, POPSUB was split into two parts, with a final cleanup being done by the LEAVESUB() macro. This is no longer needed; shuffle LEAVESUB up a bit in various places so that it always immediately follows POPSUB. Then the next commit will eliminate it altogether.
* add CX_LEAVE_SCOPE(cx) macroDavid Mitchell2016-02-031-1/+1
| | | | | | | | | | which is shorthand for LEAVE_SCOPE(cx->cx_u.cx_blk.blku_old_savestack_ix) This is the start of a new breed of macros designed to manipulate the conetect stack, that have a CX_ prefix, that will eventually superede the (PUSH/POP)(BLOCK/SUB/ETC) system.
* move POPBLOCK after arg stack mungingDavid Mitchell2016-02-031-3/+8
| | | | | | | | | | | | | | | | | | | | | | In various places where scope is left (pp_leave, pp_leavesub etc) the perl argument stack is processed: a combination of shifting return args down and mortalising or copying them. This is typically done in S_leave_common() (although pp_leavesub(lv) roll their own). Normally POPBLOCK() is called just before this, which a) initialises cx; b) sets newsp, gimme etc which are needed by S_leave_common() c) restores a bunch of PL_ vars from the saved values in cx. Logically, (c) should be the last thing done in the various pp_leave* functions, as saving the vars is the first thing done in the various pp_enter* functions. This commit moves POPBLOCK after S_leave_common() as a first step towards migrating it towards the end of the various functions. It shouldn't make any functional difference, as the values of the various restored vars aren't used by the arg munging code.
View Lorry Controller Status