►
From YouTube: FSD based on OSR 20181206
Description
Improved JVM debugging mode based on OSR
A
B
A
Variable
values,
work
or
you
can
choose
to
watch
field
access
and
few
modifications
and,
as
a
JVM
developer,
we
care
about
what's
happening
under
the
hood
and
inside
JVM.
Those
evolving
features
are
implemented
through
Trivium
tour
interface
for
the
lowest
level
of
government.
Interests
are
provided
for
the
debugging
tools
and
give
EMT
I
allow
the
buggers
to
inspect
the
state
of
the
running
Java
program
and
also
even
to
be
able
to
control
the
behavior
of
Stella
program.
A
I
will
give
you
here
are
some
examples
of
gbmt
I
interfaces
like
when
the
debugger
wants
to
set
a
breakpoint
is
actually
this
a
JVM
TI
interface
lets
setting
the
breakpoint
for
the
others,
and
when
the
debugger
wants
to
inspect
local
variable
values
is
get
local,
get
local,
kazuto
:
get
recordings
and
get
a
local
object,
and
so,
let's
get
called
to
get
the
value
of
local
variable,
and
we
want
to
turn
here.
The
watch
to
watch
used
access
and
multiplication.
Those
are
the
GBM
CI
interface.
A
A
So
we
in
GBM
the
debugging
mode,
is
triggered
when
loading
the
JVM
agent
and
a
pound
GBM
startup
before
the
actual
Java
applications.
Let's
start
swarming
with
startup
routine
called
agent
Arnold
will
be
called,
and
in
this
routine
virgilian
CIA
agent,
we'll
ask
for
the
VM
for
a
bunch
of
debugging
capabilities
like
the
ability
to
assess
response
or
dual
field.
B
A
B
A
A
A
Tuna
certifiable
and
on
the
left-hand
side,
is
some
pseudo
bicycles
that
look
similar
to
what's
going
to
be
generated
by
Java,
C
and
notice
that
the
interpreter
the
in
the
bytecode,
the
variable
are
represented
as
loss
by
auto
slot.
So
the
auto
they
roll
out
under
Minister,
D
or
toast
as
well,
and
we
can
see
that
the
fears
are
mapping
relationship
between
the
Java
program
and
what
get
executed
in
the
interpreter
so
for
each
line.
The
Java
code
corresponding
several
bytecode
instructions,
so
debugging
your
child
whole
purpose
is
easy.
A
Now,
let's
look
at
the
story
under
this
color
side
and
which
is
under
right.
Most
side
is
a
compiled
code.
We
could
get
by
Cal,
Poly,
NIDA
original
Java
method,
and
you
can
see
that
Keep
Calm
hollering
smart
and
can
be
able
to
propagate
all
the
constants
and
through
the
consolation,
and
so
if
it's
missing
all
the
intermediate
steps.
So
if
we
want
to
divide
the
original
Java
code
is
probably
not
to
the
idea
to
just
read:
welcome
powerful.
It
won't
give
you
the
real
estate
of
the
original
Java
code.
A
So
we
need
to
find
our
going
to
be
able
to
match
the
compiled
code
into
the
original
Java
code
before
I
dive
into
the
technique
of
engine
are
used
to
implement
this
first
eyes.
We
need
to
know
a
very
concepts
that
yield
point
in
our
comparison
are
in
compiled
code.
Are
your
points?
Are
in
B
to
C
point
and
the
exception
point.
They
are
usually
the
point
during
our
executing
compiled
code
when
it
reaches
those
points.
Vm
can
take
control
of
the
execution
at
those
point
typical,
but
keep
code.
A
Your
point,
good
edges
of
the
mobile
function
call
so
at
your
points
wrong
time
can
take
control
over
the
execution
and
do
whatever
it
needs
to
do
like
garbage
collection,
exception,
handling
and
calling
VM
helper
and
then,
if,
after
its
job
is
done,
it
will
give
back
the
control
to
our
twisted
compiled
code
and
in
debugging
mode.
The
debugging
events
are
actually
stopped.
The
word
event,
which
means
the
VM,
needs
to
stop
all
the
java
application
from
earning
and
for
those
threads
running
in
compiled
code.
A
A
sentinel
increment
that
the
first
academia
easy
way
is
to
mimic
interpreter
friendship
so
for
electrician
photos
I
inserted
through
your
points
into
the
Java
code,
and
here
is
the
compiled
code,
that's
generated
from
the
Java
code.
If
I
mean
meaning
interpreter
friendship
mode,
you
can
you
can
see
that
in
compiled
code,
the
X
lost
location
are
represented
by
symbols
with
x
and
meaning
anemic
interpreter
anxious,
but
somehow
somehow
matches
the
behavior
of
the
Java
code
as
interpreted
code,
and
especially
we
need
interpreters.
A
A
So
of
these
are
restrictions
of
this
restriction
on
the
brain
of
method.
On
the
method,
three
makes
it
hard
to
enable
optimization,
because
we
need
to
manually
check
all
the
optimization
and
make
sure
the
the
section
of
the
method.
Friendship
will
be
changed
because
of
the
optimization
and
even
enable
very
simple
optimizations,
like
local
local
home
expression
for
horses.
A
Eat
could
be
pretty
tricky
because
the
transformation
can
change
the
library
of
variable
and
then
we
can
get
very
subtle
back
into
T
and
because
of
those
difficulties
for
limited
interpreter
fringing
many
of
optimizations
are
disabled
and
that
give
us
pretty
pretty
bad
performance.
And
so
we
need
a
way
to
be
able
to.
A
A
Counsel
get
into
interpreted
code
and
don't
want
to
not
have
those
limitations
on
the
optimization
here
is
where
instead
is
mental
coming
to
a
picture
and
in
opening
items
another
debugging
mode,
that's
based
on
unstack
replacement,
and
we
call
it
this
way.
The
debug,
because
we
is
much
faster
than
the
naked
interpreter
friendship
version
in
be
debugging.
A
The
USB
debug
is
wrong
in
ofr
mode
called
an
involuntary
ofr,
and
it's
because
the
OSR
will
happen
at
your
point
and
when
the
debugging
event
happens
and
the
wrong
time
will
request
for
OSR
if
the
debugging
event
to
get
triggered
and
then
continue
in
interpreter.
So
the
timing
of
the
OSR
transition
is
totally
defied
on
wrong
time.
So
that's
why
we
call
this
involuntary
Ohr,
and
this
is
in
contrast
with
another
hormone
house.
A
Low-
let's
look
at
an
example
of
osr2
annotation
in
default
mode.
So,
on
the
right
hand,
side
is
a
compelled
account
that
could
be
generated
by
in
loosely
received
bugging
world.
It's
able
the
compiled
code
is
able
to
do
things
that
are
more
flexible,
but
it
can
hold
this
variable
into
into
our
register,
rather
than
store
it
directly
onto
the
stack,
and
it
can
delay
all
the
story
to
the
tax
laws
until
it
has
to
throw
in
with
facility
bag
mode.
A
We
don't
need
to
carefully
maintain
de
methods
frame
exactly
as
interpreter
it's
only
when
the
debugging
event
that
actually
happens
that
we
need
to
do
that.
So,
let's,
let's
assume
that
we
come
to
your
point
to
encoding
the
second
when
coding
those
four
functions
x
and
y.
So
if
the
last
debugging
event
is
triggered,
the
cheat
code
needs
to
get
out
after
get
out
of
execution
and
does
an
execute
film
transmission
code.
A
That
will
look
into
some
kind
of
writing
and
figure
out
which
value
to
write
into
the
metal
sphere
so
that
the
metal
frame
will
look
exactly
like
voltage,
would
look
like
in
Midgar
in
interpreter
and
after
the
transition
called
building
the
method.
As
expected,
the
interpreter
is
able
to
continue
with
that
method
astray,
because
the
values
are
exactly
what
interpreter
expected
and
we
can
see
from
this
transition.
A
A
We
need
to
be
able
to
reconstruct
the
state
of
England
cost
and
which
means
if
the
OS,
our
transition
happens
in
England
method,
we
should
be
able
to
recover
to
align
metal
frame
of
the
inline
method
and
also
its
color,
and
so
the
second
aspect
is:
we
need
to
make
sure
the
optimizations
don't
validate
those
or
at
our
mappings.
So
if
a
transformation
to
change
the
margin,
we
need
to
update
and
maintain
our
margin.
Also,
the
marking
should
be
our
chief
to
update
and
maintain
and.
A
In
open,
gen,
IV
or
F,
our
mapping
is
represented
by
the
intermediate
representation.
So
here
the
deep
blue
box
is
the
normal
basic
lock
in
jello
program
and
the
light
blue
of
is
the
translation
block
that
contains
the
OS,
our
mapping
and
inside
the
translation
block,
because
a
bunch
of
IR
source
into
the
auto
stack
laws
and,
on
the
right
hand,
side
of
the
store
contains
uses
of
the
symbol
in
G
compelled
code,
the
rule
for
for
simplicity.
You
know
we
can
just
assume.
B
A
Word
are
to
the
interpreter,
respect
laws
directly
and
in
this
way,
because
the
life
our
mapping
is
represented
as
IR.
So
there
is
no
fundamental
difference
between
those
IR
than
the
original
and
in
the
method.
So
the
optimization
to
transformation
is
able
to
take
it
into
those
stores
and
use
these
automatically
into
consideration
part
of
the
translation
and
guarantee
that
the
transformation
rules.
If
the
transmission
change
the
mapping,
the
optimization.
C
A
Other
translation
blocks,
so
there
is
the
one
translation,
block,
term
method
and
all
other
in
line
colleagues
and
colors,
or
have
your
own
basic
block.
All
have
their
own
translation
blocks
and
aligned
call
handling
is
easy.
We
just
need
to
link
the
Akalis
translation
block
into
the
colors,
so
that
is
that
wise,
our
transition
happens
in
the
cloudy.
A
Lsr
itself
is
treated
as
an
exception,
so
whenever
there's
any
OSR
point
in
one
basic
block,
there
will
be
an
exception
edge.
Connecting
that
basic
block
to
the
methods
translation
table-
and
this
idea
is
this
idea
of
treating
the
OSR
transition,
as
exception
is
pretty
neat,
because
this
way
one
basic
block
can
contain
several
bizarre
transition
points
and
we
don't
need
to
leave
the
basic
laws
and.
B
A
Got
a
lot
of
optimization
that
would
only
work
on
basic
block
and
analysis
like
a
live
range
analysis,
reaching
definition
that
you
need
to
treat
those
exception,
edges
conservatively
conservatively
to
guarantee
correctness,
and
this
is
the
intermediate
representation
part
of
the
EOS,
our
infrastructure
and
there's
actually
another
part
that
we
need
to
use
side.
Data
structure.
A
A
So
we
need
to
really
no
way
to
figure
out
which
symbols
in
the
pitch
metal
swing.
We
need
to
write
to
the
corresponding
interpreter
interval,
stack
plus,
and
this
information
can
be
cast
on
doing
like
our
live
range
analysis
right
after
iog,
because
after
Elgin
there's
no
optimization
configured,
so
the
liveness
at
this
point
in
the
program
will
represent
the
aliveness
in
interpreter.
A
So
we
will
know
that
as
a
certain
bytecode
which
which
are
which
are
cheap
symbols
is
which
this
symbol
is
a
large
and
should
be
right
to
the
interpreter
method
friend
and
because
the
live
need
to
represent
the
stage
in
interpreter.
We
don't
need
to
update
the
liveness
information
anymore,
and
so
it's
not
affected
by
later
optimization
and
long
time.
Our
we'll
look
at
aside
the
data
structure
at
around
hunt
and
copy
the
right
value
and
the
I
remember
I
said
in
for
three.
A
Basically,
we
assumed
that
the
translate
the
I
are
stored
in
the
translation
block
are
all
working
to
the
interpreter
methods
when
directly
Alice
actually
is
hide.
It
hide
an
intermediate
step.
We
are
actually
writing
the
value
of
the
GT
methods
going
to
add
our
first
so
other
in
the
translation
box.
Will
first
write
the
single
values
into
a
buffer
and
then
we'll
step
on
little
spell.
A
Writing
evaluating
to
the
buffer
is
a
same
for
all
the
translations,
but
if
second
times
that's
different
with
transition
different
in
structure,
in
this
case,
for
example,
because
the
cited
it
has
structure
shows
that
as
instruction
for
the,
we
should
write
the
values
of
simple
dermal
into
the
auto
slot
and
at
when
we
get
to
instruction
tense.
If
the
value
of
symbol,
one
that
should
be
read
to
be
written
into
the
interpreters
back
clause.
A
A
B
A
A
So
this
is
the
overall
infrastructure
in
Oh
Emma
and
are
in
SSDs,
so
we
use
lab
OMR
or
youth
or
I
thought,
maybe
to
get
the
program
out
of
the
optimize
the
version
of
this
code,
which
doesn't
really
represent
what
actually
happened
in
the
Java
code.
So
if
will
we
believe
it
banging?
Even
it
happens
and
we
always
are
out
from
optimized
version
of
the
judge
of
the
wrong
time.
You
can
choose
to
continue
in
interpreter.
A
A
We'll
assume
that
there's
no
there's
no
need
to
do
are
to
report
a
field
access
and
we
will
not
include
the
helper
call
of
the
tool
is
quoted,
as
you
will
access
as
if
the
field
watch
is
enabled
we
need
to
get
out
from
the
original
version.
The
student
doesn't
report
to
access
and
execute
in
a
different
version
that
we
will
contain.
A
That's
the
time
we
need
to
get
out
from
the
optimal
solution
and
execute
in
a
slow
version
that
can
reflect
was
the
shortest
actually
happens
in
Sid
compound
code
and
the
performance
improvement
will
be
for,
for
a
debugging
is
mostly
making
making
use
of
the
ofr
infrastructure
and
do
patching
on.
We
compile
and
there's
an
important
base
and
interesting
items
that
we
did,
that
a
little
bit
special
is
the
new
life
news
will
be
score
method,
entry,
initialization.
A
However,
we
need
to
visualize
almost
variable
as
method
entry
because
for
an
address
title
variable
if
it
appears
to
be
alive
as
a
method
entry
and
it's
not
initialized
when
the
GC
Caesar
variable
as
life
and
it's
not
initialized
GC-
will
crash
because
of
the
and
initialize
the
value.
So
that
means
as
long
as
there's
a
new
point
between
the
method,
entry
and
the
first
use
of
variables.
We
need
to
be
our
bill
initialization,
and
this
won't
be
a
problem
for
non
debugging
mode
program,
because
this
situation
is
pretty
real.
A
A
And
those
to
view
face
articles
are
consider
and
make
the
variable
alive
because
of
those
losses.
So
as
well
as
varies
and
your
point
between
the
first
use
of
a
variable
and
the
method
entry,
this
this
variable
will
appear
to
be
alive
as
a
method
entry
and
it's
become
so
common
that
we
are
actually
very
low.
Initialize
all
the
address
type
variable,
and
so
this
can
cause
a
great
overhead
and
the
frustration
is
that
Ananta
uses
in
OS
our
translation
block.
Actually,
the
state
uses
this.
A
We
are
not
real
use
in
original
program
and
they
are
only
they
only
happen
if
the
oils
are
really
really
happen.
So
what
we
want
to
do
is
that
we
don't
want
to
use
the
fake
uses,
liveness
analysis.
We
want
to
use
the
real
uses
and
the
real
users
here
is
actually
what
get
used
if
the
matter
were
executed
in
interpreter
mode.
A
A
So
in
this
way,
the
variables
that
appear
to
be
alive
because
of
the
OSR
uses
will
be
able
to
be
ignored
and
if
we
are
to
happen
as
those
zero
point,
the
nor
can
helper
we'll
be
able
to
figure
out
with
which
variable
is
actually
actually
is
dead
and
and
hasn't
been
initialized
and
then
the
wrong
time.
Helper
will
look
into
that
by
the
data
structure.
We
got
from
silent
analysis
and
the
Douro
out
the
variable
when
the
OSR
transition
actually
happens.
A
A
So
after
we're
talking
about
the
overall
OS
are
interesting
and
performance
improvement,
we
did
now
it's
time
to
attach
those
performance
with
our.
So
now
here
are
some
numbers.
We
got
from
running
a
day
trader
and
some
other
benchmarks
for
bacterium.
2008
and
the
bars
are
words
that
normalized
to
the
performance
of
mimic
interpreter
friendship.
A
B
A
An
example
of
how
open
do
not
use
the
word,
our
infrastructure
to
implement
to
argue
mode,
and
they
are
still
actually
from
some
javanese
components
in
the
oil
maja
level
that
prevents
other
staff
projects
from
using
the
same
or
as
our
infrastructure
to
it
increments
their
debugging
wall.
So
we
still
need
to
do
some
factoring
work
to
trip
out
the
Japanese
homeland
funding
or
financial
structures.
Also,
there
is
always
room
for
better
performance,
because
our
currently
there's
still
about
a
30
or
40
to
30
percent
gap
between
the
debugging
mode
and
no
defending
most
versions.