►
From YouTube: .NET Design Review: ARM Intrinsics
Description
00:00:00 - Approved: Arm Shift and Permute intrinsics https://github.com/dotnet/runtime/issues/31324#issuecomment-594124186
01:21:19 - Approved: Extend ObsoleteAttribute https://github.com/dotnet/runtime/issues/33089
01:27:41 - Approved: NativeCallableAttribute should be a public API https://github.com/dotnet/runtime/issues/32462#issuecomment-594132248
01:38:17 - Approved: Low level API support for RCW and CCW management https://github.com/dotnet/runtime/issues/1845#issuecomment-594151682
A
A
B
And
then
use
multiply
add
is
similar
to
the
huge
multiply.
No
we've,
not
we've,
not
reviewed
keys
multiplied.
Yet
that
was
when
we
needed
to.
B
B
A
F
B
G
E
H
B
G
I
J
B
H
B
F
G
G
A
B
A
G
B
B
G
E
E
H
E
A
A
G
G
I
F
F
A
B
G
H
C
B
As
well
so
so
for
I
did,
I
did
figure
out
what
the
left
and
right
are.
So
it
doesn't
necessarily
matter
which
is
which,
but
in
this
case
the
typical
usage
is
left
is
the
thing
you're
getting
the
reciprocal
for
so,
if
you
wanted,
one
over
1717
would
be
the
left
and
then
the
right
hand.
Side
is
essentially
the
changes
based
on
which
iteration
you're
all.
G
B
B
A
C
A
E
F
B
F
I
A
C
A
A
H
F
G
Don't
we
normally
make
things
like
shift,
parameter,
bytes
what
there
may
be
insisted
and
I
miss
correctly.
The
best
me.
F
L
B
B
J
J
B
B
B
If
there's
actually
a
diagram
here
that
I
missed
what
page
is
advisable,
1477
in
the
particular
copy
of
the
manual
I
have.
B
B
L
L
L
A
B
G
And
what's
the
behavior,
if
someone
passes
in
nada
needing
it,
for
that,
do
we
bail
with
one
final
one
so.
G
M
B
L
G
K
B
G
K
K
G
B
B
A
B
E
G
E
C
C
A
B
B
I
L
L
B
B
C
C
H
L
B
L
A
A
A
B
G
A
C
B
B
Yes,
because,
in
the
case
of
in
the
case
of
low,
it
clears
the
upper
half
all
in
the
case
of
I.
It
takes
the
upper
half
without
affecting
the
other
bits
so
effectively
you
would
do
low
and
then
you
would
use
the
result
of
that
as
the
accumulator
in
the
high
operand.
G
B
B
G
G
G
C
C
E
H
B
So
it
reads
the
corresponding
even-numbered
elements
from
two
source
registers
starting
at
zero.
This
is
the
result
from
the
first
source
in
two
consecutive
elements
in
the
lower
half
of
a
vector
and
the
result
from
the
second
source
register
in
two
consecutive
elements
of
the
upper
and
then
writes.
C
C
E
G
G
C
G
E
G
K
G
Evil
doctor
odd
than
I
would
expect,
like
I,
would
expect
any
outputs
at
index
0
even
sub
0
and
index
1
on
Sub
Zero
and
index,
who
even
sub
1
and
index
3
awesome
one
and
then
so.
That's
alright!
So
your
your
hand,
motions
went
from
right
to
left
like
your
index
that
there's
went
from
left
to
right
so
which
direction.
J
G
I
guess
what
I'm
saying
that
is
unpacked
low,
even
in
odd
things,
grow
out
everything
that's
in
the
upper
portion
of
between
input
parameters
and
then
explode
each
of
them
individually.
Once
they're
exploded
the
odd
parameters
values
will
be
in
the
odd
indices
of
the
destination.
The
even
parameters
values
will
be
in
the
evening,
that's
kind
of
where
I
was
going
to
that.
Maybe
but
maybe
that's
a
bit
too
using
money.
You
did
Hector
someone.
G
B
J
B
L
B
L
B
C
G
G
B
I
G
E
L
L
M
B
G
B
I
B
G
G
K
K
G
K
G
G
A
A
A
B
C
A
All
right
so
quick
thing
on
this
one,
so
we
want
to
make
more
things
obsolete
in
order
to
make
more
things
obsolete.
We
have
to
solve
the
problem
that
people
draw
obsolete
warnings.
Let
me
do
that,
and
the
mechanism
we
came
up
with
or
I
came
up
with
is
that
we
introduced
the
idea
of
the
diagnostic
IDE
that
applications
that
they
have
to
do
to
use.
The
idea
is
that
you
can
share
those
diagnostic
IDs.
A
So
if
this
thing
is
like
that
wide
it's
going
to
be
a
but
I
say
this
exactly
said
that
you
only
ever
see
like
micro
and
then
it's
like
that's
not
very
useful
right.
That's
that
and
then
the
second
one
is
the
URL
formats
so
like
they
have.
Is
like
I
think
in
the
compiler
today
on
the
IDE,
when
your
analyzer
that
actually
has
it
you're
all
set
up
the
actual
ID
they
show.
You
is
a
hyperlink,
you
can
click
on
it.
A
The
discoverability
of
is
a
super
4,
so
I
felt
another
issue
to
add
it.
Quick
back
to
the
ideas
for
code
fix
up
to
the
IDE,
then
also
to
just
launch
the
browser,
but
the
idea
is
that
you
will
have
that.
I
made
a
URL
for
me,
because
the
idea
is
that
you
can
have
one
format
specified
in
it
which
base
you
just
get
to
a
place
at
the
diagnostic
ID.
A
E
F
A
I
mean
the
other
thing
is
like
I
think
if
we
apply
them
I,
don't
think
it
would
specify
a
message
at
all,
because
the
message
will
default
to
this
API
has
been
obsoleted
because
we
can't
localize
it
and
then
the
idea
is
that.
Well,
if
you
want
to
know
why
it's
localized
deprecated,
and
what
to
do
you
have
to
follow
the
URL?
It's
basically
the
idea
that
we
don't
have
to
specify
every
stuff
in
the
narrow
list.
N
A
I
mean,
like
that's
I
mean
the
thing
with
this
attribute.
Is
that
it's
it's
already
handled
by
the
compiler,
so
every
time
you
apply,
the
compiler
will
basically
use
it
to
produce
a
diagnostic,
and
we
don't
have
many
attributes
like
that
in
the
VCR,
where
the
compiler
actually
generates
the
diagnostic
though
they
are,
this
would.
N
G
A
Attributes
are
relatively
cheap
that
the
thing
with
this
one
is
the
one
of
the
pushback
from
the
compiler
team.
Is
why
don't
you
make
a
new
attribute
and
write
your
own
analyzer
and
the
answer?
Is
you
already
have
that
thing
you
already
handle
it
and
advise
to
what
analyzer
then
the
problem
is
why
I
better
replicate
the
exactly
away
from
the
compiler,
which
it's
not
straightforward,
right,
that's
area
of
that
all
right.
But
now,
let's
look
at
your
two
issues
which
I,
thankfully.
N
This
is
so
as
it
applies
should
be
made,
be
a
public
API.
It
already
is
an
API,
it's
just
private
we've
been
using
it
since
I
think
was
implemented
in
2015,
so
it's
inside
the
runtime.
It's
basically
just
saying
that
if
the
method
that
this
is
on
as
this
attribute,
it
is
only
callable
from
a
native
anon
managed
content
and
an
end.
It
is
not
callable
from
a
managed.
If
you
try
to
call
it,
it
will
do
very
bad
exception.
N
G
N
This
is
calling
convention
pretty
straightforward.
The
entry
point
is
I,
don't
know
the
history
of
this,
but
my
my
assumption
is
that
if
you
put
this
on
there
and
you
have
an
a
ot
compiler,
that
is
the
entry
point
that
will
be
on
the
native
side.
That's
how
we
project
it
so
that
it
can
be
like
it's
symbol
and
consumable
from
a
native.
Am
I
right?
Yes,
as
a
matter
question.
G
O
N
N
O
P
G
O
P
O
P
G
B
G
O
You
know
it's
like
we
can,
you
know,
relax
it
like.
Maybe
you
can
make
it
first
tracked
in
Suns
met
outside,
but
did
you
know
the
debate?
This
is
design.
Its
design
is
kind
of
the
minimal
building
block
that
kind
of
gets
the
job
done
right.
It's
the
same
reason
like
why
this
cannot
defy
this
is
not
doing
any
marshaling
right.
It's
busy.
This
is
the
little
building
book.
O
P
O
G
O
G
O
O
A
That's
the
thing
with
attributes
those
because
the
way
attributes
are
handled
is
that
you
can
never
really
have
any
logic
in
them,
because
nobody
ever
calls
to
them.
So
they're,
just
you
know,
read
off
of
metadata,
usually
so
I
think
I
attribute
it
fundamentally
doesn't
matter,
I
mean
I,
think
we
generally
use
properties
but
like
as
I'm
saying
the
Elektra
Butte
like
a
boy
would
have
made
the
properties
just
because
they
we
do
does
everywhere
else,
but
like
just
looked
it
up
in
there
feel
some
I
don't
care.
What
area
yeah.
G
N
O
G
Right
anything
he
says:
don't
have
public
fields
feeling
Connie
to
say
we
should
Oh
attributes
I've
always
seen
everything
gets
that
again.
I've,
never
seen
I,
don't
defend
speech.
Apparently
DLL
import
has
field,
so
maybe
it's
things
written
in
1999
have
fields
and
things
written
after
that
have
properties.
O
N
F
G
N
P
F
D
It's
that
fun
is
a
pointer
like
I
think
it
is
all
type
representation
for
it.
Basically,
there.
N
Do
it
as
a
pointer
or
you
could
use
function,
pointers
when
it
becomes,
but
it
becomes
relevant
and
the
function
pointers
API
will
have
a
you,
can
specify
the
function
at
the
calling
convention
at
that
point
and
then
you
could
fully
type
it
if
you
want
it
to
or
you
can
just
pass
it
around
as
an
int.
Have
you
ever
seen?
Have
you
ever
used
function,
pointers
in
C,
yeah.
A
B
O
O
A
O
G
A
D
A
A
P
N
N
Those
are
that's
what
they're
for
right
now,
the
runtime
does
everything
all
big
din,
and
so
the
idea
is
if
we
had
code
generators,
which
is
what
is
being
proposed
for
some
of
the
win
UI
work,
which
is
a
another
thing
right,
they
can
co,
generate
everything
and
they
can
handle
it,
and
that
would
work
technically
for
calm,
but
for
WinRT
there's
a
lifetime
relationship.
If
we
need
to,
we
need
that
coordination
between
whatever
external
runtime
and
the
CLR
right,
and
so
because
of
that
we
do
need
to
have
some.
N
We
need
to
provide
something
and
that's
what
this
API
is
providing
that
low-level
hook,
so
that
we
can
provide
some
part
of
the
implementation
and
some
code
generator
or
some
third
party
can
provide,
let's
say
95%,
just
one
little
case
that
we
need
to
be
able
to
handle
and
so
expanding
that
so
that
it
has
all
of
the
the
ability
to
basically
satisfy
an
RC,
W
or
CCW
solution
was
the
approach
okay.
So
this
is
similar
to
native
call
about
a
very
low
level,
building
ball
right.
N
N
N
G
N
O
N
I
D
N
G
G
O
N
Okay,
so
how
this
works?
Okay,
coach,
first
me
yeah,
so
we
can
put
up.
So
if
you
there's
an
example
at
the
bottom
of
some
usage,
okay,
I
print
is
the
classic
type
of
calm
interface
print
implements
it.
I
unknown
vtable
the
QI
and
ref
release
that
represents
the
basically
the
runtime
side
of
things,
the
I
print
vtable
via
cable.
If
you
scroll
down
this
is
the.
N
N
N
And
then
so,
this
is
the
RCW
side,
the
eye
external
log.
This
is
kind
of
the
same
kind
of
idea.
You
lay
out
your
Qi.
You
lay
out
your
associated
key
tables
for
that
object.
You
type
everything
in
the
world
and
then,
if
the
eye
external
object,
constructor
takes
an
in
pointer
and
that's
from
the
native
side.
Now
the
marshal
pointer
struck.
That
is
not
what
we
would
advise
to
do.
That
is
for
simplicity
of
this.
Those
are
optimizations
that
could
be
done.
These
are
very
slow
api's.
N
There
are
other
ways
of
doing
it,
but
that's
the
general
gist
of
what
would
would
go
on,
and
this
is
the
classic
way
of
rolling
your
own
CC
wrz
goes
to
object.
So
if
you
keep
scrolling
down,
this
is
just
building
up
all
of
the
okay.
So
now
calm
rappers
is
the
actual
API
that
we're
proposing
that
was
all
boilerplate
to
make
it
make
sense.
N
Okay,
this
is
a
non-trivial
agent,
so
the
con
rappers
basically
represents
a
a
collection
of
AP
AP
eyes
that
allows
you
to
manage
creation
of
these
and
participate
in
some
sort
of
lifetime
management.
Okay,
the
and
excuse
me
object.
Identity
is
also
very
important
right
right,
so
that's
another
promise
that
the
runtime
uses
of
identity,
and
so
in
order
to
do
that,
if
you're,
if
the
user
is
interested
in
that,
we
need
to
have
a
bit
more
robustness,
now,
obviously
just
to
call
out
users.
N
N
Let's
say
that
we
are
going
to
create
a
calm,
callable
wrapper,
so
we
have
a
managed
object.
We're
going
to
send
down
they're
gonna,
give
me
the
managed,
object
and
basically
going
to
say,
give
me
a
end
pointer
that
I
would
pass
down.
One
of
those
steps
is:
is
there
already
a
CCW
associated
with
this
managed
object?
N
Now,
if
there
is,
we've
promised
the
object
at
any
we'll
give
me
the
same
one:
does
you
where
to
call
it
once
if
it
hasn't,
we
call
back
into
this
implement
their
implementation
of
comm
wrappers,
and
that's
why
this
is
a
protected
one
and
say
here's
the
object.
Give
me
the
V
tables
for
this,
and,
if
you
scroll,
if
you
right
there,
you
see
runtime
helpers,
allathee
type
associative
memory.
Ideally
this
would
only
be
done
once
right.
They
would
cache
this.
There's
no
reason
to
do
this
every
time.
N
It's
not
interesting,
because
the
ABI
table
for
this
object
of
this
type
is
the
same.
Is
this
tables
firm
object,
your
current
type?
This
would
be
this
would
be
per
so.
This
would
be
called
for
this
particular
object.
How
that's
implemented
would
be
ideally
a
type
if
object
comes
through
when
its
foo,
they
have
some
lookup
table
they
magically
doing
here,
but
but
the
base
class
that
you're
proposing.
G
N
E
G
N
That's
part
of
the
imp
like
if
it's
associated
with
the
tight
like
it
should
the
only
allocated
ones.
How
do
they
know
when
to
release
it,
and
so
that's
what
we
didn't
want,
replicator
with
the
dress
again,
the
actual
implementation
here
is
very
naive.
It's
not
great.
There
are
a
few
api's
in
this
that
are
interesting,
the
example
of
associating
type.
This
is
the
canonical
example,
the
other
one.
Is
you
get
Ayano
nimble?
N
This
has
to
do
with
the
ability
that
a
third
part,
a
external
runtime-
that's
not
associated
runtime
may
not
necessarily
or
maybe
maybe
want
to
do
something,
particularly
around
like
time
when
the
GC
is
occurring
right,
which
means
they
can't
implement
I
unknown
in
something.
So
we
need
to
be
able
to
provide
that,
and
so
that's
what
that's
it's
just
a
static
on
it's
a
protected
static
on
this
comm
wrappers
that
implementers
of
it
they
have
some.
N
N
They
get
associated
with
the
with
a
CCW,
we
allocate
some
more
memory
and
some
native
memory
and
then,
if
you
look
up,
if
you
go
back
up
to
the
API,
which
I
don't
have
a
columnist,
it's
basically
keep
going
on
to
the
actual
API
I.
Think
it's
get
or
creep
I'll
create
object,
no,
not
not
create
hours.
That's
the
view
be
tables.
If
you
scroll
up
it
or
create
comm
interface
for
object.
N
You've
passed
in
the
object,
that's
in
some
flag
and
the
result
is
going
to
be
an
in
point
now,
whether
that's
it
or
the
existing
end,
pointer
or
whether
I
had
to
create
or
whether
we
had
to
create
a
new
one,
because
there's
no
associated
with
it.
That's
what
that
lets,
get
or
create,
get
or
associated
or
I
have
to
compute
the
tables
and
do
all
this
other
stuff.
N
A
N
O
N
N
Along
this,
particularly
the
the
one
above
that
struct
above
it,
if
you,
this,
is
no
sorry
the
necessary
yeah.
This
way,
this
represents
a
contract
to
call
back
into
the
object
that
you've
created,
because
there's
we
have
to
lay
out
what
we
would
call
a
dispatch
table.
Basically,
at
this
point,
ER
and
how
do
I
get
to
it,.
N
N
N
N
E
N
N
G
N
N
O
You
know
there
are
a
few
questions
you
know,
but
we
there,
we
kind
of
discussed
better
dead,
come
vapors
ice-class
its
abstract,
but
it
makes
sense
to
make
it
abstracts
or
whether
it
should
as
like
some
you
know.
Is
it
dummy
implementations
of
those
callbacks
that
come
to
nothing.
G
K
N
Api
on
you
that
I
have
it's
basically
the
object,
destruction,
because
there
is
a
point
when
we
need
to
say
detach
this
object
and
we
didn't
momentous.
So
we
can't
really
attach
it.
We
have
no
incited
and
right
now
that
callback
is
protected.
Virtual
I've
implemented
it
so
that
you
don't
have
to
do.
You'd
have
to
implement
it,
but
it
throws
not
able
not
implemented
exception
by
default.
N
G
N
G
N
A
A
A
Api
is
as
well
where
you
can
ask
up
phone
whether
this
is
supported,
so
you
don't
have
to
call
the
method
in
a
blow-up,
but,
like
I
mean
in
your
case,
I
don't
know
whether
the
agenda
expectation
is
that
that's
an
implied
contract
anyway,
and
it
really
isn't
any
other
way
of
doing
it
like.
If
there's
nothing
you
can
do
in
the
elspeth
row,
then
you
might
as
well
not
ask
in
just
for
the.
If
yeah
and.
N
G
A
Well,
I'm
wondering
is
like
I
mean,
maybe
you
don't
have
enough
fantasy
but
like
how
many
ways
are
there
to
do
there
like
it's
the
only
one
way
of
doing
it
or
like?
Is
there
the
expectation
that
you
know
different
memory?
Layouts
can
do
I
guess
it's
I
mean
calm
is
effectively
in
a
bi
spec
and
so
like
how
many
ways
do
you
actually
have
to
implement
that
it's.
A
K
G
O
P
N
N
I
wanted
to
I
want
to
back
something
we
do
handle,
address
and
release
if
they,
if
our
implementation
of
address
Foley's,
we
do
all
of
what
we
do
that
ref
captain
look,
that
is
true.
The
destroy
concept
is
I
want
to
seven
or
what
they
want.
We
would
normally
call
on
the
runtime
mouth
neuter
being
like.
You
have
an
RC
W,
you
have
a
CCW,
but
the
other
side
has
been
removed.
That's
what
that
means
sever,
this
connection.
In
a
non-natural
and
and
again
they
don't
have
to
use
this.
N
N
O
N
G
E
A
N
O
N
Because
that
would
be
the
same.
It's
the
same
like
just
give
me
the
Associated
one.
It's
really
should
I
call
the
create
object
or
should
I
just
use
them,
or
can
you
already
put
the
supply
one,
but
down
the
downside
to
this
API
or
the
downside
to
this
case
is
it
is
kind
of
degenerate
in
the
sense
that,
if
I
create,
if
I
have
that
object,
I'm
going
to
return
you
one
that's
already
associated
with
that
external
come
object,
so
you've
wasted
your
allocation,
so
this
is.
N
Doesn't
it
doesn't
happen
very
often,
but
in
the
cases
that
it
does,
there
is
no
real
good
way
of
solving
the
alternative.
The
obvious
alternative
is
get
or
register
the
rapper,
and
so
it's
non.
No
so
there's
another
API,
so
you
have
get
or
create
a
create
instance
will
call
the
protected
another
API
that
says
get
or
register
object
for
comm
instance.
It
doesn't
take
a
nullable
object,
it
just
takes
an
object
and
it
will
met
that
other
API
will
never
call
create
object.
A
A
N
N
G
Controlled
manner,
I
guess
why?
Why
is
there
a
distinction
looking
for
spective
I
mean
if
the
person
who
implements
it
is
also
consumed
like
why
couldn't
everything
be
public
for
everything
be
protected?
For
instance,
it
sounds
like
you
are
trying
to
draw
a
distinction
between
who
implements
them
from
consumers,
but
now
not
clear
about.
N
That
it's
error
cases
I
don't
want
to
deal
with
like.
Why
are
you
if
you
call
that
how
yeah
I
mean?
That's,
that's
fair!
Your
that's
a
fair
point.
It's
exposing
surfeit,
supposing
a
exposing
API
is
that
you
should
never
call
this.
We
will
call
this
on
your
behalf
or
you
leave
me
in
the
runtime.
We
be
the
runtime,
because.
A
N
They
would
be
that
okay,
so
this
instance
would
probably
be
let
say,
static
on
some
sort
of
Sifu
like
concrete
implementation
right
and
that
version
of
calm
rappers
would
be
coupled
with
that
version
of
seafood
in
some
way,
and
so,
when
you
generate
when
you
generated
the
are
CW's
or
whatever
you
use
that
one,
it
would
be
private
you'll
be
private
to
that
version.
So
the
generator.
Basically.
Will
you.
A
N
G
N
N
G
O
I
N
B
I
think
the
API
surface
looks
fine,
but
after
it's
approved,
I
want
to
see
some
existing
open
source
libraries
try
and
use
it
and,
for
example,
one
of
the
mini
DirectX
wrappers
and
see
how
it
actually
works
for
them
and
maybe
I'm
a
small
write
up
and
see
what
they
say.
The
shortcomings
or
benefits
of
it
was
yeah.
N
N
B
N
Yeah
I
wish
you
could
go
back
in
time,
but
I
guess,
like
that's
I,
think
that's
the
point
of
where
we're
all
getting
it.
There's
like
going
to
be
five
people
it
worldwide
that
are
gonna
use.
This
yeah
I,
like
the
feedback
about
I,
will
change
the
not
implemented.
That's
that's
fair
I'll
make
that
abstract.
It
sounds
like
that's
preferable
approach,
a
fair
statement,
and
also
it
sounds
like
the
try
register
is
the
preferable
approach
here.
Yeah,
okay,
I
will.
N
Yes,
there's
other
okay,
so
one
last
thing:
I
guess
the
implementation
of
this
is
actually
unrelated
to
Windows
at
everything.
There's
nothing
in
here,
that's
using
anyway!
So
right
now,
this
is
only
targeted
at
this
is
only
supported
on
Windows,
but
there's
literally
no
reason
that
we
can't
flip
the
feature
flag.
N
So
they
can
do
they
could
use
this.
We
have
had
with
a
message
entity
he's
of
one
of
the
Bing
people,
yeah
he's
actually
he's
actually
said.
This
would
be
really
cool,
I.
Think,
there's
one
or
two
thumbs
up
on
that
this
is
cross
plant.
There
is
nothing
stopping
us
from
I,
don't
I'm,
not
that's,
not
a
priority
right
now,
but
it
was
designed
around
how
maybe.
G
A
Yeah
I
mean
I,
don't
see
anywhere
flank
overheads
interwove
guys
it's
not
going
to
be
pretty
know
what
we
do
and
it's
fine
like
when
Jamie
brings
his
a
crazy
crypto
API.
As
this
penguin
only
a
it
is
what
it
is.
I.
G
As
a
kzassault
question,
but
there
is
an
API
here
to
allocate
the
memory
associate
right,
is
there
potential
for
an
API
that
associates
very
date
night
with
like,
if
say,
for
instance,
that
we
wanted
to?
But
one
of
the
scenarios
that
comes
up
pretty
commonly
is
I
want
a
cache
of
something
where
the
key
on
the
cache
is
a
type
but
I'm
afraid
of
making
my
own
static
class
and
then
using
type
as
a
key,
because
now
that
Tyga's
rooted
it
can
never
be
unloaded
ever.
G
O
P
O
O
Nowadays
is
a
bad
thing
like
oftentimes,
you
need.
You
actually
burn
these
things
as
sketches.
You
don't
necessarily
get
that
kind
of
loot
like
as
long
as
the
type
you
really
care
about
hey.
You
know
this
is
kind
of
expensive
to
create.
Yes,
that
is
API
that
we
don't
have
that
I
would
love
somebody
to
pick
a
button
to
design
you,
but
you
don't
think
something
like
this
would
be.