Is a parse tree the same thing as bytecode? - perl

Question

What exactly is the difference between bytecode and a parse tree, specifically the one used by Perl? Do they actually refer to the same concept, or is there a distinction?
I'm familiar with the concept of bytecode from Python and Java, but when reading about Perl, I've learned that it supposedly executes a parse tree (instead of bytecode) in its interpreter.
If there actually is a distinction, what are the reasons for Perl not using bytecode (or Python not using parse trees)? Is it mainly historical, or are there differences between the languages that necessitate a different compilation/execution model? Could Perl (with reasonable effort and execution performance) be implemented by using a bytecode interpreter?

Answer 1

What Perl uses is not a parse tree, at least not how Wikipedia defines it. It's an opcode tree.
>perl -MO=Concise -E"for (1..10) { say $i }"
g <#> leave[1 ref] vKP/REFC ->(end)
1 <0> enter ->2
2 <;> nextstate(main 49 -e:1) v:%,{,2048 ->3
f <2> leaveloop vK/2 ->g
7 <{> enteriter(next->c last->f redo->8) lKS/8 ->d
- <0> ex-pushmark s ->3
- <1> ex-list lK ->6
3 <0> pushmark s ->4
4 <$> const[IV 1] s ->5
5 <$> const[IV 10] s ->6
6 <#> gv[*_] s ->7
- <1> null vK/1 ->f
e <|> and(other->8) vK/1 ->f
d <0> iter s ->e
- <#> lineseq vK ->-
8 <;> nextstate(main 47 -e:1) v:%,2048 ->9
b <#> say vK ->c
9 <0> pushmark s ->a
- <1> ex-rv2sv sK/1 ->b
a <#> gvsv[*i] s ->b
c <0> unstack v ->d
-e syntax OK
Except, despite being called a tree, it's not really a tree. Notice the arrows? It's because it's actually a list-like graph of opcodes (like any other executable).
>perl -MO=Concise,-exec -E"for (1..10) { say $i }"
1 <0> enter
2 <;> nextstate(main 49 -e:1) v:%,{,2048
3 <0> pushmark s
4 <$> const[IV 1] s
5 <$> const[IV 10] s
6 <#> gv[*_] s
7 <{> enteriter(next->c last->f redo->8) lKS/8
d <0> iter s
e <|> and(other->8) vK/1
8 <;> nextstate(main 47 -e:1) v:%,2048
9 <0> pushmark s
a <#> gvsv[*i] s
b <#> say vK
c <0> unstack v
goto d
f <2> leaveloop vK/2
g <#> leave[1 ref] vKP/REFC
-e syntax OK
The difference between Perl's opcodes and Java's bytecodes is that Java's bytecodes are designed to be serialisable (stored in a file).

Answer 2

Parse tree is the tokens of a program, stored in a structure that shows their nesting (which arguments belong to which function calls, what statements are inside which loops etc.) while bytecode is the program code converted into a binary notation for quicker execution in a virtual machine. For example if you had the following code in an imaginary language:
loop i from 1 to 10 {
print i
}
The parse tree might look for example like:
loop
variable
i
integer
1
integer
10
block
print
variable
i
Meanwhile the bytecode in raw and symbolic form, compiled for a stack-oriented virtual machine might look like:
0x01 0x01 PUSH 1
START:
0x02 DUP
0x03 PRINT
0x05 INCREMENT
0x02 DUP
0x01 0x0a PUSH 10
0x04 LESSTHAN
0x06 0xf9 JUMPCOND START
When compiling a program, you'd first need to parse the source code (usually producing a parse tree) and then transform it to bytecode. It can be easier to skip the second step and execute straight from the parse tree. Also, if the language syntax is very hairy (for example it allows modifying the code) then producing the bytecode gets more complicated. If there's an eval type function to execute any code, the whole compiler has to be distributed with the application to use the virtual machine for such code. Including only a parser is simpler.
In Perl 6, the next version of perl, the code is supposed to be compiled to bytecode and run on the Parrot virtual machine. It's expected to improve performance. Bytecode is fairly straightforward to compile further to the processor's native instructions (this is called a JIT compiler) to approach speed of compiled languages like C.