►
From YouTube: Lang Team Design Meeting 2020-03-16: ffi-unwind
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
Bit
so,
okay,
here's
a
paper
for
taking
live
minutes.
Well,
I,
don't
know
I,
don't
know
because
you
guys
already
started
so
I.
Don't
wanna
like
interview
too
much,
but.
C
D
E
I
think
the
difference
is
between
one
and
two
are
sufficiently
minor,
that
we
can
just
not
worry
about
them
for
now.
So
it's
really
an
edge
case
on
whether
you're
allow,
whether
you
can
long
jump
across
C
unwind
and
whether
this
is
guaranteed
to
always
work
but
I.
Don't
think
anyone's
really
going
to
do
that
in
practice
for
using
C
n
wines
you're
almost
going
always
going
to
be
calling
code
that
throws
exception
is
rather
than
long
jump.
F
B
E
E
E
B
B
E
E
The
idea
of
proposal
three
is
that
we
keep
things
simple.
We
just
keep
extra
and
see
when
you
have
pan
equals
unwind
you're
allowed
to
unwind
through
it
when
you
have
an
equals,
abort
you're
not
allowed
to
unwind
through
it,
and
it's
your
responsibility
as
the
user
to
make
sure
that
if
you
call
code
that
full
throw
exceptions
back
to
you,
you
must
compile
an
equals
and
whines.
This
is
basically
the
same
thing
as
if
you
write
C
code
that
cause
you
cuz
cause
that
made
through
an
exception.
You
need
to
use
F
exceptions.
A
If,
if
you
use
external
C,
we
don't
do
we
basically
don't
do
anything.
If
you
just
pinnacles
of
work,
an
extern
c,
we
don't
add
unwinding
tables
or
machinery.
There
were
some
earlier
drafts
where
we
were
considering.
What
would
it
be
like
if
you
did
have
like
a
shim
to
intercept
unwinding
and
things
like
that
and.
C
A
Particular
the
question
was
because,
if
we
were
one
of
the
advantages
to
having
C
unwind
is
that
you
can
only
insert
that
you
have
a
narrower
set
of
places
to
insert
shims
like
that.
So
we
were
considering
what,
if
we
put
the
shims
at
all
C
sites,
how
bad
would
that
be
and
I
did
make
a
version
of
the
compiler
that
did
that,
but
we
didn't
end
up
going
with
that
proposal.
A
Behind
remember
all
the
reasons
why,
but
that
would
not
be
this.
That
would
be
a
different
version
and
this
like,
if
we
say
that
it's
UV,
then
you
don't
need
to
have
a
shim.
So
there's
really
no
overhead.
You
can
still
a
him
as
a
debug
mode
or
something
to
help
people
catch
it
in
practice,
but
in
release
at
least
it.
G
E
E
E
E
A
B
E
So
the
main
difference
is
if,
if
you
just
have
an
extern
see
so
the
conclusion
we
reach
is
that
proposal
two
is
better
if
the
user
gets
his
annotations
right.
That
is,
if
the
user
properly
marks
functions
that
actually
do
throw
an
exception
as
C
unwinds,
then
everything
works.
Fine
on
you
get
because
you
get
you
be
F
next
receive
under
proposal
under
proposal.
You
get
you
be
if
an
external
C
function
and
whines.
E
E
A
A
E
Because
so
under
proposal,
three
it's
simpler
because
we
just
have
a
single,
a
single
API,
where
and
and
the
user
it's
easier
for
users
to
just
decide.
Okay,
my
suppose
my
signals
code
that
I'm
calling
might
throw
an
exception
so
I
just
need
to
make
sure
it's
compiled
with
panicles
unwind
and
it
will
just
work
I.
Don't
need
to
worry
about
annotating.
My
FFI
calls
correctly.
A
E
E
E
E
E
A
E
C++
code
runs
out
of
memory.
It
throws
a
bad,
a
log
exception
which
tends
to
come
as
a
surprise,
because
so
in
what
in
this
particular
rust
bug,
we
had
the
C++
exception,
just
unwinding
all
the
way
through
dress
codes
and
causing
the
seg
fault,
because
catch
on
one
couldn't
handle
foreign
exceptions
properly.
This
is
fixed
now,
but
the
point
is,
you
can
sometimes
get
surprise
exceptions
where
you
do
you
don't
expect
them
to.
B
E
E
E
A
In
some
sense,
it's
easier
to
tell
people
what
to
do.
On
the
other
hand,
the
consequences
of
failure-
I,
don't
know
you
have
to
make
sure
your
panic
equals
online
and
Panik
aboard
things
are
lining
up
with
F
no
exceptions
that
you're
expecting
if
you're
linking
against
foreign
code
and
we're
what
are
the
other
like.
What
is
the
we're
giving
up
some
kind
of
optimization
opportunity
in
the
case
of
panic
unwind,
although
I
consider
that
pretty
minor,
because
it's
probably
an
either
it
will
still
have
landing
pads.
A
E
A
Right
so
like
they
invoke
C++
code
will
throw
an
exception
and
compile
it
with
C
panic
equals
a
board
at
C++.
Code
throws
the
exception.
Instead
of
catching
it,
we
we
now
have
UB,
and
so
you
really
don't
want
to
use
really
don't
want
C
code
or
C++
code
and
panic
equals
abort.
Unless
the
C++
code
is
combined,
proud
with
F
no
exceptions
which
or.
G
And
I
know
I've
made
this
point
before,
but
just
like
coming
from
the
world
of
integrating
C
and
C++
and
rust
in
embedded
situations
and
whatnot
like
that
is
exactly
the
behavior.
That
I
would
expect
is
that
I
would
need
to
make
sure
that
my
rust
compiler
options
line
up
with
my
C
and
C++
compiler
options.
A
A
The
upside,
then,
is
that
it's
just
we
haven't
gone
it
all
into
like
some
of
the
annoying
well
I,
don't
know
how
many
corner
cases
there
were
I
guess
the
main
thing
I
was
thinking
of
I.
Guess
we
kind
of
sized
up
the
corner
cases
around
like
calling
Reed
and
having
pthread
certain
platforms
when
it
read
is
canceled
they'll
throw
an
exception,
but
I
guess
those
are
all
forced
unwind
cases.
Yes,.
E
A
E
E
B
E
A
A
E
A
E
A
E
E
B
F
E
F
I
guess
the
point
of
my
questions:
I've
been
in
other
software
shops,
where
their
approaches
to
say
well,
it
was
such
a
nightmare
to
handle
that
they
said
the
official
policy
was.
You
should
be
monitoring
your
memory
usage,
yes
ever
means
and
like
avoiding
calling
allocating
functions.
Humph
rather
never
had
this
arise.
So
I
was
curious.
F
Whether
this
is
that
scenario,
but
it
sounds
like
you're
saying
no,
we
should
treat
it
as
something
that's
may
happen,
but
rather
it's
these
c++
jobs
to
either
handle
it
within
the
foreign
code,
or
you
should
used
to
see
online
api
close
cases
and
if
you
use
the
C
API,
you
get
what
you
pay
for
that
sort
of
fun
hearing.
Yes,.
B
C
E
B
A
A
G
G
I
think
any
of
these
proposals
would
be
suitable
for
us,
because
we
have,
you
know
complete
control
over
the
the
ABI
string
used
for
the
web
assembly,
functions
that
we're
loading
and
running
and
I'm
trying
to
think.
If
there
are
there
any
other
wrinkles,
we
mentioned
the
proposal.
Three
had
some
interactions
with
function:
pointers
because
we
don't
have
attributes
in
text
for
function,
pointers
and
while
it
would
be
it
would
be
a
big
deal
for
us
if
an
attribute
was
required
to
mark
a
function
as
unwind.
G
B
G
A
It
happens
in
your
code.
You
don't
have
any
desire
to
intercept
this
rust
panic,
but
I
guess
the
only
kind
of
interesting
twist
on
that
would
be
like.
If
you
had
a
c++
frame,
I
mean
right
now.
The
destructors
would
run
first
key
post
bus
values
because
we
are
converting
to
the
native
panic
conceptually
at
least
I
guess,
there's
some
amount
of
we're
defining
a
little
bit.
What
our
panic
string
looks
like
or
whatever
on
those
platforms,
or
at
least
it's
observable.
Let's
prove
that
way.
A
G
So
looking
forward,
I
don't
expect
we're
going
to
have
C++
frames
in
the
mix
with
destructors,
but
the
webassembly
extensions
proposal
or
sorry
extension
exceptions
proposal
is,
is
moving
forward
and
it's
somewhere
between
likely
and
possible
that
we
will
want
to
use
the
native
unwinding
mechanism
to
implement
that
in
the
native
code
that's
generated
from
webassembly.
So
that
would
basically
look
the
same
as
though
we
were
wanting
our
rust
panics
to
unwind
C++
frames
and
run
destructors.
Potentially,
okay,.
A
Cool
about
covers,
although
I
guess,
the
only
other
conceptual
scenario
would
be
kind
of
C
code,
invoking
rust
in
a
book
like
the
same
situation,
but
the
sandwich
is
is
reversed
and
that
that's
already
sort
of
what
we
said
about
well.
What
if
you
wanted
to
have
C++
errors
that
propagate
through
your
s
code?
That's.
A
Okay,
the
last
thing
I
thought
gave
only
a
few
minutes
left
so
feel
free
to
steer
me
differently,
but
I
thought
it
might
be
useful
to
just
narrow
down
for
each
of
the
proposals
like
what
do
we
have
to
do
at
the
different
spots
so
that
we
understand
this
clearly
proposal,
three,
nothing
right
so
proposal.
Three,
we
we
generate
normal
function
calls
the
same.
Basically
C
and
rust
calls
are
the
same.
E
E
Would
I
would
not
worry
about
forced
in
mind
at
the
moments
when
deciding
between
proposals
two
and
three
in
practice?
I,
you
just
long
Chum
just
works
as
long
as
you
don't
want
you
just
as
long
as
you
don't
have
these
structures.
P
three
exits
just
works
as
long
as
you
have
no
disruptors
right,
and
this
is
orthogonal
to
the
whole
and
it
just
works
whether
you
have
an
equals
on
mine.
Open
equals,
Ward's,
okay.
So
it's.
E
E
E
A
B
A
A
B
E
A
A
Mean
it
seems
clear
so
introducing
and
the
unwind
ABI
is
more
work
to
implement,
but
not
a
lot
I
think
it's
not
totally
clear
to
me
whether
it's
like
more
or
less
work
for
the
humans
who
write
the
code.
It's
kind
of
simpler
on
the
one
side,
but
on
the
other,
you've
got
the
the
fact
that
when
you
switch
to
panic
equals
abort,
you
know
you
know,
there's
like
extra
considerations.
A
G
My
sense
is
that
the
the
learning
curve
is
higher
with
proposals
one
and
two,
just
if
I'm
thinking
about
like
introducing
this
concept
to
my
teammates,
there
will
be
a
lot
more
explanation
required
than
just
like.
Okay,
you
might
get
more
landing
pads
with
proposal
three,
but
there's
an
attribute
that
might
help
with
that
later
on.
Are
you
familiar
with
I
know.