►
From YouTube: OMR Compiler Architecture Meeting 20190509
Description
Agenda
* TR::intrinsic IL opcode draft (#3826) [ 0xdaryl ]
A
A
I
also
wanted
to
take
this
opportunity
to
try
out
the
new
aisle
opcode
template
that
we
had
talked
about
in
which
there's
a
PR
that
I
need
to
get
merged,
which
actually
creates
it.
I'm
kind
of
glad
I
did
that,
because
there
there
are
a
couple
of
rough
spots
with
some
with
the
way
that
you
would
write
one
of
these
following
that
template,
so
that
does
burek
there.
Oh
gosh
yeah,
that's
the
one
that
it
created
my
own
brand.
It
created
the
branch
for
me
yeah,
that's
the
one.
A
Doesn't
produce
it
so
my
definition
of
an
intrinsic
is
some
kind
of
side
effect
free
operation
that
we
want
to
basically
get
through
to
the
back
end,
so
such
that
they
can
be
turned
into
either
a
single
instruction
or
a
sequence
of
instructions.
You
have
an
example
of
something
that
side-effect
free,
that
you
would
use
it
for
right
now.
A
Well,
there
are
dozens
of
opcodes
in
OMR
that
are
basically
mapped
to
arithmetic
operations
like
double
exponents
or
sine
cosine,
that
sort
of
thing
that
that
basically
lives
until
the
back
end
and
which
our
back-end
actually
implements
an
equivalent
for
so
you
know,
Omar
alone,
there's
about
a
hundred.
You
can
probably
find
more
if
you
scrutinize
the
tables
of
it
so
I'm,
hoping
that
a
lot
of
those
could
get
collapse
down
into
an
intrinsic
opcode,
a
single
intrinsic
opcode
I'm.
A
A
Reference
suggests
that
you
can
have
a
side
effect,
but
it
does
not
mean
that
you
do
write
it
down
to
the
aliasing
set
associated
as
the
symbol
reference
right,
so
I'm
a
little
curious,
given
that
you
want
to
make
a
simple
reference
list,
how
you
propose
to
make
it
easy
to
read
the
il
to
know
what
the
intrinsic
opcode
is
right.
So
if
you're
going
to
collapse,
costs
and
sand
and
Finch
and
everything
down,
how
do
we
read
it
right?
A
So
one
way
we
could
do
this
is
to
actually
introduce
a
new
genome
that
describes
what
the
actual
intrinsic
is
it
maps
to
an
actual
intrinsic
operation.
You
could
Union
that
to
the
symbol
reference
on
a
node,
because
that's
what
other
nodes
that
don't
have
symbol
references
do
and
you
could.
You
could
provide
this
enum
that
describes
these
things.
You
could
make
it
inexpensively
numb
so
that
some
project
can
come
along
and
add
their
own
list
of
enums
or
a
list
of
lists
of
intrinsics
that
it
cares
about
to
it
if
necessary,
but
it's
action.
A
So
it's
essentially
adding
some
extra
some
side
metadata
to
identify
which
intrinsic
we're
talking
about
the
thing
about
introducing
a
symbol
reference.
If
that's,
what
you're
thinking
was
that
I
think
there
isn't
really
d
now
it
like,
they
doesn't
actually
have
a
function,
backing
it,
which
is
kind
of
what
you
use
that
for
and
then
you'd
also
have
to
go
and
create
symbol,
references
for
all
the
different
intrinsics
that
you
care
about
and
which
adds
to
the
symbol.
A
Reference
table
and
you'd
also
need
to
have
you
know,
adding
the
different
references
to
the
reference
table
so
well.
Okay,
I
can
see
the
argument
about
the
similar
reference
table,
but
I
mean
there
is
already
a
very
strong
precedent
in
the
il
or
symbol
references
that
are
not
functions.
That
map
to
so
primarily
memory
indirect,
very
like
an
offset
or
something
like
that
or
denote
a
particular
kind
of
load.
A
Even
when
the
load
is
at
the
address,
that's
specified
like
I
know
those
are
indirect,
but
some
of
them
also
specifically
say
that
it
doesn't
alias
anything
and
things
like
that,
because
you
know
like
PFT
pointers
and
things
like
that.
So
I'm
just
wondering
what
the
like
you're
going
to
have
to
have
the
enum.
Anyway,
that's
going
to
have
to
be
stored
somewhere,
and
it's
going
to
take
space
right
like
it
has
to
be
in
memory
like
when
the
DLL
loads
or
whatever
right.
A
C
A
medic
over
here
we
seem
to
have
kind
of
dole
them
down
into
the
details
of
what
this
thing
is
before
we've
kind
of
heard.
Any
description
of
why
we
might
want
to
have
an
intrinsic
I
also
is
their
conscious
that
we
stopped
on
your
identified
and
we're
talking
about
simple
references.
So
I
just
wondered
if
there's
maybe
a
slider
that
talks
about,
though
no.
A
So,
motivation
being
that
you
can
reduce
so
there's
a
lot
of
parent
duplication
with
these
different
opcode
and
it's
really
trying
to
limit
the
the
explosion
and
the
number
of
op
codes
that
we
actually
have
by
by
really
just
introducing
one
out
code.
That's
got
similar
properties
across
all
the
different
codes
that
we
have
right
now.
So,
if
you're
trying
to
teach
the
optimizer
about
some
kind
of
a
new,
you
don't
have
to
teach
the
optimizer
about
some
new
opcode
rough
day.
A
All
those
tables
you
just
basically
just
another
intrinsic
that's-
got
the
same
properties
as
all
the
other
intrinsic
setter
that
are
there.
So
it's
really
a
reduction
in
the
number
of
in
hopefully,
a
reduction
in
the
complexity
of
that
set
here
that
you
can
probably
reduce
the
number
of
opcodes
in
omr
alone
by
about
12%.
That's
about
a
hundred
opcodes
I.
A
A
Was
a
very
specialized
click,
the
double
exponent
jobs,
college
and
Convention
adds
more
like
an
ad
before
so
we're
gonna
see
if
well.
Ad
was.
The
point
of
mentioning
ad,
though,
was
that
it
would
be
slotted
into
pretty
much
the
same
scenarios
where
you
could
use
it
at
it
doesn't
really
have
a
side
effect.
You
can
use
it,
you
don't
have
to
anchor
it.
A
Than
perhaps
simplification
right,
so
we
could,
if
you're
doing
like
you,
can
do
I
think
you
could
do
simplification
of
an
intrinsic
opcode.
If
you
knew
like,
presumably
you
could
do,
let's
say
like
a
switch
on
the
whole
known
intrinsics,
and
if
it's
like
a
double
exponent,
and
you
know
that
one
of
the
children
is
zero
or
the
right
travel
to
zero.
You
can
maybe
fold
that
into
something
provided
that
we
that
the
semantics
of
the
intrinsic
are
well
understood.
A
So
I
think
that
there
are
some
optimization
opportunities
for
busy
that
and
mean
that
we
need
to
know
whether
a
given
intrinsic
is
commutative
and
transit,
whether
there
is
whether
it's
transitive
and
commutative
in
its
properties,
or
not
like
for
mathematical
operations,
right
the
things
that
you
do
with
simplification
beyond
sort
of
mathematical
identity.
Right.
A
You
want
to
know
whether
the
operation
is
commutative
commutative,
whether
its
transitive,
so
that
you
know
what
motion
is
possible
right,
because
that's
what
allows
you
to
move
things
up
and
down
across
mathematical
equations
and
fold,
expensive
things
versus
cheap
things,
so
how
you
propose
dealing
with
so
right
now.
Those
are
probably
only
pop
code
right
or.
D
D
B
What
kind
of
Kauai
would
you
do
that
this
is
a
call
outside
of
us?
You
can
recognize
the
call
can
pull
a
call.
Ken
has
perfect.
Why
would
you
change
a
cold
winds?
'ok?
Let's
say
you
go
with
terrible
suggestion
that
intrinsic
don't
have
a
side
effect.
Then
you
decide
I
have
a
call
that
I
wanted
that
can
map
to
an
intrinsic.
B
A
A
A
A
A
C
C
A
A
Extra
McCants
in
my
head
well
and
the
need
for
a
symbol.
Reference
also
associates
with
like
theme.
Even
if
there
are
no
side
effects,
the
memory
model
notation
about
what
happens
before.
Edges
that
may
be
associated
with
an
operation
right
are
captured
on
the
symbol.
Reference
file,
like
the
volatility.
A
Moment
so,
if
you
were
to
not
do
something
like
that
like
right
now,
that
would
have
to
be
a
call
necessarily
because
of
needing
to
put
that
on
it,
even
if
it
has
no
other
side
effect.
Other
than
needing
to
say
that
you
have
reflection
buffers
so
I
mean
what
I
was
I
guess
what
I
was
mainly
interested
at.
This
point
is
really
going
after
the.
A
Hundreds
of
pile-up
codes
that
are
side-effect
free-
this
should
pass
through
the
back
end.
So
if
I
have
to
form
a
definition
around
that
class
of
opcode
and
I'd
like
to
do
that.
If
there
is
enough,
if
there's
another
class,
that
has
side
effects
that
we
might
want
to
handle
as
well
like
I,
think
if
you,
if
you
start
doing
that,
then
you
also
have
to
anchor
them
to
good.
C
A
B
A
If,
instead
of
having
the
notion
of
said,
Oh
currently,
which
you
were
just
describing
about,
you
would
prevent
reordering,
is
with
edge
of
a
side-effect.
Yes,
what,
if
so
for
an
intrinsic?
We
might
have
something.
That's
a
little
that
would
not
be
a
side
effects.
I
would
still
imply,
cannot
be
reordered.
A
Things
you
would
have
to
add
a
special
case
to
all
of
the
aliasing
and
dataflow
logic
to
handle
that
right.
Right
is
currently
the
notion
of
a
side
effect
in
the
notion
of
ordering
is
intermixed
with
the
notion
of
aliasing
in
the
restaurant,
wealthy
Omar
compiler
team,
and
that
then
means
necessarily
that
if
you
make
any
exception
to
that
sort
of
a
world
of
heard.
A
A
D
A
Maybe,
to
start
with
just
nailing
down
what
we
think
the
definition
of
an
intrinsic
actually
is,
regardless
of
whether
it's
side-effect,
free
or
not,
or
what
sorry,
what
the
purpose
of
the
intrinsic
is.
That's
what
it
is.
So
if
it
is
something
that
we
just
want
to
get
through
to
the
back
end
for
lowering
at
the
back
end
implementation
at
the
back
end,
and
there
isn't
at
least
in
my
mind,
there
isn't
actually
a
function
that
would
include
that
would
end
up
getting
called
that
you
would
pass
along
with
it's
basically
you're.
A
Turning
this
into
some
kind
of
a
machine
instruction.
That
garbled
definition
is
what
I
would
consider
to
be
an
intrinsic.
But
by
that
definition,
atomic
right
is
one
of
those
things.
Okay.
So
there
is
no
implementation,
so
I
guess
the
single
pill.
When
we
start
talking
about
when
we
start
introducing
the
notion
of
these
kinds
of
side
effects
that
does
change
the
semantics
of
what
you
can
do
with
that.
A
Node
right,
like
oh
I,
prefer
I
completely
agree
by
a
definition
of
I
wish
to
have
a
node
that
will
translate
in
a
few
one
or
a
small
set
of
instructions.
I
think
a
lot
of
people
like
modular
the
math,
a
lot
of
people's
will
be
the
atomic
operations,
because
that's
what
more
people
spend
time
worrying
about
right?
There's,
like
you,
almost
have
a
side
effect
version
and
an
on
side
effect
versions,
which
is
not
pretty
you
know,
but
then
then
you
would
have
you
would
have
to
so.
A
B
C
C
A
I
think
they're
more
there
fairly
floaty,
floating-point
specific
and
in
fact
I.
Don't
even
think
we
have.
There
are
implementations
for
all
of
those
in
a
llamar
like,
even
though
the
opcodes
exists,
I,
don't
think
the
backends
fully
implement
double
cosign,
for
example,
but
the
capability
would
be
there
to
add.
A
But
it
would
be
easy
to
add
if
we
had
some
framework
in
place
for
adding
intrinsic,
so
it'd
be
easy.
If
somebody
did
want
to
add
a
double
cosign
and
actually
did
come
up
with
the
actual
proper
semantics
of
what
a
double
cosign
really
means
or
are
well
whatever,
and
they
could
easily
add
that
in
the
future
it's
necessary.
C
A
It
into
a
fully-fledged
alt
code
going
forward
no,
and
what
the
opposite,
because
that's
kind
of
the
process
and
all
the
em
has,
if
you
want
to
add
a
new
opcode
to
LLVM
ir
the
suggestion.
Is
you
first
try
to
implement
it
as
an
intrinsic
show,
the
value
of
it
as
an
intrinsic
and
then
make
an
argument
based
on
that
for
why
it
would
be
beneficial
to
have
it
as
a
fully-fledged
opcode,
because
just
an
intrinsic,
you
can't
do
these
things.
Okay,
it
gives
you
a
test.
A
A
A
C
C
C
A
C
C
Only
one
kind
of
like
the
current
typeless
model,
so
you
could
do
a
type
to
a
type
with
only
one
code
but
I
know
that
was
a
split
between
integer
and
floating-point,
because
that
made
sense
but
I
think
there.
Yes,
there
would
be
an
explosion
of
all
codes
explosion.
It
would
get
more.
We
would
get
many
more
all
codes.
A
Desktop
says:
I
guess.
My
point
is
that
there's
there's
there's
I
hate
to
say
finitely
many,
but
realistically,
probably
finitely
many
math
operations
that
people
will
care
about
enough
that
they
want
to
implement
as
intrinsics
right
like
okay,
you
need
all
the
trigonometric
functions.
These
hyperbolic
trigonometric
functions.
You
need
you
know
whatever,
but
the
areas
where
people
will
really
be
pushing
on
things
in
terms
of
exploiting
hardware
and
stuff
like
that
there's
most
of
the
new
op
codes
are
all
related
to
vector
operations
or
or
algorithm
implementation,
eyeprint,
okay.
A
A
C
A
Partly
partly
to
as
part
of
the
general
overall
I'll
clean
up
so
by
squishing
it
down
to
really
the
smallest
set
that
we
really
need,
especially
in
omr
right
now,
the
set
is
probably
over
900
with
just
the
ones
you
can
eyeball.
You
can
squish
that
down
to
probably
about
800,
maybe
more
but
yeah.
It's
really
just
driving
simplicity
across
the
across
the
board.
A
A
So
if
we
were
thinking
about
two
different
ones,
one
with
a
simple
reference
one
with
without
the
one
with
us,
so
your
concern
is
still
with
the
one
without
and
how
do
you
identify
the
operation?
Well,
I,
so
yeah
so
I
mean
that
the
proposal
to
go
and
create
a
union
around
the
symbol.
Reference
took
creating
any
of
the
Union
or
Dixit
all
right.
Well,
I
haven't
handed
you
another.
A
It's
just
around
weather.
How
is
the
code
going
to
look
surprising
because
it's
this
weird
thing
that
doesn't
behave
like
anything
else
now?
Yes,
their
intrinsic
sand
whatever,
but
I
didn't
given
how
other
things
are
currently
implemented.
Or
are
we
saying
that
we're
going
to
do
this,
because
this
is
how
we
want
other
things
to
be
done
or
are
we
doing
well
because
we
think
it's
convenient
or
I?
A
Guess
I
guess
is
my
question:
I'm
not
really
decided
myself
I'm,
just
asking
the
question:
well,
I
mean
if
you
come
out
this,
isn't
a
justification,
shot
or
sell
out?
Is
it
so
if
you
knew
that
the
opcode
was
an
intrinsic,
you
would
presumably
have
a
function
on
the
know
that
meeting
for
every
other
kind
of
opcode
that
basically
says
give.
C
Sense
or
the
one
sensor
we
think
we're
creating
a
dual
kind
of
opcode
and
it's
like
a
different
kind
of
opcodes.
That
indicates
what
it's
operation
is
using
a
different
field
on
a
node
to
tell
you,
which
is
a
fundamental
question
for
me:
comes
down
to.
Is
there
really
enough
value
in
reducing
the
number
of
all
codes
to
the
point
I
mean
I
have
to
I,
still
have
to
be
able
to
look
at
the
set
of
intrinsic
to
understand
what
all
the
different
interests
are.
So.
C
Value
in
that
list
of
operations
not
being
part
of
the
health
code
set
and
creating
this
kind
of
side
notion
of
this
is
a
different
kind
of
off
code
that
only
uses
one
opcode,
but
you
have
to
go
look
over
here
to
find
out
where
it
is.
Is
there
really
enough
value
in
doing
that
to
the
OP
code
set
right,
I
mean
this
is
another
way
of
looking
at
this,
which
is
okay,
it's
a
little
bit
mind-bending,
but
bear
with
me
for
a
moment
right.
C
You
could
argue
that
the
the
what
we
did
with
vector
op
codes
to
try
to
introduce
type
lists
all
codes.
There
is
an
example
of
this
same
kind
of
thing
right.
We
decided
not
to
use
op
code
as
the
way
differentiate
what
the
operations
were.
We
decided
to
put
another
field
somewhere
else
that
in
that
case,
you
could
derive
from
arguments
and
etcetera,
etcetera,
etc.
C
To
represent
what
the
operation
actually
is
right
and
to
me,
that
seems
like
a
move
towards
a
less
consistent
in
a
way
right,
like
the
whole,
optimizer
and
compiler
is
built
around
the
notion
of
if
I
want
to
know
what
the
thing
is.
I
look
at
the
alt
code
right
and
that's
kind
of
entrenched
through
the
MOL
compiler.
Notwithstanding
that
we've
overloaded,
a
bunch
of
polls
and
done
weird
things
that
you've
had
other
side
effects
in
in
the
optimizer
with
the
amount
of
code
you
have
to
write
in
order
to
figure
out.
C
What
exactly
is
this
thing?
This
is
another
example
of
in
in
a
way
a
special
case
where
you
have
to
write
a
bunch
of
code
to
find
out.
What
exactly
is
this
thing?
That's
not
just
as
simple
as
asking
me
also
what
it
is
so
your,
but
so
that
I'm
not
drawing
any
conclusions
yet
I'm,
just
drawing
an
analogy
right
where.
C
A
D
C
D
A
D
A
A
That
would
be
for
the
trill
to
pass
on
your
platform,
modular,
the
ones
that
aren't
tested
great
you're
gonna
have
with
the
ones
that
we
aren't
using,
but
are
they
are,
but
we
should
use
and
modulo
that
so
I,
don't
think
that
the
opcode,
the
and
intrinsic
should
be
created
for
something
that
a
back-end
doesn't
support.
So
you
would
need
to
ask
the
back
and
whether
or
not
it
actually
supports
expanding
this
intrinsic
like
this
is
there's
basic
support
for
the
intrinsic
opcode,
but
actually
the
use
of
you
would
ask
a
back-end.
C
A
C
A
D
C
B
A
B
A
C
A
A
C
The
consequence
of
having
a
like
do
I
really
want
another,
intrinsic
enum
value.
It's
kind
of
the
same
question
almost
and
I
get
this
harder
to
add
a
pop
code
than
it
would
be
to
add
to
an
enum
for
an
intrinsic
list,
but
that's
also
a
problem
we
could
choose
to
address.
Rather
than
building
this
new
I'm,
not
arguing
for
a
particular
case
right
now,
I'm
just.
A
C
Place
that
we
could
do
work
would
be
to
try
to
make
it
easier
to
add
a
new
op
go
over
to
change
the
alpha
code
set
without
you
know,
having
to
go
and
update
quite
as
many
places
for
example,
say
I
don't
know,
and
then
that
point
the
difference
would
be
updating
on
here
or
update
that
over
there.
Well.
A
So
one
potential
difference,
I
see
and
I.
Don't
know
this
is
covered
by
foot
by
what
they're
proposing,
but
in
my
mind,
and
the
idea
of
an
intrinsic
is
that
it
would
be
it
would
not
because
it
would
not
be
at
the
same
level
as
other
op
codes.
They
might
not
get
as
the
same
level
of
optimization
applied
to
it
by
the
optimum.
A
So
there
would
be
a
trade-off
there
where,
if
you
add
a
new
opcode,
you
may
have
to
teach
the
optimizer
about
these
other
things,
and
in
that
case,
if
you
actually
want
to
teach
the
optimizer
about
these
other
things,
it
makes
sense
to
read
it
as
an
opcode.
But
if
you
just
want
something,
that's
like
you,
don't
really
care
what
the
optimizers
you
just
can't
be
optimizer
to
ignore
it.
Adding
that
having
an
intrinsic
mechanism
can
make
adding
that
kind
of
operation
easier.
But
you.
C
A
C
C
A
It's
invent
it,
the
thinking
about
it
from
other
compilers
I've,
looked
at
LLVM.
Being
the
obvious
example
where,
where
the
reason
it
supports
intrinsic,
is
to
make
it
easier
for
people
to
add
these
custom
operations
without
having
to
add
a
new
opcode,
because
that
requires
fiddling
with
the
optimizer
so
that
it
doesn't
choke
on
it
if
it
sees
one
right.
But
the
argument
against
looking
at
the
LLVM
model
is
the
very
fact
that
chris
Latner
is
created.
Mli
are
and
that
they
reviewing
successive
lowering
right.
C
A
But
let's
take
the
trigonometric
functions
as
an
example.
If
you
wish
to
optimize
trigonometric
functions,
you're,
either
going
to
have
to
extend
an
existing
optimization
or
write
an
optimization,
that's
going
to
do
something
sensible
with
it
and
at
the
end
of
des
the
implementation
of
that
right
is
either
going
to
end
up
being
a
call
to
a
math
library
or
an
instruction
and
depending
on
the
platform,
it's
going
to
be
one
of
those
two
things:
whether
whether
you
have
hardware
support
or
whether
its
software
emulated.
A
So
if
you're
like,
if
what
we're
talking
about,
is
that
there's
a
domain
of
operations
that
ninety
from
you
know
a
majority
of
our
users
don't
care
about,
but
that
a
subset
of
users
do
care
about.
Then
a
successive
lowering
notion
is
a
much
more
useful
notion,
in
my
opinion,
where
they
can
do
the
stuff
they
want
at
the
higher
level
and
when
they're
done
with
it.
If
we're
going
to
support
particular
math
operations
right
at
the
the
logical
extension
point.
A
For
that
at
the
moment,
in
the
way
everything
is
engineered
with
minimum
fuss
is
that
it
is
a
call
because
the
call
may
begin
as
a
library
call
or
it
may
be
gen
as
an
instruction
and
the
choice
on
that
may
not
even
be
fixed
for
a
given
coach,
and
it
may
depend
on
what
the
operating
system
is
configured.
It
may
depend
on
a
variety
of
things
as
to
what
the
code
generator
would
take
to
do
with
that
say,
right
and
the
notion
is
well.
A
A
But
you
know
the
chances
are
that
there's
going
to
be
some
about
math
people
to
care
about
it
and
they'll
do
all
their
mapping
stuff
on
it
and
then
they'll
lower
it
and
it'll
just
turn
into
a
call
or
whatever
it
would
at
the
moment.
But
you
know
we'll
get
gent
right,
so
I
think
I'm
not
saying
that
we
should
necessarily
go
with
that
design,
but
given
that
that
is
one
direction,
that
a
very
large
community
of
people
are
going
in
after
a
lot
of
wrangling
with
a
big
compiler
framework,
there
should
be
a
consideration.
A
Is
it
whether
that
is
the
right
way
for
us
to
go
to
make
it
easier
to
add
languages
to
Omar,
where,
if
you
can
define
this
higher
level
thing,
you
write
optimizations
that
work
on
that
higher
level
thing
and
then
lower
it,
and
we
could
then
conceivably
add
like
the
MIR
feature,
where
okay
CSE,
for
example,
you
can
provide
a
definition
of
some
kind
that
that
then,
yes,
you
can
consume.
It
can
do
certain
things
to
your
opcode
right,
run
it
but
pretending
that
the
Omar
optimizer
is
going
to
be
a
fantastic
math.
A
B
D
A
Where
is
awesome
having
an
a
higher
level
IR
that
describes
the
strings
and
the
operations
on
them
so
that
you
could
actually
do
these
things
without
having
to
walk
layers
of
calls
and
anchor
children
and
stuff
would
make
a
load
of
sense
and
then
Vollmar
doesn't
care
about
the
semantics
of
you
know.
Possibly
you
eight
byte,
possibly
sixteen
by
characters
and
all
the
other
corpse
goes
with
that.
We
just
lower
it
later
right.
C
A
C
C
A
A
B
A
B
A
A
C
B
C
C
D
D
A
Mathematical
operation
in
Java,
for
example,
at
the
moment,
generate
symbol,
references
but
there's
a
white
list
that
adds
flag.
That
tells
the
optimizer
that
its
side
effect
was
from
the
point
of
view
of
aliasing
analysis
and
things
like
that.
So
for
yet
for
scape
analysis
in
open
j9,
for
example,
that
flag
will
tell
us
that
you're
not
going
to
escape
you're,
not
going
to
violate
the
rules
around
a
call
in
that
a
call
not
be
anchored,
but
it
means
that
optimizations.
That
would
necessarily
you
know
intersect.
A
It
lies
yeah,
absolutely
no
you're
exactly
right
with
that
and
I
mean
if
you
added
the
one
without
the
symbol
reference
right,
you
know
we
can
just
add
the
dummy
entry
that
says:
do
nothing
constrain
children.
You
know
whatever
I
think
that
would
be
the
sum
total
of
it.
I
think
the
the
slippery
slope
is
where
you
start
to
examine
what
the
hell
that
thing
actually
is
outside
of
anywhere
outside
of
the
code
generator.
A
That
I
think
is
a
line
that
if
we
decided
to
go
down
this
route,
we
would
would
not
be
crossed
you're
going
to
look
into
it.
It's
not
one
of
those
things
anymore,
so
the
pure
intrinsics.
You
would
prefer
a
simple
reference
for
use.
That's
flagged
appropriately,
so
I'm
going
to
see
well
and
I
have
a
reference.
Would
you
could
indicate
the
actual
intrinsic
that
you
wanted
to
represent
in
that
symbol
reference?
A
So
if
so,
if
so,
if
they,
if
the
means
by
which
you
want
to
indicate
that
I'm
a
pure
intrinsic,
is
through
a
flag
on
the
symbol
reference,
then
for
a
pure
intrinsic,
you
would
have
to
create
a
symbol
reference.
And
if
you
had
to
create
a
symbol
reference,
then
the
reference
would
be
what
would
be
used
to
identify
the
actual
intrinsic
that
you
to.
A
A
If
the
symbol
references
are
added
to
the
sim
ref
tab
lazily,
they
will
only
be
added
when
they're
actually
used
right,
which
is
the
current,
find
or
create
pattern,
and,
if
we're
not
actually
going
to
introspect
them.
If
that
is
verboten
outside
of
the
code
generators,
then
adding
a
feature
specifically
to
make
it
easy
to
introspect
them
seems
to
be
not
something
we
should
do,
because
it
attempts
people
to
do
something
which
we
wish
to
forbid.
A
Wouldn't
this.
But
what
is
this
actually
be
a
known
symbol,
Rick
becsher,
with
the
right
term,
you
chose
taken
known,
simple
reference
in
the
sense
that
it'll
be
one
of
the
predefined
numbers
of
simple
references
which
means
well.
It
will
count
for
something
in
the
table
that,
whether
you
use
it
or
not
like
when
we
have
256
known
the
symbol,
references
will
have.
We
don't
start
the
on-demand
one
until
two
that
I.
A
A
Why
are
we
going
to
make
it
easy
to
look
at
the
things,
but
I
mean
if
it
makes
sense
or
in
an
hearing
point
of
view,
sure
I
mean
it's
not
going
to
clutter
up
the
optimizer,
so
you
know
it's
only
going
to
be
sure
we're
there,
but
the
enums
yeah
of
unions
with
the
symbol.
Reference
know
if
you
want
to.
A
If
you
want
to
union
enum
into
the
symbol,
reference
slot
and
that's
what
you
want
to
do
to
represent
these
I
guess
sure
I
mean
I'm,
just
I'm,
just
trying
to
look
at
uniformity
and
do
stuff
and
the
feet.
One
of
the
arguments
for
the
feature
was
it
would
make
things
easy,
but
we
don't
want
people
to
do
that.
Therefore,
it
shouldn't
be
easy.
I.
A
D
Mm-Hmm,
we
not
have
two
different
ways
of
figuring
out
what
I
happen
to
get
my
own
ice
cream
forever
for
pure
versus
side
effects.
Sorry
here
the
first
pretty
fresh,
so
forth.
Few
reverses
side
effect
intrinsic.
Wouldn't
we
have
two
different
ways.
What
this
thing
is,
if
you
have
this
extra
side
table
thing,
Platinum
one
would
have
some
reference,
you'd
query
what
the
symbol
is,
and
so
our
Dakota
symbol
is
the
intrinsic.
For
so
is.
There
are
two
different
off
codes.
A
Then
I
mean
we
already
have
the
notion
of
you
got
like
a
million
methods
on
on
node,
depending
on
the
actual
opcode
that
answers
the
question
that
you
want
so
presumably
before
you
ask
that
question,
you
have
to
ask:
what
are
you
first
like?
Are
you
a
bound
check
or
you
it
your
pure
spirit
of
pure
intrinsic,
that
kind
of
thing?
If
the
answer
is
yes,
then
you
ask
the
question
you
wanted.
You
want
to
ask
so
I'm
thinking
is
it'll
just
be
different.
B
D
C
D
D
A
C
This
whole
way
of
representing
intrinsic
one
way
or
the
other
different
than
the
way
that
we're
currently
representing
this
ball
for
that
function
that
sits
on
those
that
everyone
calls
ask.
What
intrinsic
is
this,
and
that
makes
me
question
the
value
of
the
approach
unless
there's
some
other
part
of
this.
That's
making
this
getting
really
a
lot
easier.
Like
the
you
know,
adding
a
new
intrinsic
is
just
putting
a
name
in
an
enum
or
creating
some
kind
of
symbol,
reference
easy
to
create
symbol,
reference
that
represents
them.
Okay,.
C
But
is
that
enough?
Is
my
I
guess,
my
yeah?
That's
the
basic
value
prop
right,
so
you're
you're,
making
it
you're
coming,
describe
it
in
a
way
that
you
might
find
less
charitable
you're
coming
up
with
a
new
scheme
to
represent
internally
what
a
certain
set
of
operations
that
you're
calling
intrinsic
that
the
rest
of
the
compiler
largely
won't
be
forced
to
understand
why
that's
being
represented
differently
than
other
things
that
are
like
these
concepts
already
exist
right.
We
already
have
intrinsic.
We
have
a
bunch
of
all
codes
that
are
pure.
C
We
have
a
bunch
of
call
notes
that
people
are
creating
which
have
have
side
effects
right.
No,
there's
a
solution
in
place
right
now,
we're
proposing
a
change
to
how
we
represent
that
those
kinds
of
all
codes
and
calls
which,
on
the
one
hand,
all
you
do-
is
collapse
a
bunch
of
all
codes
into
one
off
code
to
represent
the
pure
ones,
and
you
take
a
call
that
has
a
simple
reference
and
you
convert
that
to
another
type
of
op
code,
which
has
a
simple
reference
right.
C
So
we're
it's
like
the
difference
between
where
you're
trying
to
go
and
where
our
doesn't
feel
very
large
to
me
so
I
know
that's
an
unfair
statement
to
make,
but
but
when
you
portray
it
that
way,
it
doesn't
sound
very
different
right
and
then
the
complexity
of
figuring
out,
which
thing
you've
got
you
already
have
to.
In
order
to
avoid
having
to
make
billions
of
changes
throughout
the
codebase,
you
have
to
make
some
smart
function
on
node
or
somewhere.
C
Because,
in
the
end,
why
do
we
have
to
make
it
hard
to
add
new
opcodes
right?
Just
have
to
be
that
hard
to
add
an
opcode
to
the
compiler,
and
why
do
we
have
to
it?
Except
that?
That's
it's
that
hard
and
that's
as
hard
as
it's
going
to
be,
and
everybody
should
have
to
do
that.
Much
work
to
add
a
new
approaches,
compiler
or
even,
if
they're
not
going
to
optimize
it
immediately
right.
So
we're
not
solving
choosing
not
to
solve
that
problem,
essentially
right
and
instead
for
a
certain
class
of
off
codes.
C
C
I'm
going
to
have
to
leave
shortly
so
having
thrown
that
grenade
into
the
room
series
of
grenades,
I
mean
in
the
end
I'm,
not
I'm,
I'm,
certainly
not
invested
in
the
implementation
that
we
have
right
now
for
this,
but
so
I'm
not
trying
to
argue
for
status
quo.
Just
because
I
think
status
quo
is
the
most
brilliant
thing
on
the
face
of
the
earth.
C
That's
not
the
case,
but
right
I
guess,
there's
there's
the
way
I'm
seeing
it
it
looks
like
there
are
different
ways:
you
can
invest
the
solve
problems
that
would
have
similar
kinds
of
effects.
I
guess
the
question
is:
what's
the
right
one
to
target
to
maximize
the
improvement?
So
if
you
approve
how
hard
it
is
that
are
not
code
to
the
optimizer,
that
has
the
potential
to
improve
lots
of
people's
lives.
C
B
A
I
guess
I
mean
another
thing
that
might
weave
into
this
as
well
is
sort
of
the
philosophy
behind
the
aisle
in
the
first
place,
and
whether
or
not
whether
or
not
we
want
for
the
maximum
set
of
maximum
il.
Or
do
you
want
a
minimum
set
of
I
ask
I
think
we
kind
of
kicked
the
tires
not
much
in
the
past
or.
A
A
C
A
Be
added
because
there
is
overhead
associated
with
adding
an
opcode
not
just
to
the
front
end,
but
also
to
the
back
end
as
well,
like
the
coke
generator,
for
example,
needs
to
add
some
kind
of
people
a
handler
for
that
was
off
code.
Even
it
was
nothing,
but
it
you
have
to
expand
the
size
of
the
table.
So
if
there
is
an
awareness,
you
need
to
have
any
additional
opcode.
So.
D
C
B
C
A
C
There
are
still
in
our
history
if
there's
some
way
to
document
the
ones
that
we've
taken
out
in
the
past,
maybe
and
when
they
got
taken
home
and
if
you
somewhere,
maybe
I,
don't
I
doubt
anyone
will
ever
go
and
look
at
it.
But
but
in
principle
the
history's
there
and
people
could
resurrect
anything
that
they
needed.
I.
A
Would
argue
that
we've
already
had
several
proof-of-concept
integrations
of
our
compiler
technology
to
project
and
we've
run
into
op
codes
that
we
were
we
once
upon
a
time
removed
and
then
now
it
turns
out,
we
need
them,
and
I
can
tell
you
some
of
those
up
codes.
You're
talking
about
removing
or
not
those
so
I
would
say
if
we
haven't
encountered
it
up
until
now,
we're
very
unlikely
to
encounter
it
in
the
near
future.
C
C
I'm
not
sure
we've
had
enough
proof
of
concept
projects
built
on
top
of
all
more
to
be
able
to
categorically
say
no
one's
going
to
come
around.
Looking
for
this,
maybe
no
one's
but
but
you're
right,
but
but
you're
right.
We
have
you
that
Omar
compiler
husband
used
in
a
number
of
very
different
scenarios.
Yeah.
A
I
guess
forms
so
what
I'm
thinking
of
it
at
one
time
when,
just
when
we
open
source
the
technology,
we
were
trying
to
clean
things
up,
and
we
kind
of
started
removing
all
codes
indiscriminately
without
thinking
too
much
about
whether
they
would
be
needed
and
some
of
those
it
turns
out,
we've
needed
them
with
one
of
them
come
on.
The
other
argument
for
actually
removing
opcode
is
that
we
also
have
this
effort
to
actually
document
the
il
and.
C
C
A
Right
so,
but
I
think
I've
me
if
I'm
moving
past
that,
so
there
is
potentially
the
notion
of
adding
it
up.
It
is
also
the
perhaps
we
should
just
purge
a
lot
of
those
awkward
in
the
first
place,
but
not
even
make
them
interest.
But
the
intrinsic
is
more
of
a
means
that
if
somebody
wants
to
add
them
back,
what
would
be
an
easy
way
to
for
them
to
do
that,
but
maybe
I.