►
From YouTube: Rust Cologne, June: Florian Zeitz - Inline Assembly
Description
Rust's support for inline assembly is currently unstable. The talk will give an overview of the current unstable implementation in Rust, as well as inline assembly support available in other programming languages. This will lead into a discussion about a sensible design for this feature and a way to stabilize this eventually.
More on the website: http://rust.cologne/2017/06/07/rust-2nd-aniversary-part-2.html
A
Okay,
so
hello
yeah
today,
I
want
to
talk
to
you
about
inline
assembly
actually
in
general
I'm,
not
just
in
rust,
but
let
me
get
to
some
background
about
that.
So,
basically,
I
am
among
the
person
suit,
like
some
inline
assembly
in
rust,
because
I'm
often
doing
relatively
close
to
the
metal
programming
and
doing
embedded
I'm
at
least
interested
in
writing
kernel
code,
so
I
think
that's
something
that
would
be
nice
to
have
and
rust
does
happen.
Mb
right
now,
but
only
on
the
nightly
branch
and
into
the
state
that
could
never
be
stabilized.
A
Defector
also
is
in
the
state
very
similar
to
what
other
compilers
do
and
people
hate
what
does
a
compiler
student,
so
my
hope
is
that
we
could
do
better,
and
this
is
sort
of
a
survey
talk
of
what
do
other
people
do.
What
could
we
borrow?
What
do
we
definitely
not
want
to
borrow
and
what
would
be
a
decent
design
point
for
us
be
possibly
right.
Okay,
so
sort
of
the
rundown
of
this
stuff
is
going
to
be
first
of
all,
why?
A
Why
would
you
want
inline
assembly,
then
the
quick
overview
just
about
what
is
assembly
in
general
I
know.
We
have
some
very,
not
lower
hardware
at
guys
here,
which,
by
the
way,
also
means
if
at
any
point,
if
we
like
you,
have
a
question
or
something
just
ask
if
possible,
use
the
mic
for
the
recording,
but
also
just
ask
and
I
repeat
it,
because
I
realize
a
lot
of
the
stuff
is
possibly
obvious
to
me,
but
not
obvious
to
any
of
you,
so
I'm
going
to
try
to
explain
it.
A
But
if
you
have
questions,
just
ask
so
quick
overview
of
what
is
assembler
just
so
we
are
all
talking
about
the
same
thing,
quick
overview
of
what
I
think
designed
all
so
this
should
be
like
what
is
this
coming
out
or
that
we
should
get
to
with
the
design
and
then
with
that
in
mind
prior
art.
So
what
are
other
languages
doing
in
terms
of
inline
assembly?
As
I
said?
What
can
we
borrow?
What
not,
then
a
quick
run
enough?
A
A
So?
This
is
the
first,
why
you
always
get.
If
you
tell
anybody,
I
went
in
my
assembler
and
rust,
because
Russ
supposed
to
be
that
super
safe
language,
like
no
tech,
Falls,
know
that
he
Rises
know
anything.
So
what
the
hell
are
you
doing
putting
in
on
is
something
in
there.
That's
like
super
insecure,
and
why
would
you
ever
do
that
right?
So
here's?
Why
sometimes
you
just
need
to
get
to
that
low
level
right
and
maybe
that
started
the
bottom.
A
The
rest
philosophy
in
general
is
be
safe,
but
if
necessary,
have
an
unsafe
escape
hatch
that
you
can
rape
in
an
unsafe
block
and
make
sure
that
what
you're
doing
is
actually
safe
but
provide
that
escape
hatch
if
necessary.
So
what
you
can
do
with
inline
assemblies
a
lot
of
different
things.
You
can
get
a
lot
of
control,
particularly
like
colonel
or
emitted
space.
You
might
want
to
have
write
access
to
convict
register,
so
maybe
some
hardware
can
only
really
be
accessed
from
a
something
right
like
DMA.
Spi
interfaces
are
kind
of
stuff.
A
You
might
want
for
performance
if
your
compiler
is
not
actually
intelligent
too
enough
to
optimize
certain
things
you
might
want
to
go
back
to
assembly
just
to
get
the
performance
you
need
for
a
certain
case,
maybe
you're
doing
video
playback.
Whatever
you
want
to
use
vector
instructions,
the
compiler
can't
figure
out
that
it
can
use
them
because
of
whatever
circumstances
on
your
problem,
you
might
want
to
be
able
to
drop
down
to
that.
A
Sometimes
you
need
predictable
timing
in
ember
that
you
sometimes
need
predictable
timing,
because
maybe
your
hand
writing
something
that
turns
certain
pins
high
at
low
and
you
need
to
produce
a
certain
clock
or
whatever
you
want.
Predictable
timing
in
cryptography
actually
won't
usually
constant
timing,
so
that
the
timing
does
not
depend
on
the
input.
So
nobody
could
guess
what
you're
encrypting
from
observing
timings
of
your
messages,
so
side
channel
resilience
also
usually
better
to
do
if
you
have
access
to
the
assembly,
even
in
assembly
hard
to
do,
but
that's
a
whole
different
problem.
A
And
lastly,
to
the
point
of
why
do
you
need
inline
assembly?
Because
you
could
write
a
separate
assembly
file
right
and
link
to
that
mostly
convenience?
In
some
cases?
It's
for
performance,
because
you
have
the
immediate
interaction,
because
your
inline
assembly
injection
code,
but
in
many
cases
you
could
write
a
separate
assembly
file,
put
that
certain
assembler
link
that
with
the
rest
of
your
code,
but
it's
inconvenient
you
have
that
separate
file.
Maybe
that
feels
a
bit
alien
to
the
rest
of
your
code
and
it's
not
just
a
function
is
the
same
file.
A
Okay,
so
this
is
heme
that
we're
all
talking
about
right.
What
does
that
even
and
I
thought?
That's
started
with
some
examples
in
case
yeah,
like
never
seen
something
so
assembly
is,
let's
say,
a
textual
description
of
what
instructions
run
on
your
computer
and
naturally,
there
are
different
dialects
depending
on
what
processor
you
are
using,
but
rather
unfortunately,
there
are
even
different
dialects
for
the
same
processor
occasionally.
A
A
What
is
which
is
what
the
new
assembler
would
expect,
and
the
answer
is
the
syntax
that
intellectually
puts
in
all
of
their
manuals
and
that
some
of
the
Microsoft
assemblers
accept,
or
at
least
something
similar,
that
things
like
nazma,
diaz,
except
and
also
people
seem
to
generally
agree
that
the
Intel's
index
is
much
more
readable
of
Angie
AT&T
syntax,
but
the
AT&T
syntax
is
way
more
straightforward
to
get
access
to
if
you're
on
a
new
system.
A
Listed
up
with
commas
and
between
them
and
operands
to
those
interactions,
I
use
routines
like
either
numbers
so
call
them
idiots,
because
you
immediately
encoded
into
the
instruction
that
you
have
a
five
and
that
five
go
straight
in
there
and
those
have
different
ways
to
write
them.
Like
AT&T
Centex
writes
it
was
the
dollar
sign
in
front
of
it.
Intro
syntax
just
writes
up
line.
Five
armed
writes
in
medians,
with
a
hash
sign
in
front
of
them.
Powerpc
also
doesn't
really
put
things
in
front
of
them
for
registers.
You
also
have
different
conventions.
A
Also,
something
I
want
you
to
pay
attention
to,
because
it's
going
to
get
relevant
later.
Is
there
are
a
lot
of
special
characters
in
use
here,
like
you
already
saw
there?
Is
that
also
and
there's
a
person
sign
there
round
braces,
there's
an
exclamation
mark.
Sarah
square
braces
hash
sign
whatever
you
have
plus
times
so
many
different
things
that
could
have
here
in
just
regular
assembly
right
and
we
get
to
why?
That's
important
later
this
a
properly
what
I've
already
covered.
So
it's
a
texture
presentation.
You
call
them
instruction
names,
basically
mnemonics.
A
They
don't
have
to
want
to
want
checked
with
CPU
instructions.
That
might
also
depend
on
the
operands
that
it
has,
but
they
are
a
mnemonic
name
for
the
instruction
and
you
have
various
operands
registers.
Immediates,
sometimes
labels
to
which
we
sought
to
address
in
the
code
and
combinations
arrow
like
something
you
see
at
the
bottom
of
the
x86
assembly
is.
This
is
a
way
to
address
memory
based
on
contents
of
registers
and
then
multiply
it
by
some
immediate
okay,
subs
angles.
Where
do
we
actually
want
to
me?
A
And
the
list
is
not
super
long
like
it
should
be
easy
to
use?
Okay,
that's
what
you
usually
run
from
any
new
feature
right,
I
think
it
should
be
portable,
like
personally
meaning
between
platforms,
so
you
wouldn't
want
to
define
something
that
really
only
works
on
x86,
only
we're
saying
264
only
on
arm.
You
should
have
some
way
to
have
this
work
across
architectures
because
defining
it
and
then
figuring
out
like
okay.
A
Now,
if
x86
covered
and
I
want
to
do
some
member,
the
programming
on
my
arm
or
AVR
processor
and
just
not
being
able
to
could
be
rather
annoying
and
generally,
we
would
also
want
it
to
be
portable
between
backends,
like
the
Ross
compiler
is
right
now
L
am
base
and
there's
one
R
Us
compiler.
But
this
to
me
it
feels
like
the
ultimate
goals
that
rust
is
a
language
specification
and
there
could
be
more
than
one
implementation.
A
People
have
already
talked
about
porting
parts
of
the
actual
main
rust
compiler
over
cretonne
to
cretonne
to
get
faster,
compile
times.
Someone
had
started
on
a
GCC
based
port
of
rust,
and
we
would
we
be
shame
if
we
did
something
that
super
locked
us
to
only
being
able
to
implement
this
on
a
VM
I.
Think
that
would
be
earth
unfortunate
and
that's
sometimes
check
I've
actually
put
a
question
mark
behind
is
it
would
be
nice
if
I
supported
all
instructions
with
all
possible
upper
end
types
on
them?
A
But
it's
actually
to
me
at
least
an
open
question,
if
that's
at
all
possible,
because
you
always
need
some
knowledge
in
the
compiler
itself
about
the
instructions
for
that
to
work,
which
means
that
for
every
new
processor,
basically
you'd
have
to
change
the
compiler
immediately
and
I.
Don't
think.
That's
particularly
feasible.
A
Okay,
so
some
prior
art.
So
let's
look
at
what
others
do.
D
noticeably
is
also
a
rather
modern
programming
language
systems,
programming
language.
A
What
they
did
is
they
basically
implemented
in
DSL,
which
goes
into
a
NASM
block
which
to
start
with
as
iment
and
the
actual
DSL
and
curly
braces,
and
they
say
this
is
standardized
per
CPU
family.
So
every
different
CPU
can
have
a
completely
different
DSL.
In
theory,
though,
the
only
ones
that's
currently
available,
actually
x86
and
MD
64,
so
the
x86
processors
are
textures,
so
to
speak
as
it
can
be
marked
additional
to
as
pure
and
no
throw
so.
You
can
actually
make
certain
assertions
about
your
assembly.
That's
a
compiler.
A
A
What
does
it
actually
look
like
in
the
case
of
xe6
and
AMD
64,
because
that's
the
only
one
that
actually
has
like
a
defined
yourself
now
and
what
they've
done
is?
They
have
kept
it
pretty
close
to
regular
intel
syntax.
So
just
what
you
would
write
for
an
Intel
processor,
basically,
changes
are
that
registers
always
have
to
be
uppercase
names.
A
Mnemonics
are
always
lowercase,
and
then
you
can
refer
to
variables
of
the
enclosing
scope
by
a
name,
or
at
least
you
can
refer
to
them
by
a
name
indexed
by
the
base
pointer.
So
your
sec
base,
pointer
or
if
you're,
not
writing
naked
codes.
The
codes
that
doesn't
actually
set
up
a
stack
you
can
also
refer
to
them
just
by
the
variable
name.
They
allow
many
D
expressions
into
somebody
statements
too,
so
you
can
do
regular,
Namira
calculations.
In
your
assembler
statement.
A
They
use
the
dollar
sign
to
represent
the
program
counter,
so
the
registers
are
tells
you
at
which
point
is
a
program,
your,
but,
interestingly
enough.
That
is
only
supported
for
jumping
between
instructions.
You
cannot
use
it
to
refer
to
memory
relatively
to
your
program
content,
which
is
something
that
you
might
want
to
do
when
writing
so-called
position
independent
code,
where
the
benefit
is
said
it
doesn't
matter
at
which
ever
is
a
memory.
A
That
code
lies
which
is
nice
to
have
for
security,
because
people
can't
depend
on
addresses
of
the
code
when
they're
writing
spots
for
it.
Interestingly
enough,
they
also
don't
support
accessing
the
external
instruction
portraits
or
are
there
are
IP
address
register
is
not
defined
for
amd64,
which
would
be
another
way
to
do
that.
A
There
are
some
Authority
operations
to
get
alignment
to
certain
addresses,
to
define
data
in
line
and
also
instruction
prefixes
I'm,
not
entirely
sure
what
instruction
prefix
is
upside.
You
operations
are
not
actually
prefixes
to
the
instruction.
If
you're
writing
your
customers
I'm
there
anyway,
that
seems
like
something
you
should
have
been
able
to
do,
but
you
have
to
write
them
as
proper,
separate
instruction
before
the
instruction
you
want
to
prefix
by
them.
A
So
some
very
very
simple
examples
for
this,
so
this
is
just
codes
that
will
increment
variable
var
by
5
and
it's
actually
pretty
straightforward.
You
define
the
variable,
you
read
nezam
block
and
you
call
to
the
add
instruction
and
you
can
use
the
variable
that
name
in
line
and
just
to
have
shown
it.
You
can
do
usual
D
calculations
in
there,
so
you
can
add
3
to
2
and
then
it
ruins
as
a
result
of
that
in
the
generators
assembly.
A
Something
a
bit
more
complex
to
actually
show
some
of
the
edge
cases,
get
the
size
of
the
l1
cache,
and
since
this
is
the
first
time,
I'll
show
you
the
code
I'm
going
to
talk
about
it
in
more
bit
more
detail
for
other
versions
of
game
to
glance
over
it.
I
guess
so.
The
way
to
do
that
is
basically
the
CPUID
instruction,
which
gets
you
a
lot
of
different
information
about
your
cpu
and
so
information
that
it
does
get.
A
You
actually
depends
on
the
current
value
of
a
register,
the
EAX
register
and,
if
you
set
it
to
4,
which
is
what
the
first
line
that
gives
you
information
about
caches
and
the
ECX
register
specifies
which
catch
cache
level.
You
want
to
get
information
about
so
setting
it
to
zero,
which
is
what
the
XO
does
gives
you
information
about
the
first
level
cache
right.
A
A
A
A
My
guess
would
be
that
they
probably
also
can
be
executed
at
runtime,
because
what
that
anta,
what
I
suspect
that
would
end
up
doing
that
said
like
that
is
it
will
actually
pull
those
expressions
before
the
assembler
block
and
then
insert
the
return
value
of
that
into
the
block.
So
if
it
had
side
effects,
they
would
just
happen
before
your
assembly
granted
that's
actually
surprising,
behavior,
possibly
and
I.
Don't
know
if
that
is
the
behavior
or,
if
they've
restricted
it
sufficiently.
A
But
that
would
be
my
guess
about
what
they
are
doing
might
also
be
there's
only
stuff
that
can
be
constant
folded
like
it
certainly
accesses
to
struct
members,
excess
tears
and
stuff
like
that
all
works,
anything
else:
okay,
so
MSP
C,
so
we're
now
in
theory,
territory
of
the
C
and
C++
language.
This
is
a
microsoft,
visual
c
compiler
and
they
actually
doing
a
very
similar
thing.
So
I've
not
put
as
many
words
in
it.
They
have
a
DSL,
it's
also
an
ism
block.
This
time
it's
written
with
to
an
alliance.
A
A
Marineland
assembly
is
only
really
supported
for
x86
and
particularly
also
saying
the
instructions
we
support
for
that
platform
are
only
what
you
get
on:
Pentium
4
and
AMD
Athlon
processors,
so
nothing
from
later
processors,
I
presume
at
least
so.
This
D
is
ours
to
some
extent.
Basically,
what's
the
Microsoft
macro
assembler
accepts
simple,
just
as
expressions
in
those
curly
braces,
and
it
allows
some
rather
interesting.
A
Things
like
you
can
do
jumps
from
your
assembly
code
to
see
labels
and
you
can
do
jumps
or
go
to
actually
from
your
C
code
to
assembly
labels
just
restricting
some
of
the
upper
and
lowercase
Ness
of
them.
You
can
also
freely
call
into
C
functions
from
your
assembly
without
any
fear
of
that
affecting
anything
else
which
is
not
usual
because
calls
into
C
functions.
Of
course,
change
a
lot
of
registers,
so
you'd
have
to
take
care
of
restoring
them
properly
once
returning
from
them
right.
A
Also,
you
can
use
some
sleep
and
suppose,
no,
you
can't
use
any
see
in
simplest
operators
in
your
inline
assembly,
so,
unlike
D
they've
restricted
that
from
happening.
So
some
things
they
support
from
the
Mazon
syntax
or
if
they
didn't
support,
you
can't
do
data
definitions,
also,
unlike
D,
which
has
special
proceed
operations.
For
that.
You
also
can't
do
macros,
which
give
the
macro
assembler
is
name
right.
A
What
you
can
do
is
you
can
do
alignment,
so
you
can
align
instructions
to
certain
addresses
and
you
can
do
comments
in
mine,
which
is
kind
of
nice
from
C
and
C++
elements.
You
also
can
use
the
C
comments
you,
so
you
get
plenty
of
comments,
syntax.
Actually,
you
can
use
any
symbols
that
exist
in
C,
so
label
55,
as
I
said,
you
can
also
even
jump
to
them
function.
Names
variable
names
can
be
used
in
line
you
can
use
constants
from
the
sea.
A
So
the
same
examples-
and
actually
they
also
quite
looks
the
same
I-
think
with
this
one-
it's
actually
the
same
coat
and
that
matter
could
be
a
copy
and
paste
error,
because
there
it's
missing
two
underlines
for
this
one.
It's
a
bit
different
and
I
should
probably
say
that,
because
I
don't
readily
have
access
to
em.
As
we
see
I
did
not
test
those
I
tested
all
of
the
other
ones,
including
the
D
ones,
didn't
test
those
actually,
but
from
the
documentation.
The
way
how
that
works
is
pretty
much
exactly
the
same.
A
You
have
to
call
your
rivals
different
from
your
registers,
because
you
can't
does
that
mean
Big
Ear
it
between
them.
Otherwise,
so
you
have
to
do
this
in
this
case,
I'm
a
line
D
trick,
but
other
than
that
you
fill
your
registers,
you
call
cpuid
and
you
move
your
register
contents
to
your
variables.
A
B
B
A
So
yeah,
so
the
usually
determined
we'll
get
to
that
Bailey
over
the
next
two
or
three
slides
is
which
registers
a
club
art
so
which
are
used
by
the
assembly.
And
yes,
since
this
is
a
DSL
and
C
compiler,
basically
has
full
knowledge
about
what
happens
inside
there.
It
knows
and
it
will
assign
reduces
accordingly
to
variables
and
all
that
stuff
see.
B
A
Cpuid
desu
klappa
forages
is
technically
right
because
it
has
output,
EAX,
EBX,
ECX
edx,
and
that
would
have
to
be
defined
in
this
assembly.
Implementation
like
from
what
I'm
understanding
is.
This
is
basically
full
assembler
written
in
your
compiler
to
some
extent
based
on
what
they're,
supporting
and
aren't
supporting,
probably
borrowing
heavily
from
azzam,
but
that's
a
guess,
and
they
know
about
side
effects.
Yes,
I
as
far
as
I
can
see,
elbows,
D
and
M,
as
we
see
do,
because
otherwise
it
would
just
break
down
with
every
surrounding
code,
obviously
yeah.
A
A
Okay,
so
still
in
seed
and
GCC
GCC
also
has
an
extension,
the
C
extension
for
inline
assembly,
maybe
I,
should
actually
make
that
more
clear.
C
does
not
itself
standardize
how
inline
assembly
works.
So
if
you
can
do
an
eye
assembly,
it's
an
extension
of
the
compiler
M
as
we
see
as
one
Jesus.
Yes,
a
different
one,
and
it's
actually
very
different,
like
it's
almost
fair
to
say
that
those
are
the
two
different
schools
of
it.
A
A
So
the
compiler
itself,
the
C
compiler-
does
not
have
to
know
about
the
instructions
or
anything
it
just
has
to
generate
a
string
from
what
you
gave
it
that
will
later
work
with
the
system's
assembler,
so
the
syntax
you
put
in
there
will
basically
also
have
to
end
up
being
what
your
system
assemble
supports,
which
is
in
some
way
very
nice,
because
it
means
if
your
CPU
gains
a
new
instruction,
that
your
system,
assembler
is
updated.
An
instruction
will
be
supported
as
long
as
you
can
fill
the
placeholders
correctly,
which
is
the
catch
explained.
A
So
what
do
these
templates
look
like?
They
are
basically
usual
instruction
sequences
and
the
placeholders
are
dollars:
equity
%
4,
followed
by
number
or
followed
by
angle,
braces
and
then
a
name
in
them.
So
you
can
use
names,
parameters,
sort
of
and
positional
ones.
You
can
use
some
modifiers.
So
if
you
say
I
want
to
insert
a
register
in
there,
but
it
should
be
a
16-bit
and
set
of
a
32-bit
register.
You
can
use
the
W
modifier,
for
example,
just
in
front
of
these
number.
A
It
also
supports
some
rather
obscure
features
like
in
cases
like
x86,
where
for
the
very
same
architecture,
you
have
different
dialects,
AT&T
and
dental.
Sometimes
you
can
write
those
different
dialects
next
to
each
other,
just
wrapping
them
in
curly
braces
and
putting
a
bar
between
them.
The
catch
about
that
is
that
you
either
just
write.
The
first
supported
one
in
the
lists,
which
is
AT&T
for
GCC
and
for
x86
all
you
have
to
specify
all
of
them,
so
there
are
like
for
some
reason,
five
dialects
for
CPU.
A
A
What
they're
all
saying
necessitates
is,
of
course,
that
you
have
to
escape
all
those
special
characters.
So
if
you
actually
want
the
person
signing
your
assembly,
you
have
to
put
first
two
person
signs
in
your
template,
so
it
will
escape
and
not
be
treated
as
a
place
over.
Similarly
for
curly,
braces
and
submerged
character,.
A
So
what
do
you
arguments
that
are
put
into
those
placeholders
actually
look
like,
so
you
have
to
specify
three
things:
outputs
inputs
and
flowers,
so
inputs
are
things
that
come
from
a
register.
Your
assembly
in
some
way
reads
and
that
well
get
used
by
it.
How
puts
are
things
that
will
go
into
a
variable
and
that
your
assembly
in
some
way
writes
it
is
important
for
the
way
that
GCC
generates
the
code
of
that
that
you
only
do
those
things
with
them.
A
If
you
write
an
input
that
could
totally
break
your
program,
if
you
written
out
would
probably
less
that
things
will
happen,
but
they
usually
have
just
undefined
values
in
them.
So
you
don't
want
to
do
that.
A
third
thing
is
clubbers
and
we
talked
about
clubbers
before
so,
since
the
template
is
completely
apart
to
the
compiler
and
it
doesn't
understand
what
those
instructions
actually
do.
It
has
to
have
knowledge
of
what
registers
were
influenced
by
what
the
template
did.
So
in
flowers,
you
basically
specify
okay.
A
This
code
touched
these
registers,
and
maybe
it
also
touched
memory
that
you
don't
know
about,
and
maybe
it
touched
some
facts
in
the
CPU
and
changed
them
that
you
don't
know
about
so
the
compiler
know.
We
said
it
would
have,
for
example,
to
reload
memory
to
say
for
register
to
memory
before
it
executes
the
assembly
block
and
load
it
back
from
memory
after
it
executed
it.
So
the
value
remains
the
same
and
all
those
things
and
that's
sort
of
what
makes
GCC
style
assembly
very
difficult,
because
you
have
to
keep
in
mind
all
side
effects.
A
All
the
instructions
you
just
use
have,
and
often
that's
not
as
explicit
like
you
saw.
Cpuid-
has
no
operands
whatsoever,
but
it
affects
four
registers
at
has
a
one
operand
version
that
implicitly
always
writes
two
EAX
and
EBX.
So
those
things
can
be
very
unhappy
as
to
you
and
you
have
to
manually
specify
them
yeah.
A
So
obviously
need
to
know
a
bit
more
about
those
parameters
to
fill
the
template.
So
you
can't
just
say:
okay
use
an
input,
and
that's
going
to
be
this
variable.
You
also
have
to
know,
does
I
have
to
go
in
the
register.
It's
just
an
introduction
that
supports
and
registers
an
operon.
This
is
a
memory
address.
It
is
an
immediate.
So
what
exactly
needs
to
go
in
the
template
so
that
it
will
actually
assemble?
A
For
that?
You
specify
certain
constraints
on
your
operands.
Those
are
usually
in
GCC
just
signal
letters
which
makes
it
occasionally
you
bit
hard
to
remember
those
letters
are
architecture-specific,
so
they
are
different
for
x86
different
for
arm,
though
there
are
some
that
are
common
among
all
those
system.
The
dialects
which
are
usually
are
M
and
I,
which
is
just
for
a
register
for
memory
location
and
for
an
immediate.
A
A
Right
so
building
even
on
that
there
are
some
ways:
the
constraints
have
to
be
specified,
so
output
operands,
even
though
they
go
in
a
certain
location
in
the
list,
I
always
have
to
start
with
either
an
equal
sign
or
a
plus
sign.
The
equal
signs
means
this
is
not
pelipper
and
the
plus
sign
means
this
is
an
input
and
an
output
up
run.
A
The
reason
to
do
that
in
turn
is
that,
specifically
on
platforms
that
have
only
very
few
registers,
you
don't
want
to
allocate
too
many
registers
to
variables,
so
what
the
compiler
will
actually
do
is
it
will
give
the
same
register
to
an
input
and
an
output.
So
if
you
write
to
an
output
before
reading
all
the
inputs,
you
might
just
have
overridden
one
of
your
inputs
in
order
to
make
sure
that
you
can
write
to
some
appearance
early
on.
You
have
those
syntax
to
specify.
This
is
an
early
cover
occasion,
so
it's
overwritten
earlier.
A
Then
you
read
all
the
inputs
and
that's
done
within
a
%
inputs
I,
usually
just
like
that
simulator
character
as
I'm
constrained,
but
you
can
also
specify
a
number,
which
is
the
number
referring
to
one
of
the
upper
two
operands,
which
is
saying:
okay,
4.
Is
this
operand
put
it
in
the
same
location
that
you
put
this
output
so
in
some
sense
it's
basically
the
very
same
thing
that
you
can
do
with
the
plus
notation.
A
So
say
this
is
an
input
out
an
output,
but
it
allows
you
to
specify
a
different
variable
as
the
input
that
goes
into
the
register
and
as
the
output
that
comes
from
the
register
and
clobbers
I've
already
talked
about
a
bit.
You
can
say
which
registers
were
used
which
actually,
which
registers
that
the
compiler
doesn't
already
know
about
were
used
because,
obviously
you
can
say:
okay
I
have
now
put
in
this
upper
distant
register
and
the
compiler
can
freely
choose
what
register.
A
That
is
so
it
knows
which
register
chose
for
that
upper
end,
but
it
doesn't
know
which
registers
you
explicitly
potencies
assembly.
So
this
is
baby,
specify
or
register
that
think
apart.
It
doesn't
already
know
clever,
you
can
also
say
a
flexible
modified,
you
can
say,
memory
was
modified.
Also
in
that
case
it
means
memory.
That's
a
compiler
doesn't
know
about.
So
the
compiler
knows
that
it
gave
you
a
memory
operands
that
referred
to
variable
in
and
it
was
an
output.
A
There's
also
a
volatile,
specifier
and
volatile
basically
does
two
things:
it
disables
code
motion.
So
one
of
the
nice
things.
Let's
say
that
the
ways
you
CC
assembly
is
built
allows
you
to
do.
Is
you
know
most
to
all
side
effects
of
the
instructions?
So
you
know
exactly
what
was
modified
because
you
either
have
to
specify
in
a
clapper
or
the
compiler
itself,
determined
that
this
was
going
to
be
something
that
was
going
to
be
modified.
So
you
can
do
optimizations
on
this.
A
So
if
you
know
that
nothing
is
changing
in
the
execution
of
the
assembly
across
loop,
iterations
or
whatever,
you
can't
pull
that
assembly
bug
out
of
the
loop
and
just
execute
it
once
or
if
you
know
that
the
outputs
of
that
assembly
block
are
never
going
to
be
used
for
whatever
reason
you
can
just
optimize
it
away
completely,
but
sometimes
you
don't
want
that
and
in
those
cases
you
declare
the
70s
volatile
cases
where
this
is
required.
For
example,
something
like
the
WAV
instruction
on
arm.
A
What
it
does
is
it
waits
for
an
interrupt,
so
waiting
for,
interrupts
doesn't
technically
have
any
side
effects
like
it
pauses
execution
until
an
interrupted
see
it
comes
in
from
somewhere,
but
it
doesn't
write
memory.
It
doesn't
write
a
register.
It
has
nothing.
You
could
actually
tell
the
compiler
changed
right,
but
you
still
definitely
want
it
to
execute,
because
you
wanted
to
pause
the
execution
to
save
energy.
Usually
so
that's
a
case
where
you
would
specify
volatiles
so
executors,
always
even
if
you
think
it's
completely
unnecessary
and
would
want
to
throw
it
away.
A
So
those
are
basically
the
same
examples
just
this
time
more
complex
because
say
GCC,
something
you
still
declare
a
variable
and
then
you
have
thousand
blocks,
and
this
is
what
those
templates
look
like,
and
in
this
case
it
seemed
kind
of
nice
like
it's
AT&T,
syntax,
so
I
said
everyone
likes
Intel.
This
is
the
reason
why
those
dollar
signs
took
in
front
of
your
immediate
but
other
than
that.
A
There's
a
person
zero,
that's
one
of
those
placeholders
we
talked
about
and
then
at
the
end
there
is
a
specification
of
an
output
operand
in
line
two
with
a
plus
sign.
So
that
says
this
is
post
an
input
in
now
put
meaning
I
chose
a
register.
I
read
from
the
variable
var
into
the
register.
I
execute
your
instruction
and
then
I
write
from
that
register
back
to
the
variable
right
and
as
I've
mentioned
before
it
another
way
to
do
that
is
define
both
an
input
and
an
output
with
the
same
variable.
A
A
A
Okay,
so
I'm
going
to
assume
I've
confused
everyone
sufficiently
to
that
point,
so
we're
still
going
to
do
together,
yeah
one
cash
example,
because
that's
even
more
complex
right,
so
the
assembly
is
still
exactly
the
same.
Just
something
you
will
notice
is
now
we
have
those
placeholders
which
start
with
the
percent
signs
and
18t
syntax
once
all
register
names
to
start
with
a
percent
sign.
A
A
That's
in
copilot
choose
chose
3cx,
something
you
can
do
and
actually
I
think
we
couldn't
really
do
in
D
and
M
SVC
before,
as
we
can
tell
the
compiler
hey
this
variable,
please
tie
that
to
the
C
register,
so
the
whole
CFM
rename
CL
CX
@
e,
CX
r
CX,
so
we
can
say
equals
C.
Meaning
puts
us,
get
this
from
the
C
register
and
write
it
into
the
ECX
variable,
which
does
nothing
else
then
write
that
mauve
instruction
for
us.
A
Basically,
and
then
we
talked
about
these
clubbers,
so
the
CPI
uid
instruction
clubbers
EAX
EBX
ECX
EDX.
Now
the
compiler
knows
that
it
treats
ECX
as
an
output.
So
we
don't
have
to
specify
ECX
in
that
level
list
anymore
and
actually,
if
we
do,
the
compiler
will
complain
and
tell
us
hey.
Your
constraints
are
uncomfortable
you're
asking
me
to
never
use
ECX,
but
you
also
has
community
to
use
easy
access
and
output,
and
at
that
point
we
do
let's
say
the
usual
calculation.
It
said
more
or
less
here,
what's
happening
there
more
or
less.
A
C
A
So,
okay,
so
not
right,
not
all
instructions
support
using
them
with
all
registers
and
basically
the
way
that
works
is
that
those
constraints
specify
a
certain
register
clause.
So
if
you
say
R,
that
means
not
any
registers,
and
but
that
means
any
general
purpose
register
right
so
for
C's
is
very
obvious.
That's
one
specific
register,
so
you
have
to
make
sure
that
this
instruction
works
with
that
specific
register
for.
A
A
So
yeah
a
pop
quiz,
sorta
I've,
made
this
3/3
example
for
GCC
just
to
get
a
point
across.
So
what
this
is
meant
to
do
is
you
have
an
input
and
output
variable
the
input
assets
is
3
and
you
want
to
well
but
really
increment
I.
Guess
you
want
to
add
1
to
the
value
of
input
and
write
that
2
out
so
started
to
get
into
nothing
of
my
C
from
out
here.
What
does
assembly
does?
Is
it
moves
the
value
1?
So
there's
an
immediate
right
into
the
first
operand.
A
So
it's
white,
we
have
placeholder.
The
first
operand
in
this
case
is
a
register
which
is
bound
to
the
out
variable,
so
it
moves
1
2
out
basically,
and
then
it
adds
the
second
operand
of
the
second
well
argument.
Let's
say
to
that
out
variable
so
naturally,
since
we
had
one
in
there
and
then
we
added
the
value
of
the
in
variable,
that
should
be
the
in
varial
plus
1
right.
So
is
this
correct
assembly
inline
assembly?
Does
that
actually
work.
B
A
So
either
if
those
variables
are
even
in
memory,
because
the
compiler
could
allocate
variables
and
registers,
naturally
there
will
be
a
muff
instruction
from
the
register
back
to
memory
after
the
assembly
is
executed.
Yes,
so
inside
the
assembly,
since
the
constraint
is
our
for
register,
it
will
always
be
in
the
register.
Yes,.
C
A
You
can't
do
that,
because
what
ends
up
happening
is
you're
using
the
output
before
they
are
using
at
the
input,
which
is
forbidden
as
I
said,
and
what
happens
is
that
your
compiler
would
be
very
clever,
but
we'll
determine
that
okay,
we
could
actually
competitors.
It
will
determine
that
we
could
put
out
into
the
EAX
register
and
then
we'll
think
about.
Okay,
where
do
we
put
the
in
variable?
A
A
Interestingly
enough,
your
in
variable
also
would
have
changed
because
that's
actually
started
memory.
It
was
just
temporarily
copied
to
the
X
register
and
isn't
amount
operant
right.
So
you
end
up
with
the
value
of
sort
of
three
plus
one
and
changing
three.
So,
to
speak,
being
the
input
is
3
and
the
apples
too,
and
it's
great
when
you
come
across
it
the
first
time
and
then
the
tenth
time.
You
might
remember
that
they're
snappers
are
missing
right
there
in
95.
A
Great,
so
something
else,
I
wanted
to
talk
about
real
quick
or
are
there
any
questions?
Laughter
what'd.
You
see
a
street
like
this
okay,
so
something
else
I
wanted
to
talk
about
is
some
inline
assembly
sorted
in
LLVM
ir
and
on
some
level
this
is
much
less
interesting
because
none
of
you
will
ever
right
out
of
EMI
are
behind,
or
at
least
one
of
you
that
are
not
writing.
Compiler
tests
for
LLVM
to
be
fair,
usually
compilers
will
generate
this,
and
the
purpose
this
exists
is
actually
to
implement
GCC
like
assembly.
A
D
A
A
We
don't
want
it
to
be
able
to
be
only
expressed
in
the
human
eye
assembly.
At
least
we
want
something
that
can
be
discussed.
So
since
this
is
to
implement
GCC
style
assembly,
it's
pretty
definitive
style
assembly,
it
has
a
template,
it
has
constraints,
but
inputs
and
outputs
are
it's
different.
Syntactically,
like
all
outputs,
are
return
values
from
a
call
to
the
inline
assembly,
so
to
speak,
and
all
inputs
are
just
arguments
and
the
constraints
are
specified
completely
separately
from
both
just
in
one
long
string.
A
It
also
has
different
placeholders,
it
uses
dollar
sign
number,
it
doesn't
have
name
parameters
which
is
fine
for
something
that
is
not
meant
to
be
written
by
humans.
So,
yes,
it
has
similar
to
Jesus
year
supports
those
modifiers
again.
The
syntax
is
a
bit
different,
its
dollar
sign.
Then
in
curly
braces
you
have
the
number
:
and
then
the
modifier
you
want
to
specify
as
the
escape
for
that
is
just
again
doubling
the
character.
A
So
Talos
and
all
the
size
constraints
are
interestingly
enough,
but
is
the
documentation
for
them
reads
a
bit
different
than
the
one
for
GCC
I
can't
for
the
love
of
God
tell
if
they're
actually
different
or
even
the
answer
ends
up
being
the
same
signal
on
some
level.
So
they
have
a
lot
of
single
letter
constraint
codes
and
those
definitely
are
I
want
to
one
mappings
to
what
GCC
does
at
least
I'm.
Pretty
sure
about
that.
Then
there
is
also
like
a
circumflex
fault
by
two
letters.
A
A
Again
you
can't
specify
multiple
alternative
constraints
again,
just
like
in
GCC
and
then
there's
something
that's
not
available
in
GCC,
but
I
think
used
occasionally
to
implement
some
of
Jesus's
output
mode,
which
is
an
indirect
output
where
you
basically
add
a
star
modifier,
which
tells
you
okay,
don't
give
me
a
memory
operand,
but
give
me
a
register.
Operand
that
contains
the
address
of
that
memory,
so
the
difference
being
one
thing
actually
gives
you
an
address.
However,
that's
written
in
your
assembly,
language
and
the
other
thing
gives
you
a
register
containing
that
is
address.
A
So
further
four
constraints:
outputs
are
also
a
bit
simplified.
There
is
no
plus
for
input
and
output.
At
the
same
time,
that's
just
emulated,
with
the
tying
of
inputs,
outputs
that
we've
seen
before
in
GCC,
so
there's
no
real
reasons
to
implement
them
using
your
inline
assembly
at
least.
If
you
are
backend,
you
still
have
that
funny,
ampersand
character.
To
say
this
is
an
early
clubbers.
A
This
is
written
before
all
inputs
are
read
right
and
for
the
inputs
you
can
still
tie
them
to
output,
saying
okay,
this
input
gets
the
same
register
as
the
sockets
clubbers
are
with
different
two,
because
everything
is
in
one
long
string
and
it's
not
separated
with
Collins's
and
UCC
cut
lovers
are
determined
by
his
seeing
if
this
is
a
stringer
start
with
a
tilde.
So
basically
outputs
are
equal.
Science
clubbers
are
Tildy
and
everything
else
as
an
input.
A
Okay.
So
what
does
that
look
like
granted?
That's
actually
an
optimized
code,
so
that's
on
some
more
complicated
than
it
needed
to
be,
but
at
least
it's
service
shows
sort
of
the
operations
you
would
expect.
So
this
first
line
just
allocates
memory
for
a
32-bit
integer
with
an
alignment
of
four
and
calls
that
person
sign
one.
So
I
love.
A
If
you
don't
know
about
LVM
intermediate
representation,
it
basically
models
a
computer
with
infinitely
many
registers
and
those
registers
are
just
numbered
as
percent
and
then
some
number
and
you
can't
change
registers
ever
so
for
each
new
value.
You
use
a
new
register,
also
called
systemic
single
assignment
form,
at
least
the
variant
theorem
so
register.
A
A
Your
argument
is
register
2,
so
the
value
you've
loaded
from
the
allocation,
a
k0
which
is
what
we
stored
in
there
just
land
before
that.
So
obviously
this
load
and
store
could
be
optimized
outright,
but
it
isn't
because
it's
not
enough
too
much
code
and
then
the
return
value
from
that
quarter
in
an
assembly
will
be
what's
in
dollar
zero.
A
Similarly,
getting
the
one
cache
size,
you
have
just
two
variable
allocations
so
to
32
bits,
integers,
and
then
you
call
in
to
this
inline
assembly
expression
without
any
arguments,
because
we
had
never
had
inputs
for
that
right.
We
only
have
outputs.
We
only
want
to
get
the
values
of
EDX
and
ECX
out
of
there
and
the
way
IBM
does,
that
is
benefit
returns
the
to
tupple
of
two
32-bit
integers,
and
then
our
constraints
are
basically
okay.
A
You
have
one
output
that
isn't
register
if
one
output
that
comes
from
you,
CX
and
you're,
clobbering,
EAX,
EBX
and
edx
and
assembly
is,
while
probably
as
readable,
exactly
the
same
as
we
always
had
before
and
following
after
that,
it's
basically
just
getting
the
first
in
the
second
part
of
that
topple
in
lines,
six
and
seven
and
then
storing
those
parts
that
got
from
this
topple
back
to
the
rebels.
Rillette.
E
A
Well,
yes,
and
no
so
you
tell
it
that
a
certain
operation
accesses
a
variable
right
and
then
in
the
end,
what
ends
up
doing
is
it
gives
the
compiler
complete
freedom
in
terms
of
how
it
accesses
a
variable.
So
if
you
have
a
move
instruction
and
you're
saying
okay,
move
something
to
this
variable
move
is
like
super
complex
in
terms
of
what
operands
it
supports.
It
could
be
a
memory.
A
Operand
could
be
a
register,
it
could
be
whatever
so,
basically
the
decompiler
it
has
to
know
what
operands
can
go
there
and
then
it
will
freely
choose
whatever
fits
it
best.
So
you
can't
say:
okay
definitely
give
me
a
register
for
that
variable
and
move
to
that
variable
via
a
register,
which
you
could
argue
it's
bad,
but
on
the
other
hand,
you
give
the
compiler
of
the
freedom
to
access
the
variable
in
any
way
you
want.
A
So
if
it
thinks
okay
on
where
you
have
a
few
registers
and
a
lot
of
things
access
those
registers,
but
the
inline
assembly
is
just
executed
once
it
could
choose
to
just
write
to
the
memory,
because
that
memory
write
is
only
done
once
anyway.
So
why
clean
up
a
register
for
that
and
it's
something
why
didn't
I
see
C
and
I
know
somebody
would
generally
tend
to
just
said:
okay,
yeah
put
it
in
a
register
and
then
write
it.
B
E
But
in
in
the
D
assembly
you
explicitly
wrote
register
names
so
that
a
compiler
can
do
anything,
oh
well,
it
could
be
if
it
really
knows
about
all
the
side
effects
and
all
so.
A
I,
don't
I
can
see
use
they
could
actually,
which
is
that's
the
point
you're
making.
They
could
exchange
registers
that
you
have
explicitly
specified,
but
other
things
they
do,
but
that's
pretty
much
the
same
thing
that
also
happens
in
GCC
assembly,
like
you
see
that
I'm
explicitly
clear
setting
a
XCX
Pacific
here
in
ECX
and
those
will
always
be
e
CX
and
also
it
actually
becomes
a
bit
difficult
to
tell
the
compiler.
A
A
Anything
else
yeah,
so
we've
heard
about
different
languages
and
what
they
do.
So,
let's
talk
about
what
Russ
doesn't
now
and
actually,
let's
talk
about
something
that
dress
doesn't
do
right
now,
so
there
is
one
RFC
that
has
been
accepted
for
assembly
and
could
actually
like,
in
theory,
be
stabilized,
so
is
treated
as
very
experimental
and
that's
global
asthma
and
what
is
accepted-
it's
not
even
implemented,
but
the
idea
is
that
what
that
would
do
is
not
exactly
inline
assembly,
but
something
that
our
VM
calls
module
level
inline
or
something.
A
So
basically,
you
just
write
a
bunch
of
assembly
into
this
global
asthma
macro
at
local
scope
and
the
assembled
version
of
that
will
end
up
in
your
executable.
So
you
could
write
pretty
much
arbitrary
functions.
We
set
in
assembly
and
then
later
call
in
to
them,
but
they
are
not
in
any
way
inline
in
your
existing
functions.
It's
just
a
separate
code
that
will
also
be
in
your
object.
It
could
also
be
used
to
define
data
or
whatever,
if
you
actually
wanted
to
whatever.
Basically
a
system
with
some
supports.
A
And
then
actual
inline
assembler
rust
as
I
said
it's
right
now
only
available
or
nightly.
There
is
beyond
see
atom,
heater
gate
as
a
macro,
and
it
looks
pretty
much
like
what
you
see
Cedars
that
you
get
those
template
strings,
that
you
specify
outputs
inputs
and
covers.
You
can
also
specify
options
that
option
list
is
well
actually
a
bit
strange.
If
you
ask
me,
so
you
can
say
it's
volatile,
which
does
exactly
the
same
thing
as
a
dozen
GCC
disables
code
motion
and
disables
dead
code
elimination,
you
can
tell
it
to
align
the
stack.
A
So
yes,
assembly
will
end
up
at
some
blind
address
for
no
specific
alignment
that
you
could
actually
specify,
which
is
something
that
seems
sensible
for
the
architecture
so
to
speak,
and
you
can
say
that
it's
actually
in
full
assembly
and
not
18
th
century
an
except
for
volatility,
actually
the
very
same
modifiers
as
the
other
VMI.
Are
it
night
assembly
instruction
supports.
So
this
is
a
very,
very
straight
mapping
to
that,
including
the
fact
that
it
uses
dollar
sign
for
placeholders
instead
of
the
person
sign,
but
it
does
like
GCC
support
the
plus
modifier.
A
So
what
does
it
look
like
if
you
use
it
pretty
much
like
the
brainchild
of
using
LLVM
syntax
for
inline
assembly
with
GCC
syntax,
very
nice
happening
so
very
much
in
the
same
way.
You
have
this
at
with
double
dollar.
Sign
is
another
VM
to
specify
the
immediate,
but
then
you
have
a
plus
sign
on
the
register
to
specify
this
as
an
input
and
output
as
it
was
in
GCC.
A
Similarly,
getting
there,
one
cash
also
looks
pretty
much
exactly
as
it
looked
in
GCC,
except
the
specification
for
reading
from
the
ECX
register
is
not
a
single
C,
but
in
curly
braces
EC
X,
which
is
a
specification
that
comes
to
straight
from
other
VM.
So
this
is
in
some
ways
a
very
direct
mapping
to
what
lrvm
internally
provides
you
masked
as
what's
familiar
from
GCC,
so
to
speak.
D
A
A
Yeah
inline
assembly
is
not
in
an
unsafe
block
for
no
reason,
let's
say
sir
apparently
and
I
did
not
quite
realize
that
you
can
specify
immutable
variables
as
output
operands.
That
may
or
may
not
be
a
bug,
that's
already
reported
or
intentional,
because
we
have
things
like
interior
much
usability.
After
all,
oh
yeah.
A
It
still
has
all
of
the
let's
say,
bad
things
that
GCC
has
or
annoying
things
what
would
be
actually
sensible
to
do
very
early
on
in
Ruth's
life,
or
at
least
in
the
life
of
the
GRC
process.
There
was
a
proposal
for
different
assembly
syntax,
which
was
still
so
it's
still.
A
The
template
approach
right
was
very
different,
syntax,
well,
not
very,
but
different
syntax,
so
it
would
risk
a
few
easy
assembly
template
and
then
split
up
the
rest
of
the
parameters
into
first
camel
positional
parameters
then
come
on
name
parameters
and
then
come
clubbers
and
options
sort
of
party
together
because
by
what
the
string
actually
is,
you
can
differentiate
whether
it's
a
cover
or
not,
and
what
was
specified
back
then.
Was
this
videos
increase
in
tax
off?
You
can
write
an
expression
and
that
will
be
treated
as
an
input.
A
You
can
write
an
expression
and
then
an
arrow
and
then
an
expression
and
as
we
treat
it
as
an
input
and
an
output
which
go
into
the
same
place
right
and
then
only
for
positional
parameters,
I
guess,
because
the
assumption
is
that
those
won't
actually
ever
be
used
explicitly.
You
can
provide
a
string.
That
is
a
constraint,
so
you
can
say
this
variable.
Please
write
it
to
EAX.
Some
instruction
will
use
it,
but
I
won't
explicit
him
ever
mention
DX
and
occurred
possibly
and
will
be
camera
parent
in
the
next
slide.
A
A
So
just
an
example
of
what
that
looks
like
what
was
decided.
There
was
the
format.
Syntax
that
we
have
in
rust
is
not
that
bad
actually
like
we
have
those
curly
braces
and
we
can
specify
a
name
in
there.
We
can
specify
the
positional
number
in
there
and
after
a
column,
we
can
specify
some
modifiers
if
we
need
to
so
the
specification.
There
said
that,
basically,
you
can
use
an
operand
these
multiple
times
with
different
constraints
and
the
constraints
go
in
your
place,
holder
instead
of
on
the
operand.
A
That's
exactly
what
this
code
does.
It
returns
once
the
addition
of
a
and
B
and
then
a
subtraction
of
an
e,
so
it
uses
B
both
times
for
both
yet
in
the
sub
instruction
in
a
register,
and
then
it
uses
also
a
but
in
two
different
registers,
one
that
is
also
tied
to
C
as
an
output
and
one
that's
also
tied
to
D
as
an
output.
A
Also,
it's
super
under
specified
what
that's
supposed
to
do
in
terms
of
constraints,
because
I
could
argue
that
this
is
actually
wrong,
because
clearly
the
first
operand
is
something
that's
read
from
a
and
written
to
C.
So
it
can't
be
a
pure
output
of
around
right,
but
it
also
is
not
really
the
plus
instead
of
the
equal
sign,
because
it's
not
written
and
read
from
the
same
variable
and
at
any
rate
there
is
no
input
for
the
a
variable
as
a
constraint
anywhere.
A
So
while
I
think
it's
pretty
conceivable
that
you
could
map
that
trailer
yeah.
My
are
the
details
of
that
seems
super
honest
specified
to
me.
Also.
It
seems
a
bit
unnecessary
to
me
that
you
would
have
syntax
in
the
operands
to
say:
okay,
a
is
an
input
and
the
output
is
C
and
then
still
specify
in
the
constraint
that
something
is
an
output.
A
But
that's
me,
so
that's
one
possible
future
that
ticket
was
closed
a
long
time
ago,
people
said
municipal
that
was
probably
before
1.0
people
said.
We
should
experiment
with
that
in
separate
crates,
possibly
compiler
plugins,
but
you
could
also
just
map
from
any
syntax
that
you
sing
would
be
decent
to
Russ
current
inline
assembly,
syntax
right
and
just
still
what
we
probably
have
to
do.
A
But
the
question
is:
do
we
want
something
exists
or
something
get
completely
different,
so
some
questions
and
I
actually
like
to
before
telling
you
my
own
opinion
on
them
like
to
post
those
to
you
first
like
which
route
is
actually
better?
Should
we
go
down
the
DEA's,
our
route,
that
dnm
SVC
did,
or
should
we
go
to
a
temporary
and
the
trade
that
was
pretty?
Obviously,
if
you
do
a
DSL
you're,
writing
an
assembler
and
you're
writing
an
assembler
for
each
and
every
architecture
that
you
support.
A
What
does
one
do
about
early
clubbers
like
something
you
could,
for
example,
do
about
them
is
just
say
everything
is
not
leak.
Trouble
like
it's
perfectly
legal
to
write
output
before
inputs.
That
just
means
you
have
to
allocate
more
registers,
possibly
what's
a
decent
place.
Holder
like
is
dollar
sign
and
%
good,
or
should
we
use
what
Ross
currently
uses
everywhere
else?
A
A
Our
constraints
is
just
single
characters
that
might
sometimes
on
numeral
actually
sends
it
to
a
sensible
thing
to
do.
Should
we
maybe
like
have
a
mapping
from
we
call
it
record,
not
our
and
hard-coded
an
in
compiler
again.
That
would
mean
hard
cutting
that
in
the
compiler
architecture,
because
those
constraints
are
read
our
architecture
specific,
but
also
they
are
probably
back
in
specifics.
So.
A
Be
sensible
anyway,
and
also
our
all
those
signals
sensible
like
having
equal
signs
plus
signs
and
percents
till
they
us
do
you
want
to
write
those.
Do
you
want
something
else?
What
would
be
something
else
like
that
are
sort
of
the
design
questions
I'm,
asking
myself
there
and
I'm
happy
to
your
opinions
on
any
of
them
actually.
C
C
C
A
F
A
Heavy
constraints
is
actually
something
the
question
is:
are
there
benefits
to
any
of
them,
so
I'm,
so
glad
with
constraints
is
actually
something
that
I'm
calling.
What
GCC
has
right,
because
they
have
all
those
sigils
like
they
have
equal
sign,
plus
sign
and
percent
in
their
constraints,
all
right,
so
this
is
not
like
equivalent
to
character
every,
but,
like
we
have
symbol.
A
Sort
of
that
speak
for
a
lot
of
what
they
do,
which
is
also
like
to
put
that
back
to
that
discussion
of
what
rust
original
is
it
rust
originally
had
a
allocate
this
on
the
heap
operator,
which
was
so
tilde
right
now
we
don't
even
have
operator
for
that
anymore
that
the
operator
for
that
is
called
box.
Cullen
Cullen
new
parent
ceases.
A
So
personally,
a
super
want
to
get
that
box
operated,
but
different
discussion,
so
it
rest
certainly
has
been
moving
away
from
Sidious
anyway,
the
question
is
is:
if
familiarity
is
not
something
that
for
pizza.
A
So,
okay,
let's
let
be
a
bit
more
provocative,
so
something
that
we
definitely
saw
is
that
dnm
SVC
are
like
super
easy
to
write.
Right
like
this
to
me
personally,
I
could
write
that
preparing
for
this
talk
and
be
reasonably
sure
that
I
did
not
mess
up
and
I've
certainly
never
felt
that
way
with
GC
style
templates
right
and
that's
sort
of
also
something
that
rust
wants
to
get
you
like.
B
A
So
the
registers
on
gear
sound
might
not
necessarily
technically
be
the
correct
term
or
DSL
like
it's.
What
I'm
calling
what
dnm,
as
we
see,
do
like
basically
redefining
what
D
and
M
as
we
see
do,
is
what
I'm
calling
years
I
like
more
DSL.
You
could
also
call
it
custom
assembler
of
whatever
I
attempt
like
like
is
what
I'm
calling
oh
jesus.
You
know
vm
approach.
E
B
I
totally
both
father
diesel
approach
and
I
think
challenge
average.
He
isn't
a
strong
reason
to
copy
the
GCC.
Maybe
there
are
other
reasons
but
familiarity.
It
wasn't
the
reason
for
us
to
adopt
several
or
several
things
and
Russ
has
chosen
a
lot
of
things
just
because
they
are,
they
could
collected
good
things
from
other
languages
and
familiarity
was
you
know
most?
The
second
choice
on
this
I
think
you
Sunda
should
go
the
same
way.
B
C
So
one
argument
that
goes
against
the
ESL
is
support
for
instructions
that
are
going
to
appear
later
and
there
are
some
sort
of
CPU
specific
instructions
that
are
not
present
in
the
release
of
the
language
that
you
are
actually
using
right
now.
I,
don't
know
how
it
works
with
languages
which
are
constantly
development.
By
imagine
that,
in
some
situations
you
are
stuck
with
a
single
version
and
your
hardware
moves
on.
B
In
assembler,
you
normally
have
the
opportunity
to
to
insert
plain
roll
bytes
just
to
express
instruction
that
aren't
covered
by
the
assembly,
language
itself
or
art
in
you
to
be
covered
by
the
language.
But
you
someone
have
to
declare
the
side
effects
and
this
this
instruction
would
have.
But
if
you
have
a
notation
for
the
clobbering
in
and
out
I,
don't
think
that's
a
big
obstacle
to
support
generic
new
assembly
instructions
that
aren't
known
yet
or
use
some
internals
of
the
CPU
that
aren't
exposed
by
the
assembly
at
all.
A
Right
so
first
thing
I
should
possibly
mention
at
that
point.
Is
that
M,
as
we
see,
actually
has
an
emitter
instruction,
which
will
that
you
make
robots,
but
something
that
I
at
least
think
would
become
increasingly
difficult,
is
sort
of
using
raw
bytes
to
emit
an
instruction,
but
then
mix
that
with
possibly
even
giving
the
compiler
freedom
to
use
a
certain
register.
A
Okay,
so
just
so,
we
can
finish
up.
We
could
certainly
talk
about
your
prison
if
you
want
to
my
thoughts,
are
I'm
personally
fan
of
temperance,
not
just
because
of
newer
instructions,
but
I
think
that
it's
generally
more
sensible
for
portability
across
platforms,
because
I
don't
see
us
writing.
Basically,
our
own
sampler
for
Russ
is
probably
right.
A
On
the
other
hand,
I'm
not
sure
that's
a
fair
claim
like
he
could
possibly
generate
those
assemblers
from
that
audience,
description
of
instructions
or
something
like
that.
Maybe
that
would
be
an
option,
but
my
feeling
is
that
templates
are
goods
like
to
me
personally
in
terms
of
I'm
accessing
the
system
or
something
via
that
and
whenever
that
changes
I
get
access
to
them.
A
Another
kind
of
point
to
like
count
on
myself
a
bit
is
what
I've
said
in
the
very
beginning.
You
always
have
to
be
able
to
use
your
to
specify
your
parents,
probably
in
the
template
model.
So
if
you
have
a
new
instruction
and
it
uses
a
completely
new
register
class
and
your
compiler
can't
assign
values
to
that
register
class
at
all
because
it
doesn't
know
it
exists,
that's
not
helpful
to
you
best
thing
you
could
do,
but
you
could
still
do
that
is
mention
the
register
explicitly
in
the
assembly
and
then
do
moves
from
memory.
A
Assembly
has
them
arm.
Assembly
has
them
for
register
sets
and
I
wouldn't
say.
The
register
sets
are
uncommon,
like
I.
Never
if
you
find
some
of
them
in
each
function,
but
they're
used
for
things
like
right
back
to
registers,
from
the
stack
where
you
save
them
and
right
back
to
the
program
counter
at
the
same
time,
to
do
a
return
for
some
reason.
That's
available
in
RISC
architecture
Island,
but
it
doesn't
know
Keo
very
often
and
I
wouldn't
say.
A
I
would
claim
that
probably
accuse
even
that's
an
inline
assembly
that
compilers
like
to
generate
them,
because
it
allows
them
to
do
a
lot
in
one
instruction.
But
it's
not
something
that
should
come
up
all
too
often
in
line
assembly,
and
it's
not
like
you
can't
at
all
type
those
characters
just
because
we
use
them
as
placeholders.
You
can
still
double
them
out
them
that
would
be
escape.
A
I
also
seem
sigils
are
annoying
because
you
have
to
remember
them
inline
assembly
years,
even
as
a
systems
guy
you
know,
an
assembly
is
not
something
that
you
super
commonly
do
in
many
projects.
You
write
have
to
write
some
you
write.
It
run
sided
behind
the
macro,
whatever
never
look
at
it
until
it
breaks
or
something
so
I've
met.
People
who
I
know
are
super
familiar
with
that
stuff,
but
still
have
forgotten
some
other
details
about
it.
A
Currently,
you
have
to
specify
all
outputs
and
then
all
inputs
and
then
access
them
by
number
of
my
name,
whereby
name
of
courses
pretty
decent
still,
but
it
would
be
nice
to
be
able
to
do
them
in
any
order
and
then
just
write,
curly
braces
since
they
get
read
in
that
order
and
then
early
clubber
I
think
that's
pretty
much
one
of
the
things
that
bites
most
people
who
first
read
in
line
assembly
I
think
it
could
be
an
option
to
do
it
by
default.
A
So
my
suspicion
is
that
at
least
on
platforms
with
few
registers,
that's
not
really
an
option
for
performance
because
it
clubbers
a
lot
of
well
clubbers,
so
to
speak.
I
get
to
science,
a
lot
of
registers
that
can
no
longer
be
used
as
inputs
at
the
same
time
or
so.
If
we
can't
do
early
clever
for
whatever
reasons
by
default,
I
think
we
should
probably
at
least
be
explicit,
like
don't
make
do
something
like
okay,
you
have
an
ampere
to
a
ten
percent
for
this
to
be
early
cover.
A
Make
people
make
this
choice
explicitly,
for
example,
something
that
rusts
right
now
does
for
raw
pointers?
Is
you
can
they
are
not
like
share
pointers
in
the
sense
that
you
have
much
or
nothing?
You
have
to
have
much
or
Const,
constantly
reminding
people
that
this
is
a
choice.
This
is
either
constant
of
this
is
mutable
specifically
because
it
could
pass
a
consequent
or
somewhere
and
still
mutate
it,
since
this
is
completely
unsafe
code,
so
you
make
this
source
very
explicit
to
them
that
this
is
okay.
A
A
This
is
something
that
I
came
up
actually
a
while
back
and
I
have
no
idea,
if
that's
at
all,
sensible
or
whatever,
but
this
would
be
my
emergency
text
for
doing
something
in
terms
of
inline
assembly.
So
it's
a
template
and
it's
more
wordy
right.
You
have
security
breakers
as
a
placeholder,
you
say:
okay,
I
have
an
input
and
output
at
the
same
time,
so
this
thing
could
also
be
just
in
or
just
out.
Maybe
it
should
be
in
late
out
or
whatever,
which
makes
this
super
wordy
and
super
annoying
to
type.
A
But
whatever
you
get
a
constraint
in
Britain
in
parantesis,
let's
say
it's
right:
maybe
it
should
be
registered
because
rust
tends
towards
full
words.
But
I'd
say
this
is
something
get
actually
sensible
to
write
per
architecture,
from
wrapping
from
words
to
one
that
your
constraint
specifiers,
just
because
it
makes
things
a
lot
more
readable
and
a
lot
more
remembering,
and
then
lastly,
you
specify
what
variable
goes.
We
set
up
right
same
thing
for
the
other
one
cache
variant,
you'd,
say
out
and
then
say:
okay,
this
is
a
register
and
it's
written
to
the
EBX
variable.
A
You
say
out
and
say
this
is
read/write
actually,
because
it's
not
put
from
zcx
register
and
goes
to
the
exit.
Issei
is
variable,
and
then
you
have
a
list
of
clubbers
specified
inside
a
sort
of
club-record
each
and
to
me
personally.
That
seems
like
it's
a
good
in-between
of
being
a
bit
more
wordy,
but
yet
reasonably
familiar
and
also
reminding
people
of
what
things
actually
do.
Instead
of
like
equals,
R
equals
C,
break
parentheses,
variable
name
or
something
like
that.
A
Okay,
so
that's
my
20
cents,
let's
say
a
pretty
long
talking.
Thank
you
for
listening
for
that
long
time,
I'm
happy
to
still
answer
any
remaining
questions.
The
slides
will
be
available
at
that
address.
They
are
not
yet
but
yeah.
D
A
No,
that's
let's
say
that's
a
title:
no
def,
definitely
curly
braces
I,
think
that
was
actually
in
my.
What
we
were
thinking
about
is
this,
like
I
think
we
should
go
with
curly
braces
just
because
it's
familiar
from
everywhere
else
in
the
language
where
we
have
template
these
things.
So
it
looks
nice
so
was.
F
A
A
My
assumption
has
always
been
that
there
is
some
magic
happening
in
terms
of
the
variable
that
you
give
it
like.
If
you
give
it
a
32-bit
integer,
it
would
end
a
person
in
a
32-bit
register,
naturally,
and
also
you're
right
reading
from
a
32-bit
integer
register.
If
you're
outputting
to
an
integer
that
size,
the
I
feel
like
I'd
have
to
look
at
more
at
what
it
actually
generates
into
the
template,
because
I've
just
today
seen
something
like
the
this
assembly
yeah.
A
This
assembly,
where
you
say
okay
I,
want
you
to
read
from
the
C
register.
If
you
look
at
that
in
the
L
and
the
M
version,
it
actually
doesn't
specify
that
it
wants
to
read
from
the
ECX
register.
It
says
it
wants
to
read
from
the
CX
register,
which
is
not
technically
the
same
thing,
but
still
works
out,
probably
due
to
instruction
and
coding,
and
admittedly
I'd
like
to
understand
better
how
that
selection
works.
Exactly
I
think
the
most
sensible
thing
is
probably
from
variable
size
that
are
specified,
but
I.
Don't.