►
Description
Speaker: Pawel Bylica, Ethereum
Topic: Weird quirks while testing WebAssembly
Fizzy https://github.com/wasmx/fizzy
Ethereum https://ethereum.org/en/
Wasm in Web3 workshop https://avive.github.io/wasm_on_the_blockchain_2021/#/
A
Okay,
hello,
everyone
out
there
watching
and
listening
to
to
today's
talks.
This
talk
is
about
testing
web
assembly
in
relation
to
the
project.
Alex
was
mentioning
before
the
original
title
was
weird
quirks
about
that,
but
I
think
in
the
end
I
ended
up
or
more
positive
side
of
the
things
and
and
yeah
try
a
little
quick
journey
about
what
you
have
learned
about
that.
A
I
was
also
working
for
e-wasm
project,
which
the
main
goal
was
to
introduce
web
assembly
to
ethereum
blockchain
previously
as
a
replacement
for
evm,
and
then
we
thought
about
running
them
side
by
side
and
currently
I'm
I'm.
We.
We
did
change
her
name
to
the
team
that
was
working
on
execution
engines
and
the
current
name
is
epsilon,
which
alex
mentioned
before,
and
you
can
find
some
of
some
of
our
notes
on
the
site
linked
there.
A
A
But,
first
of
all,
we
need
to
answer
the
question.
What
actually
we
mean
by
the
web
assembly
1.0?
So
I
think
that
the
most
correct
answer
to
that
what
it
is
is
that
is
the
document
that
is
published
under
name
web
assembly,
core
specification
done
in
december
2019-
and
this
is
this-
is
official
w3c
recommendation
and
you
can
find
it
on
on
this
link.
A
A
So
this
is
this,
is
these
are
two
important
parts
of
that,
but
the
problem
we
had
with
with
with
this
repository
it
doesn't
really
mark
the
the
1.0
version,
so
there
are
different
git
tags
and
different
git
branches.
That
kind
of
suggest
this
is
work
related
to
to
1.0,
but
we
weren't
100
sure
that
we
actually
have
the
correct
one.
A
So
we
don't
really
want
to
use
spec
tests
from,
let's
say
master
branch
where
there
are
some
extensions
added
and
it
tracks
what
is
called
web
assembly
1.1,
although
that
never
this
version
never
has
been
finalized.
Yet
so
that's
that's
not
really
option
for
us,
and,
and
additionally,
there
are
some
some
issues
to
the
spec.
That's
my
would
welcome
some
corrections.
They
are
not
like
substantial
problems,
but
we
we've
seen
some
small
corrections
happening
on
the
way
and
they
are
not
included
in
the
the
1.0
document.
A
So
one
of
example
of
such,
like
small
bug,
fixes
I
just
found
it
mine-
searched
that
recently
it's
done
by
some
other
contributor
and
it
mostly
fixes
a
typo
but
just
like
it
makes
it
makes
the
specification
more
correct
and
less
confusing
this
way.
So
there's
in
this
case,
and
it
affects
the
the
load
instruction,
which
is
definitely
part
of
1.0
specification,
so
I
double
check
that
and
in
the
in
the
master
or
like
the
the
recent,
the
recent
specification
published
regularly.
A
A
Originally,
we
we
mostly
considered
test
pack
porting
to
that,
but
they
also
like
small
fix,
also
included,
and
we
also
had
some
discussion
with
the
maintenance
of
the
spec
repo,
but
I
think
that
hasn't
been
resolved
fully
and
the
the
interest
in
that
I'm
not
sure
like
to
mine
to
my
impression
was-
was
like
limited
so
yeah.
I
think
that
was
needed
for
our
job
and
we
we
started
to
to
do
that.
However,
there's
this
one
issue
of
the
with
the
the
process:
how
how
does
work?
Does
it
work?
A
So
we
prefer
to
do
at
least
the
the
new
test
auditions
to
be
first
included
in
the
the
upstream
spec
repository,
but
the
only
option
to
include
them
is
to
to
to
to
target
and
the
master
branch
of
that,
so
that's
sometimes
challenging
because
of
the
additional
extension
that
already
exists
there,
and
only
after
this
change
is
acts
I
mean
the
test
set
is
accepted
and
upstream
we
can
backboard
that
to
to
our
branch.
So
it
also
kind
of
prolongs
the
the
process
where
we
fall.
A
A
If
this
I
mean,
if
this,
the
the
generated
input
are
interesting
or
not,
the
most
famous
feedbacks
is
is
if
you're,
if
your
program
crashes,
that's
like
great,
because
the
the
father
is
super
happy
about
that,
but
there's
other
options
to
to
provide
some
feedback
information
to
this,
to
this
testing
and
in
case
of
web
assembly
validation.
That's
that's
that's
ideal
and
also
simple
case.
It's
because
of
the
of
the
like
structure
of
of
validation.
A
So,
in
particular
this
in
in
our
case,
we
we
used
because
most
of
the
code
we
did
test
is
c
or
c
plus,
plus
we
used
leap
fuzzer,
which
is
part
of
another
vm
tool
chain,
along
with
the
llvm
sanitizers
and
and
there
we
there.
We
used
less
known
at
least
additional
instrumentation
options
and
runtime
options
to
to
extend
number
of
checks.
The
the
sanitizers
are
performing,
especially
for
our
code.
A
I
didn't
I
didn't
list
all
of
these,
but
if
you
may
be
interested
in
this,
there's
a
way
to
find
that
in
our
repository
in
the
configuration
files-
or
I
can
also
some
other
time
about
that-
and
the
main
targets
were
fizzy.
Our
project
and
wabit
mentioned
before
wabit
is
a
hobbit
is,
is
a
web
assembly
binary
toolkit
which
can
serialize
deserialize,
validate
and
also
interpret
webassembly
code
and
and
also
resides
on
in
the
webassembly
github
organization?.
A
A
A
A
A
To
do
yeah
so
those
sum
summary
to
summarize
the
this,
this
fuzzing
effort,
it's
not
completed
because
after
extending
the
the
the
fuzzing,
mostly
the
the
input
size,
we
discover
new
issues
and
it's
like
it's
quite
time
consuming
to
to
fix
this
all
the
problems
at
in
this
single
point
in
time.
So
this
is
ongoing
process.
A
Taken
and
con
continued
by
someone
else
and
and
and
and
most
of
the
the
issues
we
found
are
are
related
to
first
of
all,
custom
sections
that
can
happen
in
web
assembly.
So
in
our
implementation
we
ignore
them,
because
we
don't,
we
don't
have
any
interest
in
them
in
them,
but
it
it
happens
to
that.
Some
of
the
custom
sections
are
actually
specified
in
some
other
places
and
they
also
have
some
validity
rules,
so
I
would
understand
some
of
them.
A
That
means
it
will
also
validate
custom
sections
if
they
happen
to
found,
find
them,
and
this
is
the
one
of
the
reasons
physient
and
wabbit
are
in
disagreement
about
some
of
the
modules
most
meaning
like
fizzy,
will
consider
them
valid,
and
why
would
not?
Because
some
of
the
custom
sections
are
actually
not
valid
so
for
us
there's
not
really
other
way
to
to
kind
of
add
some
ignorance
to
the
to
the
tool
to
ignore
such
errors.
It's
a
bit
of
annoying
part
but
can
be,
can
be
solved.
A
A
A
A
So
so
we
put
a
bit
of
attention
to
this
and-
and
we
separate
test
coverage
reports
by
the
the
tests
that
we
are
running
so
for
internal
unit
tests.
We
we
do
have
separate
report
and
for
official
spec
test.
We
have
additional
report
and
then
we
can
see
in
this
additional
report
that
which
lines
in
the
code
of
our
implementation
are
not
covered
by
that.
A
Yeah-
and
that
was
like
pretty
straightforward
way
to
to
extend
number
of
spec
tests
upstream,
I
think
we
didn't
cover
all
of
the
cases
yet.
The
example
from
the
previous
site
was
actually
taken
from
from
the
most
recent
test
coverage
report,
but
this
is
this
is
a
relatively
straightforward
process
and
you
can
repeat
that
over
and
over
again
until
you
have
until
you
reach
a
100
coverage,.
A
So
if
you
recall,
I
mean
this
one
bit
of
information,
I
will
need
later
so
well,
there's
this
a
lot
of
say
about
flaunting
points.
But
one
thing
I
will
need
later
is
that
it's
you
can
decompose
such
representation
floating
point
representation
as
a
as
a
sign
bit
exponent,
part
and
and
monty
support
and
yeah.
Let's
move
on
so
so
we
did
consider
starting
fizzy
product
and
also
web
assembly
product,
as
as
a
whole,
I
mean
he
was
in
project
as
a
whole
to
skip
floating
point
instructions
altogether.
A
So,
first
of
all,
we
don't
believe
they
are
super
critical
to
implement
blockchain
programs
or
smart
contracts
so
that
that
zone
can
save
us
over
60,
less
instructions
to
implement
and
to
test
and
to
maintain
and
to
do
all
the
stuff.
That
is
related.
I
mean
it's
also
like
limits
the
id,
the
attack
attack,
surface
and
all
other
properties
of
the
system,
but
most
most
importantly,
the
the
floating
point.
Specification
for
web
assembly
allows
the
operation
to
be
non-deterministic
and
that's
that's
like
critical
part.
A
A
A
A
So
they
are
only
not
deterministics
around
nuns,
which
are
special
values,
meaning
not
a
number,
and
if
you
can
recall
from
the
previous
sides,
when
we
had
this
three
different
part
of
representation
of
floating
point
nuns
are
the
values
that
has
all
bits
set
in
the
exponent
exponent
part
and
at
least
one
bit
set
in
the
in
demand.
Support.
A
A
A
First,
one
is
arithmetic,
which
is
also
called
quiet,
quiet
man
in
some
other
other
specifications
outside
of
web
assembly
and
also
signaling
nouns,
and
the
difference
is
that
the
first
bit
of
quiet
noun
is
is,
is
always
set
to
one
and
a
signified.
One
is
always
set
to
zero,
so
signaling
one
has
to
has
to
have
some
other
bits
set
to
one
and.
A
A
A
Let's
say:
set
of
semi
semi
equations,
but
mostly
the
rule
is
that
if
you
have
some
inputs
to
the
floating
point
extraction
and
only
it
only
has
real
normal
values
that
are
non-non-values
and
some
of
them
are
canonical
nouns.
They
they
must
stay
as
a
canonical
noun.
Although
the
bits
the
sign
bit
might
change
and
only
if
you
have
some
other
nouns
being
the
input.
This
is
the
the
fourth
of
this.
A
A
A
A
A
A
You
can
expect
inspect
that
on
your
own,
and
for
for
that
case,
it
generates
quite
substantial
number
of
test
cases
with
the
expected
results.
All
of
them
are,
all
of
them
are:
are
output
in
in
hex
form
matching
binary
representation
and
they
also
additional
information
as
the
expected
exp
exceptions,
happening
and
and
other
bits
of
information.
But
the
point
is
you
can
precisely
and
parse
this
this
this
test
cases
and
and
confront
your
implementation
with
what
the
the
test
float
product
expects,
and
this
is
what
we
did.
A
We
we
built
a
custom
tool
which
is
relatively
simple:
the
it
has
two
main
main
features.
First
of
all
it
it
takes
these
specific
test,
float
inputs
and
and
process
them
to
create
internal
tests
and
for
internal
tests.
It
also
generates
a
very
simple
web
assembly
program
that
uses
this
particular
extraction.
A
A
A
In
the
floating
point
specification
known
in
the
web
assembly
specification,
I
mean
the
precise
payloads
that
you'd
expect,
but
self-taught
matches.
What's
what
this
architecture
generates.
Maybe
that's
the
other
way
around.
I
didn't
investigate
that
fully
yeah,
but
we
were
kind
of
happy
what
we
what
we
had.
So
we
also
extend
the
test
for
for
non-payloads
to
make
sure
like
they
stay,
as
as
we
wanted
them,
and
we
were
quite
happy.
A
Can
we
go
back?
One
slide,
please,
and
but
there
are
some
there's
some
issues
we
discovered
with
with
this
already
so
so
web
assembly
and
and
also
like
all
the
compilers.
We
know
actually
doesn't
pay
so
much
much
attention
to
nano
values
and
propagating
man,
values
for
instructions
that
are
like
mathematically,
mathematically,
commutative
like
additional
multiplication
and
so
on,
actually
means
that
if
you
provide
some
nano
values
as
an
inputs,
the
order
actually
matches
and
compilers
heavily
disagree
with
us.
A
So
they
they're
happy
to
swap
the
the
operands
in
the
code
in
which
order
they
actually
feed
it
to
the
instruction.
So
we
already
had
some
issues.
For
that
I
mean
it
still
stays
with
the
web
assembly
conformance,
but
at
least
depending
on
the
build
options,
and
without
this
deterministic
web
floating
point
distractions,
you
actually
may
get
different
results
in
your
program.
A
So
that's
that
was
the
first
discovery.
Secondly,
we
moved
to
to
arm.
I
don't
remember
a
lot
of
details
about
that,
but
at
least
the
non-payloads
start.
Mismatched
with
this
outflow
produces
that's
still
fine
in
terms
of
web
assembly
specification,
but
we
already
knew
that
we
can't
test
these
at
least
for
this
at
the
architecture.
So
so
strictly
and
finally,
we
also
tried
a
32-bit
version
of
x86
architecture,
which
happened
to
by
on
this
lowest
level,
using
special
floating
point
unit,
which
executes
with
floating
point
instructions,
and
that
was
pretty
messy.
A
So,
first
of
all,
due
to
the
the
abi
and
nature
of
this
floating
point
distractions,
it
it
kind
of
silently
converts
signaling
numbers
to
non
non-signaling
nouns
or
this
arithmetic
lens.
We
need
we
needed
that.
We
wanted
that
to
actually
test
what
how
how
your
implementation
will
respond
to
signal
implants
if
they
happen
to
load
them
from
memory,
for
example,
that
was
really
hard
to
do.
I'm
not
sure
we
actually
fully
succeeded
with
that.
We
did
some
workarounds
some
special.
A
A
Secondly-
and
this
is
already
something
that
breaks
the
the
compliance
with
the
web
assembly
spec-
is
that,
and
this
fpu
unit
operates
on
higher
precision
that
you
expect.
I
mean
it
operates,
how
it's
it
says
it
will
operate,
but
it
actually
operates
on
higher
precision
that
is
required
by
webassembly.
A
So
with
you
by
default,
it
uses
a
special
extended
precision
which
is
80
bit
long,
and
only
when
you
see
the
results
only
store
it
somewhere
else.
It
will
convert
and
round
your
results,
and
this
happened
to
be
actually
problem
for
for
64
64-bit
types,
because
then
rounding
actually,
even
if
you,
even
because
you
execute
the
instructions
higher
precision,
it
may
happen
that
the
results
will
be
rounded
differently,
that
you
would
do
with
going
with
lower
precision
of
64
bits.
A
Apparently,
there
is
a
way
to
ask
the
cpu
to
to
change
the
precision
of
fpu.
I
don't
think
I'll
ever
succeeded
doing
this,
although
some
say
it's
possible,
but
it
mostly
means
by
in
default
settings
this
32-bit
x86
architecture.
Are
it's
not
compliant
with
webassembly,
so
we
we
did
found
a
solution
or
maybe
a
workaround,
and
so
we
can.
You
can
ask
your
compiler
to
actually
not
use
fpu
and
use
ssa
to
instructions.
A
A
So
what
so
web
assembly
spec
expects
a
single
rounding
mode
which
is
around
to
nearest
around
to
even
around,
to
nearest
even
depending
how
it's
it's
called.
It
means
the
same
thing
and
not
really
going
into
details.
It
would
yeah
if,
if,
if
your
result,
mathematical
result
is
needs
rounding
to
some
representation,
it
will
pick
the
even
nearest
representation
to
the
result.
I
mean
it
will
pick
the
nearest
one
and
in
case
you
are,
you
have
equal
distance
to
two
different
representations.
A
It
will
be
the
even
one
and
yeah
for
fortunately,
that's
like
default
mode,
the
cpu
operating
on-
and
I
don't
know
everyone
who
would
really
want
to
change
that.
Maybe
there's
some
like
numeric
algorithm
things
that
would
require
this,
so
yeah
definitely
not
recommended.
But
still
we
wanted
to
know
what
will
happen
if
someone
would
be
able
to
do
that.
So
this,
this
rounding
mode
is
is
assigned
to
cpu.
A
So
that's
why
we
kind
of
investigated.
What's
going
on
in
case,
someone
will
be
able
to
do
that
or
maybe
that
can
be
used
as
a
feature.
So
you
will.
Your
implementation
will
not
be
really
possibly
compliant.
If
you
change
that,
but
maybe
you
want
to
re,
do
this
for
your
application,
so
yeah.
So
that's
what
will
that
affect?
Firstly,
it
will
affect
rounding
in
the
results-
that's
kind
of
expected,
but
we
also
discovered
number
of
compiler
backs
that
relates
to
that
and
they
provide.
A
A
Okay
and
finally,
so
it's
it's
a
bit
of
summary
of
of
of
our
small
achievements.
So,
first
of
all,
we
would
be
really
interested
in
having
some
kind
of
maintained
and
progressive
web
assembly
1.0
spec.
So
we
don't
want
to
change
it
in
terms
of
how
it
how
the
implementation
should
behave,
but
at
least
increase
number
of
spec
tests
and
maybe
fix
some
small
typos
and
back
and
small
issues.
That's
that's
how,
if
like
use
the
spec
as
a
way
of
communicating
between
different
implementations,.