►
From YouTube: OMR Compiler Architecture Meeting 20180523
Description
Compiler Architecture Meeting agenda:
* Develop a specification for TR IL [ @0xdaryl ]
Please add any comments/questions to the GitHub agenda issue: https://github.com/eclipse/omr/issues/2570
A
Okay,
so
welcome
everyone
to
compiled
architecture
meeting.
So
today's
topic,
we
only
have
one
one
topic
on
the
agenda.
It
is
to
talk
about
the
developing,
a
specification
for
the
Testarossa
intermediate
language.
So
this
is,
you
know
the
it's
really
sort
of
the
lifeblood
of
of
the
compiler
technology.
It's
the
you
know.
It's
been
in
existence
for
probably
18
19
years
now
and
without
any
sort
of
real
specification
behind
it
other
than
what
the
the
Java
technology
sort
of
dictated
it
does.
A
So,
whatever
Java
did
that's
sort
of
what
the
practice
actually
was,
but
I
think
that,
now
that
there
are
technologies
other
than
Java
starting
to
consume,
Omar,
it's
it's
probably
time
to
actually
start
to
formalize
it
a
bit
more
and
to
put
some
rules
around
around.
You
know
how
the
trees
are
structured
with
the
semantics
of
the
various
file.
A
So
so
what
I
did
was
I
started
a
sort
of
an
epic
issue
here
in
in
the
eclipse
of
our
project,
2569.
If
you
want
to
bring
that
up
and
follow
along
I'm,
not
going
to
bring
it
up
on
the
screen
right
now,
because
I
want
to
take
some
notes
as
we
as
we
go
through
this,
but
feel
free
to
bring
that
up
and
follow
it
through.
A
But
in
there
I
threw
down
some
basic
ideas
of
the
thing
that
I
think
that
we
need
to
cover
in
developing
this
specification.
What
I
was
hoping
to
accomplish
today
was
to
really
sort
of
introduce
this
idea
and
to
collect
input
from
everyone
on
on
really
it's
sort
of
a
brainstorming
session
on
whether
or
not
you
think
this
is
a
good
idea.
A
If
you
don't
think
it's
a
good
idea,
why
don't
you
think
it's
a
good
idea
and
what
kinds
of
things
do
you
think
should
should
make
up
the
specification
for
the
il,
and
perhaps
we
can
start
talking
through
up
some
of
those
things.
I
certainly
expect
that
this
is
going
to
be
a
fairly
large
undertaking,
and
it's
not
one
thing.
That's
going
to
give
it's
not
going
to
get
done.
A
I
think
that,
just
following
down
the
points
that
I
have
in
that
in
that
issue,
I
think
that
one
of
the
first
things
that
that
needs
to
happen
is
to
provide
some
kind
of
a
definition
as
to
what
the
compiler
technology
thinks.
The
sinks
in
isle
actually
is
what
it's
attempting
to
achieve
and
understand
what
the
different
components
of
that
aisle
actually
are.
So
without
giving
a
huge
amount
of
thought
to
it.
The
parts
that
I
came
up
with
were
treetops
nodes,
the
actual
aisle
opcodes
themselves,
symbols
and
symbol.
A
References
for
describing
you
know,
references
to
memory
and
block,
which
is
one
that
mark
wanted
to
add
to
this.
So
that
was
basically
my
understanding
of
or
my
very
quick
under
understanding
of
that
anything
that
anybody
wants
to
bring
up
there.
If
you're
going
to
put
blocks
in
I,
think
you're
going
to
need
the
CFG
as
well
right.
The
notion
that
you
have
a
block
the
control
flow
graph
is
sort
of
intimately
connected
with
that
right.
B
B
A
C
C
A
That
CFD
is
required
simply
because
of
simple
fire.
You
won't
know
the
target
of
an
exception,
throw
so
if
you,
if
you
are,
if
you
are
using
the
throw
opcode
to
know
if
there,
what
catch
handler
that
will
throw
or
how
it
will
leave
the
method
requires
that
is.
You
won't
have
enough
information
to
reconstruct
that
yeah.
C
A
A
A
B
A
A
Some
particular
semantics
may
be
dependent
on
how
the
code
generators
forgiving.
We
interpret
a
particular
plank
one
that
comes
to
mind
just
as
an
example
for
the
purposes
of
framing
the
discussion
would
be,
if
you
Marcus
ever
remember
all
the
time
exactly
what
fences
your
languages
memory
model
requires
and
what,
how
you
flush
and
when
you
flush,
and
that
kind
of
thing
may
vary
between
implementation.
Now,
there's
some
implicit
meaning
about
it,
but
there's
going
to
be
some
there's
some
wiggle
room
there.
Similar
kind
of
thing
would
be
like
a
write
very
early.
A
When
does
when
do
you
have
to
admit,
write
barriers?
What
do
write
barriers
report?
Well,
they
they
capture
the
notion
that
you
need
to
inform
somebody
about
a
particular
store
with
some
particular
metadata.
At
the
moment
they
have
a
current
set
of
semantic
meaning
in
the
context
of
open
j9g
system
from
omar,
fine,
conceptually
with
a
different
garbage,
collector
or
a
different
language,
they
may
serve
a
related
button,
semantically
slightly
different
purpose
right.
You
might,
rather
than
just
reporting
references
to
the
nursery
added
to
the
ten
year.
A
C
B
B
A
B
C
A
C
A
It's
not
necessarily
specified
is
really
what
the
sizes
of
these
different
types
actually
are
right.
What
is
the
actual
size
of
an
integer,
and
is
that
something
that
we
should
do
as
part
of
this
effort
to
really
make
it
consistent
across?
So
everybody
knows,
you
know
other
we're,
calling
it
an
int
or
who
knows.
Maybe
we
should
actually
call
it
a
32-bit
or
an
I-32
versus
another
patent
on
it,
so
that
up
there
I
think
large
amounts
is
the.
G
B
A
A
So
yeah
that
mean
that
is,
it
depends
on
what
you
were
taking
the
address
of.
So
the
question
is:
how
do
we
actually
handle
that?
Do
we
need
to
introduce
another
address
type
to
the
like
a
variable
address
space
or
a
compressed
address
type
very
well.
The
notion
actually
are
all
kind
of
exists
in
the
current
implementation
that
we
know
if
a
given
address
is
a
collected
or
uncollected
reference.
A
The
choice
of
when
a
compression
or
decompression
operation
takes
places
more
left
the
code
generators
of
the
present
Tyler
constraint
so
that
when
it
has
to
happen,
there's
freedom
of
maneuver
about
when
the
compressed
representation
needs
to
be
decompressed,
for
example.
So
is
that
a
property
of
a
symbol
by
no.
C
A
However,
with
the
addressed
conversion,
so
the
fact
that
you
can
take
an
address
and
then
convert
it
to
an
integer
type
and
then
back
to
an
address.
The
notion
of
whether
an
address
is
a
collected
reference
or
not
has
to
be
computed
across
the
tree.
Like
you
have
to
look
at
the
children
to
know
you
have
it
for
an
address
type
dog
code.
A
You
have
to
look
at
the
address
child
of
that
address
type
opcodes,
only
a
memory,
indirect
operation
or
an
address
relative
operation,
the
collectiveness
of
the
address
being
on
the
child,
and
that
is
not
simply
a
function
of
the
sim
race
at
the
bottom
of
that
chain.
But
the
conversion
operations
that
appear
underneath
or
the
huge
piece
of
work
done
by
lacuna
on
that
to
make
that
consistent,
so
that
we
could
decide
it.
F
C
B
A
C
B
B
B
A
C
A
I'm
not
sure
how
much
we
actually
want
to
define
what
an
aggregate
means
is
part
of
a
specification,
because
but
that's
something
that
we
could
go
down
that
path
that
we
wanted
to
actually
provide.
It
will
provide
more
information
about
that
and
how
they
should
be
used.
I
think
it's
more
of
a
function
of
how
much
does
the
optimizer
or
other
components
within
omr
examine
that
data
type
and/or
manipulate
those
data
values
right
if,
if
for
the
most
part
they
just
sort
of
Whittle
through
mostly
unaffected,
then
it
can
be
left
more
loops.
D
A
A
I
mean
that's
fairly
well
baked
into
PRI
l.
There
are
examples,
I'm
looking
what
Mark
was
getting
to
and
is
about
versus
the
vector
op
codes
that
are
basically
typeless,
but
very
fine,
one-time
business,
but
yeah
we're
the
way
that
TRL
is
evolved
is
really
good,
put
the
be
signed
or
unsigned
this
on
the
actual
code
itself.
A
B
To
speak
to
the
current
occurring
notion,
yeah
and
I
also
think
that
the
deduplication
of
otherwise
completely
redundant
operations
is
a
very
good
thing.
We
don't
need
to
ads
and
to
subs
and
to
constants
and
billing
things
like
that
yeah
to
molt
moles.
Well,
though,
we
do
need
to
mole
ages,
but
that's
fine,
yeah.
C
C
A
C
B
B
C
A
A
We
did
take
a
shot
at
defining
what
some
of
these
means
and
how
and
when
to
actually
use
them.
There
actually
is
a
document
that
that
was
added
to
the
eclipse,
Omar
codebase,
leonardo
wrote
that
takes
at
least
an
attempt
at
describing
what
these
actually
do.
We
may
need
to
expand
on
that
a
little
bit.
D
A
Okay,
so
I
guess.
The
next
thing
is
to
actually
start
to
define
how
the
trees
are
actually
structured
and
what
the
rules,
what
rules
are
in
place,
for?
What
is
a
well-formed
tree,
actually
looks
like
what
are
the
rules
are
putting
together?
Trees
is
Earth
what
it
would
do,
but
what
can
be
in
a
tree
table?
You
know
what
what
kind
of
side
effects
can
they
have?
You
know
there's
be
a
lot
of
cycles.
A
C
G
C
A
Okay,
you
know
the
other
one
would
be
passed
through
news
when
they
are
allowed
to
be
generated
when
they're
allowed
to
exist.
There
are
a
lot
of
parts
of
the
optimizers
that
are
surprised
if
they
arrive
in
various
places,
they're
expected
to
disappear
relatively
quickly.
They
exist
for
a
purpose,
but
they
don't.
B
A
Before
we
jump
to
the
notion
that
we
have
to
handle
arbitrary
pastors,
there
may
be
information
complexity
of
the
optimizer
to
be
able
to
handle
them
in
a
large
number
of
arbitrary
places.
So
I
think
we
need
to
be
careful
saying.
Well,
we
shouldn't
have
restrictions
about
them.
I
think
that
there
are
some
care
needs
to
be
taken.
A
We
may
need
to
define
some
sense
of
normalization
or
when
they
are
allowed
to
exist,
because
dealing
with
arbitrary
chains
of
passed
through
nodes
in
the
middle
of
all
kinds
of
places
can
become
extremely
complex
for
some
of
the
thoughts
that
are
operating
in
the
optimizer,
but
I
think
the
node
exists.
It
has
a
purpose
it
in
the
places
where
it's
introduced.
A
It's
generally
cleaned
up
at
some
point
in
relatively
close
proximity
to
that
part
of
a
transformation
I
think
some
study
of
those
uses
is
probably
warranted
and
then
some
guidance
on
how
they're
supposed
to
be
used
is
warranted.
I
I'm
not
generally
in
favor
of
allowing
arbitrary
change
of
meaningless
nodes,
because
it's
been
of
me
some.
B
What
I
would
say
is
that
there's
a
difference
between
the
complexity
is
old
or
not
falling
over
when
presented
with
something
and
the
complexity
involved
for
doing
a
good,
optimization
job
when
presented
with
something
and
the
operation
represented
by
pasture
node,
is
the
simplest
possible
operation
that
we
have
so
it's
a
bit.
Yeah
I
mean
if
we
can't
not
crash,
for
example,
okay,
I
I.
A
Agree
with
the
I
agree
that
we
shouldn't
crash,
however,
I
think
some
guidance
for
those
uninitiated
to
the
internals
of
this
rather
complex
compiler
on
how
they
are
used
when
they
are
used,
and
the
problems
of
leaving
them
in
the
il
for
a
long
period
of
time
is
something
that
will
be
helpful
to
people
that
are
new
to
this
representation.
We
is
that
the
node
is
there
and
the
uses
is
not
immediately
apparent,
I,
don't
think
from
it.
C
There
is
a
to
add
to
a
point:
there
is
a
bit
of
a
variability
in
how
it
gets
used
as
a
context
in
which
get
just
kept
used
as
here's
something
to
stop
it
on
to
the
child
and
there's
nothing
inherently
being
represented
by
a
pass
through
itself.
And
then
there
are
other
context
of
the
pass.
Truth
does
have
some
state
associated
with
it
already.
C
C
C
A
side
effect,
we
call
is
a
side
effect,
having
rules
around
what
is
allowed,
how
many
side
effects
are
not
in
a
tree
is
one
thing,
but
then
the
other
aspect
of
it
which,
because
the
trees
are
really
dying,
and
you
can
have
a
node
being
referred
to
from
two
different
parents,
where
the
value
of
memory
location
changes
in
between
the
two
uses
right.
That
notion
is
always
something
that
trips
top
people
early
on
and
with
plans
of
this
node
evaluated
under
that
parent
could
get
a
different
value
to
evaluate
it
under
this
parent.
B
Sort
of
it's
not
ambiguous,
it
would
just
require
codifying
that
yeah
that
it
gets
evaluated
here
and
then
later
it's
already
been
evaluated.
If
you
have,
the
same
value
now
also
affects
what
the
side
effects
appear,
because
the
calls
can
have
a
return
value
and
then
they
appear
later
and
they
had
better
not
get
evaluated
again.
But
yeah.
A
It's
the
so
legging
the
evaluation
workers,
typically
driven
or
the
evaluation,
is
really
driven
by
the
the
code.
Generator
and
I
know
that
we've
we've
been
tripped
up
many
times
in
the
past
by
code
generators,
doing
certain
tricks
to
try
to
avoid
generating
a
register
or
a
store.
That
kind
of
thing
in
the
code.
I
wonder
if
we
should
put
some
rules
around
perhaps,
but
it's
getting
we're
saying
there
was
just
put
some
rules
around
the
actual
order
in
which
you're
allowed
to
do
evaluation
and
what
is
defined.
F
C
A
So
I
mean
other
than
I
give
you
you.
We
talked
a
little
bit
of
a
pastor.
Are
there
any
other
sort
of
very
special
kind
of
nodes
that
they
need
extra
consideration
like,
for
example,
jail,
reg
debts
which
have
perhaps
different
semantics,
not
the
they
have
different
slightly
different
meanings
depending
on
the
copis,
depending
on
the
back
end.
That's
actually
because
they're
being
consumed
in
I
think
we.
D
C
Showing
the
result
check
especially
result
results
check
is
interesting
from
multiple
angles.
One
the
child
of
the
result
check,
while
appearing
to
be
a
load,
could
actually
result
in
a
call
happening
at
that
point.
If
you
are
loading
a
class
with
run
a
class
initializer,
which
was
an
arbitrary
code,
but
the
result
check
can
also
be
merged,
with
a
null
check,
for
example,
Solomon
or
check
those
kinds
of
the
both.
At
the
same
time,
combinations
are
relatively
rare
in
the
compiler.
A
Okay,
so
we're
talking
about
tree
formation
rules,
and
we
also
think
that
blocks
and
CFG
should
be
part
of
this
I
think
that
the
rules
around
out
when
you
can
extend
blocks
and
what
they
look
like
and
how
do
you
form?
What
does
this
DFG
actually
look
like
you
know
the
rules
around
how
those
are
our
candy
form
well,.
A
B
D
C
C
A
B
H
Difficulties
again
like
oh
whenever
I
say
somebody,
you
need
to
explain
the
basics,
I
always
charges,
you
know
their
totals
and
they
have
for
side
effects.
Powerful
effect
reason.
Hp
is
have
side
effect.
The
children
will
achieve
don't
too
important,
but
then
just
fine,
as
you
encountered
business
with
a
store
under
it,
I
find
it's
very
confusing.
Again.
You
can
have
store
the
channel
you.
Maybe
they
should
either
fix
it.
Oh
because
I
really
use
it.
C
May
or
may
not
be
flexible
in
certain
cases,
you
can
have
a
null
check,
for
example,
with
a
store
under
it,
and
while
you
would
separate
those
two,
it
would
largely
be
suboptimal.
I
mean
the
null
check
is
being
done
as
part
of
the
indirect
store
those
cases
so
move
generally,
is
that
you
put
the
other
in
direct
access
under
the
null
check,
and
in
that
case
the
indirect
access
happens
to
be
sort
of
similar.
Things
are
true
for
unresolved
as
well.
C
C
H
For
you
didn't
yeah,
but
are
you
for
the
side
effects
and
and
Melissa
you
right
now,
checkers
or
chicken?
They
do
special
builders
and
go
parties.
We
always
picked
it
up,
because
our
reputation
has
been
likes
to
check
all
children
for
side
effects
or
not
so
there's
already
a
jury.
Doesn't
the
window
special
to
me
as
general.
This
is
an
exception.
A
We've
run
into
some
issues
recently
with
some
of
the
forty
points
with
some
floating-point
code.
Their
job
is
expecting
certain
behavior
to
occur
with
not
a
numbers
but
speed
as
something
different,
so
we
need
to
kind
of
you
know,
standardize.
What
we
wondered
is
one
what
I
want
to
do
forward
with
that?
I
would
say
that
we
need
to
be
a
little
careful
about
that,
because
different
languages
will
have
different
selling
point
rules.
C
A
I
don't
know
if
I
feel
strong
enough
to
be
able
to
say
that
I
feel
that
at
the
moment,
but
I
guess
what
I'm
saying
is,
is
that
some
people
and
I
certainly
have
fallen
into
this
bucket.
At
various
point,
you
know
fielded
said:
oh
well,
you
know
the
floating-point
operation,
you
know
should
be
just
defined.
C
A
They
handle
particular
kinds
of
numerical
semantics
thinking,
particularly
of
some
of
the
APL
based
languages.
Like
are
things
like
that,
where
the
particular
mathematical
properties
of
the
representations
are
very,
very
important
to
that
community.
If
we
are
overly
strict
in
the
definition
in
OMR,
we
may
exclude
certain
potential
users
because
they
find
it
impossible
to
express
the
semantics
that
they
require.
So
I
think
we
need
to
while
I
agree.
E
B
A
The
thing
like
we're
going
through
this
exercise,
right
now
of
of
adding
to
loading
points
more
more
fooling
point,
optimizations
to
the
tip
to
the
optimizer
right,
X
simplifier,
about
a
propagation
I
guess
in
those
particular
circumstances
right
we
want
to
be
able
to.
We
do
want
to
be
able
to
do
some
kinds
of
effects.
Folding
operations
on
on
on
floating
point
values,
but
it
also
needs
to
be
able
to
act.
C
B
And
it
is
likely
there
are
variable
things
like
around
these
strange
values
that
we
get
in
and
I
Triple
E,
but
then
also
things
like
can
I
sort
of
it
with
air
quotes
here.
For
those
who
can't
see
me
incorrectly,
assume
associativity
here
can
I,
you
know,
ignore
those
cases
in
this
context
can
I
can
I
use
extra
precision
can
I
turn
this
into
a
fuse
multiply
ad,
which
sort
of
and
all
kinds.
A
C
Poulet
struck
me
as
a
bit
odd
how,
when
you
have
to
fold
to
floating
point
of
a
fold
of
code
for
a
find
operation
away,
because
you
know
that
it's
on
two
constants
compiler
can't
or
do
it
on
its
own.
It
has
to
ask
front-end
to
do
it
on
its
behalf,
right
which
in
this
world
up
tell
me
what
does
our
cord
means
right
and
then
one
of
our
context
could
be
the
position
that
someone
takes.
There's
no
asking
anybody
else.
C
C
A
I
mean
if
there
could
be
alternative
design
points
that
could
be
considered
where
we
have
Bomar
has
a
standard
model
that
it
uses,
but
we
are
clear
that
there
are
ways
to
opt
out
of
that
standard
model.
If
you
want
different
semantics,
if
your
code
Jen
will
do
different
semantics
and
you
don't
want
the
Omar
to
mess
with
those
things,
then
you
can
tell
us
or
tell
us
the
subset
of
things
that
you
don't
know.
A
Okay,
so
in
the
in
the
in
the
issue
here,
I
just
very
quickly,
you
sort
of
categorized
a
variety
of
different
codes
into
in
various
different
categories.
That's
spina,
where
you're
diagnosed
by
no
means
a
complete
list
and
probably
a
lot
of
stuff
scale
problems
of
the
miscellaneous
category,
but
anyways
that
when
it
comes
time
to
documenting
I,
think
it
would
be
interesting
to
line
up
codes
up
under
under
those
kinds
of
categories,
but
I
think
I
feel
have
already
brought
up.
A
C
A
C
D
C
H
D
C
G
C
D
D
A
A
And
there
are
other
places,
I
think
in
open
j9
that
would
care
about
it.
Yeah
I
there
are
either
are
going
to
be
op
codes
that
are
found
that
have
a
many
varied
assorted
history
around
how
they've
been
used
and
are
not
beautiful
things
that
we
wish
to
codify,
and
we
may
just
call
there
may
need
to
be
a
this
is
deprecated
and
we're
going
to
define
the
new
set
of
op
codes.
A
G
A
C
Although
then
artist
point
was
a
good
one,
I
guess
in
that
who,
after
the
cleanup,
those
that
problem
ceases
to
exist
in
the
code
base.
But
someone
may
be
on
a
version
of
the
code
base
that
still
has
yes,
five
child
Anna
Street
Calvary
copy,
in
which
case
they
would
have
to
shave
the
dock
petition
than
that
I.
A
Certainly
think
that
when
we
make
one
of
those
transformations
we
can
say
what
it
is
that
we're
doing,
but
I
think
that
the
the
top-level
specification
and
documentation
should
just
call
out
that
this
is
that
you
shouldn't
use
it's
deprecated.
If
you
have
used
it
in
the
past,
you
can
find
out
the
gory
details
here,
but
that
is
only.
G
E
G
Difficult
it
kind
of
causes
the
number
of
cases
that
have
to
be
handled
to
grow
pound
rather
unpleasantly,
and
it
just
really
creates
a
mess
for
things
like
the
dev
check
and
null
check
I'm
not
too
off
the
top
of
my
head.
I,
don't
really
see
a
problem
with
introducing
ones
that
have
similar
behavior,
but
I
would
like
to
see
very
clear
reasons
why
we
would
want
that
so
I
conducted.
A
Yeah
I
think
calling
out
the
pain
and
then
I
think
it's
going
to
be
difficult.
It's
going
to
be
difficult
to
different
sort
of
guidelines
around
the
kinds
of
exceptions
that
we
want
to
know
about
the
rule,
but
I
think
we're
going
to
have
to
kind
of
deal
with
it
case
by
case
and
I.
Think
discussing
it
in
a
forum.
C
B
We're
stuck
with
that
one
at
least
four
calls,
but
there
at
least
we
might
we
want
to
say:
let's
please
be
trying
to
avoid
doing
this,
and
then
you
can
look
at
things
on
a
case-by-case
basis.
If
people
don't
know
to
try
to
avoid
doing
that,
then
it
sort
of
becomes
like
did
somebody
who
was
thinking
about
this.
Look
at
it
out
of
time,
I.
A
E
Unit,
so
I
was
thinking
that
we
should
decide
whether
we
want
the
aisle
to
be
expensive,
edible
by
third
parties,
whether
that
make
sense
or
not,
because
what
we
have
now
is
is
some
of
the
opcodes
are
in
j9
and
some
tamari
Omar
and
as
it
stands,
we
have
a
lot
of
code
in
Omar
that
this
test
j9
because
very
hard
to
deal
without
codes
that
are
defined
elsewhere.
How
do
you
want
that
to
remain?
E
D
A
While
that
may
be
well,
that
is
a
valid
position.
I
think
that
the
fact
that
you
are
going
to
have
common
optimizations
makes
it
very
difficult
to
introduce
a
lot
codes
with
radically
different
semantics,
because
they're,
what
if
a
naught
optimization,
is
going
to
inspect
the
intermediate
representation
and
try
to
make
even
conservatively
correct
assumptions
about
what
to
do.
If
you
have
a
node
or
an
opcode,
that
has
a
behavior.
That
is
a
radical
departure
from
the
way
that
op
codes
are
structured
and
how
things
operate.
A
It
will
be
very
difficult
to
ensure
that
every
optimization
will
be
conservatively
correct
according
to
whatever
it
is
that
you
define
it's
going
to
be
very
hard
to
define
optimizations.
That
will
work
in
general
if
the
current,
beyond
which
it
must
work,
varies
and
significantly
it's
going
to
vary.
Do
that
I.
B
B
A
A
A
C
A
C
E
C
Don't
care
about
optimization
I
just
wanted
to
get
through
the
other
extreme
is
I,
wanted
I'm,
introducing
the
barcode
and
magically
lots
of
simplifications
or
hoisting,
and
all
those
traditional
things
I
want
those
things
to
happen
so
which
camp
are
you
in?
What
is
the
specifics
of
your
opcode?
How
abnormal
protein
code
is?
It
are
all
difficult
to
reason
about
in
generalities.
I
think
you
do
need
break
it
down
a
bit
more
and
if
discussing.
H
A
Think
there
is
yeah,
I
mean
I,
mean
I
thought
up
value
in
extension,
but
I
think,
as
in
Jay
said,
I
think
you
know,
there's
it's
a
separate
discussion
on
its
own
and
requires
a
separate
considered
like
once.
We
have
a
notion
of
what
our
final
semantics
are
and
what
the
rules
are.
I
think
we
will
be
in
a
better
position
to
discuss
how
extension
could
fit
into
that
framework.
Maybe.
C
A
C
G
A
You
there's
a
funny
Beach
going
on
here.
We're
going
to
figure
out.
What's:
what's
happened,
okay,
so
aliasing
defining
of
I.
Think
there
is
a
you
know.
There
is
a
role
for
a
lien
for
at
least
defining
the
aliasing
within
the
conflict.
Since
we're
talking
about
symbols
and
symbol,
references
I
think
there
is
a
role
for
aliasing
as
part
of
the
specification
here.
A
You
know
this
technology
I
think
does
have
a
different
set
of
terminology
in
some
cases
that
it
uses
when
we're
talking
about
aliasing
and
perhaps
the
different
slightly
different
set
of
rules
in
some
contexts
as
well.
I
know
that
there's
there
are
those
that
are
wanting
to
use
this
technology
that
are
interested
in
learning
more
about
aliasing,
and
it's
it's
somewhat
unspecified
at
this
point,
how
it
all
works
without
actually
diving,
very
deep
into
the
code.
A
G
C
Yeah
I
would
probably
agree
in
spirit
with
what,
in
order
just
that
as
well,
everything
is
another
one
of
these
things
that
varies
significantly
language:
the
language
to
draw
parallels
with
other
things
that
we
discussed
in
this
meeting-
it's
not
built
by
the
I'll
gem.
It
is
invalidated
regularly
and
rebuilt.
It's
mostly
used
to
do
optimizations
I,
don't
believe,
but
beyond
I,
don't
believe
you
need
anything
to
generate
code.
C
You
could
just
go
ahead
and
generate
code
from
the
trees
that
you
have
and
now
it
still
be
correct.
You
eat
the
notion
of
it
unless
you're
doing
an
optimization,
but
that
then
takes
it
very
much
into
the
kind
of
domain.
That
structure
was
right,
like
an
optimization
that
having
structure
permits
optimizations
are
permitted
by
having
aliasing.
So
is
it
an
essential
part
of
the.
E
C
What
the
queries
mean
maybe
are
possible
to
standardize
on
without
getting
into
the
specifics
of
the
language,
but
whether
that
needs
to
be
made
part
of
the
il
or
not
is
a
different
question.
But
it
does
need
to
be
documented
in
some
way,
perhaps
under
its
own
banner.
If
I'm
long-winded,
Li
I'm
saying
that
I'm
not
sure
if
it
belongs
under
the
Iowa
banner,
but
it
definitely
deserves
documentation
and
treatment
along
the
lines
as
Bernardo.
A
So
this
is
the
sort
of
notion
that
we
we
do,
keep
some
kind
of
a
version
numbering
system
with
with
the
il
so
that
it's
potentially
comparable
like
this
particular
opcode
was
introduced
in
version
two
point:
eight
point,
four,
that
kind
of
thing
it
could
potentially
go
in
lockstep
with
the
people
amar
release.
This
is
better
that
are
going
to
be
coming
in.
Perhaps
that's
perhaps
that's
the
way
to
actually
do
it
is
to
actually
have
it
version
with
respect
to
that,
as
opposed
to
having
its
own
independent
versioning.
B
Know
that
it
would
need
its
own
versioning
unless
we
provide
a
physical
and
it's
somehow
like
if
we
had
some
format
for
serializing
or
syntax
or
something
where
we're
in
right
like
that
might
be
something
where
you
would
necessitate
a
version,
but
otherwise
I
guess
the
aisle
as
a
version
of
Omar,
is
about
as
specific
as
it
could
possibly
need
to
be.
I.
A
Guess
trill
would
have
to
be
kept
like
the
version
of
trill
would
have
to
like
the
closest
thing
we
have
to
serializing
il
at
this
point.
That's
true
so
I
guess
there
has
to
be
some
kind
of
a
connection
there,
but
if
and
whether
or
not,
but
even
then
you
could
still
go
with
the
the
the
verse
does
exist.
The
release
of
Omar
like
if
we're
doing
monthly
releases,
which
is
what
the
expectation
is
it's
going
to
be
fairly
regular.
So.
G
I
think,
even
with
something
like
trill,
if
we
consider
treadle
to
be
part
of
the
OM,
our
project,
presumably
trill
will
be
updated
at
the
same
time
as
the
IL
is
updated.
So
there
would
never
be
a
case
where
they
get
out
of
sync.
If
assuming
we
do
things
correctly,
in
which
case
even
then,
there
is
not
really
a
need
for
the
two
to
have
different
version
numbers
and
I.
E
G
A
A
A
Okay,
okay
and
then
I
guess
the
last
point
that
I
just
wanted
to
raise
on
this
first
call
was
around
I,
guess,
we've
kind
of
touched
on
already.
It
was
around
I,
guess,
testing
and
validation
and
sort
of
the
need
for
having
some
mechanism
for
ensuring
that
the
whatever
specification
we
we
end
up
coming
up
with
is
met
by
the
code
that's
being
or
bought
by
the
dial
that's
being
produced.
So
you
know
this
is
getting
into
creating
test
cases
with
trill.
Perhaps
we've
started
work.
A
G
B
Right,
I
think
it
would
be
good
to
be
able
to
generate
some
aisle
and
just
run
an
optimization,
so
run
this
optimization
pass
and
then
I
want,
to
you
know,
inspect
certain
properties
of
the
output
code
and
probably
I
want
to
run
it.
Maybe
I
go
to
two
Co
gen
part
of
the
thing
there
is
that
it's
going
to
depend
on
what
code
gen
does,
which
is
sometimes
quite
fancy
itself,
so
there
might
be.
It
might
make
sense
to
have
something
like
can.
We
just
go
and
interpret
this
il
using
the
simplest
possible
strategy.
B
Right,
great
and
then
you
could
have
you
could
have
like
the
interpreter
could
be.
You
know
something
that
clearly
matches
the
back
and
then
you
can,
you
could
say,
take
some
il.
You
know
what
it's
supposed
to
do
and
you
can
see
that
we
know
that
it's
supposed
to
do
that
and
then
you
can
run
it
through
code
gen
and
see
that
it
still
does
that
or
that's
where
you
could
sort
of
detect
mismatches.
That
way.
C
Interpreter
and
whatever
the
cases
in
which
a
drill
interpreter
will
be
needed,
as
opposed
to
just
saying
kids
on
sir
I
expect
you
to
get
when
you
do
this
operation
I'm,
giving
you
a
concept,
this
is
on.
So
you
get
the
answer.
You're
good!
You
don't
get
it
you're,
not
right
that
doesn't
require
I'm
an
interpreter
rap
in
the
traditional
sense.
It
just
involves
a
person
writing
the
text,
all
right,
I,
just.
B
B
G
B
G
C
So
the
out
the
talking,
what
cases
when
the
output
could
be
a
pattern
in
the
il
and
are
not
getting
mired
in
specifying
that
pattern
to
check
for
as
the
output
from
the
test,
because
if
the
pattern
changes
slightly,
then
this
case
gets
broken.
Instead,
if
you
had
an
interpreter
which
was
able
to
tolerate
mild
variations
that
are
ultimately
boil
down
to
the
same
answer,
semantically,
that's
preferable
for
that
reason
that
it
would
be
able
to
accommodate
those
mild
page,
but
that
a
fair
summary
lynard
yeah.
B
D
B
C
A
A
Okay,
so
I
solving
this,
like
a
start,
I
think
what
the
next
steps
here
are
to
start
to
break
this
down
into
smaller
tasks
and
and
start
to
make
a
bit
of
progress
on
defining
some
of
these
things.
So
I
certainly
will
have
a
look
at
the
paper
that
that
Vijay
mentioned
and
see
how
we
can
incorporate
parts,
that's
as
appropriate
into
any
zero
documentation
that
we
have.