Perhaps B::Concise produces something like you want? An example from its documentation:

           % perl -MO=Concise -e '$a = $b + 42'
           8  <@> leave[1 ref] vKP/REFC ->(end)
           1     <0> enter ->2
           2     <;> nextstate(main 1 -e:1) v ->3
           7     <2> sassign vKS/2 ->8
           5        <2> add[t1] sK/2 ->6
           -           <1> ex-rv2sv sK/1 ->4
           3              <$> gvsv(*b) s ->4
           4           <$> const(IV 42) s ->5
           -        <1> ex-rv2sv sKRM*/1 ->7
           6           <$> gvsv(*a) s ->7
[download]

Thank you both for anwsers.
Fletch you hit the bull's eye, It is exactly what I wanted to obtain.
Thank you again for the time and trouble.
Next time I will try harder searching my own anwser, as It seems that it was just under my nose.

With the -exec flag, B::Concise gives output closer to your example:

$ perl -MO=Concise,-exec -we'print "Hello, world!\n";'
1  <0> enter
2  <;> nextstate(main 1 -e:1) v
3  <0> pushmark s
4  <$> const[PV "Hello, world!\n"] s
5  <@> print vK
6  <@> leave[1 ref] vKP/REFC
-e syntax OK
[download]

by showing execution order rather than the op tree (but no longer shows optimized-away ops and can make branching ops less clear).

Your best bet is probably

perl -MO=Bytecode
[download]

You'll want to use something in the B module hierarchy.

Re: Advanced Perl Programming, 2nd edition walks through some detailed examples of how to examine the opcode tree (I think with B::Generate, but I don't have the book with me at the moment).

Update:

perl -MO=Debug foo.pl

This may quickly give you what you want.

Sample Terse output:

>perl -MO=Terse -e "print qq{Hello, world!\n};"
LISTOP (0x1ab0b04) leave [1]
    OP (0x1ab8bac) enter
    COP (0x1ab0b3c) nextstate
    LISTOP (0x1ab0bb8) print
        OP (0x1ab0b90) pushmark
        SVOP (0x1ab0be0) const  SPECIAL #0 Nullsv
-e syntax OK
[download]

The Concise equivalent:

>perl -MO=Concise -e "print qq{Hello, world!\n};"
6  <@> leave[t1] vKP/REFC ->(end)
1     <0> enter ->2
2     <;> nextstate(main 5 -e:1) v ->3
5     <@> print vK ->6
3        <0> pushmark s ->4
4        <$> const(SPECIAL Null)[t2] s ->5
-e syntax OK
[download]

The Debug equivalent:

>perl -MO=Debug -e "print qq{Hello, world!\n};"
LISTOP (0x1bb2ec0)
        op_next         0x0
        op_sibling      0x0
        op_ppaddr       PL_ppaddr[OP_LEAVE]
        op_targ         1
        op_type         178
        op_seq          6612
        op_flags        13
        op_private      64
        op_first        0x1ab8b84
        op_last         0x1bb2f84
        op_children     3
OP (0x1ab8b84)
        op_next         0x1bb2f08
        op_sibling      0x1bb2f08
        op_ppaddr       PL_ppaddr[OP_ENTER]
        op_targ         0
        op_type         177
        op_seq          6607
        op_flags        0
        op_private      0
COP (0x1bb2f08)
        op_next         0x1bb2f5c
        op_sibling      0x1bb2f84
        op_ppaddr       PL_ppaddr[OP_NEXTSTATE]
        op_targ         0
        op_type         174
        op_seq          6608
        op_flags        1
        op_private      0
        cop_label
        cop_stashpv     main
        cop_file        -e
        cop_seq         6608
        cop_arybase     0
        cop_line        1
        cop_warnings    0x0
.
.
.
[download]

perl -MO=Bytecode -e '...'
[download]

perl -Mmodule -e ' ....'
[download]

-MO loads the O module, of course, which loads the B::* module listed after the equal sign.

B stands for Backend.

As you know, -M is the command line equivalent of use. The equal sign specifies the arguments to pass to the import function. So perl -MO=Bytecode is the command line equivalent of use O 'Bytecode'; in actual Perl. Likewise perl -Mopen=:utf8,:std is the equivalent of use open qw(:utf8 :std);.