►
From YouTube: Cranelift
Description
Dan Gohman explains the basic idea of the Cranelift code generator, covering the setup of the IR, the overall philosophy of its design, and some details of how it could be integrated with rustc.
A
B
So
quite
lifts
just
gonna
be
a
little
talk
about
today
and
then
I
will
basically
what
Queen
it
is.
You
know
if
you
some
talking
support
Queen
if
they
are
and
what
kind
of
things
we're
doing
with
it
and
why
we
think
it's
designed
Bell
and
talk
about
augmentation
that
we're
doing
now
and
stuff.
We
want
to
do
in
the
future
and
stuff
that
that
people
using
cleaners
can
do
before
they
start
using
agreements
so
chopping.
You
do
it.
A
B
B
Is
a
series
of
crates,
the
central
crate
is
the
queen
of
kujan
crate
and
antis
cords
actually
function.
It
sort
of
mathematical
sense
for
the
input
is
first
of
all.
Why
are
you
know,
but
your
position
for
a
function?
It's
a
big
data
structure
that
rids
a
whole
function
of
code,
a
target
description
which
is
basically
a
machine
like
x86.
No
just
you
know
what
that
is,
as
well
as
a
couple
engine
settings,
optimization
level
things
like
that,
the.
B
Of
all
machine
code,
which
is
just
an
array
of
bytes,
it's
bytes
that
you
presented
to
your
CPU.
It
can
execute
them
and
also
metadata
to
describe
those
bytes
metadata
that
can
describe
things
like
which
instructions
are
expected
to
trap,
which
instructions,
reference
symbolic
addresses
that
need
to
be
relocated
and
other
properties
of
the
chapter
in
your
code,
debug
it
film
can
also
be
in
there
along
with
quail
Akutan.
We
have
a
bunch
of
other
treats
that
sort
of
augment
it
and
for
extra
functionality.
A
B
Krishna
fairy
is
a
system
for
generating
native
object
files,
data
files
with
quaint
enough
code
generated
members.
You
can
creative
code.
We
also
have
a
queen
of
simple
jets.
There
are
many
ways
to
use
cream
efforts,
including
easily
the
Jets.
You
don't
have
to
use
simple
to
it,
but
simple
Jade
is
sort
of
a
simple
framework
that
ties
a
lot
things
together.
It
provides
a
lot
of
services
for
you
to
just
run
the
code
Aquino
cream
of
generates
memory,
but
making
an
executable
I'm
running
it's
rightly.
B
No
I
didn't
a
little
bit
about
the
fire,
so
quit.
If
I
are,
is
the
central
data
structure
that
the
code
generator
uses
and
I
belong?
The
system
is,
could
organized
rounds.
It's
a
it's
an
in-memory
data
structure.
Of
course
we
also
have
a
textual
representation
of
it
and
we
can
go
back
to
40
and
now
here's
a
screenshot
of
Mir
I'm,
just
gonna,
give
you
a
flavor
of
what's
going
on.
Basically,
the
main
unit
of
what
they
are
is
the
function,
so
we
have
a
function.
B
Queen
of
desired,
operate
on
a
single
function
at
a
time
absolutely
compiled
functions
are
parallel
with
the
VA
since
to
create
that
suppose
the
quickly
just
focus
on
like
that
might
one
function
and
that's
my
universe.
Everything
is
in
that
now
inside
the
function,
there
are
a
sequence
of
you
start
with
those
ticket
declarations,
I
guess
in
this
code
here
there's
just
that
SS
0
0
is
a
stack
slot
and
then
there's
a
series
of
basic
blocks.
Apb's
has
four
extended
basic
block.
A
B
So
the
perimeter
is
four
blocks
come
in
when,
when
a
block,
when
you're
not
dominated
when
they
use
his
dominate
over
the
deaf,
so
you
know
potentially
multiple
different
values
that
when
I
get
used-
and
this
is
so-
this
is
getting
into
that
SSA
for
a
little
bit
in
order
to
preserve
as
a
safe
form,
every
variable
can
have
a
single
death.
But
if
you
have
something
like
Indian
else,
where,
in
the
source
code,
you
assign
a
different
value
in
the
if-else.
B
Typical
to
SSA
form,
would
you
Sophie
node
to
merge
the
two
together
at
the
merge
point
into
a
single
death
for
the
merge.
Freimuth
uses
a
called
gone
parameters
because
basically
the
same
thing
as
he
knows
it
just
looks
a
bit
different
in
there.
It
just
looks
like
the
blocks.
Hence
hemorrhage.
You
can
almost
think
of
the
blocks
as
being
little
functions.
You
can
call
it
sits
along
the
Devon
on
the
lines
of
a
CPS
kind
of
system
where
basic
locks
recipe
functions,
although
we
don't
go
to
full
CPS
to
do
that.
A
B
A
safe
form
is
the
subtle
concept
and
we
actually
make
this.
We
rely
on
this
in
all
aspects
you
geek
as
as
I
a
form.
Then
we
preserve
it
all
the
way
through
code
generator,
we
do
alleged
occasion
in
SSA
form.
So
that's
that's
a
very
special
guide
yeah
and
in
Owen
with
that
we
use
one
ir
through
a
code
generator
instead
of
switching
between
a
mid-level
miser.
Ir
code
generator
our
if
you
just
use
one
that
is
suitable
freezing
totally
through
source
selection
and
education.
B
A
B
Means
we
don't
have
a
gentleman
put
our
instruction
there
just
unit
or
instructions.
It
simplifies
things
writer,
the
coordinator,
because
at
a
hardware,
level
pointers
are
just
integers
on
most
of
our
pictures,
so
they'll
use
the
same
registers
and
the
single
functions,
so
it
supplies
things
we
just
have.
We
just
exclusively
are
they're
just
integers
in
this
level
and
I'll
talk
a
bit
about
later
but
like
what.
If
we
want
to
do
memory,
operations
and
point
operations,
what
we
need
to
do,
what
hapless.
B
B
Ideas
is
what
a
memory
is
minimize
the
memory
usage,
especially
for
the
very
common
case
of
just
generating
coal
quickly,
so
we
don't
have
built
in
death,
useless
yeah
in,
for
example,
LVM
there's.
It
maintains
a
lid
list
for
every
useful
value
automatically,
so,
whatever
you
create
a
value
or
a
branch,
these
linked
lists
of
all
the
values
that
are
being
used
all
the
places
their
values
being
used
is,
maybe
none
might
be
in
cui
that
doesn't
maintain
that
it's
just
an
extra
data
structure
that
it's.
B
We
also
don't
have
Ontario
sized
integers
like
el
viento,
so
there's
no
I-77
type,
and
this
again
is
of
a
biased
for
its
code.
Generator
focus
hardware,
don't
miss,
wasn't
most
hardware
platforms,
don't
have
integer
types
like
I
77.
We
just
have
stared
spinard,
I
ate
I
69
32
24
and
some
queen.
That
does
really
focus
in
those
types
with
the
expectation
at
this
point.
If
people
want
to
use
other
side's
integers,
those
could
be
lowered
before
producing
cream
if
they
are
a
higher
level.
B
B
A
B
That,
instead
of
having
a
large
soup
of
pointers,
essentially
a
lot
of
commodity
records
are
basically
just
big
graphs
of
pointers
in
Queen
left.
We
have,
is
the
large
arrays,
essentially
arenas
and
indices
into
arrays,
so
we
didn't
same
kind
of
things.
We
have
the
same
time:
data
structures,
it's
same
photographs,
but
instead
of
there's
pointers
on
where
it's
into
season
two
arrays-
and
this
is
a
couple
of
bandages
I'm
gonna
talk
about
a
little
later-
just
want
to
go
back
and
look
at
the
in
our
example.
Again.
B
One
interesting
thing
to
point
out
here
is
that
the
numbers
you
see
so
the
value
numbers
on
the
left
of
every
instruction.
We
see
anything
like
b2
equals,
say
two
more
pots.
Those
value
numbers
aren't
arbitrary
straightness.
Those
are
actually
says:
V
2,
that's
actually
indexed
to
an
Italian
table.
When
we
see
SS
0
for
the
stack
slot,
that's
actually
stack
slot
0
in
the
stacks
about
table,
and
so
you
can,
you
can
very
clearly
see
all
the
MCS
in
in
the
textual
dump.
B
B
B
Ecs
is
cool.
One
of
the
cool
things
you
can
do
with
ECS
is
a
thing
called.
A
secondary
map
so
woke
up
needing
compilers
is
when
you
have
something
you
care
about
like
instructions
or
basic
blocks.
You
often
want
to
associate
extra
information
for
every
instruction
or
education
for
every
basic
block
and
the
ECM
system
exactly
it
used
to
do.
We've
got
my
cuts,
bacala
secondary
map.
B
It
is
basically
another
array
that
uses
the
same
index
base
is
your
primary
array,
and
so
you
can
use
one
day
next
to
look
up
the
main
instruction
in
the
instruction
table.
We
could
use
that
same
index
to
look
up
the
unsealer
information
in
your
secondary
table.
So
it's
very
quick.
We
don't
need
to
have
a
lot
of
hashmaps
to
associate
extra
information.
B
A
B
Is
we're
getting
further
into
this
kind
of
design
we're
actually
finding
persons
and
the
shortcuts
for
coming
so
we're
running
into
that's,
causing
some
problems?
One
of
them
is
that
we're
not
really
using
ECS
in
a
kind
of
conventional
way
when
you
think
what
using
easiest
a
game
engine
a
common
use
for
ECS
is
that
you
would
like
start
all
of
your
raised.
B
A
lot
of
what
we
end
up
doing
is
random
access
its
arrays.
So
we
just
have
you
know
here's
an
interruption
that
want
to
see
what
operands
in
our
operates
it
has.
Those
are
indices,
infinity
table
I
want
to
see
what
we
have.
Those
are
more
indices,
we
end
up
doing
essentially
book
but
ends
up
looking
like
Twitter
chasing,
but
it's
actually
do
like
you.
Next
submitter
write
chasing
these
are
all
of
item
access,
accesses
and,
of
course,
we're
using
bus.
So
the
green
seas
are
all
bounds,
checked
and.
A
B
A
B
And
using
random,
X's
and
arrays,
so
we
can
I.
Have
this
open
question
there
about
it?
Pretend
it's
a
lot
we're
not
really
interested
in
living
that
of
people,
and
we
don't
have
the
same
kind
of
problem
that
a
lot
of
array
access
uses
have
we're
not
doing
indices,
we're
not
doing
arithmetic
on
our
indices.
The
indices
are
basically
just
these
will
pick
tokens,
and
so
it's
very
unlikely
that
well
Branca
chances
on
our
way
out
of
balance
because
we're
never
using
an
arbitrary
index
girl.
B
That's
using
a
token
that
was
given
to
us
from
you
right
itself,
and
so
you
could
argue
that
we
don't
really
need
those
bound
chicks.
So
the
kind
of
question
is
like:
should
we
add
unsafe
to
get
back
that
80%?
Should
we
make
that
option
to
our
users
like
a
cargo
feature
or
something?
So
it's
an
interesting
design
for
that
question.
We're
sort
of
thing
up.
There
is,
as
we
get
further
in
this
ECS
design.
One.
A
B
Right
so
clear,
remove
a
block
in
our
case
the
index
it
just
remains
essentially
dead
at
that
point
and
we'll
never
reuse
it,
and
so
we
just
have.
We
just
remove
the
block
from
the
code
and
we
delete
all
references
to
it
and
then
basically
just
leak
that
index
and
never
try
to
reuse
it.
Okay.
That
makes
things
simpler
for
us
and
and
because,
because
again
is
also
that
it's
getting
back
to
the
food
in
focus
we're
not
doing
a
lot
of
aggressive
sort
of
blue
team
instructions
or
cleaning.
B
You
know
reorganizing
instructions,
most
things
we
assume
in
code,
gen
they're
gonna
be
pretty
close
to
the
format
that
can
look
like
in
the
output,
and
so
we
don't
need
a
lot
of
reuse
and
actually
that
simplifies
our
energy
possessed
of
a
lot,
because
we
don't
even
do
things
like
the
generational
system
with
indices
or
try
to
keep
track
of.
Is
this
in
X
dangling
somehow
and
but
yeah?
We
can
get
away
with
that
because
we
know
we're
compiler
Beca
and
it
won't
compile
just
one
function.
Nothing.
A
B
B
A
generation
testable,
for
example,
another
challenge
we
found
with
the
system
is
that
we
end
up
keeping
a
lot
of
our
raise
around
a
memory
between
lift
is
designed
to
be
quite
paranoid
about
calling
malloc
I
wonder
if
s/he
is
it's
too
paranoid,
but
we
had
a
whole
bunch
of
arrays.
We
have
the
instruction
array,
we
have
the
data
array
or
the
value
array
basic
wakame.
You
have
sex
a
lot,
arrays
tables
and
we
just
keep
all
these
tables
around.
We
have
the
bodhi
like
when
you're
done
on
one
function.
B
B
One
of
the
things
that
we're
kind
of
thinking
about
is
an
alternative
I'm,
really,
a
big
fan
of
the
life
away
like
Athena
structure,
it
SpiderMonkey
so
life
away,
like
is
basically
just
a
big
bug,
cleaner
alligator
and
it
really
fits
the
kind
of
compiler
or
use
case.
What
are
you
saying,
I'm
going
to
compile
one
function
and
while
I'm
compiling
I'm,
just
gonna
bump
later
elekid,
not
ready,
we
use
any
memory
at
all
and
just
telling
Alec
Alec
Alec
Alec
throw
the
whole
thing
away.
B
B
Probably
get
away
with
actually
freeing
and
shrinking
our
memory
usage
more
often
right
now
we
don't
do
that
very
often,
because
we
have
lots
of
medium
sized
arrays
and
one
big
array,
and
so
we
end
up
paying
more
because
we,
the
sum
of
all
the
media
types
of
races
more
than
the
one
big
array.
That's
we
you're.
B
B
Yeah,
yes,
I,
think
I
think
we're
looking
at
and
that's
nobody
in
our
state
experiment
to
do
one
thing
that
I'm
sort
of
missed
is
and
he's
coming
from
SpiderMonkey
the
late
boil
activate:
has
the
bodhi
there's
a
vector
class
that
sort
of
always
set
up
to
use
the
life
was
a
vacuum
stored?
So
you
basically
just
have
multiple
vectors
to
write
code
widths.
I,
don't
have
to
worry
about.
B
B
Interesting
possibility
area
we
want
to
explore
that
may
end
up
moving
us
away
from
the
ACS
system
because
it
may
just
have
like
one
big
arena
and
then
we
might
just
look
at
using
regular
players
instead
of
indices.
Although
that's
an
integer
question,
because
using
a
2
C's
means
we
can
use
32-bit
in
to
see
photos.
So
if
you
didn't
see
it,
we
didn't
save
half
of
our
memory,
because
so
much
of
our
Asian
Tricia's
players
and
other
generations.
B
B
This
is
pretty
cool
when
that
arraigns
at
being
dense,
because
it's
just
one
big,
dense
array,
but
when
it's
sparse,
we
use
a
lot
of
memories
because
a
for
array,
an
element
for
every
instruction
where,
if
you
only
need
to
annotate
a
small
number
instructions,
reason
why
we
didn't
use
so
I
think
the
system
could
have
encouraged
us
towards
secondary
maps.
But
sometimes
we
do
that
too
much
and
we
should
probably
just
get
to
go
back
to
hashmaps
and
use
less
memory.
Some
pieces
I.
B
A
B
Yeah
so
I
guess
this
kind
of
a
tangent
here,
but
also
want
to
address
the
topic
about
like
why?
Don't
we
use
web
assemblies
or
ir
and
and
a
couple
quick
questions
that
one
of
them
is
that
web
assembly
is
designed
to
be
a
safe
language
and
some
of
the
stuff
that
code
narrators
do
is
just
fundamentally
unsafe.
B
B
Another
thing
is
that
we're
actually
looking
to
use
crane
left
as
a
back-end
for
more
than
just
webassembly
we're
looking
at
using
anis
back
in
for
the
Ross
compiler
as
well
and
Brust
being
a
systems
language
once
relatively
complete
access
to
go
in
a
white
platform
wants
all
the
goodies,
all
the
intrinsics.
All
the
special
colleague
mentions.
We
want
to
explain
all
those
things,
and
so
we
can't
do
that.
We
can
simply
we
know
much
more
complete
by
our
is
is
where
we're
gonna
go.
B
Initially,
design
question
I
just
wanted
to
bring
up
here
and
keep
people
have
thoughts
about
this.
What
kind
of
going
through
this?
So
we
don't
have
a
lot
of
clear
guidelines,
so
we're
adding
a
feature.
We
can
add
things
as
an
ir
construct
directly
or
we
can.
We
can
lower
things
in
the
finance.
For
example,
pretty
recently
we
had
someone
contribute
a
patch
to
allow
us
to
do
mem
copy
if
you're
a
front-end-
and
you
want
to
you-
know,
copy
a
structure,
an
array
we'll
be
able
to
call
them
copy.
B
So
the
IR
data
from
here
itself
never
actually
hasn't
been
copy
instruction,
and
this
is
a
question
that
we
have
a
kind
of
over
and
over
again
and
we
don't
actually
have
a
lot
of
clear
answers
for
once.
We
do
something
in
one
side
or
other.
How
did
IRB
and
a
lot
of
it
comes
down
to
like
this
having
things
as
an
opcode,
and
now
you
discipline
to
optimize
things
more
than
what
otherwise
and
with
meant
copy.
B
The
answer
is
not
really
because
per
month
it's
a
code
generator
already
traje,
but
not
really
focused
on
things
like
thumb,
calculations,
that'll
be
something
that'll
be
higher
level.
So
right
now,
would
it
make
sense
for
an
about
coke
that
no?
But
this
is
a
question
that
will
probably
end
up
reviewing
disappoint.
We
also
have
questions
for
like
arbitrary
signs.
Integers
or
people
want,
even
just
like
egg
128.
If
you
want
that,
I
will
28
type.
That
ghost
has
should
we
add
that
to.
B
B
This
you
can
almost
even
think
of
this
question
is
contending
in
essence,
a
construction.
We
went
all
the
way
and
said
we're
not
even
get
haven't
IR
that
can
represent
an
essay
form
at
all.
So
in
order
to
even
produce
IR,
you
have
a
say
form
up
front.
This
can
be
awkward
for
fun
ends
because
not
all
friends
have
us
a
form
coming
in,
and
so
we
basically
pushed
esta
construction
into
the
queen
of
finance
rage.
We
have
a
pretty
simple
API
that
you
can
use.
B
B
B
A
B
Spirit
of
thinking
about
what
belongs
in
the
AR
versus
what
belongs
in
the
finitely,
we
were
actually
able
to
push
us
as
a
construction
team
in
the
front
end.
So
at
the
back
end
and
the
data
doctors,
don't
even
need
to
worry
about
the
possibility
of
being
on
the
state
form
and
we
don't
even
need
to
break
ball
things
like
mint
oregano
differently.
Does
it
for
you.
So
they
have
this
not
as
super
firm
representatives
memory,
but
it's
kind
of
a
special
memory
that
could
be
optimized.
B
All
right,
that's
what
it
concludes.
My
my
brief
tour
of
the
IR
and
I
want
to
move
on
to
authorization
and
talk
about
first
operation
that
crane
itself
is
doing
today
and
then
also
talk
about
what
kind
of
illusions
we
want
to
do
in
the
future
and
how
we
can
how
we
can
arrange
it
compiler
to
help
make
those
operation
possible
so
first
rate,
if
we're
currently
focused
on
being
a
code
generator
and
so
we're
doing
that
sort
of
code
and
operation
things.
B
One
of
those
is
translating
from
quickness
relatively
mid-level
ir,
which
has
some
obstructions
now
into
machine
level,
IR
which
basically
uses
machine
up
codes,
so
example
that
it's
like
the
pop
code.
Instruction
in
Queen
of
Pop
code,
is
just
an
instruction
code.
Of
course,
not
all
hardware
platforms
have
a
pub
Co
instructions,
so
if
you
do
have
it,
obviously
we
just
use
that
instruction.
If
you
don't
want
that
construction
might
turn
into
a
sequence
of
instructions
or
maybe
even
a
library
column.
B
So
we
call
this
process
of
turning
things
that
are
not
legal
for
the
machine.
Being
a
machine
has
no
equivalent
of
that
up
code
into
things
that
are
legal
from
the
sheet
mean
the
machine
has
a
thing
that
is
say
like
a
pop
construction
that
exactly
corresponds
the
operations
we're
doing-
and
this
is
this-
is
our
the
same
process
of.
We
also
call
this
lowering
and
it's
also
sort
of
the
same
thing
as
instruction
selection
to
some
level.
Just
like
deciding
what
machine
opcodes
we're
going
to
use
the
binder
particular
constructs
great.
B
It
doesn't
currently
have
a
very
fancy
system
for
doing
this.
We
just
kind
of
walk
through
the
code
and
expand
when
the
unit
I'm,
but
this
is
an
area
where
there's
been
a
lot
of
academic
work
in
this
area
and
a
lot
of
the
art
is
pretty
advanced.
Those
areas
I'm
having
a
fancy
system
for
deciding
the
best
way
to
lower
puna
construction
or
to
tile
ACEF
instructions
with
with
machine
out
codes.
B
That's
an
area
that
we're
hoping
to
get
into
in
the
future
that
we
don't
do
yet
so
I,
don't
have
a
lot
to
say
about
again
one
of
things
that
happens
kind
of
in
any
compiler.
Whenever
you
lower,
whenever
you
go
from
any
ir
to
another
ir,
that's
lower
level,
it
almost
always
exposes
my
tendencies,
because
our
anomaly
are
typically
has
we
don't
see?
Is
that?
Are
there
implicit,
they're
kind
of
bound
up
in
the
operation,
because
to
make
many
things,
when
you
expand
it
into
a
simpler
operation,
this
those
redundancies
become
exposed.
B
Of
course,
whatever
you
do,
that
it
becomes
valuable
to
do
things
like
GBM
le
cm
to
get
rid
of
the
dependencies.
Gd
n
is
just
operation
that
looks
for
the
same
expression
that
carry
multiple
times
and
instead
of
competing
multiple
times.
We
just
computed
once
and
hold
value
in
register.
La
cm
is
conceptually
the
same
thing,
except
that
it
works
across
smooth
puppies.
So
if
you're
competing
the
same
value,
every
iteration
of
a
loop,
you
can
compete
at
once
outside
of
a
loop
and
just
reuse
that
value
of
the
register
of
iterations
loop.
B
B
Maybe
we
keep
our
state
I
are,
but
we
canÃt
eight
the
instructions
with
a
machine
opcode
encoding.
So
we
have
that
I.
Add
instruction,
which
is
just
the
in
you
know,
in
the
middle
of
a
lie.
Are
it
just
appear?
I,
add
you
know
it's
your
add
just
to
a
brands,
doesn't
add
it
all
to
the
same
type
and
then
we
can
do
is
we
can
take
that
same
instruction
without
changing
it,
and
we
do
so
sign.
A
B
Exactly
so,
they
can
actually
ignore
the
encoding
this
for
the
most
part
when
they're,
when
they're
actually
driving
instructions,
they
need
to
be
careful,
but
when
you're
trying
to
find
like
is
this
expression,
you
know
congruence
to
use
the
term
to
an
earlier
expression
that
the
opcode
doesn't
know
the
gene
encoding
doesn't
come
into
it.
They
can
actually
just
look
good,
though,
that
IR
level
opcode,
which
is
just
like
IGAD
and
then
sort
of
hide
the
block,
quotes
totally
decide.
Okay.
This
is
this.
A
B
B
B
Don't
know
what
to
say
about
that
here:
that's
kind
of
a
bigger
topic.
This
finish
talk,
but
we
do
SSA
based
education,
sweeper
your
cousin,
say
for
all
the
way,
through
its
kind
of
this,
using
the
sebastian
hack
technique
of
doing
spilling
first,
to
make
sure
that
your
SSA
graph
can
be
allocated
that
machine,
and
then
we
can
observe
the
the
basic
of
the
page.
Investing
vegetation
is
that
an
SSA
graph,
the
interference
graph
for
is
a
chordal
graph
and
you
can
color.
A
B
Fast,
but
in
practice,
what
we've
really
done
is:
we've
split
a
hard
problem:
Bridgette
a
patient
into
two
hands,
one
of
them,
which
we
call
next
occasion
becomes
the
easy
part
room,
and
then
the
hard
problem
gets
put
into
the
first
half,
which
is
just
one
problem,
pursuit
of
it.
We
can.
We
can
say
Li
Mei
occasion,
easy
by
splitting
out
the
hard
part
into
us
have
a
problem.
It's
for
this
little
trick
that
come
other
writers
like
to
do,
and
so
so
it
ends
up.
B
The
original
occasion
is
is
actually
not
as
fast
as
we
would
hope
it
to
be
right
now,
and
so
that's
actually
an
area
we
need
to
overcome.
But
again
that's
kind
of
a
big
topic.
I'm
gonna
stick
to
more
high-level
stuff.
In
this
talk,
that's
done.
The
codec
C
is
ready
to
go
once
we
have
registers,
that's
enough
for
us
to
encode
which
instructions,
the
cookie
that
says
what
what
we
should
up
good
is
gonna
use.
B
B
So,
if
example,
x86
has
branch
invidious
as
a
branch
there's
an
8-bit,
immediate
and
French
as
the
30
DB
DB.
Yet,
depending
on
how
far
the
brush
needs
to
go,
you
can
do
the
smaller.
We
get
more
bigger
immediate
now,
once
we
know
how
big
the
actual
file
on
coding
wealthiest
ructions
are,
we
know
how
far
part
of
it
is
and
we
can
pick
the
actual
brush
target
so.
B
B
Stuff
that
compilers
otherwise
used
to
think
it
was
their
job
like
in
charge
of
scheduling,
is
something
we
do.
E2A
first
fluctuation,
don't
have
to
work,
but
there
still
will
be
a
place
for
it
and
we
may
actually
look
at
doing
it
someday,
but
but
for
a
while,
you
can
basically
just
rely
on
the
hardware
to
schedule
for
you.
It
has
a
pretty
good
job.
B
B
We
don't
have
live
plants
here,
but
we
do
have
some
some
ideas
for
what
should
I.
Think
that
you
take
the
very
first
thing
we
get.
You
need
figured
out
sort
of
the
frame
upon
which
a
lot
of
stuff
will
be
built,
easy
in
lighting
in
lighting.
You
can
either
think
of
it,
as
some
people
call
it
the
mother
in
wild
malposition,
some
people
call
it
the
poor
man's
interprocedural
analysis,
but
in
lighting
really
is
the
thing
that
makes
it
possible
to
do
a
lot
of
Opposition
in
a
language
like
rust.
B
B
Mentioned
their
previous,
the
coordinator
is
organized
to
just
think
about
100
a
time,
so
it
actually
isn't
very
well
positioned
to
be
aligning
and
I
expect
to
do
a
mid-level
pfizer.
We
would
have
to
add
other
layer
between
we
currently
think
of
is
rust
and
crane
efforts.
That
would
add
the
ability
to
think
about
multiple
Funky's
at
a
time
and
people
to
inline
one
into
another.
B
So
many
Lighting's
really
important,
of
course.
What
to
do
in
mining
then,
then
we're
back
to
our
same
old
story
again:
eliminate
redundancies,
of
course,
at
the
middle
optimizer.
This
is
extended
to
include
limiting
weekends
between
loads
of
stores.
Food
is
really
important.
We
also
think
about
again
think
what
eliminating
indents
is
between
the
loop
iterations
and
may
also
extend
that
to
Lowe's
and
stores
Siddalee.
You.
B
Sort
of
big
high
level
tasks
that
the
middle
of
pleasure
to
do
is
user
use,
deeper
instructions
in
us,
that's
constant
folding,
but
I
also
sort
of
move
in
that
category.
Algebraic
simplifications,
just
like
you
know,
multiply,
is
more
expensive,
a
shift
so
convert
mobilizing
the
shifts,
also
more
complex,
stainless,
but
also
great
operations.
But
if
you
have
a
branch
you
can
prove
the
condition
is
constant.
B
You
can
fold
that
away
and
result
in
more
locations,
and
so
most
of
these
things
we
don't
need
a
lot
of
help
in
terms
of
like
what
can
work
in
people
look
in
front
ends.
People
producing
my
are
you
do
for
us.
Aligning
will
need
help
to
figure
out.
How
can
we
organize
the
compiler
to
manage
local
function
than
just
in
terms
of
the
data
structure
and
managing
memory
inside
the
compiler,
but
the
main
thing?
B
What
we
need
we
really
care
about
when
we
look
here,
but
what
the
fund
that
telling
us
is
memory
instructions,
so
those
are
stores
it
may
be.
We
done
see
between
them
rate
vibrations,
I,
guess,
I've
gotta
have
this
slide
here.
So,
in
lighting
one
of
the
big
things
the
Eleni
is
also
heuristics
and
so
that'll
be
an
itching
question
going
forward.
It's
when
you
decide
to
put
you
in
line
and
when
it.
B
A
B
Even
in
debug
mode
funny
and
I'm,
those
things
always
and
that's
that's
a
different
set
of
heuristics
those
those
obstruction
levels
that
are
conceptually
just
like
user
rights.
Those
with
the
expectation
that
will
always
be
in
mind
is
kind
of
a
different
level
aligning
them
what
sometimes
people
call
back
in
the
aligning
which
is
sort
of
more
focused
on
okay,
now
I'm
gonna
try
to
make
a
heuristic
they're
gonna,
try
to
balance
code,
size
versus
performance,
so
I
try
to
make
a
clever
decision
about
you.
B
This
are
the
arguments
constants
that
could
be
folded
away
if
I
in
the
inline
body,
or
is
this
inside
of
a
hot
loop.
These
kind
of
questions
feels
like
a
different
set
of
heuristics,
so
I
can
see
a
place
where
rushed
at
the
mere
level
in
lines.
The
first
category
of
things
of
just
like
I'm
doing
the
things
that
I
considered
the
instructions
that
should
always
be
in
mind,
and
the
second
level
is
now
I'm
gonna,
try
to
like
think
about
the
Machine
of
line
and
I
think
about
no
I.
B
B
Liner
at
some
weight,
that's
the
interesting
trade-off.
I,
sometimes
talk
about
the
way
for
elevators
water
by
compilers.
We've
got
about
a
C
code.
The
way
would
look
like
if
a
programmer
from
the
70s
wrote,
C
code
and
the
way
programmers
in
the
70s
write.
C
code
is
like
when
they
have
things
they
want
in
line.
They
don't
write
functions
they
write
about
goes
because.
B
That's
how
you
do
mind
things
in
70s
writing,
so
that
kind
of
code
turns
out
to
be
kind
of
a
coincidence,
but
also
kind
of
a
result
of
the
way
C
worked
in.
That
era
was
kind
of
this
low
level.
Sign
language
for
the
program
was
kind
of
thinking
in
terms
of
how
should
I
lay
out
the
code
in
a
way
that
will
compile
at
a
good
code,
and
so
we
kind
of
watched
front-ends
to
produce
for
us
that
kind
of
code.
That's
what
things
look
like.
B
We
want
things
to
have
like
if
a
smart
program
in
seven
days
would
have
written
a
macro
for
this.
We
want
the
front
end
of
the
invited
for
us.
Ideally
so
this
kind
of
our
that's
kind
of
our
like
ideal
picture,
like
you
know,
can
give
us
the
best
possible
code.
That's
what
it
would
look
like
is
the
sort
of
medium-sized
functions
not
too
big,
but
not
small
functions,
because
those
of
kaliesha
that
in
mind
and
and
not
only
simple
code,
that's
not
doing
a
lot
of
abstract
things
and
that's
really
what
can
operate
one.
B
B
Actually
one
of
my
ideas
is
that
front
ends
actually
have
a
better
idea
of
what
you
can
think
of
as
a
abstraction
versus
there's,
a
pure
heuristic
approach
of
just
like
looking
at
code
size
and
looking
kind
of
guess
about
what
cuts
of
folding
and
what
could
be
possible
so
wouldn't
be
undermining
of
looking
at
memory
ones
is.
This
is
one
of
one
of
the
big
big
tasks.
B
It's
such
a
big
task.
We
split
up
into
many
categories
because
EDM
called
we
don't
know,
we
call
it
the
ACM,
we
call
it
dead,
store,
elevation,
start,
look,
forwarding
s
are
away
scaler
placements,
you
know
it's
registered
promotion.
The
only
basically
means
of
an
essentially
names
for
the
same
thing
of
trying
to
get
rid
of
redone.
This
one's
in
stores
tried
destroyed
instead
of
going
through
memory,
can
be
hold
values
and
registers
more,
and
can
we
just
avoid
no
doing
the
same
local
times
before
we
doing
stores
we
don't
need?
B
B
We
can
split
this
into
two
halves:
there's
the
transform
half,
which
is
of
the
mechanics
of
like
taking
a
loop
and
doing
some
some
advanced
reservations
to
it,
but
the
first
half
of
that
is
the
analysis,
the
analyze
loop
and
say
now.
First
of
all,
what
is
safe
to
do
in
this
loop?
Is
it
possible
to
to
do
gonna
change?
Is
it
possible
to
do
other
kind
of
operations?
It
would
change
the
order.
B
B
We
can
take.
Is
it's
difficult
to
think
in
terms
of
alias?
Tells
us
in
terms
of
think
of,
can
I
prove
these
two
pointers
are
the
same
or
different,
and
that
actually
ends
up
being
more
of
a
use,
a
means
other
than
end.
The
question
that
we
really
want
to
ask
is:
if
I
have
a
loader
store
or
a
call
can
I
move
past,
some
other
load
or
store,
and
so
it
really
becomes.
The
question
isn't:
is
this
load
loading
from
the
same
address
as
that
store?
B
It's
is
a
safe
to
move
this
load
across
that
store,
and
so
that's
actually
another
reason
why
we
think
that
Twitter
types
in
the
IR
aren't
the
important
part
we
can
get
a
front-end
that
can
provide
us
with
high
level
memory
dependence,
information
about.
You
know
what
storage
find
out,
what
loads
and
what
loads
by
the
store
and
so
on.
B
Then
we
think
we
can
get
away
without
having
to
do
pointer
analysis,
which
is
really
attractive
because
pointed
also
some
compilers
is
really
complicated
and
really
arrow
heads
they
get
caught
up
and
fail
in
a
lot
of
ways
yeah
in
sort
of
a
very
confusing
way,
because
you
end
up
having
to
have
these
very
complex
solvers.
That
can't
explain
how
they
came
up
with
the
answers
they
came
up
with
so.
A
B
The
hard
problem
is
any
others
I'll
say:
is
you
seen
throw
away,
or
you
start
with
a
situation
where
you
have
all
these
pointers?
You
know
nothing,
you,
basically
a
sort
of
reverse
engineer
or
the
quite
ablation
sips
from
nothing
you
could
have.
This
system
of
you
know
like
look
at
all
the
assignments
of
player
transfers
and
put
them
all
in
a
big
country
system
and
solve
it
and
in
language
like
class.
That
has,
for
example,
an
immutable
reference.
B
You
know
not
matter
I
R,
then
it
could
make
all
the
things
were
going
to
do
all
the
operations
and
it's
a
large
part
of
what
my
visors
do
is
just
basically,
this
kind
of
set
of
things
of
know
can
I
move
these
stores
to
pass
these
other
stores.
It
will
be
flowed
across
these
stores
or
calls
yeah.
That
would
basically
give
us
a
lot
of
stuff
for
free,
which
is
way
too
talkative.
It.
B
Ipc,
less
analysis
and
C
is
notoriously
problematic
for
a
lot
of
reasons,
and
it
gets
us
out
of
the
business
of
trying
to
mean
if
you
look
at
LVM
example,
there's
this
question
of
like
they're
trying
to
do
memory
semantics
and
it's
very
difficult,
because
the
rules
for
what
even
just
trying
to
describe
what
GE
n
is
doing
today
is
is
actually
quite
complicated
because
they
kind
of
have
always
like
discovered
rules
about.
No,
this
seems
to
work
across
a
large
body
x,
equals
code
piece.
B
B
Think
it's
also
interesting
to
bring
up
another
example
of
the
see,
restrict
pointer
feature
see
as
this
keyword
called
restrict,
which
is
kind
of
confusing,
but
one
of
the
one
of
the
key
insights
that
I
think
they
had.
We
think
it's
a
really
good
insight
was
that
you
can't
discuss
or
the
chain
of
repetition
matters.
Look
how
you
get
a
pointer
matters
is
if
we
can't
discuss
all
the
different
possible
ways
that
you
can
get
from
one
pointer
to
computing.
B
You
still
care
about
that
dependency,
even
though
the
pointers
are
aren't
equal
or
if
sometimes
the
CL
+
theta
gets
confused
about
whether
or
not
she
should
be
carrying
about
people
who
have
the
same
memory
into
multiple
pieces
of
their
outer
space.
At
the
same
time,
which
then
has
two
different
pointers
that
can
have
excess
as
a
dependent
each
other
just
by
having
completely
different
addresses,
and
so.
B
B
A
B
Is
it
safe
to
vectorize
this
loop?
Is
it
safe
to
cache
block
this
loop
right
at
what
distance
kind
of
vector
is
this
kind
of
famous
also
turn
into
memory?
Memory
depends
how
questions
you
care
about,
not
just
what
other
store
instructions
in
they
are,
but
transforming
it
into
the
road.
Nine
one
time
domain
and
thinking
about
coming.
B
Iterations
ahead
is
another
store
that
will
depend
I,
can't
cross
and
so
there's
all
kind
of
collapses
in
the
same
problem
now
loose,
of
course,
they're
they're
different
than
the
straight
line
code
that
we
don't
see
is
at
one
time
rather
than
at
compile
time.
So
we
need
different
mechanisms
for
the
Google
loops,
but.
B
A
B
Of
is
just
say
that
every
store
depends
I,
have
a
previous
store
or
has
a
dependency
that
we
really
care.
We
can.
We
can
sort
of
look
at
the
two
stores
and
figure
it
out
if
we
know
that
one
who
does
the
own
sell
one,
but
in
order
to
sort
of
factor
of
the
dependencies
to
avoid
an
EM
pens
and
dependence
tree,
we
can
basically
say
every
store,
gonna,
sterilize,
all
the
stores,
but
then
loads
will
all
just
point
to
the
one.
Most
recent
story
depend
on
kind
of
a
cheaper
way
to
do
it.
B
So
that's
actually
kind
of
a
good
Celtic
player.
We
could
have
an
immediate,
fast
points.
One
of
one
of
Queen
left
goals
is
to
be
as
well
as
a
what
I
call
the
pretty
good
compiler,
which
is
a
compiler
that
can
optimize
decently
well
with
with
quite
fast
of
all
times,
so
not
the
highest
quality
performance,
but
also
fast
enough
that
in
typical
builds
debug
girls
are
like
you're,
so
slow
because
you're
not
doing
any
inlining
we're
not
doing
enough.
You
lining.
We
could
have
kind
of
a
middle
balance
where
you
have
enough
code.
B
B
The
other
talk
briefly
about,
we
didn't
load
elation,
and
actually
this
is
kind
of
the
view
of
doing.
We
didn't
motivation,
unclear,
there's
a
data
structure
and
I,
actually
a
really
really
cool
technique
for
doing
this,
that
we
can
use
an
intrical.
This
code
cache
map,
which
is
basically
a
hash
map
where
you
have
checkpoints
and
rewind
in
checkpoints.
So
you
can
basically
say
you
know,
take
this
half
map
put
a
bunch
of
things
in
it.
B
Up
really
well
with
a
Dominator
tree:
that's
for
search
traversal,
so
for
walking
down
the
Dominator
tree
every
time,
I
go
down
a
level.
We
can
look
ahead,
look
at
checkpoints
and
then
we
keep
walking
instructions
in
that
I
made
a
tree.
Node
editing
instructions
there
and
then,
when
we're
done
we're
gonna
pop
back
up
the
DFS
tack,
then
we
can
just
like
rewind
at
that
checkpoint
and
go
down
the
next
bunch
of
the
DFS
tree.
B
B
You
can
do
a
double
your
trade
search,
and
this
is
basically
enough
if
you
have,
for
example,
a
trust
mirror.
If
you
just
want
to
do,
we
done
a
little
asian
over
in
beautiful
references.
If
you
could
build
animator
tree,
you
can
do
a
let's
go
back
map
traversal
overrides
them.
You
could
do
this
pretty
quickly
and
pretty
evenly.
B
This
is
better
I've
heard
some
people
have
tossed
on
the
idea.
I'm
just
like,
let's
voice
all
the
loads
at
the
ng
block
or
sort
of
to
the
highest
off
point
you
they
can
go
I
think
doing
this
in
terms
of
like,
let's
take
the
loads
where
they
are
and
just
really
limited.
The
redundant
ones
is
actually
a
little
bit
safer
to
do
in
terms
of
cobalt
ion,
because
maximally
wasting
loads
can
increase.
Register
pressure
will
be
like
leading
library
is
the
flipside
of
factory
downloads.
Is
that
we're
holding
things
and
registers,
which
is
great?
B
If
you
have
enough
I
deserve
able?
If
you
don't,
then
we
get
enough
spilling
things
we've
done.
It
causes
us
to
potentially
make
were
stored
in
some
cases.
So
it
sort
of
conservative
thing
of
don't
move
any
loads,
but
just
delete
the
other
ones,
and
so
a
good
trade-off
point.
You
can
do
it
pretty
easily
with
this
scope
at
map
and
other
key
can
approach
now
mater
tree
kind
of
approach.
This
is
also
one
thing
and
I
said
what
this
book
is.
B
You
can
extend
it
through
GBM,
so
gbn
also
wants
the
same
thing
and
once
a
hashmap
that
wants
to
be
sort
of
scope,
/
/,
Dominator
tree
traversal,
and
so
you
can
extend
this
kind
of
concept.
It
is
to
have
that
and
get
of
arbitrary
expressions,
rust
mirror
doesn't
have
SSA
form,
which
makes
the
GP
a
little
bit
more
complex,
but
one
of
the
ideas
there
is
that
you
can
rely
on
the
fact
that
you
have
immutable
references
or
unit
above
my
bindings.
B
By
default,
you
can
search
meet
those
as
I,
say:
values
limit
yourself
to
just
those
values.
You
might
be
able
to
get
a
fair
amount
done.
You
know,
might
allow
you
to
delete.
No
coach
have
West
code,
which
might
what
means
less,
where
it
sounds
good
passes
to
do,
which
could
good
speed
up
contact,
and
so
it's
an
interesting
thing
to
consider.
Of
course,
the
DN
isn't
free
you
doing
a
lot
of
passion,
Apple
games,
so
visiting
me
there.
It's.
A
B
B
Yeah,
that's
a
good
point
and
also
just
within
a
basic
block.
It's
pretty
easy
to
just
if
you're
doing
a
top-down
walk
the
base
of
park,
it's
busy,
you
just
remember
the
most
and
definitely
something
you've
seen
I.
Think
the
only
kids
but
fairly
tricky
is
when
you
have
a
use
of
variable,
let's
define
you
know
and
some
other
control
condition
basic
black.
Whatever
we
want
to
college,
and
so
you
don't
know
exactly
chef,
it
is
but
everything
else.
It's
actually
pretty
easy
to
sort
of
keep
as
subsets
of
vessels
a
form
on
the
fly.
B
Alright
and
just
all
the
finished
up
here,
I
just
on
to
give
a
kind
of
brief
status
of
queen
of
cabal
system.
First,
we
have
our
github
site
here,
cool
thing:
that's
going
on
the
bus
community
of
always
adjusted
in
Buren.
Three
is
working
out
back
end
for
the
roster
Pilar
infamous.
This
is
kind
of
built
on
a
lot
of
good
pieces
of
and
kind
of,
slowly
come
into
place.
B
So
Dennis
very
goo
did
a
lot
of
work
with
us
this
last
summer
to
to
refactor
their
West
back-end,
so
that
all
the
code
that
rust
has
for
translating
into
LVM
now
goes
through
at
rate,
and
so
this
this
trade
now
currently
just
has
a
single
open
agent
in
the
treat
which
is
the
LV
employed.
So
it's
basically
just
like
making
on
the
same
alien
API
calls
and
which
nickname
into
LVM.
B
But
now
we're
going
to
do,
and
with
this
with
this
new
crew
dinner
is
built
on,
is
to
go,
get
to
just
create
when
there's
traits
with
Queen
methods
back
and
instead
cleanups
IR
builder
is
pretty
similar
to
ellaby
MSI
our
builder.
There
are
some
differences,
but
it's
sort
of
within
business
of
generalizing
these
traits
to
to
produce
either
LV
Mir
creel
if
they
are
actually
really
a
factoring.
The
backend,
because
there's
a
lot
of
code
in
in
rust
for
the
translation
from
here
to
var.
B
A
B
B
So
some
of
the
major
ones
we're
using
cream
ifs
in
spider
monkey
to
do
website
like
evolution
and
that's
actually
that's
something.
That's
that's
ongoing
projects
we
have
it
in
Firefox
nightly.
If
you
get
slightly
and
flag,
you
can
enable
innovation
forum
assembly-
it's
not
very
fast
yet
because
I
have
more
operation
work
to
do
yet.
But
that's
that's
in
place
in
the
tree
and
I
passed
the
test
week.
So
we're
kind
of
moving.
B
A
B
Use
of
clean,
lift
is
was
imagine
that
I'm
building
called
buy
some
time
and
I'm
building
with
this,
with
the
hope
that
we're
gonna
sort
of
broaden
the
scope
on
forum
assembly
genomica
so
who
can
put
together
a
coalition
of
people
there
used
to
do
rigging
I'm
with
with
us
taking
them
assembly
beyond
the
web.
The
big
focus
right
now
is
actually
building
on
a
set
of
API
is
for
plugging
the
final
stone
in
a
sandbox
way.
B
So
if
you
wanna
be
able
to
do
nulls
and
files
and
that
kind
of
thing
with
I/o
outside
a
browser,
you
can
do
that
kind
of
thing.
We
don't
just
want
to
give
a
website
program,
this
flushes
about
something,
because
the
whole
benefit
of
bumps
on
these
with
your
sandbox.
So
this
is
a
big
thing,
I'm
working
on
in
wasn't
time
right
now.
So
if
my
checkup
wasn't
fun,
another
big
user
of
green
EFT
is
is
fastly
so
fastly.
B
It's
also
using
a
enough
to
do
what
tell
me
completion
and
they're
doing
web
site
of
occupation
in
the
edge.
Firstly
is
a
CDN,
and
so
they
provide
they
have.
Servers
are
on
the
world
and
they
could
my
web.
So
my
code
on
our
servers
is
a
service
for
customers,
so
if
I
check
out
fastly
and
think
they
have
a
demo
called
terrarium
we're
essentially
using
so
we're
free
month
online
expect
the
best
buy.
My
past
thing
so
go
check
those
out.
B
So
if
you,
if
you
just
search
for
a
simple
jet
demo,
all
in
the
communication
project
you'll
see
the
demo
project,
it's
a
it's
actually
really
simple
toy
language
to
be
built
so
use
the
queen
of
backends
to
compile
my
language
and
I'll.
Show
you
the
basics
of
using
that
interpreted,
API
and
acquaintances.
Builder
API
is
to
go
by
our
and
generate
them
into
code,
but
it
so
those.