►
From YouTube: OMR Architecture Meeting 20230817
Description
Agenda:
* JitBuilder 2.0 Continued [ @mstoodle ]
A
B
C
Right
we'll
see,
everyone
can
hear
me,
hopefully
right
so
last
week,
I
talked
about
a
number
of
things
in
the
update
on
jetbuilder
2,
but
there
were
some
topics
that
I
didn't
get
a
chance
to
go
into
fact.
I
hadn't
had
a
chance
to
create
slides
for
them,
yet
so
I've
now
had
an
extra
month
to
create
some
slides.
C
And
I
guess
one
of
the
other
things
to
point
out
which
I
think
I
forgot
to
mention
last
week,
is
that
our
last
presentation
was
that
really
the
state
of
things
it's
really
building
out
a
framework
for
building
compilers.
It's
not
really
a
compiler
itself,
although
there
is
a
path
to
using
the
jit
Builder
API
to
actually
generate
code.
So
it
can
do
some
interesting
things
right
now,
but
it's
not
really
a
fully
fledged
compiler
per
se.
C
So
just
keep
that
in
mind
when
you're,
seeing
all
of
this
stuff
so
I
wanted
to
start
off
by
since
the
last
presentation
basically
went
right
to
the
end
of
the
meeting
time
and
there
wasn't
really
any
time
for
questions.
I
thought
I
would
give
a
pause
at
the
very
beginning
to
see
if
anybody
had
any
outstanding
questions
that
they
didn't
get
a
chance
to
ask
last
time.
C
C
The
other
three
topics
that
I
had
as
I
realized.
After
the
doing
the
talk
actually
while
I
was
starting
to
create
slides
for
this
presentation,
I
realized
that
I'd
never
actually
shown
any
IL
print
out
from
the
the
the
compiler
framework.
Last
time,
I'd
only
ever
talked
about
the
code
that
you
write
when
you're
writing
a
compiler,
so
I
thought
I'd
go
through
an
example
output
for
one
particular.
It's
actually
one
of
the
test
functions
that
runs
as
part
of
the
base.
C
Extension
and
I'll
just
show
you
kind
of
what
that
looks
like
it's,
not
complete,
but
it's
a
fairly
itch.
It
shows
cases
some
of
the
features
of
the
of
the
the
compiler
framework
and
the
third
topic
was
memory
and
allocators,
always
a
topic
of
great
interest.
I
guess
very
important
topic
for
for
a
compiler,
especially
a
dynamic
pilot,
eject
compiler
and
then
the
last
stop
is
extensibility.
So
I
wanted
to
go
into
some
of
the
details
for
how
some
of
the
dynamic
extensibility
mechanisms
work
in
in
jb2
all
right.
C
So,
let's
dive
in
because
it's
probably
going
to
be
another
hour
and
a
half
meeting
or
it
could
be
anyway,
so
I
I'm
just
going
to
put
up
this
oil.
This
is
basically
something
that
you
can
get
it
to
print
out
automatically
from
running
a
particular
compile.
It
can
print
out
the
state
of
the
IL.
This
isn't
perfect
right
now.
C
There
are
some
changes
that
I
still
need
to
make
to
it,
but
but
I
can
take
you
through
and
show
you
kind
of
the
flavors
for
some
of
the
stuff
is
now
there's
five
slides
here.
So
don't
think
this
is
everything,
but,
but
this
is
where
it
starts
off,
so
basically
use
this
square
brackets
as
kind
of
a
delimiter.
C
So
you
can
pop
back
and
forth
between
beginning
and
end
of
a
lot
of
different
things
and
understand
where
they're,
where
they
apply,
a
compilation
has
actually
one
of
the
things
that
I've
done.
The
last
month
is
recently
I
just
took
all
of
the
basic
IL
that
gets
created
in
the
compiler
and
put
it
under
an
object
called
IR.
C
Subject:
Builder
function
in
this
case,
one
of
them
is
a
type
dictionary
and
it
contains
basically
responsible
for
having
all
of
the
types
that
are
being
referenced
in
this
compile
unit.
You
can
see
there's
a
linked
dictionary
here,
so
this
is
type
dictionary.
T1
everything
gets
an
identifier,
so
this
is
the
number
one
type
dictionary
it
has
a
link
to
dictionary.
Basically,
a
parent
dictionary
which
is
t0
t0,
is
the
sort
of
a
type
dictionary
is
associated
with
the
compiler
object,
so
the
compiler
object
gets
t0.
C
If
you
have
types
that
you
want,
every
compilation
to
be
able
to
see,
you
can
Define
them
there.
In
fact,
that's
where
these
primitive
types
come
because
they're
created
by
the
base
extension,
which
you
can't
tell
that
right
now
from
the
output,
so
I
need
to
change
that,
but
essentially
each
one
of
these
lines
shows
all
of
the
shows
a
type.
C
That's
that's
been
created
inside
this
type
dictionary
and
they
are
also
given
identifiers
for
lowercase
t
as
an
identifier
for
types,
uppercase
t
for
the
type
dictionary
so
type
zero
is
a
special
thing
called
No
Type,
it's
kind
of
like
void,
and
then
you
know
the
usual
sort
of
primitive
types
that
you
hadn't
had
access
to
in
in
the
jit
Builder
API
and
they're
all
tagged
as
primitive
types,
so
they
all
print
out.
You
can
tell
what
they
are.
These
ones
are
fairly
obvious.
C
C
It's
not
right
now,
so
there's
there,
this,
the
t0
does
not
come
out
as
part
of
this.
This
output
right
now,
but
it
it
could
I
mean
T1-
was
printed
by
calling
a
function
on
the
type
dictionary
to
print
itself
out
to
the
log.
So
in
principle
you
can
print
out.
T0
I
haven't
worked
out
all
of
the
sort
of
logging
options
that
are
needed
here,
but
certainly
you
could
get
this
same
output
from
t0
and
in
fact,
like
I,
said,
T1
actually
inherits
these
types
from
t0.
C
C
There
is
also
a
type
T4
in
t0
that
in
in
the
type
dictionary
zero,
that
is,
that
is
the
64-biting,
so
it
just
inherits
these
types.
So
basically,
what
what
happened
in
this
particular
case
is
those
extensions
can
come
along
and
if
you
have
something
like
a
primitive
type,
where
you
don't
have
to
create
different
versions
of
it,
like
you,
like
pointer
to
pointer
to
pointer
to
N64,
might
not
be
a
type
that
you'd
use
everywhere.
C
But
if
you
had
a
compilation
unit
where
you
needed
that
type,
you
could
create
it
and
it
would
be
in
that
type
dictionary
in
the
case
of
the
Primitive
types
they're
all
the
same,
so
the
extension
basically
creates
it
and
stores
it
into
the
compiler's
type
dictionary.
And
then,
when
you
create
a
compilation
that
type
dictionary
for
that,
compilation
basically
inherits
those
primitive
types,
and
so
that's
what
this
is
showing,
although
it
doesn't
actually
show
The
Inheritance
aspect,
so
need
to
figure
out
this
logging
a
little
bit
better.
But
anyway,
that's
that's.
Basically
it
okay.
C
So,
in
addition
to
a
type
dictionary,
there's
a
symbol
dictionary
which
folds
the
symbols
that
are
defined
within
the
compilation
unit,
it
also
has
a
linked-
and
you
know
same
mechanism
here.
Capital
is
the
dictionary
lowercase
is
the
the
the
the
symbols
there's
a
linked
s0,
which
is
the
compiler's
symbol
dictionary?
C
So
if
you
had
Global
symbols
that
the
compiler
wanted
to
create
it
or
that
the
extensions
wanted
to
add
to
you
could
have
them
there
and
they
get
inherited
in
this
particular
compilation,
which
I
should
have
actually
shown
the
code
that
it
actually
does.
This.
This
function
is
a
test
function
for
a
for
Loop,
so
it
has
a
for
Loop
inside
it
and
parameter.
C
C
S1
is
like
all
these
symbols
have
an
underscore
T,
which
tells
you
what
type
that
parameter
is.
So
you
get
to
go
back
to
the
type
dictionary
which
is
awkward
here,
but
I.
Can
you
know?
T3
is
n32,
so
these
are
all
32-bit
integers
in
Additionally
the
counter.
Sorry,
the
the
eye
for
the
iteration
count
of
the
loop
is
also
an
in
32,
and
this
counter
guy
is
for
some
real
he's,
a
64-bit
integer
because
he's
just
basically
accumulating
a
count
of
the
inside
the
loop.
C
So
it's,
if
you
iterate
a
lot
of
times,
you
can't
actually
blow
up
the
32-bit
above
32-bit,
so
I
just
created
it
as
a
64-bit
there's
also
a
literal
dictionary
to
hold
literals,
so
constants
are
represented
a
little
bit
differently
than
inject
Builder.
You
have
to
actually
call
out
your
literals
and
create
them.
C
So
here
there's
a
64-bit
integer
64,
but
integer
zero
for
the
value
zero
one
for
the
integer
one
and
they're
also
named
and
then
can
be
referenced
in
later
on
in
the
IL
and
again
same
basic
idea:
right,
there's
a
capital
l
for
dictionaries,
there's
a
lowercase
L
for
for
actual
literals,
and
then
we
can
get
into
what
are
we
actually
compiling?
So
this
provides
details
of
the
compile
unit.
In
this
case,
it's
a
function.
C
Its
name
is
dot,
got
awful
things
which
actually
gets
constructed
because
there's
a
whole
bunch
of
tests
that
test
different
types
being
used
for
for
Loops.
All
of
them
are
supposed
to
be
blocked,
except
for
this
one
that
uses
32
minutes,
because
it's
the
only
one
that's
actually
supported
by
jit
Builder,
really
so
anyway.
So
it's
so
it
it
has
this
naming
scheme.
This
is
like
initial
final
bump
and
the
iteration
counter
types.
So
all
of
those
types
can
be
set
to
different
types
and
then
create
the
formula
function
for.
C
Exactly
it's
not
a
signature
role,
so
this
origin
is
like
the
creation
location
for
so
this
is
the
original
the
the
spot
in
base
test,
which
is
the
name
of
the
the
file
that
has
all
the
tests
for
the
base
extension
in
it.
It's
a
wine
1074
and
it's
using
g-test,
so
they'll
think
it's
embedded
in
in
a
function
called
test
volume.
It
has
a
return
type
of
T4,
which
was
our
60
or
64-bit
integer
going
right.
C
C
So
what
a
voltage
look
like,
so
here's
the
entry
Builder.
So
it's
a
you
know,
Capital
B1,
again,
they're
numbered
it
has
a
name.
You
can
give
Builders
a
name.
You
don't
have
to
give
them
names,
but
it
has
a
name
if
you
wanted
to
Builders
can
have
parents
so
there's
a
there's,
a
tree
structure
of
Builders
within
the
function,
and
it's
also
got
a
scope.
I
talked
about
Scopes
in
the
last
meeting,
which
is
basically
represents
a
region
of
code.
So
this
Builder
is
a
part
of
this
scope.
C
C
B1
has
several
children
Builders,
and
that
comes
out
as
a
we'll
see
later.
What's
inside
this
Builder
we'll
be
able
to
see
what
these
Builders
are.
It
is
not
a
bound
Builder,
which
means
it's
it's.
The
control
in
and
out
of
this
Builder
is
not
determined
by
some
operation
somewhere
that
somebody
branches
to
it.
In
essence,
it's
not
a
target
of
a
branch,
and
then
the
operations
are
listed
here.
We
have
this
nice
tag,
which
makes
them
sort
of
readily
easily
to
identify
where
these
operations
are
and
which
Builder
they
originate.
C
So
you
can
find
things
fairly
easily
and
then
sort
of
familiar
kind
of
three
address
type
form
where
you've
got
values
which
are
V
with
an
ID
associated
with
them
again
underscore
with
the
type
that
they
have.
So
all
of
the
IL
is
typed.
Sorry,
all
of
the
values
that
you're
working
with
are
typed
because
the
operations
themselves,
the
actions,
are
not
in
jit
Builder.
We
used
to
have
things
like
constant
8,
constant
16,
constant
32,
blah
blah
blah.
C
Now,
there's
only
a
constant
thing
which
basically
tells
you
to
load
one
of
the
literals,
so
it
just
references
a
literal
which
is
L1
and
as
a
reminder,
it
tells
you
that
that's
in
64
and
a
zero.
So
you
know
that
this
is
the
64-bit
integer,
zero,
constant
being
loaded
into
b0,
and
then
it's
just
a
sequence
of
operations.
So
it
does
a
store
with
a
symbol
and
again
it
reminds
you
of
what
it's
called.
C
So
you
can
kind
of
fall
around,
follow
along
and
follow
along
with
what
it's
actually
doing
right,
it's
storing
zero
into
counter.
Then
it
loads
the
parameter
so
that
it
gets
the
initial
the
final
of
the
bump
for
the
for
Loop.
The
interesting
one
is
o6
here,
which
is
a
for
Loop
up
operation,
which
basically
uses
this.
C
It
says
I'm
going
to
use
the
symbol
I
as
an
iteration
variable,
and
then
it's
going
to
loop
from
V1
to
V2
by
V3
right
so
initial
to
final
by
bump,
and
then
the
actual
code
for
the
for
Loop
is
specified
by
the
body.
So
the
the
code,
that's
inside,
every
iteration
of
the
loop
is
B2
Builder.
B2
and
then,
if
somebody
needs
to
break
out
of
the
loop
they
can,
they
can
Branch
go
to
to
the
to
the
loop
break,
Builder,
B3
or
B4.
A
C
C
B
C
C
No,
you
know
conditional
branches
happening
right
and,
as
opposed
to
an
if
compare
greater
than
instruction
basically
says
you
know,
fall
through
if
you're,
if
it's
not,
and
if
the
condition
is
true,
then
you
jump
over
there,
but
it
doesn't
say
anything
about
what
happens
when
you
get
back
like
at
the
end
of
that
one.
It
doesn't
say,
come
back
to
this
operation
and
it
doesn't
stop
anybody
else
from
muscle
branching
to
that
to
that
Builder.
So
it's
Unbound
right,
it's
not
bound
by
this
operation.
C
C
So
this
this
one
automatically
the
for
Loop
is
what
the
for
loop
operation
creates
B2
automatically.
So
it
knows
that
it's
the
body
of
the
loop,
so
it
actually
gives
it
a
name
of
loop
body
for
you
just,
but
it
would
do
that
for
every
Loop,
so
every
Loop
could
be
called
Loop
body,
but
you
could
change
that
name
if
you
wanted
to
its
parent.
Does
that
be
one
Builder
that
we
just
looked
at?
C
It
also
has
the
same
scope,
function,
scope
and,
as
this
one
says,
it's
bound
to
operation
06
right.
So
it
also
provides
an
easy
way
to
go
back
and
forth
between,
like
if
I
have
a
six
I
can
find
B2
and
go
look
at
it.
If
I'm
in
B2
I
can
I
can
look
at
it
and
say
oh
I'm
bound
to
o6
and
find
o6
and
in
B1
that
should
really
say:
B1,
bang
06,
but
anyway
it
doesn't
right.
C
Now
it's
not
a
Target,
which
means
nothing
else,
branches
to
it,
and
then
its
set
of
operations
are
here.
So
the
the
control
operations
for
the
loop
are
not
put
into
the
body
explicitly
they're.
It's
the
for
Loop
up
that
handles
the
mechanics
of
iterating
and
it's
just
the
body
is
just
the
code
that
needs
to
be
executed
for
each
iteration
of
the
loop.
So
here
we're
loading
the
counter
value,
we're
adding
one
and
or
the
constant
one,
adding
them
together
and
then
storing
it
back
in
counter.
C
B
C
Don't
think
so,
that's
a
good
question
because
entitling
usually
what
you're.
So
yes,
you
have
to
understand
what
like
entirely
enough
to
understand
how
much
data
is
being
accessed
by
an
iteration
and
then
how
big?
How
how
big
the
iteration
space
is
that
you
need
to
to
keep
the
memory
that's
accessing
in
Cache,
so
yeah
it's
going
to
be
in
two
different
places,
but
I
mean
the
alternative.
C
C
It's
a
for
Loop
option
right
right
now
that
doesn't
mean
you
don't
need
the
ability
to
be
able
to
recognize
a
for
Loop
when
someone
doesn't
use
for
Loop
off,
but
it
does
mean
that
if
you
create
code
like
this,
you
can
very
easily
tell
where
the
loops
are
and
how
many
times
they're
going
to
iterate.
What's
the
primary
induction
variable
right,
it's
all
right.
There
called
out
in
the
in
the
code
because.
C
And
you
can
even
get
like
if
you're
in
a
nested
Loop
right,
if
you're
in
the
inner
one
and
you're
inside
there,
you,
you
know
which
Builder
you're
in
you
know
what
operation
it's
bound
to,
which
gets
you
one
thing
out
and
then
from
that
one
you
can
get
to
its
Builder,
which
is
bound
to
the
next
Loop
out
right.
You
can
very
easily
find
your
way
around.
C
And
in
fact,
the
ways
it's
the
one
of
the
internal
details
of
how
the
IL
is
arranged
is
that
a
pointer
to
an
operation
basically
can
get
you
anywhere
like
it.
It
it
locates
you
exactly
in
the
IL
somewhere
and
then
you
can
get
anywhere
else
from
there
like
you
can
go
forward
in
the
operation
list
backward
in
the
operation
list
up
to
the
Builder
that
created
it
like
you
can
go
anywhere
basically
or
iterate
the
builders
that
are
referenced
in
the
operation
and
go
down,
so
you
can
go
anywhere
from
like
an
operation.
C
C
So,
let's
see
I
did
want
to
do
a
little
bit
of
a
preamble
here
on
why
this
is
so
important
for
gb2
or
why
I
think
this
is
such
an
important
topic
for
jb2
and
partially.
Basically,
it's
because
in
jb2
it
has
the
notion
of
multiple,
potentially
multiple
compiler
objects,
which
are
com
can
organize
differently.
So
you
can
imagine
a
world
where
you've
got
a
rig,
X
compiler,
a
python,
compiler
and
I,
don't
know
something
else,
compiler
all
like
the
solid
debuggers
as
a
compiler
too.
C
C
You
want
to
be
able
to
get
rid
of
the
memory
if
you
don't
need
it
and
when
it
goes
away,
you
want
it
to
only
take
away
its
memory
and
nobody
else's
memory,
and
you
want
to
be
able
to
if
you
have
to
create
these
things
and
Destroy
them
all
the
time
and
not
sort
of
sabotage
the
memory
safety
of
the
program
or
the
the
process
that
you're
you're
in
so
so
all
of
those
things
kind
of
mean
you.
We
really
need
to
be
very
careful
about
how
we
manage
memory
analysis.
D
C
So
you
know
make
space
for
me
because
I
need
lots
of
memory
and
then
be
able
to
recreate
it.
And
again
you
don't
want
anybody
to
sabotage.
You
don't
want
one
compiler
to
sabotage
another
compiler
ever
so
oops,
so
a
lot
of
that
is
notional
in
that
I
haven't
implemented.
All
of
that
support.
Yet
but
it's
part
of
the
vision
for
how
jb2
should
work,
and
so
I've
spent
some
time
going
through
all
of
the
classes
of
jit
Builder
and
making
sure
that
it's
allocation
is
sort
of
under
control.
C
It's
not
a
fully
complete
process
yet,
but
it's
very
close
right
now.
It
doesn't
really
provide
any
facilities
to
optimize
the
use
of
memory.
It's
a
very
simple
allocator!
That's
provided
right
now,
just
use
Malik
and
free
under
the
covers,
but
the,
but
the
the
use
and
management
of
all
that
memory
is
all
pervasive
throughout
the
compiler.
At
this
point,
there's
nothing.
That's
not
using
allocators
that
could
use
allocators
I'll
talk
about
what
I
mean
there
in
a
minute,
all
right,
so
the
basic
currency
of
dynamically
allocated
objects.
C
C
C
So
it
basically
provides
a
very
two,
very
simple
things.
It
gives
you
the
allocator
that
allocated
the
object
and
the
size
of
invite,
so
every
object
knows
who
allocated
it
and
what
the
actual
size
the
the
object
is
now
sometimes
you
want
to
be
able
to
stock,
allocate
an
object
that
can
also
be
dynamically
allocated,
so
that's
also
supported
by
having
a
null
allocator
and
a
null
size.
C
So,
basically,
when
you
stack
allocate
something
you
don't
need
to
worry
about
it
size
or
it's
it's
who
allocated
it,
because
it's
stack
of
memory,
it's
managed
by
the
compiler
itself,
but
the
allocator
framework
needs
to
be
able
to
know
that.
That's
one
of
that
that
one
of
those
objects
is
here
and
it
doesn't
have
to
do
anything
special
with
it.
C
So
that's
kind
of
a
special
case
for
that's
handled
and
that
kind
of
pervades
through
some
of
the
support
when
the
objects
in
that
you
have
to
provide
multiple
Constructors,
which
is
kind
of
one
of
the
one
of
the
most
painful
aspects
of
this.
But
it's
it's
not
too
bad
in
practice,
knocked
on
what
I
said
all
right.
C
So
obviously,
that's
kind
of
a
this
solution
is
not
great
for
allocating
a
raise,
because
it
means
that
every
object
in
the
array
will
also
have
this
mem
and
size
thing
associated
with
it,
which
I'm
not
happy
about
this,
but
it
is
what
it
is
for
now.
So
there's
overhead
memory
of
of
that
and
it's
basically
the
first
object
knows
how
big
the
thing
is,
and
everybody
else
sort
of
doesn't
so
not
awesome.
C
I'm,
not
super
proud
of
this,
but
again
my
main
goal
in
starting
this
was
just
to
get
an
interface
in
place
so
that
it
could
be
modified
and
improved
later
and
having
these
things
represented
in
the
source
code,
as
opposed
to
you
know,
invisible
values
that
are
stored
behind
the
object
pointer
that
you
had
to
allocate
extra
space.
For
you
know,
all
of
those
things
can
be
done,
all
those
magic
things
can
be
done
later
and
hidden
behind
this
same
API
and
and
improve
the
ability
to
allocate.
C
Like
I
mentioned
classes
can
support,
Dynamic
and
or
stack
allocation
and
there's
a
bunch
of
helper
macros
that
I've
defined
that
are
very
similar
to
like
TRL
that
used
to
exist.
It
still
does
exist,
I
guess
in
Testarossa,
there's
a
JB
Alec,
there's
an
allocation
category
all
very
familiar
to
Testarossa
folks,
which
you
just
insert
JB,
Outlook
and
name
a
category.
C
You
can
put
that
into
the
class
definition
in
the
header
and
that
will
take
care
of
making
sure
that
you
can
allocate
this
object
and
that
it
has
a
category
that
will
be
associated
with
it
when
it's
allocated
and
then
in
a
class
file.
You
do
this
init,
JBL
or
cat,
and
that
just
takes
the
class
name
and
and
the
category,
and
it
will
register
that
category
when
that
classes
in
in
the
compiler
when
that
class
is
used.
C
A
C
C
The
but
I
found
in
order
to
support
both
stack
and
dynamic
allocation,
I
needed
to
not
only
use
the
placement
new
Option,
but
also
have
the
allocator
provided
as
the
first
parameter.
So
when
it's
stack
allocated,
you
don't
provide
an
allocator
and
when
it
isn't,
when
it's
dynamically
allocated,
you
do
provide
the
allocator.
So
there's
a
double
a
double
sort
of
parameter
that
you
need
to
provide
in
Dynamic
allocation
cases,
which
means
you
need
to
have
two
Constructors
one
for
dynamic
allocation
and
one
first
stack
allocation.
C
C
It
defines
two
Constructors
one
with
the
allocator
parameter
and
one
without
so
that
you
can
do
both
and
then
yes,
you
got
to
go
and
Implement
both
of
them
and
yes,
that's
a
pain
and
yes,
I,
don't
like
it,
but
at
least
it's
a
thing
you
do
once
when
you
create
the
class
and
you
create
the
constructors
and
then
and
when
you're
actually
going
and
allocating
objects,
it's
actually
pretty
straightforward
to
use
and
easy
to
use.
So
it's
it's
pain
on
the
developer
side,
but
on
the
use
side
it
actually
looks
pretty
reasonable.
C
Let's
see
fun
fact,
yeah,
so
I
created
this
data
I
happen
to
notice
that
that
Outlook,
if
you
did
it
backwards,
you
could
actually
make
a
name.
That's
that's
in
HEX
that
sort
of
looks
like
bad
Alec
right
b,
a
d,
a
one:
that's
like
l,
l,
zero,
C,
right,
OC
right,
and
that
has
a
nice
property
that
it's
actually
not
aligned
that
value
to
right.
So
anyway,
nothing
actually
uses
jv2.
C
C
C
D
C
Its
core,
but
it's
hidden
within
string,
so
nobody
actually
directly
accesses
it.
So
again,
the
API
is
clean
and
means
it
could
be
replaced
later.
So
I
want
to
write
a
string
class
like
a
real
string
class.
So
this
JBL
up
thing,
you
know
basically
says
I
I
need
to
be
able
to
do
allocations
of
this
thing
and
it
will
create
a
class,
a
category
that's
associated
with
string
for
string
and
then
the
constructors
are
in
in
this
case
I
thought
it
was.
C
You
know
people
would
are
likely
to
want
to
create
strings
on
the
stack
as
well
as
dynamically
allocate
them
right.
They
don't
want
to
always
have
to
dynamically,
allocate
a
string
so
I
provided
all
out
allowed.
There's
a
no
Works
version
just
for
macro
craziness,
that's
pre-processor
crap,
but
the
borrower
stuff
works
better.
If
it
knows
there's
no,
if
there
is,
there
have
to
be
RX
to
use
the
horror
example
anyway.
So
in
this
case
you
can
create
a
string,
an
empty
string.
Basically
with
no
arguments
you
can
pass
a
const
car
star
to
it.
C
So,
yes,
that's
awful
and
ugly
I,
don't
like
it.
In
fact,
I
think
in
compilation,
I
even
used
a
macro
for
the
field,
so
I
didn't
have
to
have
four
different
versions
of
20
Fields
being
defined
similarly,
but
anyway,
yeah.
So
that's
kind
of
just
how
this
works
right.
So
you
can
see
that
the
ones
for
dynamic
allocation
have
an
allocator
A.
C
The
ones
that
are
for
stack
allocation
do
not
have
an
allocator
and
they
just
call
into
allocatable
with
an
imp
either
with
an
empty
thing
or
with
an
eight
and
that's
how
how
it
determines
later
on.
So
if
somebody
calls
you
know,
because
you
know
JB
Outlook
is-
is
overriding
placement
new,
creating
deletes,
you
know
doing
all
that
stuff
under
the
covers.
C
So,
on
the
on
the
user
side,
you
want
to
create
Dynamic
strings,
you
can,
you
know,
use
the
three
things
and
here's
where
you
see
the
double
the
double
thing,
which
is
you
know
it's
a
little
bit
ugly,
but
it's
not
too
bad.
You
get
used
to
it
pretty
quickly
and
otherwise
it
just
looks
like
a
instructor
and
then
you
can
delete
them
later
on,
as
if
you
like,
because
there
obviously
these
are
allocated,
so
you
need
to
deallocate
them.
So
there's
there's
no
bolt
free
right
now
and
then
stack
allocations.
C
Yeah
so
I'll
get
to
some
of
that
soon.
This
is
kind
of
a
speed
of
the
way
things
are
right
now.
So
yes,
right
now,
all
of
the
objects
are
being
manually
deleted,
which
hasn't
been
as
painful
as
I
thought
it
might
be,
but
I
do
still
think
that
a
bulk
free
allocator
is
a
better
choice
for
doing
a
lot
of
this
stuff.
But
right
now,
I
don't
have
a
bulk
three
allocator,
so
I've
got
a
few
deletes
sprinkled
around
and
it
is
pain.
E
C
Right,
but
that's
that
would
be
a
separate
object
being
allocated
and
managed
independently
of
the
string
itself,
so
the
delete
the
delete
is
still
being
called
and
if
there
is
a
if
there
is
an
underlying
thing
like
that,
then
it
needs
to
be
handled
right.
So
a
better
example.
So
string
in
this
case
is
backed
by
a
standard
string
and
it's
actually
an
embedded
standard
string.
So
there's
no
actual
Dynamic
allocation
happening,
but
you
can
imagine
for
something
like
list
where
it
has
to
manage
items
and
those
items
are
dynamically
allocated.
C
C
E
C
E
C
C
Okay,
so
I
missed
an
allocator,
that's
supposed
to
be
folded
and
wanted
in
red
anyway,
right,
okay,
so
let's
switch
over
to
the
allocators
that
are
there
in
kp2,
so
the
allocator
API
right
now
so
there's
a
class
called
allocator,
which
is
a
base
class
for
all
of
these
things.
Allocator
is
actually
allocatable,
I.
Think
or
maybe
it's
not.
C
Maybe
it's
one
of
the
few
that
isn't
I
can't
remember
now,
in
any
case,
no
I'm
pretty
sure
they
are
allocatable
anyway,
there's
not
much
to
the
API
right.
Now,
it's
basically
an
allocate
de-allocate
and
there
is
a
little
bit
of
sort
of
other.
You
know
you
can
specify
a
minimum
allocation
size.
So
if
you
wanted
to
do
like
a
segment
allocator,
it
provides
a
little
bit
of
support
for
doing
that.
But
it's
nothing
actually
does
this
right.
C
Now
it's
everything's
using
the
minimum,
allocate
size
of
one,
so
it's
just
allocating
through
Matlock
and
three
or
allocating
through
Malik
and
freeing
through
deallocating
through
free,
and
it
does
have
a
little
bit
of
support
for
allocation
categories
like
intestarosa,
but
I.
Don't
know
that
anybody
feels
like
that's
super
valuable,
so
I
might
actually
remove
that
at
some
point,
but
it's
there
for
now
and
you
can
ask
an
allocator
if
it's
the
same
as
another
allocator
but
nothing's.
C
Actually,
oh
sorry,
you
can
ask
if,
if
you
can
ask
if
an
object,
if
an
allocator
was
used
to
allocate
a
particular
object
by
checking
that
object,
allocator
thing
in
but
anyway
it's
just
a
convenience
thing.
There
are
three
actual
concrete
allocators
that
are
defined
right
now
that
all
three
of
them
are
extremely
simple:
allocator
raw
is
the
the
you
know
just
uses
malikin
free
to
do
allocate
and
deallocate.
There
is
a
tracer
allocator,
which
is
a
concreate
allocator.
C
So
at
the
end
of
the
pro
at
the
when
the
when
the
allocator
is
destructed,
it
checks
to
see
that
you've
deallocated
everybody
it.
You
think
you've
deallocated
every
bike
that
it
thinks
it
allocated
and
that
the
number
of
so
that
the
number
of
allocations
is
the
same.
Sorry
I'm
saying
this
poorly
that
you
deallocated
every
memory
region
that
you
think
you
allocated
and
that
the
total
number
of
bytes
that
you
allocated
is
the
same
as
the
total
number
of
bytes
that
you
think
you've
deallocated.
C
So
it's
a
little
bit
of
a
validation
on
doing
it.
You've
done
things
properly,
but
it's
not
super
rigorous
right.
I
100
agree
with
that.
I'll
talk
more
about
that
in
a
minute
too,
so
how
you
configure
and
use
them.
So
there
are
a
few
life
cycles
that
I've
sort
of
defined
already
as
part
of
the
of
jb2.
So
there's
every
compiler
has
an
allocator,
so
you
can
ask
a
compiler
for
its
memory.
C
So
if
you
need
something,
that's
tied
to
that
same
life
cycle
as
the
compiler
object,
I.E
crosses
all
the
compilations
crosses
all
the
runtime
of
the
code
that's
been
compiled,
then
you
can
ask
the
compiler
for
its
memory
and
allocate
things
there.
The
compilation
itself
has
a
has
an
allocator
which
you
can
ask
and
use
the
IR
has
its
own
memory
allocator.
B
This
is
a
point
that
I
thought
about.
Looking
at
this
in
terms
of
allocated
yeah
you,
you
could
and
force
an
API
where,
instead
of
the
user
having
to
do
new
map
streaming,
you
can
have
a
static
method.
S
and
then
you
just
have
Place
Windows
everywhere.
You
can
just
use
that
just
to
clean
up
the
code,
if
you're
forced
to
have
to
pass
the
allocator,
both
replacing
new
I
am
the
Constructor
yeah.
You
could
just
hide
that
away.
So.
C
B
C
Maybe
let
me
look
into
that.
I
mean
that's
a
fair
amount
of
code
to
change
now
too,
but
it's
still
not
it's
easier
to
change
now
than
later.
All
right,
you
know,
let's
talk
about
that
more
later,
a
bit
right,
so
I
already
kind
of
talked
about
this.
So
basically
you
can
only
get
it's
again.
It's
the
same
double
thing
here
again
the
Tracer
and
track
allocators
can
be
automatically
configured
based
on
the
the
config
that
you
send
into
the
compiler.
So
you
can
there's
a
set
Tracer
track.
C
Compiler
allocations
that
when
the
compiler
creates
its
allocator,
it
will
actually
automatically
allocate
a
tracer
or
a
Tracker
allocator
to
to
with
the
parent
as
the
actual
Raw
allocator
and
similarly
with
the
compilation,
so
it'll
check
this
this
flag.
Basically
to
see
whether
or
not
you
want
that
turned
on
are.
C
It's
just
it's
just
a
string
of
like
every
allocator
has
a
parent
allocator.
So
if
it
doesn't
know
how
to
allocate
something,
it
asks
its
parents
to
allocate
if
it
has
it
so
so
the
Tracer
and
tracker
allocators,
all
they
do
is
the
tracing
and
the
tracking
and
if
they
and
to
actually
allocate
they
call
the
parent,
which
is
your
allocator,
a
very
simple
allegation,
framework
status
in
future
directions.
So
I
run
everything
with
valve
grind.
C
Looking
for
leaks
and
I
went
through
a
process
of
a
few
days,
cleaning
the
hell
out
of
everything
and
once
I
got
clean,
I
added
Vel
grind
into
the
sea
tests
that
I
create
for
all
of
this.
So
it
runs
everything
right
now.
Every
test
that
runs
runs
without
grind
and
if
there
is
any
leak
or
any
overwriting
of
memory
or
reuse
or
double
freeze
or
anything
like
that,
that
valgrind
can
find
the
test
fails.
C
C
There
are
currently
no
tests
to
test
cross-contamination,
but
enough
everything
allocates
through
a
memory
allocator
that
it
can
get
to
and
there's
no
wave
other
than
a
parent
field
in
a
compiler
which
nobody
ever
sets.
There
is
no
way
to
get
from
one
compiler
object
to
another
to
get
another
compiler's
allocator.
So
there's
I,
don't
believe
that
there's
any
cross-contamination
right
now.
C
There
are
still
a
couple
of
uses
of
STL.
There
are
a
bunch
of
standard
maps
and
a
bunch
of
stand,
obviously
standards
during
this
inside
string
that
doesn't
use
this
framework.
So
there
is
still
memory
allocation,
that's
happening!
That
does
not
have
anything
to
do
with
my
allocator
framework,
I'm,
hoping
eventually
to
get
rid
of
those,
but
I've
been
too
occupied
with
other
things,
to
go
and
write
my
own
hash
map
so
and
that's
the
horror
string
class.
What.
C
A
C
C
It
does
check
the
iterators
do
check
to
see
whether
or
not
the
underlying
container
has
been
changed
created,
and
you
can
I
checked
this.
Actually
after
Irwin
asked
about
it
in
the
last
one
there
you
can
create
an
iterator
that
cares
about
the
underlying
container,
changing
or
not.
So
you
can
be
bothered
by
modifications
or
not
be
bothered
by
modifications,
and
it
creates
a
copy
of
the
elements
when
it
does
it.
C
So
you'll
always
get
the
iteration
of
the
thing
that
you
asked
for
an
iterator
of,
and
then
it
will
continue
to
when
you
ask
for
iterate,
when
you
ask
for
things
from
the
iterator,
it
will
continue
to
check
whether
or
not
the
underlying
container
has
been
modified
before
it
returns
an
item.
If
you've
asked
it
to
do
that,
otherwise
it
won't
here
we'll
just
give
you
the
iterated
version.
C
Future
I
think
it
would
be
a
good
idea
to
recreate
some
of
the
allocator
styles
that
are
there
in
Testarossa.
Although
I
haven't
thought
very
deeply
about
it.
At
this
point,
and
I
would
like
to
support
some
additional
life
cycles
other
than
the
ones
that
I've
got
there
right
now
again
kind
of
oriented
towards
the
things
that
people
do
with
compilers
and
the
types
of
data
that
people
manage
in
compilers
and
then
sort
of
more
along
the
lines
of
integrating
with
other
things
would
be.
C
All
right
52
minutes
and
we
got
through
three
of
them
so-
and
this
was
probably
the
most
complicated
one
so
saved
the
best
for
last
one,
my
throat's
already
starting
to
go,
but
anyway,
so
I
did
all
right.
Sorry,
I,
just
I
should
pause.
Are
there
any
other
questions
about
allocators
that
before
our
memory
management
gb2
before
we
move
on.
C
You
know
I've
had
enough
of
it
too.
All
right,
accessibility,
so
I
did
I
gave
a
brief
summary
of
this
at
the
near
the
end
of
the
talk
last
time
which
basically
covering
me,
there's
I,
think
I
have
this
I
think
I
presented
this
in
the
yeah
I
did
so.
Basically,
there
are
static,
extensibility
mechanisms
supported
in
jb2
and
used
all
over
the
place
like
inheritance
and
composing.
C
There
are
also
Dynamic
extensibilities,
so
most
of
what
I'm
going
to
focus
on
in
this
section
of
the
dynamic
extensibility
ones
that
I'll
very
quickly
go
through
the
fact
that
there
is
standard,
C
plus
plus
mechanisms
that
you
can
use
you're
allowed
to
extend
things
like
subclass
things.
In
fact,
there's
lots
of
examples
of
this
throughout
the
code
base
and
in
fact,
I
think
this
is
the
primary
mechanism
for
doing
extension,
because
it's
just
the
one
that
c
plus
does
well
as
long
as
it
fits
the
use
case
that
you're
trying
to
to
fit.
C
So
you
know
the
the
best
example
of
this
is
compile.
Unit
is
a
base
class,
that's
defined
in
jb2,
which
is
kind
of
not
a
very
useful
thing,
because
it
doesn't
know
about
what
entry
points
it's
got,
what
it's
doing,
how
to
pass
values
in
so
there's
in
the
funk
extension,
which
has
its
own
namespace
called
I,
should
say
it's
a
function
extension,
but
it's
in
the
function.
C
Namespace
defines
a
compile
unit
called
function,
which
is
a
subclass
of
compile
unit,
and
the
expectation
is
there
that
you
know:
you'll
create
function,
objects
rather
than
compile
unit
objects.
Compile
unit
objects,
aren't
very
useful
on
in
and
of
themselves,
but
a
function
object
is
because
it
knows
about
that.
It
has
an
entry
point.
It
knows
what
that
there
are
parameters.
C
It
knows
that
there
are
local
variables
in
the
stack
frame
Etc
and
then
there's
an
extension
called
VM,
which
has
all
of
the
virtual
machine
stuff
from
the
original
jet
Builder
API,
actually
I
shouldn't
say
all
of
it
as
most
of
it
and
it
defines
another
subclass
or
subclassical
function
called
VM
function
where
it's.
It
basically
sets
you
up
to
have
a
bytecode
builder
as
the
entry
point,
rather
than
a
builder.
C
As
the
entry
point
so
that
you
can
pass
a
VM
State
around
very
easily
and
then
the
expectation
is
that
you'll
be
creating
VM
function,
objects
and
not
just
functional
objects.
So
so
so
inheritance
and
subclassing
is
a
very
well
accepted
thing
and
used
all
those
places.
I
mean
you
can't
use
the
subclass,
but
the
obviously
the
subclass
functionality
won't
be
in
the
superclass.
If
you
use
it,
that's
the
main
thing
virtual
functions,
encouraged
composition
can
be
used.
C
Thanks,
Devin
static
polymorphism,
which
we've
been
using
in
the
Omar
compiler,
isn't
specifically
prevented,
but
I
haven't
I'm,
not
using
it
anywhere,
and
it's
not
really
a
favorite
approach
and
the
main
reason
for
this
is
because
I'm
intending
jb2
to
be
more
of
a
dynamic
extensible
thing,
rather
than
like
your
loading
extensions
at
runtime
you're,
not
creating
a
compiler
and
sort
of
arranging.
All
the
pieces,
statically
and
then
compiling
them
and
building
them
all
together
and
then
running
that
thing.
It's
it's
more
of
a
your
assemble
things
at
runtime,
together.
C
C
Strangely,
yes,
it
gets
smaller
if
you
strip
out
all
the
debug
info,
the
symbol
names
are
just
like
they're
enormous
anyway,
all
right
so
Dynamic
extensibility,
so
jb2
implements
a
dynamic
extension
mechanism.
That's
basically
like
being
able
to
add
a
mix
in.
So
it
allows
you
to
attach
what
I
call
add-ons.
So
you
can
have
an
object
that
has
an
add-on
that's
attached
to
it,
and
then
you
can
sort
of
structure
these
things
and
there's
some
mechanisms
that
jv2
provides
to
make
this
work
easily.
C
So
as
an
example
here,
the
base
extension
attaches
an
object
called
a
base,
IR
add-on.
So
that's
going
to
be
add
onto
the
IR
object.
So,
in
an
extension,
you
can
create
new
operations,
new
types,
new
symbols.
Basically,
you
can
create
things
that
the
base
infrastructure
has
no
idea
about,
but
you
need
to
be
able
to
represent
those
things
in
the
IR
object
and
you
need
to
be
able
to.
You
know,
make
sure
in
the
case
of
say,
the
base
extension.
C
You
can
create
pointer
types
and
struct
types,
but
you
don't
want
to
create
like
the
same
pointer
type
over
and
over
and
over
again
just
because
you
need
a
pointer
to
an
n32.
So
you
need
a
place
to
be
able
to
sort
of
capture
that
you
know
here
are
the
pointer
types
that
are
here
and
yes,
it
could
be
the
type
dictionary.
C
But
you
got
to
look
things
up
all
the
time
so
in
this
base,
IR
add-on,
there's
a
there's,
a
standard
map
which
which
actually
records,
which
pointer
types
and
struct
types
have
been
created
as
part
of
this
compilation,
and
then
you
can
and
then
it
uses
that
to
do
it.
But
pointer
and
struct
types
only
exist
in
the
base
extension,
so
those
that
that
standard
map
can't
really
exist
in
the
IR
and
I.
C
Don't
want
to
limit
the
the
kinds
of
things
that
you
can
do
so
it
creates
this
device,
IR
add-on,
which
is
just
an
object
that
holds
those
standard
maps
and
allows
you
to
access
them
very
easily,
and
then
it
uses
this
infrastructure
to
to
to
attach
them
to
the
IR
object.
So
the
example
here
you
know
you
get
your
hands
on
an
IR
object
which
there's
one
hanging
off
the
compilation.
C
So
that's
easy
and
then
you
can
allocate
one
of
these
base,
IR
add-on
objects,
and
one
of
the
things
you
pass
to
it
is
the
root
IR
object,
so
it
can
kind
of
get
back
and
forth
and-
and
you
have
to
use
the
same
allocator
as
the
root
object
in
order
to
allocate
this
add-on
so
that
its
lifetime
matches
the
lifetime
of
the
of
the
object
or
at
least
matches
the
lifetime
of
the
object
that
you're
attaching
it
to.
And
then
you
just
go
on
the
root
object.
C
C
Basically,
the
registration
and
notification
process
that
allows
that
to
work
and
I'll
go
into
more
detail
on
this
I
know
I'm,
covering
it
a
very
high
superficial
level
here
and
then
finally,
to
use
it,
anybody
who
can
get
their
hands
on
an
IR
object
by
you
know
getting
it
from
the
compilation
again
can
just
ask
for
the
add-on
for
the
base,
IR
add-on.
So
any
code
that
knows
that
there's
a
base
extension
around
can
ask
for
that
add-on
and
access
it,
but
other
code
that
doesn't
need
to
know
about
the
base.
C
Extension
and
may
not
even
you
know
like,
and
there
may
not
even
be
a
basic
Center
on,
doesn't
need
to
know
about
this
class
or
this
process
or
any
of
that
right.
So
it's
the
base
infrastructure
doesn't
need
to
know
about
this
in
order
to
for
another
extension,
to
be
able
to
do
it.
Okay.
So
how
does
that
actually
work
in
a
little
more
detail?
So
there's
a
few
mechanisms
here
so
add-on
and
extension
are
kind
of
two
of
the
ones
that
I've
mentioned
in
passing.
C
There
are
actually
five
classes
here
that
are
kind
of
working
together
to
make
all
of
this
work.
There's
a
base
class
called
extensible
and
a
lot
of
the
objects
in
the
day.
B2
Implement
code
base
are
actually
derived
from
extensible,
either
directly
or
through
something
else,
so
it
so
if
this
provides
some
functionality
for
the
compiler
framework
to
be
able
to
allow
things
to
add
add-ons
attach
add-ons
to
various
objects
at
the
core
of
that
is
a
thing
called
kind
service
which
helps
to
assign
categories
of
things.
C
C
You
have
to
make
it
a
subclass
of
add-on
and
then
compiler
also
participates
in
the
registry
and
notification
for
extensible
objects
and
I'll
talk
about
some
of
these
mechanisms
in
a
little
bit
more
detail
the
way
I'm
going
to
go
through.
This
is
not
the
order
that
I
just
talked
about
them.
I'm
going
to
talk
about
kind
service
first,
because
it's
kind
of
at
the
base
of
everything
and
and
then
I'll
talk
about
add-on
a
little
bit
more
and
kind
of
reference.
C
If
I
can
talk
about
how
the
other
bits
kind
of
play
a
part
in
how
this
all
works,
all
right
kind
service,
so
as
I
mentioned
it's
kind
of
analogous
to
rtti,
but
there
are
reasons
why
I
didn't
use
rtdi,
so
I
I
created
a
thing
called
kind
service
which
basically
allows
you
to
create
categories
of
classes
within
the
the
compiler
independently.
They
don't
have
to
match
your
actual
class.
C
You
don't
have
to
define
a
different
kind
for
every
class,
but
it's
common
to
do
that
and
there's
one
that's
in
particular,
that's
important,
which
is
the
one
that's
inextensible,
but
I'll
talk
about
that
in
a
minute.
So
the
way
a
kind
service
works
is
that
when
you
create
a
subclass
epic
of
the
of
the
kind
you
can
it
basically
registers
with
the
with
the
kind
service
to
assign
an
index
a
kind.
It's
not
actually
an
index,
it's
a
bit
Vector
right
now,
but
it
assigns
a
kind
which
captures
you
know.
C
For
so
you
can
you
can
it's
not
it's
not
the
same
thing
as
being
tagged
with
a
bft
and
obviously
things
have
pfts
and
C
plus
plus
classes.
But
it's
it's
a
it's
a
it's
a
visible
implementation
of
a
class
hierarchy,
relationship
and
then
extensive
sorry.
And
then,
if
you
have
kind
service
inside
an
object
type,
it
provides
some
useful
convenience
functions
for
asking
about
what
an
object
is.
So
you
can
ask
if
an
object
is
an
exact
kind.
C
So
if
T
is
a
a
a
particular
kind,
you
can
ask
if
object
is
exactly
a
t
or
you
can
ask
if
T
is
a
subclass
or
sorry.
If
the
object
is
a
subclass
of
t
or
T,
and
you
can
do
downcasting
very
simply
without
having
static
casts
sprinkled
throughout
the
thing,
and
it
doesn't
automatic
assert
to
make
sure
that
it's
it
actually
is
one
of
those
things.
C
So
this
is
probably
all
sounding
very
much
like
what
rtti
would
provide
you,
but
the
basically,
the
most
important
kind
services
in
extensible
is
the
one
I'm
going
to
focus
on
here.
Although
there
are
a
few
things
in
the
compiler
still
that
have
different
client
services
and
I'm
getting
rid
of
them
and
making
it
all
into
extensible.
C
Why
not
just
use
rtti
you're,
probably
thinking
so
kind,
is
currently
a
bit
Vector
so
that
it's
very
easy
to
kind
of
mouse
things
together.
So
you
can
do
the
his
exact
kind
and
his
kind
or
his
kind
is
the
easiest
one,
but
I'm
eventually
going
to
change
that
to
an
ID.
So
it
will
be
so
then
basically
kinds
turn
into
a
contiguous
set
of
IDs,
which
you
can
use
to
do
higher
performance
decoding
and
dispatching
for
various
extensibility
features
that
wouldn't
be
possible,
I,
don't
think
or
clean
with
an
RT
with
rtti.
C
Ability
to
use
what
rtti
is
doing
it
doesn't,
let
you
build
I,
don't
think
vfts
and
other
kinds
of
things
so
basically
I
think
I
can
do
some
useful
optimizations
to
make
this
Dynamic
extensibility
framework
more
efficient
by
not
using
rtti
and
having
control
over
how
these
things
get
assigned,
but
I
guess
that
remains
to
be
seen
because
I
haven't
actually
done
it
all
right.
So
what
does
kind
service
support?
Actually
look
like?
C
So
if
you
have
a
class
that
you
want
to
assign
a
kind
to
like,
for
example,
function
compilation,
which
is
a
subclass
of
compilation,
compilation
is
a
jb2
core
class
compilation,
itself
extends
extensible.
So
it's
in
the
hierarchy
here.
So
in
the
class
definition
you
do
a
subclass
kind
service.
Decal
I,
don't
like
this
ordering,
but
it
is
what
it
is
right
now
and
basically
it
knows
extensible,
because
because
you
can
have
kind
services
for
multiple
categories,
not
just
extensively,
you
could
create
other
ones.
C
C
C
It's
basically
a
way
to
optionally
augment
an
API.
So
if
an
extension
isn't
loaded,
then
if
add-ons
won't
be
created
and
or
attached
to
anything,
so
it
won't
impact
anything,
nothing
can
access
it,
but
once
the
extension
is
loaded,
it
can
tack
in
its
API
into
the
object,
and
it
means
that
you
don't
have
to.
It
means
that
objects
can
be
allocated
anywhere
throughout
the
compiler
without
knowing
which
extension
apis
have
to
be
added
to
it,
and
that's
the
notification
mechanism
that
I'll
talk
about
shortly.
C
These
extension
objects
are
the
things,
so
the
extension
object
represents
a
plug-in
so
that
it
basically
typically
creates
an
add-on.
It's
the
thing,
that's
creating
add-on
objects,
and
so
I'll
expand
on
a
couple
of
use
cases
that
I've
had
so
far,
so
you
can
attach
a
new
API
to
a
specific
object.
So
in
the
case
of
the
the
JB
extension,
so
JB
extension
is
a
thing
that
provides
NATO
code
generation
via
calls
to
the
ohm
Argent
Builder
API
and
select
the
previous
version
of
this
Library.
C
Tell
me
when
new
extensions
get
loaded,
so
if
somebody
loads
a
new
extension
I
want
to
find
out
about
it
and
using
that
mechanism,
it
watches
to
see
if,
for
example,
the
base
extension
gets
loaded
and
if
the
base
extension
gets
loaded,
the
base
extension
adds
a
whole
bunch
of
operations
and
types
and
things,
and
so
it
needs
to
be
able
to
generate
code
for
the
base
extension
to
to
to
to
be
able
to
generate
code
for
it.
So
it
creates
a
base.
C
Extension
specific
Builder
code
generator,
so
the
and
and
then
attaches
it
to
the
base.
Extension
we'll
go
and
again
I'll
go
out
well,
not
again.
I'll
go
into
a
little
bit
more
detail
on
this
too
I
just
wanted
to
kind
of
give
the
basic
flavor
of
the
idea
right.
So
there's
that
code
generation
object,
that's
taking
care
of
how
to
how
to
how
to
generate
code.
C
C
But
if
those
extensions
aren't
loaded,
then
there's
no
way
to
refer
to
the
IL
of
that
extension.
If
that
extension
hasn't
been
loaded,
so
you
you
have
to
kind
of
do
it.
Optionally
right,
you
can
only
I
can
only
talk
about
with
a
good
example.
I
can
only
talk
about
an
ad
operation
if
the
if
the
basic
extension
is
loaded,
so
I
can't
add
API
to
the
code
generator
unless
the
base
extension
gets
added
gets
loaded.
In
order
to
talk
about
it,
not
very
well.
B
C
Okay,
so
so
this
is
why
I
should
have
actually
done
a
talk
about
extension
objects
first,
so
the
extension
object
is
like
I
I
said
it
earlier,
but
I
probably
should
expand
on
it
a
little
bit.
So
the
the
extension
object,
like
the
extension
extension
object,
represents
a
plug-in.
So
there
was
so
I
talk
about
the
base
extension,
but
there
is
actually
a
class
called
base
extension,
which
is
in
the
base
extension
right
and
the
way
that
you
create
objects
is
by
calling
you
get
a
you
use.
A
pointer
to
the
base.
C
C
It's
a
second
there's
a
if
you
if
I
were
to
pull
up
the
base
extension
class,
you
would
see
a
whole
bunch
of
public
stuff
in
it.
That's
like
here's!
How
to
get
here's
you
know
into
eight
in
16
and
32
float.
32
float
60,
but
here
are
the
types
it
doesn't
have
any
symbols,
but
it
defines
oh
there's
a
way
to
create
pointer
types,
there's
a
way
to
create
struct
types,
there's
and
then
there's
all
these
operations
that
you
can
use
like
add
sub
mode,
if
compare
greater
than.
B
C
Yes,
so
the
way
it
works
is
in
this
particular
case,
the
code
generator
basically
picks
up
an
operation.
So
it
only
knows
about
operation,
it
picks
up
an
operation.
It
says
which
extension
created
you,
okay
and
then
it
delegates
to
that
extension
on
I
think
I'll
show
this
later
on,
but
it
delegates
to
that
extension
to
say
use
your
JB
code,
generator
add-on
to
generate
code,
and
it
provides
some
other
pointers
to
stuff
that
it
needs
to
do
that.
B
C
No,
that's
and
that's
so.
The
thing
that
creates
operations
is
the
extension
object.
Okay,
the
extension
object
is
a
subclass
that
extensible,
but
it's
not
an
add-on.
Okay,
so
you
can't
add
an
extension
to
something
like
an
extension
object
or
something
else,
but
you
can
add
extension.
You
can
add
add-ons
to
an
extension
object.
Oh
okay,
yeah.
C
C
Okay,
let's
skip
the
second
exam.
So
the
example
where
you
know
different
objects
get
created
and
they
need
to
have
stuff
tacked
into
them,
and
the
example
of
that
is
the
IR
one
that
I
used
before
right,
so
IR
objects
get
created
by
compilation
objects
by
by
compilations,
and
you
need
to
be
able
to
tack
in
add-ons
into
those
objects.
C
It
exemplifies
all
the
stuff,
and
in
fact
the
first
example
I
gave
is
not
actually
really
implemented
with
add-ons
right
now
so
conceptually
it
will
be,
though,
all
right,
so
here's
what
the
base
IR
add-on,
looks
this
code.
So
it's
a
little
bit
simplified,
but,
as
I
remember,
I
mentioned
that
the
core
IR
has
no
idea
what
a
pointer
type
is
or
a
struct
type
is
that's
only
in
the
base
extension
that
you
can
get
access
to
those
things.
So
this
base,
IR
add-on,
is
a
way
of
tracking
which
pointer
types
have
been
created.
C
So
you
don't
create
many
of
the
same
kind.
Don't
worry
about
base
that
on
right
now,
so
it
it's
it's
allocatable.
It's
it
has.
This
base
extension
object
as
a
friend
class,
because
the
Constructor
is
projected
I,
don't
want
just
anybody
creating
these
things
and
then
the
public
API,
for
this
is
basically
giving
me
the
pointer
type
from
a
base,
type
and
register
a
pointer
type.
C
So
when
I
create
this
thing,
obviously
I
remember
it
has
to
be
dynamically
allocated.
So
it
has
an
allocator
passed
in.
It
needs
to
know
about
the
base
extension
object
and
it
needs
to
know
which
root
object,
it's
being
attached
to
and
then
add-on.
Basically
just
takes
all
that
stuff
away.
Right,
so
forget,
forget,
base
add-on
in
here.
It's
just
essentially
add-on,
because
this
stuff
really
just
gets
passed
back
into
add-on.
C
The
only
reason
I
have
a
base
add-on
class
is
so
that
this
can
be
an
actual
base
extension
and
not
an
extension.
So
it's
easier
for
people
to
get
access
to
the
base
extension
all
right,
and
then
it
adds
this.
This
standard
map,
which
which
Maps
a
type
any
type
to
the
pointer
type
that
points
to
it
to
that
like
to
point
to
objects
of
that
type.
So
if
somebody
calls
pointer
type
from
base
type
within
32,
it
will
hand
back
a
pointer
to
n32
thing.
C
If
somebody
else
asks
for
it,
it
will
hand
back
the
exact
same
type.
It
will
create
two
different
pointers
to
n32,
so
you'll
never
see
you
know,
T5
is
or
not,
T5
t13
is
pointer
to
n32
and
then
T15
and
it's
pointer
to
n32
and
then
T20
is
pointer
to
n32.
Everything
will
be
t13
432
and
if
it's
easier,
it's
only
one
example
of
it
and
then
it
needs
to
be
part
of
the
extensible
add-on
coin
service.
C
So
it
gets
its
own
kind
and
then
later
on,
you
have
to
do
the
info
for
it
as
well.
Then
how
does
it
get?
How
does
the?
How
do
these
things
get
created
right
so
base
extension
when
base
extension
is
being
constructed?
So
when
you
load
an
extension,
it
calls
the
Constructor.
It
builds
a
base,
extension
object.
It
creates
that
object
and,
as
part
of
constructing
that
object,
it
says:
hey
register
for
register
me
for
seeing
allocations
of
the
IR
extensible
kind,
like
the
IR
objects.
C
Basically
any
object
that
has
kind
IR
notify
me
about
that
right
and
there's
a
bit
of
there's
a
bit
of
ballet
that
happens
here.
It
goes
down
to
extension
and
then
over
to
compiler.
Compiler
is
the
thing:
that's
actually
doing
the
registration
notification.
So
what,
when
you
do
this
register
for
extensible
thing?
What
it
actually
does
is
call
into
the
compilers
register
for
extensible,
and
that
thing
just
remembers
a
list
of
extensions
that
are
interested
in
allocations
of
this
kind
right.
So
it's!
This
is
a.
C
This
is
a
standard
map
which
takes
a
kind
and
Maps
it
to
a
list
of
extensions.
So
it
finds
the
the
list
that
that
corresponds
to
this
kind,
and
then
it
adds
it
adds
this
extension
onto
the
end
of
that
list.
Now,
obviously,
you
might
have
to
create
a
new
list
if
it
hadn't,
if
nobody's
registered,
for
it
before,
but
that's
the
basic
idea
and
then
so
so
now,
if
an
IR
object
gets
so
I
see
registered
to
be
notified.
So
what
happens
when
it
actually
notifies?
C
So
in
the
Constructor
of
ir,
it
does
a
notify
creation
thing
and
says:
what
might
what
its
extensible
kind
is.
So
this
as
the
last
step
of
the
Constructor,
so
we've
completely
created
this
object
basically
and
we're
just
about
to
return
from
its
Constructor.
So
we
notify
the
compiler
that
this
object
type
has
been
created
and
then
the
compiler
calls.
This
thing
called
create
any
add-ons
for
this
extensible
object.
C
This
is
the
one
that
just
got
created
that
has
this
kind
and
and
then
it
goes
and
sucks
that
same
thing,
and
it
looks
up
in
the
coin
to
find
a
list
of
extensions
who
are
interested
in
this
kind,
and
then
it
walks
down
that
list
and
for
each
extension
that
it
gets
there.
It
calls
create
add-on
on
the
extension,
so
the
extension
knows
how
to
create
the
add-ons
that
are
necessary
for
this
object.
C
That
passes
the
in
this
case
it
would
be
the
IR
object,
but
it
works
for
any
extensible
object
and
then,
finally,
the
base
extension
implements.
This
create
add-on,
callback,
I
guess
and
as
part
of
that,
it
says
if
the
client
is
IR
and
you
know
it
might
have
to
register
for
different
ones,
so
it
might
have
to
decode
what
kind
of
thing
it
actually
is.
C
In
fact,
I
could
probably
extend
that
by
adding
a
kind
to
it.
I
wouldn't
have
to
look
in
the
object,
but
basically
then
it
takes
the
allocator
that
was
used
to
allocate
e
allocates
the
appropriate
add-on,
that's
needed
and
then
called
e
attach,
and
it
just
attaches
that
object
onto
there.
So
now
you
know
that
IR
object
as
it's
passed
around
through
the
compiler.
Nobody
has
to
know
that
that
add-on
is
there
unless
they
actually
want
to
access
that
add-on,
and
so
you
know
some
function
somewhere.
C
C
Five
minutes
status
in
future,
Direction
I
think
I
made
it
so
right
now
most,
but
not
quite
all.
Extensible
classes
are
subclasses
of
extensible,
some
of
them
I've
gone
through,
as
you
might
imagine,
a
process
of
discovering
how
to
do
this,
and
so
not
all
of
the
code
base
is
currently
in
the
right
state.
But
there
is
some
vestigial
stuff
of
context.
C
For
example,
I
think
I
fixed
context
recently,
but
context
used
to
be
its
own
kind
of
its
own
kind
service
that
was
independent
of
extensible,
and
so
it
couldn't
participate
in
all
of
this
stuff.
But
you
know
it's
really
just
needs
to
be
folded
into
the
extensible
kind
service
and
have
an
extensible,
Base,
Class
and
as
a
space
class
and
then
and
then
it
can
participate
in
all
of
this
stuff.
C
Using
in
in
possibly
even
a
different
allocator,
so
it
basically
just
makes
a
copy
of
the
IR
that
can
then
be.
You
can
do
anything
you
want
with
it.
So
the
that
one
that
was
motivated
by
the
debugger,
because
the
idea
there
was,
if
you're,
in
the
middle
of
a
compilation
you
take
a
snapshot
of
the
IR
and
the
debug
object
knows
what
that
IR
was.
C
And
then
you
can
even
let
that
completion
proceed
and
have
the
IR
finish
and
it
can
generate
code,
but
you
still
have
a
copy
of
the
IR
as
it
existed
at
that
moment,
which
is
tied
to
the
debugger.
The
debugger
can
walk
through
that
and
you
can
debug
it
and
you
don't
have
to
you.
Don't
have
to
hold
on
to
the
compilation
throughout
that
whole
process
anyway
and
then
and
then
base
function.
C
Extension
add-on
is
also
probably
going
to
get
rid
of
this
one
actually,
but
it
basically
adds
some
additional
API
onto
the
function.
Extension
object.
So
if
you
load
the
base
and
the
function
extension,
it
adds
on
some
API
into
the
function
extension.
But
it's
not
really
I
I,
don't
think
I
need
it.
The
way
it
was
implemented
before
is
so.
Basically
the
functions
that
get
added
are
to
it's
their
helpers
for
creating
increment
operations.
C
So
there's
in
the
in
the
base
extension
it
does
it
used
to
have
an
increment,
which
you
give
it
a
symbol.
Actually
you
give
it
a
local
symbol
and
and
a
value,
and
it
would
basically
just
do
the
load
of
the
local
symbol.
Add
the
value
onto
it
and
store
it
back
into
the
local.
Now
local
symbol
is
something
that
only
exists
in
the
function.
Extension
function.
C
I
can't
talk
about
ad
unless
the
basic
extension
is
loaded.
If
they're
both
loaded,
then
I
can
do
that.
So
the
idea
was
you
add
this
increment
helper
onto
the
function
extension
so
that
you
can
add
increment
on
top
of
the.
If
you,
if
you
do
have
both
of
those
you
can
say,
I
want
to
increment
the
symbol
with
this
ad
local
symbol.
I
fixed
that
very
easily
by
saying
it
doesn't
have
to
be
a
local
symbol,
it
could
just
be
a
symbol,
and
then
everybody
knows
about
symbol.
C
There's
no
more
dependency
on
on
the
function.
Extension,
specific,
Concepts
and
so
I
don't
need
it
anymore,
but
it's
still
there
right
now.
There
are
also
a
couple
of
facilities
that
currently
exist
in
jb2
that
I
haven't
yet
migrated
to
using
add-ons.
One
of
them
is
called
extended
pass,
which
is
how
the
JB
code
generator
crap
is
actually
sorry.
Stuff
is
actually
implemented
right
now,
but
an
extended
pass
is
really
a
it's.
C
A
more
limited
notion
of
add-on
that
I
didn't
realize
could
be
generalized
when
I
built
it
so,
basically,
I
created,
extended,
pass
and
I
was
like
this
doesn't
have
to
be
so
limited
as
just
to
be
done
for
passes.
I
could
do
this
for
anything
and
that's
when
I
created
add-ons
and
moved
it
up,
there's
also
validity
checking,
which
is
another
painful
topic
for
operations.
You
know
the
the
idea
is
that
it
shouldn't
be
possible
to
create
an
incorrect
operation.
C
So,
for
example,
you
shouldn't
be
able
to
create
an
ad
operation
well,
at
least
under
the
current
way,
that
this
works.
You
shouldn't
be
able
to
create
an
ad
operation
that
adds
an
n32
and
a
float32,
because
the
types
are
mismatched,
so
it
your
ad
operation
should
have
matching
types,
so
it
should
add
to
it
32s
and
create
an
32
or
whatever
you
want
to
Define
it.
C
What
happens
if
you
create
a
complex
extension
which
adds
a
complex
32
type,
can
I
add
two
complex,
full
32s,
and
does
it
generate
a
complex
float?
32
like
how
do
I
check
the
validity
of
that
the
basic
can't
know
because
it
doesn't
know
anything
about
complex,
so
complex
has
to
be
able
to
kind
of
tack
into
that
process.
So
it's
very
similar
to
the
add-on
there's
a
similar
need
to
the
add-on
thing,
but
it
doesn't
currently
use
add-ons
to
do
that
and
then
yeah
I
mentioned
kind
service
now
returns
bit
vectors.
C
I'd
really
like
that
to
actually
change
that
to
kind
IDs
at
some
point,
because
I
think
they're,
more
flexible
and
then
the
kind
service
would
I
mean
they'll
still
be
bit
vectors.
It's
just
they'll
be
main
managed
internal
to
the
to
the
client
service
and
you'll
have
to
ask
the
client
service
to
compare
to
two
IDs.
C
So
in
summary,
wow
sorry,
a
little
bit
long
I
went
through
the
example.
Il
I
talked
about
dynamic
memory.
Allocation
using
allocators
and
I
talked
about
the
dynamic
extensibility
mechanisms.
There
are
more
things
you
know
see:
I
I
did
I
did
notice
about
extensions.
I've
got
that
topic
there.
I
probably
should
go
through
extensions
and
talk
and
show
you
some
examples
of
what
an
extension
object
looks
like
and
how
it
works
and
I
I
think
I've
showed
examples
for
how
to
load
them.
C
But
anyway,
I
can
talk
in
more
detail
about
the
IL
debugger,
which
is
still
on
the
floor.
But
it's
getting
there
there's
the
contribution
strategy.
So
where
does
this?
How
does
this
get
into
omr
Etc
and
then
I
guess
I
could
talk
about
anything
else.
People
are
interested
too.
If
there's
other
questions
that
have
come
about,
I
guess
I'll
probably
have
to
start
the
third
one
of
these
with.
Does
anybody
have
any
questions
that
they
didn't
give
tongue
to
ask
in
the
last
talk
because
I
talked
too
long.