1PERLINTERP(1) Perl Programmers Reference Guide PERLINTERP(1)
2
6 perlinterp - An overview of the Perl interpreter
7
9 This document provides an overview of how the Perl interpreter works at
10 the level of C code, along with pointers to the relevant C source code
11 files.
12
14 The work of the interpreter has two main stages: compiling the code
15 into the internal representation, or bytecode, and then executing it.
16 "Compiled code" in perlguts explains exactly how the compilation stage
17 happens.
18 Here is a short breakdown of perl's operation:
20 Startup
22 The action begins in perlmain.c. (or miniperlmain.c for miniperl) This
23 is very high-level code, enough to fit on a single screen, and it
24 resembles the code found in perlembed; most of the real action takes
25 place in perl.c
26 perlmain.c is generated by "ExtUtils::Miniperl" from miniperlmain.c at
28 make time, so you should make perl to follow this along.
29 First, perlmain.c allocates some memory and constructs a Perl
31 interpreter, along these lines:
32 1 PERL_SYS_INIT3(&argc,&argv,&env);
34 2
35 3 if (!PL_do_undump) {
36 4 my_perl = perl_alloc();
37 5 if (!my_perl)
38 6 exit(1);
39 7 perl_construct(my_perl);
40 8 PL_perl_destruct_level = 0;
41 9 }
42 Line 1 is a macro, and its definition is dependent on your operating
44 system. Line 3 references "PL_do_undump", a global variable - all
45 global variables in Perl start with "PL_". This tells you whether the
46 current running program was created with the "-u" flag to perl and then
47 undump, which means it's going to be false in any sane context.
48 Line 4 calls a function in perl.c to allocate memory for a Perl
50 interpreter. It's quite a simple function, and the guts of it looks
51 like this:
52 my_perl = (PerlInterpreter*)PerlMem_malloc(sizeof(PerlInterpreter));
54 Here you see an example of Perl's system abstraction, which we'll see
56 later: "PerlMem_malloc" is either your system's "malloc", or Perl's own
57 "malloc" as defined in malloc.c if you selected that option at
58 configure time.
59 Next, in line 7, we construct the interpreter using perl_construct,
61 also in perl.c; this sets up all the special variables that Perl needs,
62 the stacks, and so on.
63 Now we pass Perl the command line options, and tell it to go:
65 exitstatus = perl_parse(my_perl, xs_init, argc, argv, (char **)NULL);
67 if (!exitstatus)
68 perl_run(my_perl);
69 exitstatus = perl_destruct(my_perl);
71 perl_free(my_perl);
73 "perl_parse" is actually a wrapper around "S_parse_body", as defined in
75 perl.c, which processes the command line options, sets up any
76 statically linked XS modules, opens the program and calls "yyparse" to
77 parse it.
78 Parsing
80 The aim of this stage is to take the Perl source, and turn it into an
81 op tree. We'll see what one of those looks like later. Strictly
82 speaking, there's three things going on here.
83 "yyparse", the parser, lives in perly.c, although you're better off
85 reading the original YACC input in perly.y. (Yes, Virginia, there is a
86 YACC grammar for Perl!) The job of the parser is to take your code and
87 "understand" it, splitting it into sentences, deciding which operands
88 go with which operators and so on.
89 The parser is nobly assisted by the lexer, which chunks up your input
91 into tokens, and decides what type of thing each token is: a variable
92 name, an operator, a bareword, a subroutine, a core function, and so
93 on. The main point of entry to the lexer is "yylex", and that and its
94 associated routines can be found in toke.c. Perl isn't much like other
95 computer languages; it's highly context sensitive at times, it can be
96 tricky to work out what sort of token something is, or where a token
97 ends. As such, there's a lot of interplay between the tokeniser and the
98 parser, which can get pretty frightening if you're not used to it.
99 As the parser understands a Perl program, it builds up a tree of
101 operations for the interpreter to perform during execution. The
102 routines which construct and link together the various operations are
103 to be found in op.c, and will be examined later.
104 Optimization
106 Now the parsing stage is complete, and the finished tree represents the
107 operations that the Perl interpreter needs to perform to execute our
108 program. Next, Perl does a dry run over the tree looking for
109 optimisations: constant expressions such as "3 + 4" will be computed
110 now, and the optimizer will also see if any multiple operations can be
111 replaced with a single one. For instance, to fetch the variable $foo,
112 instead of grabbing the glob *foo and looking at the scalar component,
113 the optimizer fiddles the op tree to use a function which directly
114 looks up the scalar in question. The main optimizer is "peep" in op.c,
115 and many ops have their own optimizing functions.
116 Running
118 Now we're finally ready to go: we have compiled Perl byte code, and all
119 that's left to do is run it. The actual execution is done by the
120 "runops_standard" function in run.c; more specifically, it's done by
121 these three innocent looking lines:
122 while ((PL_op = PL_op->op_ppaddr(aTHX))) {
124 PERL_ASYNC_CHECK();
125 }
126 You may be more comfortable with the Perl version of that:
128 PERL_ASYNC_CHECK() while $Perl::op = &{$Perl::op->{function}};
130 Well, maybe not. Anyway, each op contains a function pointer, which
132 stipulates the function which will actually carry out the operation.
133 This function will return the next op in the sequence - this allows for
134 things like "if" which choose the next op dynamically at run time. The
135 "PERL_ASYNC_CHECK" makes sure that things like signals interrupt
136 execution if required.
137 The actual functions called are known as PP code, and they're spread
139 between four files: pp_hot.c contains the "hot" code, which is most
140 often used and highly optimized, pp_sys.c contains all the system-
141 specific functions, pp_ctl.c contains the functions which implement
142 control structures ("if", "while" and the like) and pp.c contains
143 everything else. These are, if you like, the C code for Perl's built-in
144 functions and operators.
145 Note that each "pp_" function is expected to return a pointer to the
147 next op. Calls to perl subs (and eval blocks) are handled within the
148 same runops loop, and do not consume extra space on the C stack. For
149 example, "pp_entersub" and "pp_entertry" just push a "CxSUB" or
150 "CxEVAL" block struct onto the context stack which contain the address
151 of the op following the sub call or eval. They then return the first op
152 of that sub or eval block, and so execution continues of that sub or
153 block. Later, a "pp_leavesub" or "pp_leavetry" op pops the "CxSUB" or
154 "CxEVAL", retrieves the return op from it, and returns it.
155 Exception handing
157 Perl's exception handing (i.e. "die" etc.) is built on top of the low-
158 level "setjmp()"/"longjmp()" C-library functions. These basically
159 provide a way to capture the current PC and SP registers and later
160 restore them; i.e. a "longjmp()" continues at the point in code where a
161 previous "setjmp()" was done, with anything further up on the C stack
162 being lost. This is why code should always save values using "SAVE_FOO"
163 rather than in auto variables.
164 The perl core wraps "setjmp()" etc in the macros "JMPENV_PUSH" and
166 "JMPENV_JUMP". The basic rule of perl exceptions is that "exit", and
167 "die" (in the absence of "eval") perform a JMPENV_JUMP(2), while "die"
168 within "eval" does a JMPENV_JUMP(3).
169 At entry points to perl, such as "perl_parse()", "perl_run()" and
171 "call_sv(cv, G_EVAL)" each does a "JMPENV_PUSH", then enter a runops
172 loop or whatever, and handle possible exception returns. For a 2
173 return, final cleanup is performed, such as popping stacks and calling
174 "CHECK" or "END" blocks. Amongst other things, this is how scope
175 cleanup still occurs during an "exit".
176 If a "die" can find a "CxEVAL" block on the context stack, then the
178 stack is popped to that level and the return op in that block is
179 assigned to "PL_restartop"; then a JMPENV_JUMP(3) is performed. This
180 normally passes control back to the guard. In the case of "perl_run"
181 and "call_sv", a non-null "PL_restartop" triggers re-entry to the
182 runops loop. The is the normal way that "die" or "croak" is handled
183 within an "eval".
184 Sometimes ops are executed within an inner runops loop, such as tie,
186 sort or overload code. In this case, something like
187 sub FETCH { eval { die } }
189 would cause a longjmp right back to the guard in "perl_run", popping
191 both runops loops, which is clearly incorrect. One way to avoid this is
192 for the tie code to do a "JMPENV_PUSH" before executing "FETCH" in the
193 inner runops loop, but for efficiency reasons, perl in fact just sets a
194 flag, using "CATCH_SET(TRUE)". The "pp_require", "pp_entereval" and
195 "pp_entertry" ops check this flag, and if true, they call "docatch",
196 which does a "JMPENV_PUSH" and starts a new runops level to execute the
197 code, rather than doing it on the current loop.
198 As a further optimisation, on exit from the eval block in the "FETCH",
200 execution of the code following the block is still carried on in the
201 inner loop. When an exception is raised, "docatch" compares the
202 "JMPENV" level of the "CxEVAL" with "PL_top_env" and if they differ,
203 just re-throws the exception. In this way any inner loops get popped.
204 Here's an example.
206 1: eval { tie @a, 'A' };
208 2: sub A::TIEARRAY {
209 3: eval { die };
210 4: die;
211 5: }
212 To run this code, "perl_run" is called, which does a "JMPENV_PUSH" then
214 enters a runops loop. This loop executes the eval and tie ops on line
215 1, with the eval pushing a "CxEVAL" onto the context stack.
216 The "pp_tie" does a "CATCH_SET(TRUE)", then starts a second runops loop
218 to execute the body of "TIEARRAY". When it executes the entertry op on
219 line 3, "CATCH_GET" is true, so "pp_entertry" calls "docatch" which
220 does a "JMPENV_PUSH" and starts a third runops loop, which then
221 executes the die op. At this point the C call stack looks like this:
222 Perl_pp_die
224 Perl_runops # third loop
225 S_docatch_body
226 S_docatch
227 Perl_pp_entertry
228 Perl_runops # second loop
229 S_call_body
230 Perl_call_sv
231 Perl_pp_tie
232 Perl_runops # first loop
233 S_run_body
234 perl_run
235 main
236 and the context and data stacks, as shown by "-Dstv", look like:
238 STACK 0: MAIN
240 CX 0: BLOCK =>
241 CX 1: EVAL => AV() PV("A"\0)
242 retop=leave
243 STACK 1: MAGIC
244 CX 0: SUB =>
245 retop=(null)
246 CX 1: EVAL => *
247 retop=nextstate
248 The die pops the first "CxEVAL" off the context stack, sets
250 "PL_restartop" from it, does a JMPENV_JUMP(3), and control returns to
251 the top "docatch". This then starts another third-level runops level,
252 which executes the nextstate, pushmark and die ops on line 4. At the
253 point that the second "pp_die" is called, the C call stack looks
254 exactly like that above, even though we are no longer within an inner
255 eval; this is because of the optimization mentioned earlier. However,
256 the context stack now looks like this, ie with the top CxEVAL popped:
257 STACK 0: MAIN
259 CX 0: BLOCK =>
260 CX 1: EVAL => AV() PV("A"\0)
261 retop=leave
262 STACK 1: MAGIC
263 CX 0: SUB =>
264 retop=(null)
265 The die on line 4 pops the context stack back down to the CxEVAL,
267 leaving it as:
268 STACK 0: MAIN
270 CX 0: BLOCK =>
271 As usual, "PL_restartop" is extracted from the "CxEVAL", and a
273 JMPENV_JUMP(3) done, which pops the C stack back to the docatch:
274 S_docatch
276 Perl_pp_entertry
277 Perl_runops # second loop
278 S_call_body
279 Perl_call_sv
280 Perl_pp_tie
281 Perl_runops # first loop
282 S_run_body
283 perl_run
284 main
285 In this case, because the "JMPENV" level recorded in the "CxEVAL"
287 differs from the current one, "docatch" just does a JMPENV_JUMP(3) and
288 the C stack unwinds to:
289 perl_run
291 main
292 Because "PL_restartop" is non-null, "run_body" starts a new runops loop
294 and execution continues.
295 INTERNAL VARIABLE TYPES
297 You should by now have had a look at perlguts, which tells you about
298 Perl's internal variable types: SVs, HVs, AVs and the rest. If not, do
299 that now.
300 These variables are used not only to represent Perl-space variables,
302 but also any constants in the code, as well as some structures
303 completely internal to Perl. The symbol table, for instance, is an
304 ordinary Perl hash. Your code is represented by an SV as it's read into
305 the parser; any program files you call are opened via ordinary Perl
306 filehandles, and so on.
307 The core Devel::Peek module lets us examine SVs from a Perl program.
309 Let's see, for instance, how Perl treats the constant "hello".
310 % perl -MDevel::Peek -e 'Dump("hello")'
312 1 SV = PV(0xa041450) at 0xa04ecbc
313 2 REFCNT = 1
314 3 FLAGS = (POK,READONLY,pPOK)
315 4 PV = 0xa0484e0 "hello"\0
316 5 CUR = 5
317 6 LEN = 6
318 Reading "Devel::Peek" output takes a bit of practise, so let's go
320 through it line by line.
321 Line 1 tells us we're looking at an SV which lives at 0xa04ecbc in
323 memory. SVs themselves are very simple structures, but they contain a
324 pointer to a more complex structure. In this case, it's a PV, a
325 structure which holds a string value, at location 0xa041450. Line 2 is
326 the reference count; there are no other references to this data, so
327 it's 1.
328 Line 3 are the flags for this SV - it's OK to use it as a PV, it's a
330 read-only SV (because it's a constant) and the data is a PV internally.
331 Next we've got the contents of the string, starting at location
332 0xa0484e0.
333 Line 5 gives us the current length of the string - note that this does
335 not include the null terminator. Line 6 is not the length of the
336 string, but the length of the currently allocated buffer; as the string
337 grows, Perl automatically extends the available storage via a routine
338 called "SvGROW".
339 You can get at any of these quantities from C very easily; just add
341 "Sv" to the name of the field shown in the snippet, and you've got a
342 macro which will return the value: "SvCUR(sv)" returns the current
343 length of the string, "SvREFCOUNT(sv)" returns the reference count,
344 "SvPV(sv, len)" returns the string itself with its length, and so on.
345 More macros to manipulate these properties can be found in perlguts.
346 Let's take an example of manipulating a PV, from "sv_catpvn", in sv.c
348 1 void
350 2 Perl_sv_catpvn(pTHX_ SV *sv, const char *ptr, STRLEN len)
351 3 {
352 4 STRLEN tlen;
353 5 char *junk;
354 6 junk = SvPV_force(sv, tlen);
356 7 SvGROW(sv, tlen + len + 1);
357 8 if (ptr == junk)
358 9 ptr = SvPVX(sv);
359 10 Move(ptr,SvPVX(sv)+tlen,len,char);
360 11 SvCUR(sv) += len;
361 12 *SvEND(sv) = '\0';
362 13 (void)SvPOK_only_UTF8(sv); /* validate pointer */
363 14 SvTAINT(sv);
364 15 }
365 This is a function which adds a string, "ptr", of length "len" onto the
367 end of the PV stored in "sv". The first thing we do in line 6 is make
368 sure that the SV has a valid PV, by calling the "SvPV_force" macro to
369 force a PV. As a side effect, "tlen" gets set to the current value of
370 the PV, and the PV itself is returned to "junk".
371 In line 7, we make sure that the SV will have enough room to
373 accommodate the old string, the new string and the null terminator. If
374 "LEN" isn't big enough, "SvGROW" will reallocate space for us.
375 Now, if "junk" is the same as the string we're trying to add, we can
377 grab the string directly from the SV; "SvPVX" is the address of the PV
378 in the SV.
379 Line 10 does the actual catenation: the "Move" macro moves a chunk of
381 memory around: we move the string "ptr" to the end of the PV - that's
382 the start of the PV plus its current length. We're moving "len" bytes
383 of type "char". After doing so, we need to tell Perl we've extended the
384 string, by altering "CUR" to reflect the new length. "SvEND" is a macro
385 which gives us the end of the string, so that needs to be a "\0".
386 Line 13 manipulates the flags; since we've changed the PV, any IV or NV
388 values will no longer be valid: if we have "$a=10; $a.="6";" we don't
389 want to use the old IV of 10. "SvPOK_only_utf8" is a special
390 UTF-8-aware version of "SvPOK_only", a macro which turns off the IOK
391 and NOK flags and turns on POK. The final "SvTAINT" is a macro which
392 launders tainted data if taint mode is turned on.
393 AVs and HVs are more complicated, but SVs are by far the most common
395 variable type being thrown around. Having seen something of how we
396 manipulate these, let's go on and look at how the op tree is
397 constructed.
398
400 First, what is the op tree, anyway? The op tree is the parsed
401 representation of your program, as we saw in our section on parsing,
402 and it's the sequence of operations that Perl goes through to execute
403 your program, as we saw in "Running".
404 An op is a fundamental operation that Perl can perform: all the built-
406 in functions and operators are ops, and there are a series of ops which
407 deal with concepts the interpreter needs internally - entering and
408 leaving a block, ending a statement, fetching a variable, and so on.
409 The op tree is connected in two ways: you can imagine that there are
411 two "routes" through it, two orders in which you can traverse the tree.
412 First, parse order reflects how the parser understood the code, and
413 secondly, execution order tells perl what order to perform the
414 operations in.
415 The easiest way to examine the op tree is to stop Perl after it has
417 finished parsing, and get it to dump out the tree. This is exactly what
418 the compiler backends B::Terse, B::Concise and B::Debug do.
419 Let's have a look at how Perl sees "$a = $b + $c":
421 % perl -MO=Terse -e '$a=$b+$c'
423 1 LISTOP (0x8179888) leave
424 2 OP (0x81798b0) enter
425 3 COP (0x8179850) nextstate
426 4 BINOP (0x8179828) sassign
427 5 BINOP (0x8179800) add [1]
428 6 UNOP (0x81796e0) null [15]
429 7 SVOP (0x80fafe0) gvsv GV (0x80fa4cc) *b
430 8 UNOP (0x81797e0) null [15]
431 9 SVOP (0x8179700) gvsv GV (0x80efeb0) *c
432 10 UNOP (0x816b4f0) null [15]
433 11 SVOP (0x816dcf0) gvsv GV (0x80fa460) *a
434 Let's start in the middle, at line 4. This is a BINOP, a binary
436 operator, which is at location 0x8179828. The specific operator in
437 question is "sassign" - scalar assignment - and you can find the code
438 which implements it in the function "pp_sassign" in pp_hot.c. As a
439 binary operator, it has two children: the add operator, providing the
440 result of "$b+$c", is uppermost on line 5, and the left hand side is on
441 line 10.
442 Line 10 is the null op: this does exactly nothing. What is that doing
444 there? If you see the null op, it's a sign that something has been
445 optimized away after parsing. As we mentioned in "Optimization", the
446 optimization stage sometimes converts two operations into one, for
447 example when fetching a scalar variable. When this happens, instead of
448 rewriting the op tree and cleaning up the dangling pointers, it's
449 easier just to replace the redundant operation with the null op.
450 Originally, the tree would have looked like this:
451 10 SVOP (0x816b4f0) rv2sv [15]
453 11 SVOP (0x816dcf0) gv GV (0x80fa460) *a
454 That is, fetch the "a" entry from the main symbol table, and then look
456 at the scalar component of it: "gvsv" ("pp_gvsv" in pp_hot.c) happens
457 to do both these things.
458 The right hand side, starting at line 5 is similar to what we've just
460 seen: we have the "add" op ("pp_add", also in pp_hot.c) add together
461 two "gvsv"s.
462 Now, what's this about?
464 1 LISTOP (0x8179888) leave
466 2 OP (0x81798b0) enter
467 3 COP (0x8179850) nextstate
468 "enter" and "leave" are scoping ops, and their job is to perform any
470 housekeeping every time you enter and leave a block: lexical variables
471 are tidied up, unreferenced variables are destroyed, and so on. Every
472 program will have those first three lines: "leave" is a list, and its
473 children are all the statements in the block. Statements are delimited
474 by "nextstate", so a block is a collection of "nextstate" ops, with the
475 ops to be performed for each statement being the children of
476 "nextstate". "enter" is a single op which functions as a marker.
477 That's how Perl parsed the program, from top to bottom:
479 Program
481 |
482 Statement
483 |
484 =
485 / \
486 / \
487 $a +
488 / \
489 $b $c
490 However, it's impossible to perform the operations in this order: you
492 have to find the values of $b and $c before you add them together, for
493 instance. So, the other thread that runs through the op tree is the
494 execution order: each op has a field "op_next" which points to the next
495 op to be run, so following these pointers tells us how perl executes
496 the code. We can traverse the tree in this order using the "exec"
497 option to "B::Terse":
498 % perl -MO=Terse,exec -e '$a=$b+$c'
500 1 OP (0x8179928) enter
501 2 COP (0x81798c8) nextstate
502 3 SVOP (0x81796c8) gvsv GV (0x80fa4d4) *b
503 4 SVOP (0x8179798) gvsv GV (0x80efeb0) *c
504 5 BINOP (0x8179878) add [1]
505 6 SVOP (0x816dd38) gvsv GV (0x80fa468) *a
506 7 BINOP (0x81798a0) sassign
507 8 LISTOP (0x8179900) leave
508 This probably makes more sense for a human: enter a block, start a
510 statement. Get the values of $b and $c, and add them together. Find
511 $a, and assign one to the other. Then leave.
512 The way Perl builds up these op trees in the parsing process can be
514 unravelled by examining toke.c, the lexer, and perly.y, the YACC
515 grammar. Let's look at the code that constructs the tree for "$a = $b +
516 $c".
517 First, we'll look at the "Perl_yylex" function in the lexer. We want to
519 look for "case 'x'", where x is the first character of the operator.
520 (Incidentally, when looking for the code that handles a keyword, you'll
521 want to search for "KEY_foo" where "foo" is the keyword.) Here is the
522 code that handles assignment (there are quite a few operators beginning
523 with "=", so most of it is omitted for brevity):
524 1 case '=':
526 2 s++;
527 ... code that handles == => etc. and pod ...
528 3 pl_yylval.ival = 0;
529 4 OPERATOR(ASSIGNOP);
530 We can see on line 4 that our token type is "ASSIGNOP" ("OPERATOR" is a
532 macro, defined in toke.c, that returns the token type, among other
533 things). And "+":
534 1 case '+':
536 2 {
537 3 const char tmp = *s++;
538 ... code for ++ ...
539 4 if (PL_expect == XOPERATOR) {
540 ...
541 5 Aop(OP_ADD);
542 6 }
543 ...
544 7 }
545 Line 4 checks what type of token we are expecting. "Aop" returns a
547 token. If you search for "Aop" elsewhere in toke.c, you will see that
548 it returns an "ADDOP" token.
549 Now that we know the two token types we want to look for in the parser,
551 let's take the piece of perly.y we need to construct the tree for "$a =
552 $b + $c"
553 1 term : term ASSIGNOP term
555 2 { $$ = newASSIGNOP(OPf_STACKED, $1, $2, $3); }
556 3 | term ADDOP term
557 4 { $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
558 If you're not used to reading BNF grammars, this is how it works:
560 You're fed certain things by the tokeniser, which generally end up in
561 upper case. "ADDOP" and "ASSIGNOP" are examples of "terminal symbols",
562 because you can't get any simpler than them.
563 The grammar, lines one and three of the snippet above, tells you how to
565 build up more complex forms. These complex forms, "non-terminal
566 symbols" are generally placed in lower case. "term" here is a non-
567 terminal symbol, representing a single expression.
568 The grammar gives you the following rule: you can make the thing on the
570 left of the colon if you see all the things on the right in sequence.
571 This is called a "reduction", and the aim of parsing is to completely
572 reduce the input. There are several different ways you can perform a
573 reduction, separated by vertical bars: so, "term" followed by "="
574 followed by "term" makes a "term", and "term" followed by "+" followed
575 by "term" can also make a "term".
576 So, if you see two terms with an "=" or "+", between them, you can turn
578 them into a single expression. When you do this, you execute the code
579 in the block on the next line: if you see "=", you'll do the code in
580 line 2. If you see "+", you'll do the code in line 4. It's this code
581 which contributes to the op tree.
582 | term ADDOP term
584 { $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
585 What this does is creates a new binary op, and feeds it a number of
587 variables. The variables refer to the tokens: $1 is the first token in
588 the input, $2 the second, and so on - think regular expression
589 backreferences. $$ is the op returned from this reduction. So, we call
590 "newBINOP" to create a new binary operator. The first parameter to
591 "newBINOP", a function in op.c, is the op type. It's an addition
592 operator, so we want the type to be "ADDOP". We could specify this
593 directly, but it's right there as the second token in the input, so we
594 use $2. The second parameter is the op's flags: 0 means "nothing
595 special". Then the things to add: the left and right hand side of our
596 expression, in scalar context.
597 The functions that create ops, which have names like "newUNOP" and
599 "newBINOP", call a "check" function associated with each op type,
600 before returning the op. The check functions can mangle the op as they
601 see fit, and even replace it with an entirely new one. These functions
602 are defined in op.c, and have a "Perl_ck_" prefix. You can find out
603 which check function is used for a particular op type by looking in
604 regen/opcodes. Take "OP_ADD", for example. ("OP_ADD" is the token
605 value from the "Aop(OP_ADD)" in toke.c which the parser passes to
606 "newBINOP" as its first argument.) Here is the relevant line:
607 add addition (+) ck_null IfsT2 S S
609 The check function in this case is "Perl_ck_null", which does nothing.
611 Let's look at a more interesting case:
612 readline <HANDLE> ck_readline t% F?
614 And here is the function from op.c:
616 1 OP *
618 2 Perl_ck_readline(pTHX_ OP *o)
619 3 {
620 4 PERL_ARGS_ASSERT_CK_READLINE;
621 5
622 6 if (o->op_flags & OPf_KIDS) {
623 7 OP *kid = cLISTOPo->op_first;
624 8 if (kid->op_type == OP_RV2GV)
625 9 kid->op_private |= OPpALLOW_FAKE;
626 10 }
627 11 else {
628 12 OP * const newop
629 13 = newUNOP(OP_READLINE, 0, newGVOP(OP_GV, 0,
630 14 PL_argvgv));
631 15 op_free(o);
632 16 return newop;
633 17 }
634 18 return o;
635 19 }
636 One particularly interesting aspect is that if the op has no kids
638 (i.e., "readline()" or "<>") the op is freed and replaced with an
639 entirely new one that references *ARGV (lines 12-16).
640
642 When perl executes something like "addop", how does it pass on its
643 results to the next op? The answer is, through the use of stacks. Perl
644 has a number of stacks to store things it's currently working on, and
645 we'll look at the three most important ones here.
646 Argument stack
648 Arguments are passed to PP code and returned from PP code using the
649 argument stack, "ST". The typical way to handle arguments is to pop
650 them off the stack, deal with them how you wish, and then push the
651 result back onto the stack. This is how, for instance, the cosine
652 operator works:
653 NV value;
655 value = POPn;
656 value = Perl_cos(value);
657 XPUSHn(value);
658 We'll see a more tricky example of this when we consider Perl's macros
660 below. "POPn" gives you the NV (floating point value) of the top SV on
661 the stack: the $x in "cos($x)". Then we compute the cosine, and push
662 the result back as an NV. The "X" in "XPUSHn" means that the stack
663 should be extended if necessary - it can't be necessary here, because
664 we know there's room for one more item on the stack, since we've just
665 removed one! The "XPUSH*" macros at least guarantee safety.
666 Alternatively, you can fiddle with the stack directly: "SP" gives you
668 the first element in your portion of the stack, and "TOP*" gives you
669 the top SV/IV/NV/etc. on the stack. So, for instance, to do unary
670 negation of an integer:
671 SETi(-TOPi);
673 Just set the integer value of the top stack entry to its negation.
675 Argument stack manipulation in the core is exactly the same as it is in
677 XSUBs - see perlxstut, perlxs and perlguts for a longer description of
678 the macros used in stack manipulation.
679 Mark stack
681 I say "your portion of the stack" above because PP code doesn't
682 necessarily get the whole stack to itself: if your function calls
683 another function, you'll only want to expose the arguments aimed for
684 the called function, and not (necessarily) let it get at your own data.
685 The way we do this is to have a "virtual" bottom-of-stack, exposed to
686 each function. The mark stack keeps bookmarks to locations in the
687 argument stack usable by each function. For instance, when dealing with
688 a tied variable, (internally, something with "P" magic) Perl has to
689 call methods for accesses to the tied variables. However, we need to
690 separate the arguments exposed to the method to the argument exposed to
691 the original function - the store or fetch or whatever it may be.
692 Here's roughly how the tied "push" is implemented; see "av_push" in
693 av.c:
694 1 PUSHMARK(SP);
696 2 EXTEND(SP,2);
697 3 PUSHs(SvTIED_obj((SV*)av, mg));
698 4 PUSHs(val);
699 5 PUTBACK;
700 6 ENTER;
701 7 call_method("PUSH", G_SCALAR|G_DISCARD);
702 8 LEAVE;
703 Let's examine the whole implementation, for practice:
705 1 PUSHMARK(SP);
707 Push the current state of the stack pointer onto the mark stack. This
709 is so that when we've finished adding items to the argument stack, Perl
710 knows how many things we've added recently.
711 2 EXTEND(SP,2);
713 3 PUSHs(SvTIED_obj((SV*)av, mg));
714 4 PUSHs(val);
715 We're going to add two more items onto the argument stack: when you
717 have a tied array, the "PUSH" subroutine receives the object and the
718 value to be pushed, and that's exactly what we have here - the tied
719 object, retrieved with "SvTIED_obj", and the value, the SV "val".
720 5 PUTBACK;
722 Next we tell Perl to update the global stack pointer from our internal
724 variable: "dSP" only gave us a local copy, not a reference to the
725 global.
726 6 ENTER;
728 7 call_method("PUSH", G_SCALAR|G_DISCARD);
729 8 LEAVE;
730 "ENTER" and "LEAVE" localise a block of code - they make sure that all
732 variables are tidied up, everything that has been localised gets its
733 previous value returned, and so on. Think of them as the "{" and "}" of
734 a Perl block.
735 To actually do the magic method call, we have to call a subroutine in
737 Perl space: "call_method" takes care of that, and it's described in
738 perlcall. We call the "PUSH" method in scalar context, and we're going
739 to discard its return value. The call_method() function removes the top
740 element of the mark stack, so there is nothing for the caller to clean
741 up.
742 Save stack
744 C doesn't have a concept of local scope, so perl provides one. We've
745 seen that "ENTER" and "LEAVE" are used as scoping braces; the save
746 stack implements the C equivalent of, for example:
747 {
749 local $foo = 42;
750 ...
751 }
752 See "Localizing changes" in perlguts for how to use the save stack.
754
756 One thing you'll notice about the Perl source is that it's full of
757 macros. Some have called the pervasive use of macros the hardest thing
758 to understand, others find it adds to clarity. Let's take an example,
759 the code which implements the addition operator:
760 1 PP(pp_add)
762 2 {
763 3 dSP; dATARGET; tryAMAGICbin(add,opASSIGN);
764 4 {
765 5 dPOPTOPnnrl_ul;
766 6 SETn( left + right );
767 7 RETURN;
768 8 }
769 9 }
770 Every line here (apart from the braces, of course) contains a macro.
772 The first line sets up the function declaration as Perl expects for PP
773 code; line 3 sets up variable declarations for the argument stack and
774 the target, the return value of the operation. Finally, it tries to see
775 if the addition operation is overloaded; if so, the appropriate
776 subroutine is called.
777 Line 5 is another variable declaration - all variable declarations
779 start with "d" - which pops from the top of the argument stack two NVs
780 (hence "nn") and puts them into the variables "right" and "left", hence
781 the "rl". These are the two operands to the addition operator. Next,
782 we call "SETn" to set the NV of the return value to the result of
783 adding the two values. This done, we return - the "RETURN" macro makes
784 sure that our return value is properly handled, and we pass the next
785 operator to run back to the main run loop.
786 Most of these macros are explained in perlapi, and some of the more
788 important ones are explained in perlxs as well. Pay special attention
789 to "Background and PERL_IMPLICIT_CONTEXT" in perlguts for information
790 on the "[pad]THX_?" macros.
791
793 For more information on the Perl internals, please see the documents
794 listed at "Internals and C Language Interface" in perl.
795perl v5.26.3 2018-03-23 PERLINTERP(1)