►
From YouTube: OMR Compiler Architecture Meeting 20190620
Description
Agenda:
1. Formalization of TR IL semantics [ @shingarov ]
2. newvalue IL opcode request (#4028 ) [ @jdmpapin ]
A
Okay,
welcome
everyone
to
this
week's
compiler
architecture
meeting
today
we
have
two
topics.
First,
is
a
boring
garage
we'll
be
talking
about
some
ion
ion
specification
topics,
and
the
second
topic
that
we
have
is
one
from
Devon
peppy
note
about
introducing
a
new
aisle
opcode.
So
to
begin
with,
we'll
start
with
the
aisle
specification
so
Boris,
can
you
take
it
away.
B
C
B
We
wanted
to
build
the
ADM
for
small
talk.
That
would
be
a
simple
trustworthy
and
we
tried
a
couple
of
different
approaches.
So
one
approach
which
isn't
really
what
I
want
to
talk
about,
but
for
the
sake
of
completeness
in
the
description
of
what
we
tried
was
its
described
in
a
paper
presented
at
the
IWC
2017.
D
B
Bus
actually
all
the
previous
buses.
Now
we
kept
a
machine
pass
and
we
replaced
everything
else,
just
with
not
all
children
the
normal
chain
of
passes,
leading
to
the
to
the
hell
and
the
past
from
the
AL
to
the
much
scale
we
replaced
that
pass
and
we
provided
teams
for
for
constructing
the
proof
of
the
correctness
of
the
past
in
Cocke
and
that
work
is
incomplete.
B
B
From
that
both
the
card,
where
guys
are
deriving
all
this
all
the
silicon
from
the
spectral,
whatever
they
do
so
I'll,
you
know
I,
don't
talk
about
this
here
and
then
what
we
do
is
we
do
an
automatic
synthesis,
taking
a
speck
of
the
semantics
of
the
aisle.
We
combine
it
with
formal
CPUs
back
and
that's
how
the
back
end,
whatever
the
did
that
we
called
the
DM
were.
D
B
B
B
For
dr.
VMs
that
we
worked
with,
this
has
been
working
pretty
well
since
the
last
five
years,
so
we
showed
the
working
proof
of
concepts
we
started
with
constructing
this.
For
an
academic
small
talk
that
John
circle.
He
is
doing
at
Michigan
called
motto
and
we
presented
first
results
in
2014
and
then
again
in
2015
and
2016.
This
was
gonna
run
the
whole
ansi
tester
and
then.
E
B
B
B
B
The
actual
semantics
of
which
instruction
and
based
on
that
they
have
it's
over,
they
wrote
in
a
nun,
hope
manner
in
C++,
so
they
take.
Those
are
deal
like
semantics
and
they
synthesize
the
details
and
they
synthesize
a
completely
loyal
VM
back-end
from
those
stacks
and
I
can
show
you
what
that
looks
like
if
somebody
is
interested
in
because
we
have
always
another
point
from
which
we
started
is
the
anger
system.
What
those
people
do
is
they
try
to
do
analysis
of.
B
Security,
whether
they're
interested
in
security
things,
we
are
interested
in
things
like
proving
absence
of
buffer
overflows
to
take
over
the
machine
and
stuff
like
that.
So
what
they
do
is
they
look
at
the
binary
and
they
use
well
gram
to
parse
that
the
binary
text
and
lift
those
city
instructions
to
NIR.
They
call
backs
and.
B
That
IR
has
simple
enough
semantics
that
they
can
execute
that
in
our
algebraic
way
or
they
call
symbolically.
But
there
is
you
know
that
there's
a
couple
different
meanings,
that's
some
ambiguity
or
when
you
say
symbolic,
so
what
they
do
is
that
that
they're
not
just
symbolic
instructions.
What
what
happens
motivations
for,
add
or
multiply
is
not
just
a
name.
B
B
E
B
Where
you
execute
that
instruction,
they
can
reason
say:
oh
well,
now
the
value
is
X
plus
1
under
certain
conditions,
and
it
is
more
systematic
than
ACC
gems.
We
reuse
the
existing
z3
solar
from
Microsoft
and
they
wrap
that
in
bison
they
also
wrap
in
Python
parts
of
well-drained
and
animal
with
the
daily
use,
a
bunch
of
interesting
things
and
all
that
all
the
rest
is
essentially
integrative
and
written
in
Python,
so
reusing
all
that
they
are
able
to
symbolically
execute
binaries
from
mini
Isis.
B
People
have
been
reusing
that
for
construction
organizers,
for
that
ok,
what's
interesting
is
because
it's
all
algebraic
bollocks.
What
happens
that?
Well,
essentially,
if
you
don't
really
just
random
stuff
at
the
super
optimized
see,
you
know
it's
not
really
a
random
search,
it's
really
logical
synthesis
or
logic
derivation
from
ma.
What
well
kinda
gives
you
looking
at
the
CPU
instructions
and
they.
C
B
B
Expect
energy
is
the
algorithmic
process,
their
process
description,
language
which
the
DFL,
so
we
parse
that
we,
while
parsing
we
assert
each
of
those
fact
is
back
into
a
probe
database
and
then
there
is
a
solver
which
is
prologue.
But
it's
not
just
your
problem,
because
when,
when
you
try
to
unify
for
each
byte
code,
it
demeans
going
to
be
a
fragment
tree.
B
Oh,
it
is
just
a
pattern
with
some
some
terms
and
try
to
unify
that
tree
or
a
term
with
what
is
available
in
each
is
Monica
beige
instruction,
and
if
you
try
to
come
to
that
you're
going
to
get
the
so
much
backtracking
that
essentially
it's
going
to
be
computationally
intractable.
So
what
we
need
is
some
sort
of
constraint,
propagation
system
and
and
what
I
use
is
still
use
an
for
solving.
So
it's
not
just
going
to
backtrack.
B
I
mean
it
does
backtrack
a
lot,
but
it
comes
the
unnecessary
branches
very
early
and
then
rewriting
I
use
fun,
Emden
equation
all
rewriter
them.
This
looks
like
well
actually
if
this
is
actual
cold
that
internet,
so
it
has
given
given
every
right,
that's
on
here.
So
from
X.
You
write
y
and
then
you
try
to
satisfy
so
you
give
X,
which
is
the
NL,
which
is
help
and
you
are
trying
to
satisfy
the
three
inclusions
and
Y
is
going
to
be
the
actual
instruction.
So
we
are
trying
to
get
e
2
and
e.
B
2
is
e
here
itself,
so
into
X.
X
here
is
when
you
are
stuck
so
you
are
already
in
normal
form,
cannot
continue
or
you
are
trying
to
do
a
step
if
there
is
a
step.
So
this
is
essentially.
This
is
essentially
a
transformational
closer
right,
so
you
have
P
1,
which
is
one
step
and
if
X
rewrites
y
explicitly
and
you
rewrite
a
lemon
to
be
a
effect
to
an
instruction.
B
There
is
no
instruction
that
does
it.
That
was
what
you
want
in
one
instruction.
Then
you
basically
substitute
a
bigger
one
from
two
smaller
ones.
So
and
you
do
it
on
the
left
and
into
it.
You
can
do
it
on
the
right.
So
that's
how
you
get
a
bigger
effect
from
smaller
bracket
and
then
obviously
well
a
bunch
of
peers
and
it's
not
an
unconditional
I
mean
it
is
a
rewriter
if
it
is
a
production
system,
but
each
production
is
conditioned
by
some
success
condition.
B
So,
for
example,
on
a
risk
items
with
any
kind
of
resizing
are:
let's
say
you
want
to
load
a
32-bit
integer
into
a
register.
Well,
you
don't
have
instructions
that
low
the
whole
little
bit.
So
you
have
to
simplify
that.
But
if
you
yeah,
but
if
your
integer
is
rather
small
or
small
enough
and
fit
into
you,
know,
load
immediate
instruction,
then
your
condition
will
be
something
like
well:
the
integer,
radians,
less
land,
less
practical,
so
then
conditionally
rewrite
that
effect
to
its
load
instruction.
B
B
C
B
B
B
Well
posed
by
the
prologue
system
and
Myra
solders
in
in
the
Quixote
bed
and
by
the
van
ambulance
already
where
their
poetry,
that
just
has
until
name
and
let
me
specify
a
few
lines
that
they
hear
well
answer
consists
of
this
part.
So
you
can
break
it
down
by
making
this
operational
phase
before
that,
you
will
get
the
actual
before,
or
the
Rio.
B
B
B
B
B
B
What
did
we
learn
from
this?
So
the
approach
works?
You
can
construct
a
VM
that
will
actually
execute
something
as
complex
as
dancy
tester,
but
you
need
a
much
simpler,
il
or
I
would
like
a
much
simpler
il
because
we
had
to
just
omit
certain
things
in
the
implementation.
It's
it's
kind
of
we
kind
of
cheated,
because
ANSI
tester
doesn't
really
mundane.
B
B
E
A
A
B
The
the
extent
of
the
study
of
the
aisle
was
dictated
by
the
work
that
that
we
were
doing
for
the
risk
five
port
right.
Obviously
you
cannot.
You
cannot
make
a
port
of
the
actual
compiler
unless
you
understand
what
it
is.
You
are
translating
from
right,
so
yeah,
I
I
think
we
do
understand
what
the
aisle
looks
like.
B
B
Any
processor
it
it
does
formalize
the
semantics,
because,
obviously,
if
well
it's
a
machine
readable
form
from
which
the
synthesizer
decides.
What
what
instruction
does?
What?
But
I,
am
afraid
that
for
the
needs
of
the
community,
that
would
not
be
enough.
So
I
think
the
next
step
would
be
to
discuss
in
what
form.
B
A
Okay,
so
when
you're,
when
you're
talking
about
so,
if
you're
talking
about
formalizing
the
Testarossa
il
now,
what
do
you?
What
would
you
require
for
that
to
happen?
Do
you
for
so,
for
example,
you
need
each
of
the,
so
it
is
a
tree
based
il.
So
we
would
need
all
the
operations
to
be
very
clearly
defined
and
the
semantics
of
all
the
opcodes
to
be
fairly
clearly
defined
and
the
way
that
the
trees
can
be
linked
together
and
ordering,
and
that
sort
of
thing
should
all
be
well-defined
right.
B
So
that
I
can
feed
it
to
my
synthesizer,
but
we
could
also
you
know:
I
guess
people
who
are
working
on
on
the
Otero's
aisle.
They
have
some
be
around
hands
on
why
they
want
this
kind
of
formalization,
so
they
have
their
own
uses
for
it
right
and
when
we
say
formalization,
obviously
we're
talking
about
you
know
machine,
readable
spec.
So
so
what
what
is?
What
is
the
plan?
Are
you
planning
to
feed
it
to
some
sort
of
machinery
that
will
I,
don't
know
automatically
verify
correctness
or,
like
so.
A
In
that.
So
that's
really
the
only
sort
of
external,
specific
external
representation
that
we
we've
ever
had
I
guess
we'd
have
to
think
of
we'd
have
to
think
about
how
we
would
want
to
do
it
if
it
was
required
to
to
export,
or
certainly
here
any
thoughts
that
you
have
how
that
should
be
done.
What
do
you
think.
A
B
B
A
Tree
validation
that
happens
right
now
is
all
internal.
The
compiler,
it's
not
really
externalized
yeah
I
mean
I,
guess
that
is
something
that
could
potentially
be
externalized
to
operate
on
the
whatever
external
form
we
come
up
with,
but
the
I
guess.
The
challenge
that
we
have
at
the
moment
is
that
a
lot
of
the
way
that
the
Testarossa
l
behaves
is
like
it.
There
isn't
any
sort
of
written
spec
that
we
that
we
follow
other
than
what
the
code
is.
A
I
mean
certainly
one
might
feed
into
the
other,
but
yeah
we
haven't.
Even
we
don't
really
have
a
lot
of
even
the
early
groundwork
to
provide
a
formal
specification
living
the
fact
that
well
other
than
the
code
so
I'm,
not
even
sure
we
could
have
a
formal
specification
right
now.
Those
lot
I'm
not
convinced
that
every.
C
F
C
I,
don't
think
that
as
a
community,
we
really
have
a
good
handle
on
the
more
corner
piece
behaviors
for
a
lot
of
the
mathematical
operations
and
those
kind
of
things
right
like
how
does
overflow
but
hey
what
are
the
floating-point
semantics,
which
we've
already
had
several
discussions
on.
So
there's,
certainly
quite
a
lot
of
vagueness
in
those
areas,
even
beyond
the
actual
coach
and
implementations
which,
for
the
kind
of
thing
that
they
discussed,
would
certainly
be
a
prerequisite
to
be
able
to
enumerate
that
properly
and
I'm,
not
even
sure
how
we
would
do
that.
A
Yeah
I
don't
so
given
that
and
and
and
the
other
things
that
we've
said,
I'm,
not
sure
if
that
changes,
your
opinion
of
the
utility
of
TRL
for
your
for
your
purpose
and
you're
right
that
it
is
a
simple
il
in
some
regards.
But
in
some
cases
it
mean
it
isn't
as
well
specified
as
as
we
would
hope
than
as.
Maybe
you
would
like.
B
Yeah,
well,
it's
no
better
than
any
other
aisle
for
any
dynamic
language
that
we
have
tried.
So
it's
definitely
much
simpler
than
any
bytecode
set
for
any
real
language,
so
I
guess
trying.
Maybe
one
part
of
attack
is
trying
to
do
something
similar
from
you
know
what
we
already
did
with
you
know
with
what
was
it.
We
have
this
approach
for
example,
and
see
where
ambiguous
is
pop
up
and
try
to
try
to
see
let's
say:
synthesize
a
back-end.
B
From
a
formal
spec
of
semantics
of
well
some
of
these
instructions
and
then
see
how
they
are
going
to
differ
from
what
the
existing
translator,
what
the
existing
generators
generate.
You
know,
mr
right
so
well.
Actually,
it's
not
even
oh
yeah,
it's
sort
of
an
S.
It's
not
even
necessary
to
generate
any
code
for
machines,
because
if
you
have
a
semantics
and
then
you
say:
okay
well
now,
I'm
executing
this
bytecode
and
this
whatever
virtual
register
t1,
contains
the
integer
X.
What
is
water
register
going
to
contain
after
the
execution
of
those
bytecode?
B
B
Existing
code
generator
in
omr
and
the
value
is
X
plus
1
right,
I'm,
grossly
oversimplifying,
and
let's
say
from
the
spec
that
we
came
up
with
it's
a:
is
it
X,
plus
1?
Or
is
it
something
else
right
now?
Yes,
this
is
a
very
over
simplified
view
of
things,
because
obviously
there
are
optimizers
and
the
at
each
step.
When
you
do
a
transformation,
the
transformation
may
not
actually
preserve
things.
D
B
But
at
least
we
could
run
some
experiments
comparing
each
step.
You
know
what
happens
with
that
value
X.
Is
it
like
on
an
Inc?
Is
it
still
X,
plus
1?
What's
what's
happening
so
it's
it's
I
mean
it's
not
the
the
valuing
in
these
very
fires,
and
then
it's
provers
is
not
just
that.
You
have
ok
well.
The
final
answer
is
that
yeah
it
conforms
to
the
spec
right,
it's
an
actual
tool
that
can
analyze
all
of
these
edge
cases.
For
you
right
and
say:
oh,
ok!
Well,
it
can
go
over
this
way.
B
It
can
go
this
way.
It
can
go
this
way
and
just
see
where,
where
it
is
this,
this
leaves
what
the
reason
why
I
initially
proposed
that
we
have
this
meeting
is
that
we
just
don't
step
on
each
other's
toes
and
if,
as
I
thought,
that
say,
there
would
be
a
lot
of
work
already
happening
on
this
in
the
OMR
team
that
you
know
we're
not
duplicating
effort,
but
from
what
I'm
hearing
is
well
pretty
much
any
effort,
he
is
gonna
read
somewhere
and
there
isn't
going
to
be
wasted.
Effort
no.
A
C
A
B
A
H
H
And
the
reason
for
this
is
that
if
we
separate
the
steps
of
allocation
and
initialization,
which
we
would
have
to
do
at
the
moment,
unless
we
represent
ourselves
an
additional
operation,
somehow
in
some
way
we're
going
to
have
stores
into
the
into
the
immutable
object.
And
then
we're
going
to
have
this
immutable
object
where
we
have
to
care
about
where
the
stores
into
it
are,
and
it's
sort
of
defeating
the
ease
with
which
we
would
like
to
be
able
to
optimize
with
respect
to
the
contents
of
immutable
objects.
H
So
I
put
here
as
the
name
new
value,
it's
been
suggested
to
me
that
people
might
not
like
the
name
and
that's
fine,
but
we'll
set
that
aside
for
the
moment
and
I'm
not
going
to
go
through.
All
of
this
in
excruciating
detail.
I
think
I'm
going
to
give
a
sort
of
high-level
like
the
the
highlights
and
then
maybe
we
can
talk
about
it
from
there.
H
H
G
H
H
I'd
like
to
be
able
to
express
for
given
one
of
these
new
value
nodes.
Is
this
something
where
we
don't
care
what
its
identity
is?
If
we
don't
care
what
its
identity
is,
and
that
opens
up
different
kinds
of
transformations
that
are
possible,
we
can
rima
t
realize
it
somewhere
else
by
just
taking
the
values
that
were
inside
and
we're
going
to
box
it
over
here,
because
we
think
it's
going
to
be
better
if
we
box
it
over
here-
and
we
don't
have
an
object
over
here.
H
H
Right
we
could
represent
this
operation
as
an
intrinsic
Col,
which
is
like
a
call
with
a
special
simmer
upon
it.
That
would
possibly
cause
certain
optimizations
to
get
conservative
if
they
see
a
call
or
something
like
that
or
Omar
could
say
well,
amar
doesn't
care
about
this
and
open
gen
I
want
to
have
mutable
objects
up
and
down
and
figure
that.
H
So,
okay,
so
this
off
code,
it's
got
a
variable
number
of
children
and
they
are
different
types.
So
it's
similar
to
a
called
as
a
simmer
phone.
It
says:
here's
the
type
that
we're
allocating
and,
depending
on
what
that
type
is,
it
has
some
field
that
we
will
have
to
know
about
and
I'll
talk
about
that
and.
H
H
There's
no
particular
constraints
on
the
children.
Now
I've
got
here
as
a
sort
of
alternative,
rather
than
having
the
sim
ref
on
the
the
new
value
node
directly
to
say
what
type
it
is.
We
could
have
a
different
simmer
in
there
that
says
whatever
it's
get
new
object
or
something
similar
to
that
you
could
have
a
first
child.
That
says
you
know
here's
how
we're
going
to
specify
the
type.
That's
the
way
that
I
originally
thought
of
this.
H
H
H
G
So
if
I
had
a
load
of
one
of
the
field
in
this
object,
if
they
relying
on
an
underlying
pointer
value,
rut,
store
rights
to
prevent
movement
code
motion
off
the
slope,
otherwise
I'm
in
a
loop
I
see
a
new
value,
actually
a
load
of
a
field
out
of
the
new
value,
pull
it
out
of
the
loop.
It
says
no
aliasing
stopping
me
from
doing
it
right,
but
it's
that
base,
but
you're
someone.
H
G
G
H
H
G
G
D
H
Well,
actually,
I,
don't
think
it
affects
new
itself.
It
affects
the
the
load
adder,
that's
where
those
unresolved
bit
committed,
isn't
yeah,
but
for
the
new
I
believe
it's
just
that
we
do
it's
just
the
GC
sim
GC
point
alias
aliasing,
and
that
would
be
more
easily
here
as
well.
No,
we
would
not
even
well
we
would.
We
would
need
the
GC
point
aliasing,
because
it
is
a
cheesy
point.
H
G
H
How
many
places
in
the
compiler
we
asked
is
new
and
then
expect
the
node
to
look
a
certain
way
and
that
it
might
not
look
exactly
the
way
it
expected
to
look,
and
so
we
could
deal
with
that
by
saying
refusing
to
say
this
is
a
new
or
we
could
deal
with
it
by
finding
those
places
and
changing
them.
It
is
the
balance
is
up
to.
You
know
how
much
work
it
is
from.
H
H
H
A
G
H
I
I
wouldn't
think
that
we
want
to
do
that
in
local
CSE.
We
would
do
that
by
seeing
we
would
end
up
with
a
load,
and
the
child
of
the
load
would
be
we're.
Loading
from
this
object
object
as
a
result
of
new
value
and
because
we're
loading
from
new
value,
we
can
just
pick
up
the
appropriate
child,
and
we're
done
so
simplifier
can
do
that.
Transformation.
Cse
would
like
if
it
got
a
thorough
variable,
then
CSE
would
propagate
the
variable.
Okay.
H
Complement
because
it
can't
replace
the
existing
new,
this
can
only
apply
to
objects
where
we're
constructing
an
object.
That's
an
instance
of
a
type
II
that
is
always
immutable
if
there's
any,
if
we
could
pass
this
to
a
function
and
it
could
be
mutated
like
we
lose
on
visit,
so
it
only
applies
to
immutable
objects
where
we
know,
based
on
the
type
that
it
has
to
be
an
immutable
object.
E
H
H
I
H
I
H
D
H
D
H
D
D
H
H
D
H
F
G
H
A
So
the
idea
of
your
idea
of
a
constructor
has
to
be
changed
to
something
where
the
constructor
runs
before
you've
done
the
allocation
and
the
constructor
all
it
does
is
compute.
Whatever
values
are
going
to
put
into
your
object,
but
the
actual
allocation
of
the
object
has
been
effectively
atomically.
F
C
To
have
code
running
when
the
object
is
being
created,
but
its
values
haven't
been
set,
and
so
how
the
language
is
the
semantics
of
that
may
vary.
But
this
is
a
separate
concept
from
new
in
that
with
new.
The
memory
is
allocated,
but
the
values
have
not
been
written
and
you
can
write
them
at
arbitrary
time
after
the
creation,
whereas
this
is
saying
they're
intrinsically
tied
together
and
if
you
want
arbitrary
control
flow
to
compute
a
value.
C
H
The
way
you
want
to
think
of
it
is
that,
in
order
for
like
the
source
code
to
use
this
feature,
the
the
source
code
does
not
say
make
it
this
thing
and
then
compute
some
values
and
then
put
the
values
in
the
thing.
The
source
code
says
compute
some
values
and
then
make
this
thing
with
the
values
that
I've
already
computed
is.
F
A
byproduct
of
the
file,
that's
really
quite
going
that
causes
the
allocation
to
happen
in
the
middle
and
then
prefer
to
get
cold.
If
you
look
at
the
Java
code
right,
you
can't
do
a
new
X
passed
a
bunch
of
things
which
are
going
to
get
evaluated
before
you
run
the
new.
If
those
things
don't
end
up,
they.
H
I
D
H
H
H
Okay,
what
do
we
got
here?
I
talked
about
symbol
reference
now
because
of
the
the
GC
aliasing.
We
may
have
to
go
with
the
case,
where
it's
an
extra
child
that
specifies
the
type.
That
being
the
case,
we
may
want
to
say
that
that
child
has
to
be
a
load
adder,
and
it
has
to
be
constant
because
we
have
to
know
what
we're
talking
about
will
be
what
yes
little.
F
F
The
symbol
it'll
actually
be
there
like
the
class,
will
actually
be
recognizable
as
immutable
classes,
so
you'll
be
able
to
tell
from
the
class
being
elevated
it's
in
a
beautiful
place,
yeah.
Well,
we
will
be
able
to
tell
from
the
class
I
don't
be
able
to
do
a
new
with
an
arbitrary.
A
new
value
of
an
arbitrary
thing
in
order
to
be
filled
in
as
immutable
is
right.
So.
H
H
So
generally,
it
should
be
the
case
that
if
we
have
a
type
we
can
introspect
on
the
type
and
know
whether
this
is
how
we
want
to
do
the
allocation
in
the
initialization
or
not
I.
Don't
think
we
would
want
any
transformation
in
the
compiler
that
turn
things
that
were
not
already
using
new
value
and
say:
okay.
Well
now
this
is
going
to
become
a
new
value.
I,
don't
think
that
makes
sense,
because
those
are
the
going
to
be
things
into
which
we
were
storing
ends,
and
we.
F
H
H
That
being
a
thing
that
you
should,
okay,
it's
being
a
thing
that
you
shouldn't
have
generate,
doesn't
mean
that
we
have
to
make
it
impossible
to
represent
you,
because
that
may
be
involved.
Now.
Maybe
we
can
expose
a
query
where
the
compiler
can
ask.
Is
this
one
appropriate
for
use
with
new
value
or
not?
And
we
can
assert
on
it
or
something
or
put
that
into
the
aisle
validation
which.
F
H
E
H
H
You
don't
necessarily
want
to
be
generating
code
where
you
use
together
that,
and
you
end
up
with
a
child
per
array
element
for
many
thousands
of
array
elements
and
like
semantically,
that's
sort
of
like
we.
We
would
evaluate
all
the
children
and
put
them
in
the
stack
and
then
we
would
allocate
the
array,
and
then
we
were
so.
H
Yeah,
so
the
idea
is
that
we're
going
to
want
to
contiguously
or
sorry
discontinuously
stack,
allocate
them
basically
anytime.
We
can
tell
what
the
type
is,
because
they
don't
have
identity,
and
this
is
why
so
we
want
this
like
identity
list
or
similar
known
flag
I'd
like
to
represent
that
explicitly,
because
I
don't
think
it
should
be
a
requirement
or
I
think
this.
Some
new
value
is
useful,
even
if
you
do
have
identity
and.
H
H
That
says
we
don't
care
about
the
identity
of
this
thing,
but
all
the
ones
that
we
generate
for
value
types
in
open
j9
will
be
identity
list
in
that
way,
which
means
if
we
have
a
variable,
X
and
we're
putting
a
point
into
X
and
everywhere
we
see
X
we're
putting
the
point
into
it.
We
can
just
completely
eliminate
X
and
replace
it
with
X,
X
and
X.
H
H
Also,
we
can,
we
can
box
them
at
any
point.
So
if
it's
like
it
doesn't
matter
whether
it
escapes
if
it
goes
off
to
this
cold
call
and
we
need
a
value
there,
we
can
allocate
it
right
there
with
the
the
values
of
the
fields
that
right
and
the
thing
too,
is
that
it's
not
like
the
current
HEPA
fication
we're
in
escape
analysis
where
you
have
to
say:
well,
we
have
a
pointer
and
we
don't
know
whether
we
move
to
the
heap
or
not.
You
can
allocate
it
right
there
and
then
throw
it
away.
G
Of
the
common
places
where
contiguous
allocation
happens
is
there's
more
than
one
pop,
very
clear
one
plaster
that
does
this
kind
of
new
value
assignment
to
M
Eclipse,
with
another
boxes
for
something
else,
as
you
see
when
you
do
emerge,
when
you
go
into
is
e
an
interval,
something
for
from
you
t
is
nothing
I'm,
not
Luke.
Envelope,
arts
object.
In
that
case,
you
need
to
keep
it
whole
in
the
conventional
sense
I'm
dealing
with
in.
You
could
often
feel
like
yeah.
C
H
G
G
H
So
I
guess
this
is
at
least
partly
tangential
because
I'm
not
trying
to
propose
a
method
of
doing
the
scaler
ization
at
the
moment,
but
it
would
be
sorry
but
okay
you're
not
proposing
a
method
yeah,
but
I,
see
that
it
relates
to.
How
would
you
represent
a
stack
allocation
that
was
contiguous?
If
you
had
to
do
one
and
I
mean
strictly
speaking,
we
don't
ever
have
to
do
one,
you
know.
So
it
depends
on
the
balance
of
right,
but
like
may
have
to
do
one
and
it
did
one
today
without
so
no.
H
G
H
G
H
C
A
H
H
We
initialize
each
field
with
corresponding
child
value
and
that
that's
what
it
does
so
I
think
I
hope
it's
a
relatively
straightforward
concept
at
the
point.
If
we
have
a
weak
memory
model,
community
memory,
fences
to
make
sure
that
we
don't
allocate
and
then
initialize
and
then
publish
the
thing
and
then
the
another
credit
can
see.
If
then
see
the
uninitialized
field.
H
So
how
will
it
be
handled
by
the
optimizer
it's
sort
of
expected
to
aid
in
the
ways
that
I've
described
for
optimization,
if
you're
using
it?
It's
pretty
likely
that
you're
going
to
see
loads
of
fields
and
you're
going
to
be
able
to
do
something
with
them
in
terms
of
all
the
backends
backends?
One
I
need
to
concern
themselves
with
this,
because
we're
going
to
do
lowering
and
it
does
not
require
any
specific
machine
instructions
or
anything
like
that
sure
lower
to
what
so
that
is
just
a
bit
first
down
and
the
issue
here.
H
H
And
for
each
one
we
need
to
know
at
least
the
offset
and
the
data
type
and
then
that
we
can
recognize
corresponding
load
right.
We
can
also,
if
we
know
that
information
we
can
generate
the
stores
that
we
have
to
actually
do
at
runtime
to
affect
the
initialization
right.
So,
of
course,
I
say
there
are
no
stores
and
that's
true
in
the
form
of
the
il
that
is
using
new
value,
and
we,
you
can
do
all
the
optimizations
in
order
to
implement
this.
H
H
But
we'll
want
to
do
that,
based
on
the
type
information
that
we've
gotten
from
the
product.
Specific
query
to
say
tell
me
the
type
of
information,
so
we
say
it'll
tell
us
that
there
is
X
at
plus,
8
or
something
and
then
given
that
we
have
X
at
plus
8,
which
is
a
float.
Give
me
a
simple
reference
for
this.