►
Description
Visit the https://archive.devcon.org/ to gain access to the entire library of Devcon talks with the ease of filtering, playlists, personalized suggestions, decentralized access on Swarm, IPFS and more.
https://archive.devcon.org/archive/watch/6/evm-some-assembly-required/
EVM assembly can be quite opaque and intimidating at first glance. In this talk we'll take a look at exactly how EVM assembly works under the hood while analyzing some common functionality we see in smart contracts - as well as showing some optimization techniques you can use by jumping down to assembly in your solidity contracts.
Speaker(s): Alex Bazhenov
Skill level: Intermediate
Track: Developer Infrastructure
Keywords: Solidity,Assembly,EVM
Follow us: https://twitter.com/efdevcon, https://twitter.com/ethereum
Learn more about devcon: https://www.devcon.org/
Learn more about ethereum: https://ethereum.org/
Devcon is the Ethereum conference for developers, researchers, thinkers, and makers.
Devcon 6 was held in Bogotá, Colombia on Oct 11 - 14, 2022.
Devcon is organized and presented by the Ethereum Foundation, with the support of our sponsors. To find out more, please visit https://ethereum.foundation/
A
A
Hey
guys,
my
name
is
Alex.
I
am
a
lead
developer
at
tally,
ho
and
I'm
here
to
talk
to
you
about
evm
assembly.
So
the
two
things
we're
going
to
cover
in
this
talk
is
first
like
what
is
evm
assembly
and
second,
how
to
read
the
op
codes,
how
to
read
op
codes
and
trace
an
evm
transaction,
but
I
think
before
we
jump
into
that,
it's
pretty
important
to
tackle
a
question
of.
Why
do
we
care
like?
Why
would
we
care
about
UVM
assembly
I?
A
Think
that
there's
a
few
reasons
so
any
of
the
code
that
we
write
as
developers
is
pretty
far
abstracted
from
the
code
that
a
machine
actually
interperson
executes
and
the
closer
we
get
to
this
real
code
and
the
further
we
we
get
from
our
abstractions,
the
more
we
can
reinforce
our
mental
model
of
the
of
what
the
machine
is
actually
doing
and
I.
Think
in
general
learning
from
first
principles
is
a
fantastic
way
to
progress
as
a
programmer
and
to
just
build
solid
and
bulletproof
mental
models
of
what
your
code
is
doing.
A
So
what
is
evm
assembly?
Well,
let's
start
with
what
is
the
evm?
So
you've
probably
heard
of
evm
zke
evm
evmls,
there's
a
lot
of
terminology
terminology
out
there
right
now,
but
at
its
core
the
evm
is
just
a
stack
machine.
It's
something
that
takes
in
instructions,
builds
up
a
stack
and
then
operates
on
that
stack.
Most
of
the
operations
consume.
Values
from
the
stack
so
add
takes
two
values
from
the
stack
adds
them.
A
A
So
let's
go
a
little
bit
more
in
depth
into
the
evm
stack
machine,
so
stack
machine
has
a
depth
of
1024
items.
Each
item
is
a
256-bit
word.
If
you're
not
sure
what
a
word
is.
That's
okay
and
it's
not
really
relevant
for
this
talk
it
just.
It
is
a
slot
on
the
stack
machine
during
execution.
The
evm
has
a
memory
that
does
not
persist
between
transactions.
It
also
has
storage
that
does
persist
between
transactions.
When
we
talk
about
writing
to
the
blockchain,
that's
what
we
mean.
A
We
are
storing
things
in
the
evm
and
also
compiled
to
Mark
contract
by
code
executes
a
number
of
UVM
op
codes.
So
we
have
some
that
you
might
be
familiar
with
if
you've
looked
at
x86
assembly
like
xor
and
add
and
sub,
and
we
also
have
a
number
of
blockchain
specific
opcodes
in
the
evm
and
we'll
dive
into
more
of
these
a
little
bit
later
and
then
I
think.
The
last
important
thing
about
the
stack
machine
is
that
each
operation
costs
a
certain
number
of
gas.
A
So
when
we
pay
gas
for
our
transactions,
we're
essentially
paying
a
little
bit
or
a
lot
of
gas
for
every
single
operation
that
the
stack
machine
executes
all
right.
So
now
that
we
have
some
understanding
of
what
an
evm
is,
what
is
assembly
so
assembly
is
something
that
lives
in
between
the
code
that
we,
as
developers
write
and
between
the
code
that
a
machine
interprets.
So
on
one
hand
we
have
solidity,
which
is
nice.
Some
people
think
easy
ish
to
read
easy-ish
to
reason
about
and
then
on
the
other
end
of
the.
A
On
the
other
end
of
the
spectrum
we
have
bytecode,
which
is
pretty
much
impossible
for
humans
to
read,
but
very
easy
and
very
efficient
for
machines
to
read
and
then
in
between
solidity
and
by
code
we
have
assembly.
So
this
is
kind
of
what
it
looks
like
and
it
is
a
Intermediate
Language
or
an
intermediate
representation,
and
what
that
means
is.
A
It
is
something
that
lives
in
between
the
code
that
we
write
and
byte
code
and
the
the
op
codes
that
you
see
there
are
what
are
actually
running
in
the
evm,
so
the
solidity
or
the
Viper
that
we're
writing
is
compiled
down
to
opcodes
and
then
running
in
the
evm.
And
that's
what
that
pattern
is.
What
lets
us
have
multiple
smart
contract
languages
that
compile
down
to
evm
and
then
are
able
to
be
executed
or
sorry,
the
compile
down
to
assembly
and
then
are
able
to
be
executed
all
right.
A
So,
let's
trace
the
transaction.
I
have
a
website
up
here.
Www.Evm.Codes,
you
might
find
it
useful.
You
don't
need
it
to
follow
along,
but
it's
a
fantastic
reference
that
has
every
single
op
code
in
the
evm,
how
much
gas
it
costs
and
what
it
does
all
right.
So
here
I've
written
this
incredibly
useful
smart
contract.
A
We
have
one
storage,
variable,
total
Supply
and
we
have
a
public
function,
that
anybody
can
call
that
sets
total
Supply
to
eight,
so
very
simple,
smart
contract,
not
much
going
on
here,
not
even
sure
why
anybody
would
use
it
right.
So
the
op
codes
representing
this
contract
should
be
pretty
simple
right.
Well,
we
can
take
a
look,
so
salsi
provides
us
with
a
handy
little
command
where
we
can
pass
a
contract
to
salsi
with
the
opcodes
flag
and
it
will
output
a
opcode
representation
of
that
contract.
A
So
our
simple
contract
becomes
that
which
is
kind
of
unreadable.
But
by
the
end
of
this
presentation,
or
this
talk,
you
guys
will
be
able
to
read
some
parts
of
it,
some
that
are
common
to
all
transactions
that
we
see
in
the
all
transactions
that
we
see
in
the
evm
and
some
that
are
specific
to
the
contract
that
we
wrote.
So
let's
go
ahead
and
trace
a
specific
transaction.
A
Imagine
that
we've
deployed
our
contract
at
some
address
and
then
we're
using
ethers
to
call
ultrasoundmoney.set
Total
Supply,
the
transaction
that
we
defined
in
the
beginning
great,
we
submitted
the
transaction.
It's
been
mined,
it's
part
of
the
blockchain.
Let's
take
a
look
at
it
so,
but
get
has
this
very
handy
command
called
debug,
Trace
transaction.
A
If
you're
here
for
the
previous
call,
you're,
probably
more
familiar
familiar
with
it
than
most
and
what
we
can
do
is
we
can
pass
in
the
transaction
hash
where
we
sent
where
we
invoke
that
sent
total
Supply
function
and
get
an
opcode
Trace
as
well
as
a
like.
A
historic
representation
of
the
stack
of
that
transaction
so
basically
find
out
everything
that
happened
in
it.
A
A
So,
let's
start
with
the
top
this
little
section,
so
we
have
push
one
zero
x80.
What
we're
doing
here
is
we're
pushing
128
onto
the
stack
128.
Sorry
0x80
is
represented
because
the
hexadecimal
representation
of
128,
then
we're
going
to
push
64
on
the
stack
and
then
we're
going
to
call
a
function
called
M
store,
which
is
going
to
store
the
value
128
at
the
offset
64
in
memory.
So,
what's
going
on
here
we
don't
have
128,
we
don't
have
64
on
the
stack
or
we
don't
have
128
or
64
in
our
contract.
A
So
why
is
this
happening
well?
What's
happening?
Is
solidity
uses
the
memory
area
between
address
0
and
address
0x7f
or
127
for
internal
purposes
and
stores
data
starting
at
address
0x80
or
128?
So
this
is
solidity
doing
some
boilerplate
internal
memory
management
for
us
fantastic.
We
don't
have
to
worry
about
this
as
solidity
developers.
This
is
just
a
straight
win.
Wonderful,
all
right!
So
now
we're
going
to
jump
to
line
25
in
our
list
of
op
codes
between
line
3
and
25,
there's
some
more
boilerplate
stuff.
A
There's
a
validation
of
message.value
and
making
sure
like
you
can't
send
ether
to
a
non-payable
function,
but
that
is
not
really
relevant
to
us
because
our
function
isn't
payable.
So
we're
going
to
go
ahead
and
skip
that
great.
So
on
25
we're
going
to
push
4
onto
this
deck
once
again,
where
is
this
four
coming
from
and
then
26
we're
going
to
encounter
our
first
blockchain
specific
opcode?
A
And
what
we're
doing
here
is
we're
pushing
the
size
of
the
input
data
onto
the
stack
and,
as
you
can
see,
we
pushed
four
onto
the
stack.
Now
we
have
four
on
the
stack
again,
so
that
means
our
input.
Data
size
is
four
bytes,
but
where
did
this
come
from?
We
didn't
send
any
ether
and
we
didn't
send
any
arguments
along
with
our
function.
Call
because
there
were
no
parameters.
It
was
just
the
public
function
that
we
invoke.
So
why
is
our
call
data
size?
Four?
Well?
A
In
our
case,
it's
not
because
4
is
not
less
than
four.
So
we
have.
We
push
false
onto
the
stack.
Remember
this
would
be
represented
as
a
zero
or
one,
and
then
we
push
0x,
280
or
38
onto
the
stack
we'll
come
back
to
that
in
just
a
second.
The
next
instruction
that
we
see
is
Jump,
I
and
I.
Think
of
that
as
jump.
A
That
is,
if
the
second
from
the
top
value
is
true
jump
to
line
38.,
since
the
second
from
the
top
value
is
not
true,
we
don't
jump
anywhere,
and
this
like
check,
executes
and
essentially
What's
Happening
Here
is
that
since
functioning
signatures
are
four
bytes
in
length
length,
if
the
call
data
size
is
less
than
four
bytes,
we
know
that
we
can't
possibly
be
calling
a
valid
function
and
then
the
function
gets
reverted.
If
the
call
data
set
is
size
is
less
than
four.
A
So
with
that
idea
of
function,
signatures
in
mind,
let's
take
a
look
at
the
next
section,
so
call
data
load
is
another
blockchain
specific
opcode,
similar
to
call
data
size,
except
instead
of
pushing
the
size
of
the
call
data
onto
the
stack
it
puts.
You
pushes
the
actual
call
data
onto
the
stack.
Remember
that
the
size
of
our
call
data
was
four
bytes.
So
here
we
have
a
four
byte
hexadecimal
value
on
our
stack.
A
That
seems
relatively
arbitrary,
but
some
of
you
are
probably
correctly
guessing
that
we
are
actually
pushing
our
function
function,
signature
onto
the
stack
on
the
next
line.
We
have
Push
four
and
we
push
that
same
exact
function,
function,
signature,
What's,
Happening,
Here
is
the
contract
is
checking
okay,
I'm
being
sent
this
function,
signature
does
it
match.
Does
it
match
this
function?
Signature?
A
And
if
the
answer
is
yes
represented
by
the
op
code,
equal,
so
equal
takes
two
values
from
the
stack
and
returns.
Sorry,
the
top
two
values
from
the
stack
and
returns
true
or
false.
If
they're
equal,
we
hit
a
one
or
a
zero,
and
we
in
our
case
it's
true.
So
once
again
we're
in
that
jump,
I
situation,
so
we
have
true
on
the
stack
we
push
45
under
the
stack
and
now
on
line
36.
A
A
This
is
the
function
that
we
wrote:
Because,
it's
the
function
that
we
tried
to
invoke
fantastic
and
like
this
is
how
the
evm
determines,
which
functions
to
call.
If
you
have
many
functions
in
your
smart
contract,
you're
going
to
have
many
lines
of
like
of
call
data
load,
does
it
equal
this
function?
Signature
does
equal
this
function,
signature.
Does
it
equal
this
one
and
then,
if
it
matches
one
it'll
jump
to
that
line
and
if
it
doesn't
it'll
result
revert
because
you
cannot
call
a
function
that
doesn't
exist,
awesome,
okay,
so
now
we're!
A
Finally,
in
that
very
simple
function
that
we
wrote
If,
you
recall
it
was
total
Supply
equals
eight.
Well,
we
see
on
line.
45
is
a
common
command
called
jump
dest
and
all
that
does
is
it
marks
that
line
45
is
a
valid
destination
to
jump
to
you
cannot
jump
to
any
arbitrary
destination.
You
need
to
jump
to
a
valid
one
or
you'll
revert.
So
this
just
lets
us
know
that
hey
we
can
jump
here.
What's
the
next
thing,
we
see
push
8
onto
the
stack
all
right
awesome.
This
is
definitely
code
that
we
wrote.
A
Total
Supply
equals
eight
I,
remember
eight
This
Is
Us
cool,
but
after
that
we
push
zero
onto
the
stack.
So
where
does
the
zero
come
from?
What
are
we
talking
about?
Well,
if
you
recall
in
our
very
simple
contract,
we
only
have
one
storage
variable
and
that
storage
variable,
because
it's
the
only
one
defined,
is
in
the
first
storage
slot,
so
the
first
storage
slot
or
the
zero
with
or
storage
slot
via
array
indexing
right.
So
this
is
awesome.
We
have
everything
that
we
need.
We
have
eight
we
have
zero.
A
All
we
have
to
do
now
is
save
this
and
we're
done
right,
but
wait
a
second.
We
see
that
in
our
transaction
we
duplicated.
We
ran
Duke
two,
so
we
duplicated
the
second
from
the
top
word
of
the
stack
okay,
then
we
swapped
the
first
and
second
words
on
the
stack,
okay,
interesting
and
then
all
right
great.
So
now
we
ran
s
store,
so
s
store,
store
and
storage,
we're
saving
eight
to
the
zero
with
storage
slot.
A
A
The
solidity
is
doing
extra
memory
management
that
we
don't
want
right,
because
we
want
to
be
as
gas
efficient
as
possible
and
be
as
yeah
be
as
gas
efficient
as
possible,
so
we
should
jump
down
into
Yule
and
try
to
optimize
this
code
right.
Well,
let's
talk
about
gas
optimization
using
yule
if
you're
not
familiar
Yule
is
simply
a
language
that
we
use
to
write
assembly
code
in
solidity.
It's
not
exactly
like
writing.
Op
codes,
not
exactly
like
writing
evm
assembly.
A
It
has
for
Loops
if
and
switch
statements,
and
it
also
disallows
some
commands
like
jump
statements,
because
they
quickly
become
very,
very
difficult
to
reason
about
and
yeah
all
right.
So
we
added
you.
We
have
this
optimize
set
total
Supply
function.
It's
awesome.
We
have
an
s
store
with
a
zero
and
an
eight,
so
we're
saving
eight
to
the
zeroth
slot.
This
is
great.
A
This
is
going
to
be
way
better
right,
go
ahead
and
let's
go
ahead
and
measure
our
our
contract
so
once
again
or
let's
go
ahead
and
look
at
the
op
code,
representation
of
our
contract
first.
So
once
again
we
take
a
look
at
the
op
codes
and
we
see
that
in
fact,
optimized
set
total
Supply
does
have
less
opcodes
than
subtotal
Supply.
This
is
fantastic.
We
know
that
op
codes
cost
gas.
We
see
that
set
total
Supply
and
optimize
that
total
Supply
have
the
same.
Op
codes
except
set.
A
A
So
here
we,
this
is
I,
think
hard
hat
gas
reporter
and
We've
ran
the
set
total
Supply
function
100
times,
and
we
see
that
the
average
gas
cost
is
22,
599.,
cool
and
then
hey
now
we
ran
optimize,
set
total
Supply
and
we
see
that
the
gas
cost
is
23.
591.
awesome,
a
gas
we
have
just
saved
our
users
like
an
enormous
amount
of
money
right.
Well,
not
really
I
kind
of
rubbed.
You
guys
here.
A
And
other
tools
when
you're
deploying
smart
contracts,
so
let's
go
ahead
and
enable
our
Optimizer
in
hard
hat
we
will
set
runs
at
200,
enable
it
and
re-measure
and
in
fact,
when
we
have
the
optimizer
enabled
it
looks
like
the
two
functions
cost
approximately
the
same
amount
of
gas
right.
So
all
our
time
spent
studying
you
will
and
learning
it
and
learning
about
a
store
was
wasted
right.
Well,
I
wouldn't
argue
that
exactly
but
I
will
say
that
optimizing.
A
Smart
contracts
is
hard
and
chances
are
that
you're
not
going
to
do
a
better
job
than
the
compiler.
Unless
you
really
know
what
you're
doing
contrast
containing
assembly
are
generally
harder
to
reason
about
in
order
to
audit
than
contracts
written
in
solidity
and
Viper,
so
what
you
might
gain
and
gas
optimization,
you
will
probably
be
making
a
trade-off
in
a
contract
or
user
security,
and
the
other
thing
that's
important
is:
if
you're
writing
your
own
assembly
code
always
measure
measure
and
make
sure
that
your
implementation
is
better
than
the
compilers,
because
chances
are.
A
There
are
some
very,
very,
very
smart
people
working
on
the
compilers
and
optimizers.
That
know
something
that
you
don't
when
it
comes
to
memory,
management
or
safety
and
I.
Guess
that's
essentially
my
last
Point
remember
a
lot
of
the
memory
management
stuff
solidity
does
under
the
hood.
Is
there
for
safety
reasons,
and
just
because
an
OP
code
looks
like
it's
unnecessary
doesn't
mean
that
it
actually
is
that
being
said,
optimizing
in
Yule
and
an
assembly
is
definitely
something
that
is
needed
and
useful,
especially
in
D5
and
on
mainnet,
where
our
gas
costs
are.
A
You
know
lower
now,
but
quite
higher
than
a
lot
of
the
other
chains,
but
yeah
I
guess
do
so
at
your
own
risk.
So
thank
you
guys.
Once
again,
my
name
is
Alex
I'm,
a
lead
developer
at
tally
ho,
and
we
are
hiring
solidity
and
typescript
developers.
So
if
this
kind
of
stuff
is
interesting
to
you
and
you're,
looking
for
a
change,
please
reach
out
and
then
finally,
I
want
to
give
a
big
thanks
to
Gilbert
Garza.
A
A
The
app
codes
that
we
were
looking
at
were
for
the
for
the
unoptimized
functions
and
we
were
looking
at
them
because
it
is
like
actually
it's
easier
and
possible
to
dissect
them
in
a
talk.
So
when
we
saw
those
two
op
code,
I
guess
have
like
optimized.
What
was
it
set?
Total
Supply
and
set
total
Supply?
Those
are
the
unoptimized
app
codes
and
then,
and
then,
when
after
the
optimizer
runs,
the
opcode
representation
of
those
two
functions
actually
becomes
the
same.
E
A
D
A
Our
unoptimized
set
total
Supply
and
our
optimized
set
total
Supply
in
our
code,
where
the
optimizer
has
not
run
before
after
the
optimizer
runs.
Both
of
these
functions
have
this
have
the
same
exact
op
code
and
in
fact,
even
though
we
have
two
functions
in
our
contract,
the
optimizer
is
smart
enough
to
know
that
they're
doing
basically
the
same
thing
so
the
when
we
were
talking
earlier
about
these
selectors
over
here
right.
A
A
You
can,
you
can
add
them
with
a
there's,
an
unchecked
flag
which
basically
tells
the
the
compiler
to
not
check
for
integer
overflow
I
believe
that
in
solidity,
nine
point
something
in
some
fairly
recent
version
of
solidity.
Safe
math
became
I
I,
guess
like
well.
There
are
a
lot
of
checks
that
run
under
the
hood.
A
You
can
turn
off
those
checks
if
you're
sure
that
you
don't
need
them,
but
and
that'll
save
gas,
but
once
again
that
can
be
very
dangerous
and
as
far
as
resources
for
learning
UL
I
think
just
like
reading
smart
contracts
and
trying
to
figure
out
what's
going
on,
there
is
the
best
way
to
do
it.
There
are,
unfortunately,
no
good
resources
to
you
or
to
learn
you
will
or
really
evm
assembly,
and
which
is
that
I
want
to
just
talk
just
like
yeah.
B
So
my
question
is
this
right,
like
say,
for
instance,
if
I'm
writing
trim
and
I'm?
Basically,
you
know
trans
transpiling,
my
smart
contract
into
into
trim
like
what
are
the
I
guess
like
the
pros
and
cons
to
that
as
opposed
to
doing
it.
You
know
your
style
like
within
solidity
and
then
don't
use
Yule.
Unfortunately,.
A
I
can't
I
can't
answer
that
question,
because
I'm
not
familiar
enough
with
trim
I
do
believe
that
Gilbert
was
the
the
person
that
I
mentioned.
Anything
in
my
talk
was
the
person
that
developed
trim
or
one
of
the
developers
and
I
would
encourage
you
to
reach
out
to
him
on
Twitter,
but
I'm
not
familiar
enough
with
shrimp
to
answer.
C
A
What
number
I
just
choose
200,
because
it's
standard
I
know,
there's
I
know
that
there
is
a
or
it's
not
standard.
It's
just
like
standard
in
what
I've
written
I
know
that
there
is
a
there's
eventually
a
trade-off
size
between
contract,
size
and
and
gas
efficiency
that
you
get.
If
you
set
your
Optimizer
to
like
I,
don't
know
500
000
a
million
or
maybe
less
but
I
generally
go
with
200.