►
From YouTube: OMR Compiler Architecture Meeting 20180711
Description
Compiler Architecture Meeting agenda:
* Default floating point semantics in OMR [ 0xdaryl ]
Please add any comments/questions to the GitHub agenda issue: https://github.com/eclipse/omr/issues/2740
A
Okay,
welcome
everyone,
so
today's
topic
is
actually
gonna
be
more
of
a
discussion.
It's
not
really
a
proposal
earning
like
that.
It
sort
of
come
to
light
lately
that
we've
had
some
issues
with
within
OMR
and
in
some
downstream
projects
where
the
the
sort
of
the
default
behavior
of
the
floating
points
in
that
the
default
floating
point:
semantics
that
are
sort
of
expected
by
the
the
simplifier
and
the
value,
propagation
and
other
parts
of
the
optimizer
and
backends
and
in
the
interaction
for
language
environments,
isn't
necessarily
consistent
and
I
guess.
A
The
idea
here
is
to
really
sort
of
come
to
some
agreement
or
where
we
want
to
go
with
it
without
impose
some
of
these
semantics
on
on
our
on
our
floating
point
code,
and
perhaps
even
some
ideas
about
how
to
actually
architect
that,
because
in
some
cases
that
may
not
necessarily
be
straightforward.
The
other
thing
that
we
could
potentially
touch
on
as
well
is
to
talk
a
little
bit
about
the
isle
op
codes
themselves
that
do
floating
point
and
see
what
kind
of
semantics
that
we
want
to
those
that
we
think
are
appropriate
there.
A
A
What
the
semantics
actually
are
and
sort
of
the
interface
that
we
have
for
doing.
That
is.
This
is
this
this
class
that
we
call
the
the
arithmetic
environment
here
with
N,
and
it
is
an
extensible
class
that
OMR
provides
an
API,
provides
a
number
of
questions
that
can
be
asked
it's
by
no
means
an
exhaustive
set
of
questions,
and
it
also
provides
sort
of
a
default
implementation
of
the
answers
to
those
questions.
In
addition
to
questions
it
actually
provides
operations
that
can
be
done
as
well.
A
If
your
project
a
downstream
project,
that's
consuming
Omar
wants
to
do
things
differently.
There
are
because
it's
an
extensible
class,
you
can
by
all
means
extend
that
API
as
you
as
you
see,
fit
and
provide
your
own
implementations
of
those
functions,
and
you
can
even
add
your
own
members
to
that
API
as
well.
If
you
need
to
ask
specific
questions
for
your
environment,
so
it
does
build
upon
the
extensible
class
framework.
A
However,
there
there
have
been
some
some
cases
where,
where
the
the
results
that
we're
coming
back
from
om
are
we're
not
quite
what
what
one
might
expect
and
I
think
one
of
the
one
of
the
things
that
we
need
to
discuss
to
come
to.
Maybe
some
some
agreement
on
here
is:
what
are
the
semantics
that
we
should
be
providing
at
the
I?
A
Guess
the
arithmetic
layer
and
should
Omar
actually
be
providing
a
default,
or
should
it
actually
just
be
providing
the
API
and
every
language
environment
has
to
be
responsible
for
providing
some
kind
of
an
implementation
for,
for
that
or
I?
Guess.
There's
one
other
design
point
right,
which
is
that
you
have
an
API.
A
That
guess
right
that
providing
doing
it
that
way
would
add
a
little
adds
an
extra
level
of
indirection
I
think
to
the
to
the
weight
of
the
class.
If
we're
going
to
use
the
accessible
class
mechanism
for
that,
then
that
adds
serve
an
extra
layer
of
indirection
onto
that
where
you
have
the
API,
but
the
actual
implementation
gets
sort
of
dynamically
loaded
or
whatever
it
happens
to
be,
but
I
think
about
that
as
well.
A
A
So
any
any
thoughts
on
on
that
I
think
in
based
on
the
discussions
last
time.
I
think
it
wouldn't
come
as
a
surprise
to
people
who
were
involved
in
that
that
my
my
position
would
be
to
do
the
API,
but
not
provide
an
initial
and
implementation.
I
provide
the
option
of
selecting
an
implementation.
We
could
certainly
have
an
implementation
in
orlimar,
but
that
it's
not
on
by
default
right.
What
were
the
sorry?
It's
not
swapped
in
by
head
right
now.
What
were
the
implications
on
the
simplifier
that
were
that
were
problematic?
A
The
case
that
came
to
mind
was
that
we
were
doing
the
square
root
optimizations
that
were
supplying
certain
semantics.
Yes,
and
what
was
ending
up
happening
is
that
the
actual
fact
the
back
end
was
changing,
was
providing
a
different
implementation
for
different
set
of
semantics.
That
square
root
operation.
A
Yes,
I,
correct
yeah,
so
I
think
that
the
issue
was
and
I
think
we
saw
that
in
the
context
of
open
j9s
used
to
when,
when
when
we
had
the
Omar
implementation
and
I
think
that
was
just
implemented
using
the
C
compilers
implementation
that
compiled
to
whatever
it
compiles
to,
and
that
was
the
implementation,
but
that
was
not
compliant
in
I.
Don't
know
if
it
was.
It
was
something
related
to
precision
now
whether
it
was
the
rounding
mode
or
some
other
detail
of
the
implementation
that
was
different.
A
It
didn't
produce
the
identical
answer
to
what
the
Java
specification
required,
and
so
we
were
starting
to
wring
our
hands
a
bit
over.
So
in
the
simplification,
so
in
the
simplifier,
so
we
attempted
to
do
a
square
roots
to
placate
like
a
full
thing.
That
say:
oh
that's
where,
and
we
am
so
in
that
case
it
did
not
call
I
know
we
don't
have
one
yet
I
think
actually
Victor
has
a
you
are
for
that,
but
that
we
did
not
call
arithmetic
library
injectors
to
do
the
folding
correct.
A
So
there's
certainly
going
to
be
a
class
of
language
implementation
where,
if
you're,
building
OMR
as
part
of
that
runtime,
if
you
are
using
the
runtime
to
do
it
in
your
language
as
it
is,
the
most
compatible
thing
for
Omar
to
do
is
to
use
the
runtime.
Now
it's
not
the
disease
is
the
runtime.
Now
that's
not
necessarily
going
to
produce
consistent
results
across
platforms,
and
you
know
having
another
implementation
that
uses
live
m
or
or
whatever
to
provide
a
compliant
implementation
would
be
sensible.
A
C
A
C
A
Problem
these
are
these
are
both
problems
we
have
to
address
at
some
point
right,
but
the
the
first
problem
was
the
actual
semantics
of
the
air,
the
if
you
actually
use
the
arithmetic
environment
class,
what
what's
the
default?
What
answers
are
going
to
be
returned
right
and
how
do
you
buy
those
answers?
How
does
the
project
provides
answers
guys
are
right
that
we
need
to
start
looking
for
a
deeper
Pilar
and
what
happens
to
the
cogent
as
well.
A
Now,
if
the
current
evaluators
need
updating
or
something
to
become
compliant
with
whatever
we
end
up
making
the
decision,
that's
the
second
issue
right,
but
I
I
think
the
problem
is
at
the
moment.
We
don't
even
know
how
to
review
the
contributions
that
people
are
trying
to
make
improve
this.
This
aspect
of
the
compositor.
A
Okay,
people,
so
looking
specifically
at
that
at
that
interface
layer,
do
people
have
thoughts
about
whether
or
not
phobar
should
be
a
very
specific
about.
This
is
the
default
implementation,
and
if
you
want
something
else
you
have
to,
you
have
to
be
very
meticulous
about
overriding
it
all
or
should
we
architect
something?
A
That's
got
a
menu
of
options
and
you
have
to
basically
build
in
the
one
that
you
want
pick
and
then
build
on
the
one
you
want
with
the
understanding
that
there
might
be
a
little
bit
of
an
efficiency
with
that,
because
we
probably
do
have
to
introduce
an
extra
layer
of
indirection
on
into
that
interface.
If
we're
going
to
continue
to
use
like
an
extensible
clasp
mechanism
or
for
that
I.
C
Think
for
five:
instead
of
providing
a
default
and
forcing
someone's
hand,
the
equivalent
would
be
providing
one
implementation
and
giving
them
having
them
to
find
the
one
minor,
because
I
gives
you
a
lot
more
flexibility,
and
if
you
want
to
find
another
one
down
the
road
or
having
multiple
and,
of
course,
is
the
user
to
really
think
about
what
they're
do
we
have
right?
Now
is
just
one
if
we
have
a
right,
but
it's
also
the
default.
A
A
So
it's
recognizing
that,
because
you're
picking
down
the
bills
you're
making
a
conscious
choice
that
I
want
that
you
want
you're,
accepting
that,
but
even
for
something
like
open
to
a
nine
I
think
they
have
to
build
both
that
version
and
the
j9
extension
of
it
right.
So
you're
billing,
the
one
that
you
don't
want
and
the
one
that
you
do
want
just
to
make
the
linker
happy
at
this
point,
which
isn't
a
great
design
either
peach
slices.
The
book
yeah.
A
A
Presumably
there
could
be
other
areas
of
all
of
this
technology
where
you're
not
really
aware
of
what
the
default
actually
is
and
you
or
there
could
be
some
things.
You
should
be
opting
into
or
least
you're
conscious
that
you're
opting
into
them,
because
maybe
this
is
a
more
general
patter
that
we
have
to
architect
in
as
opposed
to
making
it
specific
digit
floating
point.
C
B
A
A
B
A
E
C
A
A
A
The
other,
and
if
we
actually-
and
perhaps
this
is
something
that
we
would
if
we
actually
did
define
that,
let's
say
F,
add
the
f.
Add
opcode-
has
to
provide
these
exact
semantics
right.
But
let's
say
it
actually:
I
Triple,
E
754
compliant
for
C,
both
running
for
23
bit
decisions
in
one
round
the
nearest
mode
and
all
that
kind
of
stuff.
D
C,
so
we
can
put
sauce
code,
B
implementation,
detail
and
most
implementations.
They
just
go
by
the
C
API.
To
do
this,
but
technically
you
could
define
each
compiler
could
go
its
own
way,
but
they
all
have
to
in
Toronto,
but
he
makes
a
compiler
that
is
completely
incompatible
with
you,
the
other
compilers
on
the
platform.
So
they
all
kind
of
agree.
D
A
A
A
D
A
A
So
there's
two
classes
of
these
things,
there's
the
ones
where
you're
reordering
trees
and
that
may
have
an
impact
on
the
order
of
evaluation
and
then
there's
the
class
of
okay.
Well,
I
have
an
S
add
of
an
F
mole
and
I
want
to
turn
into
an
F
mole
of
an
F,
add
and
I'm
going
to
factor
the
multiplication
across
the
ad,
or
something
like
that.
A
Then
I'm
going
to
transform
a
constant
in
the
part
that,
where
there's
a
danger,
part
that
I
guess
we're
talking
about
in
the
simplifier
is
where
I
transform
that
constant
in
some
way,
I
guess
I
would
be
arguing
that
the
constant
transformation
would
be
the
thing
you
would
feed
through
the
evaluator.
Now
the
rearrangement
may
be
another
class
of
thing
but
they're
different
again,
then
we
were
just
discussing,
which
is
the
actual
evaluation.
A
Yeah,
so
what
you
would
do
is
when
you
start
up
the
when
you
load
the
jet,
it
would
take
the
floating-point
evaluators
in
your
code
generator
and
it
would
run
each
one
to
generate
a
snippet
that
does
the
equivalent
of
that
node.
And
if
you
want
to
constant
fold
a
node,
you
take
the
evaluator
for
that
feeds
a
constant.
Then
it
will
run
exactly
the
sequence
that
your
evaluator
would
have
generated
and
gives
you
an
anti-aging.
A
A
Guess
I
mean
even
also
breaking
music,
the
API
that
we
have
right
now
into
the
language
for
the
language
environment.
That
again
environment
is
not
particularly
rich.
It's
just
got
a
couple
of
questions
and
maybe
a
number
but
10
or
so
operations
right
for
multiplying,
adding
and
subtracting
that
kind
of
stuff
I
guess
we
could
add.
A
We
could
round
that
out
quite
a
bit
more
and
then
making
sure
that,
when
we're
generating
floating-point
code,
we
ask
you
need
to
ask
questions
all
the
time
to
know
exactly
what
exactly
what
kind
of
code
that
we
should
be
producing
from
that
to
try
to
make
it
a
lot
more
generically.
It
already
is,
and
even
the
simplify
I
could
do
that
too.
A
A
A
A
How
much
going
point
this?
Do
we
need
to
bake
into
that
and,
like
you're
saying
we
leave
it
up
to
the
API
so
that
are
commonly
accepted
API
on
the
target
that
you're
going
to
be
running
on,
because
at
some
point,
we're
going
to
one
of
the
things
that
we
want
to
do
is
actually
provide
more
of
a
specification
for
the
il
part
of
it
is
going
to
be
providing.
A
D
D
Shift
doesn't
necessarily
match
behavior,
but
the
C
compiler
generates
the
code
that
that
makes
it
we've
generated
a
rotate,
but
then
it
would
mask
off
bits
that
are
harder
leads
to
make
it
conformant
on
in
home.
Are
we
degenerative
shift,
and
you
really,
the
IMO,
makes
it
specific
case
somewhere
in
civil
for
today
remember
off
hand,
but
I
always
refer
to
it.
When
this
question
comes
up,
but
we
we
generate
something.
A
At
the
same
time,
that
problem,
then,
is
if
you
actually
do
have
that,
say
some
kind
of
a
simplify
operations
on
that
opcode
yeah.
You
have
to
make
it
architecture
specific,
potentially
because
simplifying
it.
If
I
got
an
example,
the
top
my
head,
that's
simplifying
us
on
power
might
be
differences,
the
way
to
potentially
simplified
on
axis
or.
E
Something
else
from
from
the
some
of
the
acts
excluding
evaluators.
It
seems
like
the.
We
expect,
the
odd
and
the
I
off
to
confine
cava
standard,
for
example,
the
routine
routine
teenager
conversion,
routing
routing
points
we
interior
conversion,
aisle
like
we
have
actual
like
a
ton
of
extra
logic
to
make
it
comply
or
Java
standard,
which
is
different
from
from
the
hardware
or
the
C
API.
E
A
That
they
are
oh
yeah,
it's
just.
If
I
understand
it,
we
have
to
make
a
specific
layer,
that's,
but
there
is
at
least
clarity
and
agreement.
That
is
how
it's
supposed
to
behave,
but
but
we
don't
have
a
great
answer
on
like
that.
One
example
of
units
has
been
the
shifter
example.
How
used
to
go
by
that
on
difference?
Our
commander,
sir,
or
even
different
projects
right
because
then
you
have
to
have
canines,
would
have
to
override
this.
D
C
A
A
C
D
D
A
A
A
D
A
C
A
C
A
Kind
of
included
the
summary
of
maybe
we
do,
there's
look
into
providing
an
API
and
Omar
and
explicit
opt-in
from
a
consumer
for
floating-point
related
things,
providing
perhaps
multiple
implementations
that
one
could
be
that
could
be
chosen.
B
compiler,
I,
Triple,
E
754,
whatever
F
you
live
in,
but
they.
A
A
Only
pragmatic
question
in
our
poll
requests
in
open
what
is
the
standards
to
be
used
to
assess
those
for
integration
into
Omar
and
to
avoid
breaking
downstream
implementations,
they're,
open,
j9
or
other
languages
like
blue
us?
That
may
not
currently
expect
those
things
start
happening
so
in
though,
and
in
the
in
the
ones
that
are
open.
Are
they
falling
back
to
just
Java
semantics,
like
domestic?
It
has
a
baby
so.
A
E
The
square
responded,
drama
semantics
is
same
as
x86
place,
a
structure,
semantics
so
I
will
see
a
compliance
with
both
and
well.
The
only
structure
in
health
make
is
for
like
when
we
don't
have
play
at
the
he
support
the
hello.
The
harbors
are
always
there,
but
it's
like
the
NASA
Oh,
a
mark
with
OMR
doesn't
used
axis,
doesn't
use
as
a
team
that
have
to
do
some.
My
conversions
from
x87
register
supposedly
SS
need,
and
rather
the
instructors
I
2002,
because
the
activities
tell
the
instructions
is
not
compliant
with
Java
members.
So.
E
A
A
As
long
as
it
isn't
going
away
from
the
direction-
I
guess
since
we
just
talked
about
here
and
it
sort
of
fits
in
with
the
rest
of,
however
Overmars
implemented
at
the
moment,
this-
that
could
be
one
standard
right,
I
think
of
kind
of
case
by
case
I'm
sure
that's
the
answer.
This
well
charge
of
the
kind.
C
A
Is
three
hours
I?
Guess?
If
that's
what
we're
going
to
say?
Well,
that's
fine!
We
need
to
have
a
direction
that
the
API
is
supposed
to
be
going
so
things
that
make
more
of
it
into
the
simplify
rows
and
delegating
it
some
point
somewhere
in
the
code
be
able
say
this
is
where
we
do
at
it
and
then
making
sure
that
those
kinds
of
floating-point
code
that
ones
get
committed
asked
ask
the
right:
ask
the
language
environment.
What
it's
doing
things
right!
That's
the
right
question
of
it!
There's
another
one!