What's New in Clang and LLVM

Keep up with the latest enhancements to C, Objective-C, and C++ made possible by advancements in the Clang compiler and LLVM. Find out about new static analyzer features and how to use them to improve your code. Learn how to take advantage of new optimizations for code size.

Resources

Related Videos

WWDC 2019

WWDC 2017

WWDC 2016

So, over the past year, we've
been working really hard on
adding some great new features
to the compiler.

I'm Jessica, and today, me and
my colleagues, JF and Devin, are
going to share some of those
great features with all of you.
So, we've got a lot of ground to
cover today.

We're going to talk about new
platform support, some low-level
code size optimizations, some
language-level code size
optimizations, some great new
diagnostics, and then we're
going to finish up with some
great new static analyzer checks
that will help you find bugs in
your code.
So, let's get started with new
platform support.

Specifically, I'd like to talk
about the Series 4 Watch.
The Series 4 watch usually a
fully 64-bit chip.
But yet, all of the App Store
apps are 32 bit.

The curious thing about this is
that on day one, all of your
apps worked seamlessly on the
Series 4 Watch.
This seems kind of like magic.
You didn't have to recompile
anything.
But yet, all of the apps worked.
How did this happen?
Now, it would be awesome if I
could get the front row or any
row of the audience to give me a
drum roll like this, but if you
don't want to it's fine.
Da da da da da da da da da, the
answer is Bitcode.
[applause]
And I explained absolutely
nothing.
So, allow me to explain this to
you.

Let's take some source code,
your favorite language.
What we're going to do is we're
going to hand that off to the
compiler.
Now, normally what you would do
here is you would continue the
standard compilation process,
and you would get like a binary
or something, but we're not
going to do that.
What we're going to do instead
is we're going to stop the
compilation process early, and
we're going to produce LLVM
Bitcode.
So, what's cool about LLVM
Bitcode is it encodes an
intermediate state in the
compiler.
And what you can do with this
intermediate state is you can
actually pick up the compilation
process where you left it off.

So, that's what we do, except
this time we do it in the App
Store.

By doing this, we could take one
Bitcode for one app and produce
two different apps from it, one
to run on a 32-bit chip, and one
to run on the fancy new 64-bit
chip as well.

Now, there kind of is a problem
here.
The problem is is that the
compiler doesn't actually know
that you're going to be
executing code on a 64-bit
device, and if it knew that, it
could actually leverage that
information to optimize the app
even more.
And so to get around that, what
we do is we collect Bitcode for
the 64-bit chip as well.
This allows us to create a
really, really fast app just
from the Bitcode.
Now, this is pretty cool.
This is like-- this is one of
the things that makes compilers
kind of magical.
It's pretty awesome, eh?
Now, let's move onto Code Size
Improvements.
This is one of my favorite
topics.
We've been hard at work having
the compiler actually produce as
small of code as possible for
you.
Now, code size is pretty
important because bigger code
means bigger, slower downloads,
and bigger apps take up more
space on users' devices, and you
notice this kind of thing.
So, to support users that
actually want to prioritize code
size over all other metrics, we
added a new optimization level
to Xcode.
And that optimization level is
-Oz.

And I'm going to keep saying -Oz
because I'm Canadian, so we
might as well call it Oh Canada.

What I'd like to show you today
is an example of the kind of
optimization that appears at
-Oz, but before doing that, I'm
going to do my best to tell all
of you how a compiler works in a
couple of minutes flat.
So, when you compile some code,
the initial representation is
very, very target independent.
It's source code.

When you put that into the
compiler, it gets lowered to an
IR, an intermediate
representation.
This intermediate representation
is still mostly target
independent, but it does have
some target-dependent features
built in.

It looks kind of like a generic
assembly.
At this point, you could just
stop the compilation process and
spit out some Bitcode, but we're
not going to do that.

We're going to keep going.
That representation is further
lowered to what we call MIR,
which is short for Machine IR.
At the end of this process, the
Machine IR looks almost
identical to the assembly for
the target, in this case arm 64
assembly.

We could put the code side by
side, for example.
Now, in the optimization that
we're going to talk about, we're
going to be working with the
Machine IR, but for the sake of
familiarity, I'm just going to
do all of our examples in
assembly, because that's less
scary.
What I'd like to tell you about
is the code size optimization
called Function Outlining.
Function Outlining is one of
those optimizations that's going
to do everything it can to save
you some size.
It's very, very late in the
compiler.
It doesn't actually rely on any
sort of a source code language.

The best way to explain what
this does is by example.
So, let's say that you have some
assembly like this.
hasse and kakutani are two
random functions in some random
program.
Now, what's interesting about
hasse and kakutani is they have
some identical instructions.
What we can do with this is we
could take those identical
instructions and factor them out
into a new function.
After we factor them out into a
new function, what we can do is
we can replace the sequences
that we found with calls or
branches.
As a result of this, we end up
with a smaller program.

And how much smaller?
Well, up to 25 percent on our
test programs.

[applause]
Now, some of you might be
wondering, okay, well where do
these savings come from?
Is it because of copied and
pasted code?
Is it because your code needs to
be refactored?
Well, no, there's actually
something a bit deeper happening
here.
If you do have a bunch of code
copied and pasted around, that
will impact outlining behavior,
but that's not really the most
important thing.
Let's look at another example.
Say you have this function.

It doesn't matter what this
function does, but what I'd like
to address is what happens if we
take this function and we put it
into the compiler.
We get some assembly.

Well, you might get something
that looks kind of like this.
Once again, you don't really
need to understand this
assembly, but what I'd like to
draw attention to is the
instructions at the beginning
and the end of the function.
These are called the function
prologue and epilogue.
These instructions don't
correspond to any individual
lines of source code.
These are instructions that are
inserted by the compiler to meet
some sort of system
requirements.
So, these types of things, like
these stores and these loads
could appear in many places
throughout your program, and
this is the kind of thing that
the outliner can actually
leverage to reduce the size of
the overall program.
There are some gotchas to do
with this though.

First off, when you outline, you
change the control flow of your
program.

Here, you might initially have
ulam called collatz, but then
you could outline the call to
collatz.
The thing about what happens
here is we've changed the
control of flow of the program.
So, the problem with this is
what happens if you crash inside
collatz?
Well, what's going to happen is
you're going to go and you're
going to take your program and
you're going to throw it into
LLDB, and you're going to
see the added outline function
in your back trace.
So, this is something you have
to watch out for if you're
actually outlining code.
Another thing is that outlining
can increase the execution time
of your program.
You're adding calls, and calls
could have an execution time
overhead.
And this is actually okay though
because -Oz prioritizes size
over everything else.
When you're going through -Oz,
you're saying, make it small.
Because of this, we don't
recommend that you compile
performance sensitive code with
-Oz.
If execution time is king in
your program, -Oz is not the
best thing to use.
However, we do recommend that
you use instruments.
What instruments is going to
tell you is where the hot spots
in your program are, and this
can allow you to make the best
decisions with respect to
optimization for your app.
The compiler has lots of
different optimization levels,
and those optimization levels
all prioritize different things.
For example, -Oz prioritizes
size at all cost, and as a
result, you might have some
slightly slower execution time.

But on the other end of the
spectrum, you have -O3.
-O3 is going to prioritize the
execution time of your program
at all costs, and as a result,
you might get a larger program.

-Os is the default optimization
level in Xcode because it has a
good balance between speed and
size.
But, you know, you might have
different optimization needs,
and so you can use instruments
to figure this out.
The compiler also offers some
extra optimizations that I don't
have a lot of time to talk about
but I would like to cover a
little bit about anyway.
It offers PGO, which is
Profile-Guided Optimization.

PGO is pretty cool because it
allows you to actually execute
your program and then collect
information about how your
program runs.
Then you can use that to guide
the compiler when you compile it
again.
It also offers LTO, which is
Link-Time Optimization.
What's cool about Link-Time
Optimization is at the cost of
some compile time, what you can
do is you can tell the compiler,
okay, let's wait until we have
every single file in the program
and use that to say provide
better inlining and outlining.

Optimizations like inlining and
outlining do better when they
have more context, so LTO could
help there.
You can also combine these extra
optimizations with the existing
optimization levels to get some
really, really good actual
performance.

Because I don't have a lot of
time to actually cover what
these things do, I recommend
that you check out the previous
What's New in LLVM talk so that
you can learn a bit more about
them.
After all that, you might be
wondering, okay, how do I enable
-Oz?
Well, just go to your project's
build settings and select -Oz as
the optimization level.
You can also enable -Oz or other
optimization levels on specific
files in Xcode by going to your
project's build phases, going to
the compile sources list, and
setting the compiler flags.
All right.
So, I just told you a lot of
stuff.
You're probably wondering, okay,
how does this impact my app's
code size?
How do I figure out this kind of
information?
Well, to figure out code size, I
recommend a little tool called
size.

I use this tool a lot.
It's a nice little terminal app.
So, size is going to give you
some nice low-level binary
information about your app.
It is not going to tell you the
actual total size of your app,
because it doesn't include
things like assets, for example.

If you have like a giant picture
in your app, and you have like a
hello world of code, the
compiler can't help you with
that.
But, let's say you want to use
size.
Here's how you do it.
It's easy.

You just say size, and here's
the path to my binary.
What it's going to do is it's
going to give you some nice
output like this.
What it's going to do is it's
going to tell you the size of
each segment in your binary, and
it's going to tell you the
overall size of the binary as
well.
But, the thing is, is each
segment in a binary is actually
comprised of many sections.
I only care about executable
instructions in this example.
So, what I'm going to do then,
is I'm going to give size a
couple extra flags.
Those extra flags are the -l and
the -m flags.

When I do this, what size is
going to do is it's going to
give me a per section breakdown.

If I want to find out more about
executable instructions, then I
can just look at the text
section.
So, I hope that all of this
helps you with gaining some more
insight into the code size of
your apps.
Now, I'm going to leave, and I'm
going to hand it off to my
fellow Canadian, JF, who's going
to tell you about some
language-level Code Size
Improvements.
[applause]
Thanks, Jessica.
[applause]
So, I'm Jeff, and I'm going
to tell you about Language-Level
Optimization.
So, Jessica told you about
low-level, kind of assembly-ish
optimizations, and I'm going to
tell you about the stuff that
happens when you use the
language itself, right, so the
constructs that you write your
code in.
I'm going to tell you about four
of those optimizations today
that also affect code size.
The first one is related to
objective C, when you use
blocks, right.
So blocks has a bunch of
associated metadata that the
compiler generates for you.
It has metadata as well as
helper functions, and we'll go
into a few examples to see what
that looks like.
So, say you write some code, and
it looks something like this.
Right.
So, you'll notice that I have
two blocks in two different
functions, and the code doesn't
really matter, but the important
bit to notice is that the blocks
do completely different things,
right.

The code has nothing to do with
each other, but they have fairly
similar struct in that the
capture for the blocks is
similar.
In this case, I capture two
arc-strong pointers.
Now, I told you that there is
metadata associated with each
block.
What does that look like?
Well, this is the metadata that
we're talking about, right.
So the compiler generates this
automatically for you when you
use blocks to track a bunch of
information about the blocks and
give them the behavior that the
language guarantees.
What you'll notice is there's a
block size in there.

There's a copy helper and a
destroy helper, which are two
methods that we'll go into in a
bit, and there's a block method
signature as well as the block
layout info.

All right.
And if you look at the example
that I have on the screen, this
is actually the synthesized code
that the compiler generates.
Now, that looks like a bunch of
gobbledygook, but what really
matters is that the struct
itself is the same, so we can
duplicate in a lot of cases.
Now, you'll notice in this case
we can't because despite
capturing two arc-strong
pointers, there's other captures
in there, and the block size
itself is different.
All right.
So, we can't merge these cases,
right.
But in general, there's some
cases where we can end up
merging these things, right.
You'll notice in this example
though, we have the functions,
right, so the copy helper and
destroy helper can be merged,
right.

And you'll notice that as of
Xcode 11, we do merge them,
right.

So, those are the same.
What does that mean?
Well, the copy helper is there
to help you when you move a
block around, right, and destroy
helper is there to help you when
the block goes away, right.
And the code that the compiler
synthesizes when you do this
looks about something like this.
All right, so in the example I
had, you'll remember I said we
have two strong arc pointers,
and the code we generate is
something like that, and we copy
it around.
You retain, and when you destroy
it, you release.

Now, there's a bunch of other
things that blocks end up having
to do when you copy or destroy.

You might have C++ objects, in
which case you have to color
copy constructor.

You might have-- and the
destructors, right.
You might have some weak arc
pointers.
You might have nontrivial C
types or something like that,
right.
So, there's a bunch of other
stuff that needs to happen, but
basically you write code using
blocks, and when the compiler
detects that there is
redundancy, we try to eliminate
as much of it as we can.
Now, how much does this pay off?
We found that in objective C
applications, it's roughly a 2
to 7 percent code size
reduction, right, and that comes
for free.
It's just enabled by default.

The second optimization I'm
going to tell you about is
related to Instance Variables of
Direct Subclasses of NSObject.
Now, that's a mouthful, and I've
got to give you an example and
explain what that actually
means, all right.

So let's say I'm writing a card
game, and I write code that
looks something like this.

The key thing to remember here
is I'm deriving directly from
NSObject, right.

So there's instance variables
generated automatically to back
up the properties that I have
here, right.
Now, the class itself that I
wrote, the compiler looks at it
and generates a struct that
looks something like this
roughly, right.

It lays out the members, one
after the other.
Now, the thing in objective C is
that you can have a base class
derived from it and then change
the code in one framework to the
other, and the base class
changes, has new members and
whatever, and the derived
classes don't break, right.
And the objective, in C++ you
can't really do that.

If you derive, then the base
class's layout changes.
You have new sizes.

Now, here I'm deriving from
NSObject.
NSObject is effectively part of
the ABI of the platform.
So, we know it's not going to
change, right.

So, we have this layout of the
class, and when we're
implementing the class, right,
so implement this initWithName
method, I know exactly the
layout of everything in my
class, right.
So, the compiler, as of Xcode
11, can go in and say, I know
where the offsets are.
I can hardcode them.
Well, okay, what does that
actually mean?
So, I look at this initWithName
method.

It'll look something like this,
right.
So, I have self.name = name.

Now, the setter, to generate a
code for that looks about
something like this before Xcode
11, right.
So, it synthesizes a lookup into
a table to know the offset of
the name property or the name
IVAR rather.
Now, that's a small amount of
code, but what we do as of Xcode
11 is something like this
instead, right.

So, we just hardcode the offset
when you're implementing the
method that's a direct
derivative of an S object.
That makes sense.
We know it's not going to change
because we're implementing the
thing that you just wrote.
And it seems pretty trivial;
it's just one instruction out of
three, right.
But it turns out to be roughly a
2 percent saving in
applications.
It's pretty s sweet.

[applause]
The next size optimization I'm
going to tell you about is
improved debuggability for C++
types.
Now, you're going to go, wait,
that's not size.
It is.
Just let me get to it.

So, I say I write some code.
Fairly straightforward code
here.

It's a command line application,
right, and what I'm doing is I'm
taking the parameters from a
command line as strings,
transforming them as integers,
putting them into a std::vector
and then printing them out one
after the other, right.
Really straightforward demo
application.
Now, what important here is I'm
using the standard library's
types.
Specifically I'm using vector
push back, and I want to go in
and put a breakpoint here.
Now, this used to not to work
really well before Xcode 11.

The reason was that we were
controlling the visibility of
lib C++'s methods just like push
back by force inlining them into
your code, right.
Now, generally that works pretty
well.
The problem is push back is
giant, and then the optimizer
goes to town, moves around,
deletes some code, and the
debugger, when you tell it break
on push back, you're not trying
to step into push back, you just
want to put a breakpoint on that
line.
The debugger doesn't really know
where push back is because it's
been splat all over the place,
right.
So, what we do as of Xcode 11 is
that we don't force inlining.
We let the inliner decide when
inlining should happen instead,
right.
So, what used to happen in this
specific example, before Xcode
11 is the breakpoint that you
put there would actually break
on the second loop, right,
because the pushbacks are just
everywhere now.
So, as of Xcode 11, we don't
force inlining, and this is what
the debugging session would look
like.

So, say I run lldb, I run my
program, and I say put a
breakpoint on line 12.

It just works, right.
It's kind of a boring demo
because it does what you expect.

It used not to.
So, the cool thing now is I'm
talking about code size
optimizations, right.
Well, this, because we don't
force inline really big things,
if you use the stl a lot in your
code, you create quite a big
amount of code bloat.

And so what we've measured is on
big applications release mode up
to a 7 percent code size
reduction when you do this.
Now, again, this is in release
mode, right.

So, that's a pretty good amount
of code savings and better
debugging.

That's nice.
The last code size saving I want
to tell you about is C++ static
destructor suppression.
And again, let me walk through
an example to show you what I
actually mean here.
So, say I write some really
generic C++ code.

Most applications end up having
a logger, something like this,
right.

And when you do logging, you
don't want to pass a logger
around throughout your
application, so you have just a
global variable called logger.
Fairly straightforward stuff.

Now in C++ when you have a
global like this, it'll have a
destructor that'll run at the
end of the application's
lifetime.
Right.

And you'll notice, the logger
contains a buffer that's a
std::vector of string, so that's
what the destructor is going to
do.
It's going to destroy that
vector of strings, right.
Straightforward thing so far.
Now, I go into my application,
and it's a game.
Right.
So I add this code here.

It's just a game.
So, again, I just have one
application and one game, and so
I just have a global here for my
game.
Totally sensible code, right.

Now, the problem is if I go in
and I add some logging code to
the struct of the game, well,
you'll notice, I have the logger
that's global.
I have the game that's global.

That might not work out so well.
The reason is in C++, between
different translation units, the
order in which the destructors
are called is not guaranteed,
right.

In a lot of cases, you'll
destroy the logger before you
destroy the game.

What's going to happen, this is
going to crash, not good, right.
So, that's kind of a headache
right here.
And then dig a bit more into how
C++ works, and this is my mental
view of what that is, right.
So, you start adding thread
local storage.

You start adding threads.
There's like the graph for C++
destructor ordering is really
complicated, and it's
complicated enough that even
like compiler people who are
supposed to know how that works,
we have no idea.
I had to fix a bug a few months
ago in Clang where Clang would
in really rare cases crash upon
termination when trying to clean
itself up, right.
That's kind of embarrassing, but
it's just to show like it's not
like a trivial thing to get
destruction order correct.
All right.

And let's go a bit further.
On iOS, this is what the
lifecycle in an application
looks like.
Right.
There's not really a logical
time for the application to shut
down.
There's times when it goes to
foreground, it goes to
background, and it goes away,
but like destruction, like the
application shutting down is not
really a thing that makes sense
with that type of lifecycle.

What you end up having is you
implement callbacks, something
like this, right, and then
you're told you're going to go
like in the background, you're
going to come back, something
like that.
Destructors don't really run in
a logical place.

So, if we go back to the code we
had earlier, right.
It's an application.

It has a logger.
This is what we wrote, well
there's not really a logical
time for this logger to flush
its buffer, right.
But the, like in the destructor.

What you really want to do is
say well, if you're going to go
in the background, please flush
the buffer first, right.
So you don't have any cleanup to
do in the destructor.

It's kind of silly to have a
destructor.
There's a bunch of code that
gets generated for nothing,
right.
So, we added, as of Xcode 11 is
an attribute that allows you to
say, hey, don't destroy this
thing, right.

It's global.
It doesn't need to have a
destructor.

Of course, you're still going to
flush manually when a callback
happens, and you can go into
your entire application in Xcode
and use the setting to do that
for the entire application.

It seems pretty trivial, but it
gives you, depending on how much
C++ you use in your code, maybe
like a 1 percent code size
reduction, right, which is
pretty nice.

So, I'm going to tell you about
five diagnostics that are all on
by default in Xcode 11.

The first one is
call-to-pure-virtual function
from a constructor or a
destructor.
What does that mean?
So let's write some good
object-oriented code starting
with a table.
All right.

So, I have this table here, and
I go and I want to have a pure
virtual function to illustrate
what I'm talking about.
So, I'm going to go and write
this galahad function that's
pure virtual, and I'm going to
have a destructor for the table,
and when the table gets
destroyed, I'm going to say,
galahad, please go and find the
grip, right.

It makes a lot of sense.
So, I do that, and I get a
warning.

The reason you get this new
warning as of Xcode 11 is
because calling a pure virtual
function from a constructor or a
destructor really doesn't make
sense.

There's nothing to call.
Because the table is the base
class, and the most derived
classes have already been
destroyed in this case, right.
So there's no implementation of
this galahad function to call
anymore.
So, how would you fix this?
Well, you could go, and in the
derived class that implements
galahad, its destructor could
call find galahad and return a
grail or something like that.
So that makes some sense.

All right.
Let's move onto another
diagnostic.

Memset with transposed
arguments.
So, say I have this struct
called inbox, right, and I have
a bunch of emails in it.
I come back from vacation, and
I'll get to inbox 0.
What do I do?
Well, I just memset the whole
inbox to 0.
Now, I wrote this code.
Who can spot the bug?
Right.
I've transposed the argument to
memset.

Like, I make that mistake
semi-frequently because I have
no idea what the order of
argument to memset is.
Whether the value I'm trying to
set destruct to is the first
argument or whether it's the
second one, right.
Whether it's the size that I'm
trying to set it to.
And so we now detect that as
Xcode 11, and we tell you about
it.
How do you fix it?
It's pretty simple; you just
flip the arguments around,
right.
Now, one thing you might want to
consider here is instead of
using memset, which is hard to
get, and even like look at that
code, it's still not obvious
that it's correct, right.
What you might want to do
instead is use something like
std::fill.
In some cases it makes sense.

You rewrite the code to look
something like that, and now
it's much harder to get wrong,
and it's easier to get what it's
doing.
Right.

So, that's kind of neat.
The third warning I want to tell
you about, return of std move.

So, move is a bit complicated in
C++, but there's a bunch of
diagnostics over time that help
you really use it the proper
way, right.
So, again, let's write an
object-oriented code to
understand what I'm talking
about here.

So, say I have three structs,
lion, goat, and snake, and love
object orientation, I'm going to
compose them into a chimara,
right.
Good code.

So, I go in and assign
bellerophon and I want to go
slay the chimara, and then
return with proof that I've
slain it.
Well, I now have a diagnostic
that tells me, hey, you know
what?
Like you're returning a chimara,
but you're just, like the return
type that you're returning is
actually just a goat, right.

So, I'm going to take that
vector, copy it over, because it
doesn't make sense to slice out
the vector out of the chimara
and put it into a goat instead.
Right. So, what you're doing
here, the code you wrote is
basically what you've been
trained to do related to
std::move.
You're trained to rely on
copy elision, right.

And most times, you don't need
to put a std::move when you do
return.

In this case you do because it
does a copy, right.
The language says returning,
just slicing out a part of the
class is kind of weird anyways.
Move shouldn't be implicit,
right.
So the warning tells that you
probably don't want to do this,
right.
So, first way to fix it, you go
in, you call std::move.

Right.
Now, that will move the vector
into the goat, right.

So it's much more efficient to
do the move this way.
So, another thing you might want
to do is well instead of
returning just the goat and
having like people trust you
that that's actually a chimara,
well you can just return a
chimara.

That makes sense, and here you
get copy elision, right.
If you were to add std::move,
the compiler would tell you that
you're pessimizing things by
adding the move.

Another thing you might want to
do because you're not sure if
you're going to get a chimara or
not is you might want to return
a std::optional with chimara,
which again does the right
thing.
It's not slicing things out of
the class and so the language
says, yes, this gets implicit
copy elision.
All right.

Another diagnostic I want to
tell you about,
size-of-pointer-div.

What does this look like?
Well, say I write this code.
Totally fine code.

No problem right now, right.
So, what I'm saying is I have
this array.

Take the size of the array
divided by the 0th element, and
that gives you the number of
elements inside the array.
That's really standard code for
C style code, right, a really
common idiom.
So, the problem here is if I
refactor this code and I do
something like this.
So, I pass the array as a
parameter instead.

Well, what happens here is that
the C rules say that the array
now decays to a pointer.

And the new diagnostic tells
you, hey, this probably doesn't
do what you want, right.

This won't return you the number
of elements in the array.
So, that's a problem.

We catch it.
How would you actually fix it?
Well, you could have written the
code a bit differently.
So, instead of using that idiom,
right, you could have gone in
and used something like
std::size, which means that
instead of refactoring the code
wrongly, you would have caught
that problem when you tried to
refactor it, right.

So std::size just does the right
thing here.
So that's a kind of a neat
warning that catches errors.
The last diagnostic I want to
tell you about is
defaulted-function-delete.
So, again, say I write this
beautiful code here, all right.

So, I have this struct
aberration.
It has some floating eyestalks,
some eyes and mouth, and I'm
like I want to default
aberration.

Please give me a default
aberration.
Well, the compiler comes in now
and tells you, hey I don't know
what a default aberration is.
Why not? Well, I have a float
reference, and I can't
synthesize the fault constructor
for that reference.

It's a type that I can't default
create.
Right.

So there's a bunch of other
ways, not just references in
C++, to create things that can't
be default constructed, and the
compiler now tells you about it.
If you ask for a default
constructor, and I can't give
you a default constructor, it'll
tell you.

So, how would you fix this?
Well, one way is to just create
the constructor yourself.

As you pass in the eyestalks,
that creates a reference
automatically.

That's kind of neat.
But personally, I think like
beauty is in the eye of the
beholder, but maybe this
aberration should be coded
differently and not have a float
reference, and maybe you should
just do this instead, right.
That makes a lot of sense,
right.
So, now I can default create to
the aberration.

All right.
So, that was the diagnostics I
wanted to the tell you about.

Now, I'm going to hand it off to
Devin, who's going to tell you
about New Static Analyzer
Checks.
Up until this point in the
talk, the warnings that we've
told you about have come from
the compiler when you build.

But we have other tools that can
help you find bugs.
One of them is the static
analyzer.
The analyzer finds deep bugs in
your code, and it can do it
without even running your app.
This makes it great at testing
and catching those
hard-to-reproduce bugs that you
never even thought to write
tests for.

And it can even show you the
sequence of steps along which
the bug manifests.

This makes it easy to understand
the problem and fix it.
Today, I'm going to tell you
about three new C++ checks that
we've added.
A check for use after move bugs,
a check for dangling C string
pointers with C++ std::string
and to check for reference
counting bugs in the new
DriverKit and in IOKit.
Let's start with use after move.

In C++, moves allow you to avoid
unwanted copies.
And here's an example of where
you might want to do that.
Let's suppose that I have
written a novel, and for those
of you who know me, I can be
quite verbose.
And so, I don't want to pay the
performance cost of copying the
entire text of the novel when I
hand it off to my publisher.

So, I'll use a move.
This moves from the source
variable rather than copying it.

And what's great about this is
that it allows me to enforce a
unique ownership semantics where
there's no confusion about who
has the latest version of the
novel, me or my publisher.

But I do need to be careful
here, and that's because moves
leave the source in an
unspecified state.
Let's see how this can go wrong.
Suppose I were to add a call to
spell check my novel after I
published it.
This can have unexpected results
or even crash depending on the
implementation of the book type.
Fortunately, the static analyzer
can now catch this bug.
To fix this, what I should do is
reorder the code.

It really does make sense to
spell check the novel before I
publish it.

All right.
Let's move on to dangling
pointers from std::string.

Those of you who have mixed C++
and C strings know that this can
be really tricky, and here's an
example.
I've created this
generateGreeting function.

It takes in a C string name and
returns a C string greeting.
And in the implementation of
this function, I've chosen to
use a C++ std::string because
it's easier to manipulate.

I declare a std::string local
variable, initialize it to
hello, append the passed in name
and then, because the function
returns a C string, I call the c
str method on the C++ string,
and that's where things start to
go wrong.
And the key thing to note here
is that c str returns an inner
pointer to a buffer inside of
the std::string.

And this buffer is deallocated
when the std::string goes out of
scope.

What this means is that I'm
returning a pointer to memory
that will be deallocated, and
then when I use that memory, the
program could crash.
The static analyzer can now
catch this bug.
So how should I fix this?
Well, we recommend matching the
lifetimes of your C++ and C
strings.
Here, I have changed the
generateGreeting function to
return a std::string, and then I
store the result into a local
variable.
This means that when I call the
c str method that local variable
stays in scope for as long as I
need to use the C string.
In essence, what I have done
here is change the scope of the
std::string to last as long as I
need it.

And I will note that it's often
easier to stay within the C++
world as long as possible and
only get the C string out at
exactly the moment where I need
it.

All right.
So, let's move on to the third
and final check I'm going to
tell you about, for Reference
Counting bugs in DriverKit and
IOKit.

These driver frameworks use
Manual Retain/Release for their
memory management.

And for those of you who are
familiar with CoreFoundation or
with Objective-C without
Automated Reference Counting,
it's very similar.
Manual Retain/Release gives you
a lot of control over memory
management, but it does come
with some additional
responsibilities.
You need to be careful to not
over release memory, because if
you do so, it could be
deallocated, and then when you
use it, your program could
crash.
Similarly, you should not
under-release your memory
because the memory could leak.
Let me give you an example of a
leak.

Here, I've written some code
that allocates a new array of
devices.

It then fills in those devices
and sets them up.
And the key thing to note here
is that OSArray::withCapacity,
it allocates a new array and
returns it retained.

What this means is that the
array will leak if it's not
released.

The analyzer can now catch this
bug.
So, how should I fix this?
All I need to do is make sure to
release the array when I'm done
with it.

Now, the memory management rules
are all based around naming
conventions, and these are very
similar in spirit to
CoreFoundation and Objective-C
under Manual Retain/Release.

But I do want to point out one
key difference for IOKit and
DriverKit, and that is that the
default convention is to return
retained.
Or, as we sometimes call it, at
+1.
What this means is that clients
must call release on the result
of a method that they call.
Otherwise, the object could
leak.

An important exception to this
rule is that getters return
unretained, or as we call it, at
+0.
Clients should not release the
result of a getter.

Now, you might write code that
differs from this convention,
and here's an example of some
code that I wrote.
This method finds the first
device in an array, and it has
the default convention.
It should return retained.
But if we look at the
implementation, it returns the
result of a getter, and getters
return unretained.

So, there's a mismatch here.
Fortunately, the analyzer can
tell us about this.

So, how should I fix this?
Well, I have three different
options.

The first is to change the
behavior to follow the
convention.

Here, the convention is that the
method should return retained,
so I could retain the result
before returning it.
Another possibility is to rename
the method.

And if I look at this
findFirstDevice method, it looks
a lot like a getter.

So, I could just rename it to
getFirstDevice, and that would
follow the guidelines.

But you might have a method that
has the behavior that you want,
and it has the perfect name.

You don't want to change it, and
that's okay.
What you should do in this case
is add an annotation to tell
both readers of your code and
the analyzer that you're not
following the convention on
purpose.
In this case, I can add the
DRIVERKIT RETURNS NOT RETAINED
annotation to express my intent.
So, if you have an IOKit driver
or you're writing a new
DriverKit driver, I highly
encourage you to run the
analyzer on your code.
To do that, all you need to do
is go to Xcode's product menu
and choose analyze.
And you can even have Xcode run
the analyzer every time you hit
build by going to your target's
build settings and enabling
Analyze During Build.

This will help you catch your
bugs before you even commit
them.

All right, so we told you about
a lot today.
We showed you how LLVM Bitcode
enabled a seamless 64-bit
transition for watchOS where
your 32-bit apps worked on day
one with Series 4 watches.
We showed you how to reduce code
size with new compiler
optimizations and language
features and how to run the
static analyzer on your code.

For more information, please
check out our session website,
and we really look forward to
talking with you in the labs.
Thank you.

Looking for something specific? Enter a topic above and jump straight to the good stuff.