[analyzer][www] Add more open projects

[george.karpenkov]

Summary

Added some extra tasks to the open projects. These are the ideas of @NoQ and @george.karpenkov, I just converted them to HTML.

[Szelethus]

Mind you, there are some ideas I didn't add to the list -- I just don't know how to put them to words nicely, but I'm on it.

@NoQ mentioned

• Enhancing constraint solving. I just simply lack the knowledge to make an entry here about it.
• Fixing up taint analysis.

@george.karpenkov mentioned assigning a unique error code to each analyzer warning, and maintaining it on the website.

Also, a lot of items on this list is outdated, but I joined the project relatively recently, so I'm not sure what's the state on all of them.

[NoQ]

Whoa thanks! Will have a closer look again.

www/analyzer/open_projects.html

33

I'll try to list other constructor kinds that i have in mind.

76

Typo: methods.

86–87

I'll try to be more, emm, positive on the website :]

234

Typo: However.

235

Typo: Development.

262

Something is unfinished here.

[Szelethus]

Thanks!

I admit that the difficulty was mostly chosen at random, so that could be brought closer to the actual difficulty of the project.

www/analyzer/open_projects.html

86–87

Oh, right, sorry, I tried to "positivitize" most of these, but apparently missed this one O:)

[MTC]

In D53024#1258976, @Szelethus wrote:

Also, a lot of items on this list is outdated, but I joined the project relatively recently, so I'm not sure what's the state on all of them.

AFAIK, the items below is outdated.

• Enhance CFG to model C++ temporaries properly (This problem has basically been fixed by @NoQ.)
• Enhance CFG to model C++ new more precisely (This problem has basically been fixed by @NoQ.)
• Implement iterators invalidation checker (IIRC, @baloghadamsoftware has solved this, see IteratorChecker.cpp.)
• Write checkers which catch Copy and Paste errors (IIRC, @teemperor has solved this, see CloneChecker.cpp)
• Enhance CFG to model C++ delete more precisely (@blitz.opensource's focus is no longer on clang static analyzer, so we should not keep him as current contact.).

And there are items, I'm not sure what the current state is. Like:

• Explicitly model standard library functions with BodyFarm. (This item is marked as ongoing, it doesn't look very active nowadays.)

If I'm wrong, @NoQ and @george.karpenkov, please correct me. In addition 2018 Bay Area LLVM Developers' Meetings may bring some new open projects :), see http://llvm.org/devmtg/2018-10/talk-abstracts.html#bof6.

At the end, there are some punctuation problems, yea, I browsed this page through the browser :).

www/analyzer/open_projects.html

98

“this function is pure” -> "this function is pure"

100

“partial -> "partial

259

Also here? “Schrödinger state” -> "Schrödinger state"

267

can‘t -> can't

268

there‘s -> there's
aren‘t -> aren't

[Szelethus]

• Fixed typos
• Fixed stupid characters (Thank you so much @MTC for going the extra mile and opening this patch in a browser!)
• Removed outdated entries as mentioned by @MTC

[NoQ]

In addition 2018 Bay Area LLVM Developers' Meetings may bring some new open projects :)

Actually, let's commit this before the conference, even if it's not perfect, so that people who suddenly get inspired to work on Static Analyzer already had an updated list :)

www/analyzer/open_projects.html

29

@george.karpenkov your turn here.

33

Actually, maybe let's turn this into a single project with sub-bullets and list all problems instead of just one.

Ok if i just dump my thoughts with markdown? >_<

Something like:

• Handle more ways of constructing C++ objects by identifying ConstructionContexts in the CFG and using them to identify and track the object until the permanent storage for the object is evaluated.
  • Constructors of fields and [[since C++17] base classes] of aggregates. When aggregates are brace-initialized, their own trivial constructor does not happen, but the constructor for sub-objects does. It would be necessary to see beyond the InitListExpr in order to find out which field of which aggregate is actually constructed. Because brace initializers can be nested, ConstructionContext for this constructor would potentially contain an indefinite amount of intermediate InitListExprs. Additionally, if the field is of reference type, lifetime extension needs to be modeled.
  • Constructors within new[]. Once an array of objects is allocated via operator new[], constructors for all elements of the array are called. Arguably, we should evaluate at least a few of them, as if it was some sort of loop. The same applies to destructors within delete[]. ConstructionContext is already available here, so it is likely that there's no CFG work required, though indicating the presence of a loopy control flow in the CFG might be helpful.
  • Constructors that can be elided due to Named Return Value Optimization (NRVO). If a local variable within a function is of object type and is returned by value on all return statements, then the compiler is allowed (but not required to, even in C++17) to immediately store this variable at the address into which the function would put the return value, thereby skipping ("eliding") copy/move constructor call (even if it has user-visible side effects). Variables eligible for NRVO can be easily identified in the AST via VarDecl::isNRVOVariable(), so no CFG work is necessary here, but Static Analyzer needs to realize that the respecitive VarRegion should be entirely replaced with the return region of the function for the whole duration of the respective stack frame.
  • Constructors of virtual method arguments. Constructors of function arguments are already supported, but Static Analyzer has problems finding the correct parameter variable declaration and the correct stack frame for the object under construction if it doesn't know how exactly a virtual call is devirtualized. It might help to simplify the identity of the parameter region to exclude the Decl of the callee and its parameters from its identity.
  • Constructors of default arguments. In C++ functions can have default values for parameters that are re-computed at run-time every time the the function is called without specifying the argument explicitly. There isn't much difference between default arguments and normal arguments when it comes to ConstructionContext-related problems. But the actual problem here is that the expression that initializes the parameter is not part of the current stack frame, but instead lives in the middle of nowhere within the parameter declaration. This means that if two calls of the same function with defaulted arguments are present within the same full-expression, we may accidentally assign two different values (corresponding to two different default argument objects) to the same expression in the Environment, which is incorrect. One of the possible solutions is to define an additional LocationContext to discriminate between different default argument evaluations, similarly to how StackFrameContext allows discriminating between values of the same expression on different layers of recursion.
  • Constructors that perform lambda captures. If a lambda captures a variable of object type by value, the object needs to be copied into the lambda, which implies calling a copy-constructor. A new kind of ConstructionContext would need to be defined in order to identify the memory region occupied by the lambda object (most likely a MaterializeTemporaryExpr that surrounds the LambdaExpr) and the sub-region that corresponds to the implicit field of the lambda object that contains the capture.

(Difficulty: Medium)

69

"supporting all of them" -> "modeling all methods in all classes of the standard library"

70

Maybe move "One good thing to start..." into a sub-bullet?

86–87

"Pointer-to-pointer casts are also causing a surprising amount of problems. The decision to re-use ElementRegion to track the type of the object behind the pointer value seems to create more problems than it solves, but..."

108–115

Let's move this into a sub-bullet of "Enhance the modeling of the standard library." and remove the part about std::string, but instead say "This is often effective for simple C functions such as atomic builtins and certain related threading functions (such as call_once) because atomicity doesn't have any meaning for Static Analyzer and can be completely ignored. This approach is not recommended for functions dealing with complicated C++ code - temporaries, templates - unless you have unbelievably good AST handwriting and recite all supported versions of the C++ standard by heart."

158

Let's move this into the construction context bullet. I think we do call the destructor now but it might be that we don't call the custom delete operator.

191

Let's mark this with "Refactoring: ".

322

This should be removed because we already have a bullet for this.

[george.karpenkov]

@Szelethus I take it this is mostly formed from @NoQ email? Language could use polishing in quite a few places, could I just commandeer this revision and try to fix it?

www/analyzer/open_projects.html

29

Let's just skip it.
I suspect the explanation would not benefit here, because a large body of assumed knowledge would be required to take on the project.

328

This is handled by Z3 invalidation, I'm not sure it's worth it spending much effort here in the long run.

[Szelethus]

In D53024#1262976, @george.karpenkov wrote:

@Szelethus I take it this is mostly formed from @NoQ email? Language could use polishing in quite a few places, could I just commandeer this revision and try to fix it?

Yes it is. Though the other item you mentioned should be on this list -- I just simply forgot to put it there before updating the diff O:). Feel free to commandeer it, this patch is barely my work.

[george.karpenkov]

I have tried to clean up the list.

[Szelethus]

Thanks, this looks great!

[george.karpenkov]

@Szelethus thanks! BTW if you really want to invest into maintaining the website,
I think it's totally worth it to change all contents to markdown,
and then have a script to generate HTML from that.
Committers would be expected to manually run that script.
This would also solve our problem with the disappearing header.

[Szelethus]

I dislike web development, but that would indeed be invaluable. I'll take a look.

[NoQ]

clang/www/analyzer/open_projects.html

27–32 ↗

(On Diff #169758)

This is extremely important to get right. Alpha doesn't mean "i did an experiment, let me dump my code so that it wasn't lost, maybe others will pick it up and turn it into a useful checker if they figure out how". Alpha doesn't mean "a checker that power-users can use at their own risk when they want to find more bugs". Alpha doesn't mean "i think this checker is great but maintainers think it's bad so they keep me in alpha but i'm happy because i can write in my resume that i'm an llvm contributor". All of these are super popular misconceptions.

Alpha means "i'm working on it". That's it.

Let's re-phrase to something like: "When a new checker is being developed incrementally, it is committed into clang and is put into the hidden "alpha" package (from "alpha version"). Ideally, once all desired functionality of the checker is implemented, checker should be moved out of the alpha package and become enabled by default or recommended to opt-in into, but development of many alpha checkers has stalled over the years."

80 ↗

(On Diff #169758)

I guess let's add the rest of the constructors from my message above.

88–89 ↗

(On Diff #169758)

Something's wrong here.

[NoQ]

Other than that, the current text looks great.

[Szelethus]

This comment has been deleted.

clang/www/analyzer/open_projects.html

153 ↗

(On Diff #169758)

Did you mean to have this newline here? Difficulty seems to have a weird placement when viewed in a browser.

[george.karpenkov]

clang/www/analyzer/open_projects.html

27–32 ↗

(On Diff #169758)

Let's ignore (3) as a red herring, but I'm not sure I see the difference between (1), (2) and (4). When someone works actively on a checker, but then stops, it immediately transfers from state (4) to state (2) and optionally (1)

80 ↗

(On Diff #169758)

What message above? The original email?

[NoQ]

clang/www/analyzer/open_projects.html

27–32 ↗

(On Diff #169758)

This is kinda mostly about the attitude with which people should put stuff into the alpha package. Yeah, if someone stops for inevitable reasons, then we're inevitably left with unmaintained experimental code in the repo, i guess that's why this section exists. But contributors shouldn't plan for this from the start. A lot of contributors literally believe that alpha is by design a stockpile of incomplete work and weird experiments and it'll make everybody happy if they add more incomplete work and weird experiments into it, i myself misunderstood this for a long time and i want to address this misconception.

[NoQ]

Ok, let's see if this actually works :)

[dkrupp]

www/analyzer/open_projects.html

322

Probably it is worth mentioning here, that there is a macro language already for describing summaries of standard library functions in StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp.

This macro language could be refactored to a separate header file so it could be used in other checkers too. Could also be extended for C++.

Another useful addition would be to enable users to describe these summaries in run-time (in YAML files for example) to be able to model their own proprietary library functions.

Then as a next step we could introduce a flow sensitive analysis to generate such summaries automatically. Which is a hard problem indeed, the others above should not be too difficult

www/analyzer/open_projects.html

 is an addition to the <a href="potential_checkers.html">potential checkers 
 list</a>. If you are interested in tackling one of these, please send an email 
 to the <a href=http://lists.llvm.org/mailman/listinfo/cfe-dev>cfe-dev
 mailing list</a> to notify other members of the community.</p>
 
 <ul>  
   <li>Core Analyzer Infrastructure
   <ul>
+    <li>Implement a dataflow flamework.
+    <p><!-- TODO: Explain. -->
+    <i> (Difficulty: Hard) </i></p>
+    </li>
+
+    <li>Handle aggregate construction.
+    <p>Aggregates are object that can be brace-initialized without calling a
+    constructor (i.e., no <code><a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">
+    CXXConstructExpr</a></code> in the AST), but potentially calling
+    constructors for their fields and (since C++17) base classes - and these
+    constructors of sub-objects need to know what object (field in the
+    aggregate) they are constructing. Moreover, if the aggregate contains
+    references, lifetime extension needs to be modeled. Aggregates can be
+    nested, so <code><a href="https://clang.llvm.org/doxygen/classclang_1_1ConstructionContext.html">
+    ConstructionContext</a></code> can potentially cover an unlimited amount of
+    statements. One can start untangling this problem by trying to replace the
+    hacky <code><a href="https://clang.llvm.org/doxygen/classclang_1_1ParentMap.html">
+    ParentMap</a></code> lookup in <a href="https://clang.llvm.org/doxygen/ExprEngineCXX_8cpp_source.html#l00430">
+    <code>CXXConstructExpr::CK_NonVirtualBase</code> branch of
+    <code>ExprEngine::VisitCXXConstructExpr()</code></a> with some actual
+    support for the feature.
+    <i> (Difficulty: Medium) </i></p>
+    </li>
+
+    <li>Fix CFG for GNU "binary conditional" operator <code>?:</code>.
+    <p>CFG for GNU "binary conditional" operator <code>?:</code> is broken in
+    C++. Its condition-and-LHS need to only be evaluated once.
+    <i>(Difficulty: Easy)</i><p>
+    </li>
+
+    <li>Handle unions.
+    <p>Currently in the analyzer, the value of a union is always regarded as
+    unknown. There has been some discussion about this on the <a href="http://lists.llvm.org/pipermail/cfe-dev/2017-March/052864.html">
+    mailing list already</a>, but it is still an untouched area.
+    <i> (Difficulty: Medium) </i></p>
+    </li>
+
+    <li>Enhance the modeling of the standard library.
+    <p>There is a huge amount of checker work for teaching the Static Analyzer
+    about the C++ standard library. It is very easy to explain to the static
+    analyzer that calling <code>.length()</code> on an empty <code>std::string
+    </code> will yield 0, and vice versa, but supporting all of them is a huge
+    amount of work. One good thing to start with here would be to notice that
+    inlining methods of C++ "containers" is currently outright forbidden in
+    order to suppress a lot of false alarms due to weird <code>assume()</code>s
+    made within inlined methods. There’s a hypothesis that these suppressions
+    should have been instead implemented as bug report visitors, which would
+    still suppress false positives, but will not prevent us from inlining the 
+    ethods, and therefore will not cause other false positives. Verifying this
+    hypothesis would be a wonderful accomplishment. Previous understanding of
+    the "inlined defensive checks" problem is a pre-requisite for this project.
+    <i>(Difficulty: Medium)</i><p>
+    </li>
+
+    <li>Reimplement the representation for various symbolic values.
+    <p><code><a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1nonloc_1_1LocAsInteger.html">
+    LocAsInteger</a></code> is annoying, but alternatives are vague. Casts into
+    the opposite direction - integers to pointers - are completely unsupported.
+    Pointer-to-pointer casts are a mess; modeling them with <code><a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1ElementRegion.html">
+    ElementRegion </a></code> is a disaster and we are suffering a lot from this
+    hack, but coming up with a significantly better solution is very hard, as
+    there are a lot of corner-cases to cover, and it’s hard to maintain balance
+    between richness of our representation of symbolic values and our ability to
+    understand when the two different values in fact represent the same thing.
+    <i>(Difficulty: Hard)</i><p>
+    </li>
+
+    <li> Provide better alternatives to inlining.
+    <p>Sometimes instead of inlining, a much simpler behavior would be more
+    efficient. For instance, if the function is pure, then a single bit of
+    information “this function is pure” would already be much better than
+    conservative evaluation, and sometimes good enough to make inlining not
+    worth the effort. Gathering such snippets of information - “partial
+    summaries" - automatically, from the more simple to the more complex
+    summaries, and re-using them later, probably across translation units, might
+    improve our analysis quite a lot, while being something that can be worked
+    on incrementally and doesn’t require checkers to react immediately.
+    <i>(Difficulty: Hard)</i><p>
+    </li>
+
     <li>Explicitly model standard library functions with <tt>BodyFarm</tt>.
     <p><tt><a href="http://clang.llvm.org/doxygen/classclang_1_1BodyFarm.html">BodyFarm</a></tt> 
     allows the analyzer to explicitly model functions whose definitions are 
     not available during analysis. Modeling more of the widely used functions 
     (such as the members of <tt>std::string</tt>) will improve precision of the
     analysis. 
     <i>(Difficulty: Easy, ongoing)</i><p>
     </li>
 
     <li>Handle floating-point values.
     <p>Currently, the analyzer treats all floating-point values as unknown.
     However, we already have most of the infrastructure we need to handle
     floats: RangeConstraintManager. This would involve adding a new SVal kind
     for constant floats, generalizing the constraint manager to handle floats
     and integers equally, and auditing existing code to make sure it doesn't
     make untoward assumptions.
     <i> (Difficulty: Medium)</i></p>
     </li>
     
     <li>Implement generalized loop execution modeling.
     <p>Currently, the analyzer simply unrolls each loop <tt>N</tt> times. This 
     means that it will not execute any code after the loop if the loop is 
     guaranteed to execute more than <tt>N</tt> times. This results in lost 
     basic block coverage. We could continue exploring the path if we could 
     model a generic <tt>i</tt>-th iteration of a loop.
     <i> (Difficulty: Hard)</i></p>
     </li>
 
     <li>Enhance CFG to model C++ temporaries properly.
     <p>There is an existing implementation of this, but it's not complete and
     is disabled in the analyzer.
     <i>(Difficulty: Medium; current contact: Alex McCarthy)</i></p>    
+    </li>
 
     <li>Enhance CFG to model exception-handling properly.
     <p>Currently exceptions are treated as "black holes", and exception-handling
     control structures are poorly modeled (to be conservative). This could be
     much improved for both C++ and Objective-C exceptions.
     <i>(Difficulty: Medium)</i></p>    
+    </li>
 
     <li>Enhance CFG to model C++ <code>new</code> more precisely.
     <p>The current representation of <code>new</code> does not provide an easy
     way for the analyzer to model the call to a memory allocation function
     (<code>operator new</code>), then initialize the result with a constructor
     call. The problem is discussed at length in
     <a href="http://llvm.org/bugs/show_bug.cgi?id=12014">PR12014</a>.
     <i>(Difficulty: Easy; current contact: Karthik Bhat)</i></p>
+    </li>
 
     <li>Enhance CFG to model C++ <code>delete</code> more precisely.
     <p>Similarly, the representation of <code>delete</code> does not include
     the call to the destructor, followed by the call to the deallocation
     function (<code>operator delete</code>). One particular issue 
     (<tt>noreturn</tt> destructors) is discussed in
     <a href="http://llvm.org/bugs/show_bug.cgi?id=15599">PR15599</a>
     <i>(Difficulty: Easy; current contact: Karthik Bhat)</i></p>    
+    </li>
 
     <li>Implement a BitwiseConstraintManager to handle <a href="http://llvm.org/bugs/show_bug.cgi?id=3098">PR3098</a>.
     <p>Constraints on the bits of an integer are not easily representable as
     ranges. A bitwise constraint manager would model constraints such as "bit 32
     is known to be 1". This would help code that made use of bitmasks</code>.
     <i>(Difficulty: Medium)</i></p>
     </li>
 
     <li>Track type info through casts more precisely.
     <p>The DynamicTypePropagation checker is in charge of inferring a region's
     dynamic type based on what operations the code is performing. Casts are a
     rich source of type information that the analyzer currently ignores. They
     are tricky to get right, but might have very useful consequences.
-    <i>(Difficulty: Medium)</i></p>    
+    <i>(Difficulty: Medium)</i></p>
+    </li>
 
     <li>Design and implement alpha-renaming.
     <p>Implement unifying two symbolic values along a path after they are 
     determined to be equal via comparison. This would allow us to reduce the 
     number of false positives and would be a building step to more advanced 
     analyses, such as summary-based interprocedural and cross-translation-unit 
     analysis. 
     <i>(Difficulty: Hard)</i></p>
-    </li>    
+    </li>
+
+    <li>Make the values in <code><a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1Environment.html">
+    Environment</a></code> immutable
+    <p>Values in the <code><a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1Environment.html">
+    Environment</a></code> should never change. Once value of an expression is
+    computed, it remains the same until the expression goes out of scope, so the
+    operation of substituting a value in <code><a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1Environment.html">
+    Environment</a></code> should have never been supported. Unfortunately,
+    adding such assertion crashes an awful lot of tests, because <code><a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1Environment.html">
+    Environment</a></code> is used for a lot of weird hacks even while modeling
+    simple operations like <code>+=</code>. 
+    <i>(Difficulty: Medium)</i></p>
+    </li>
+
+    <li>Enforcing the invariant that glvalue expressions and pointer-type
+    prvalue expressions have <code><a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1Loc.html">
+    Loc</a></code> values, other prvalue expressions have <code><a href="https://clang.llvm.org/doxygen/classclang_1_1ento_1_1NonLoc.html">
+    NonLoc</a></code> values.
+    <i>(Difficulty: Medium)</i></p>
+    </li>
+    
+    <li>Refactor <code><a href="https://clang.llvm.org/doxygen/namespaceclang_1_1ento_1_1bugreporter.html#a532da89ff4c3d8214a04da342a553dc5">
+    trackExpressionValue</a></code>.
+    <p>The process of tracking values is very unclear. One should understand the
+    basic simple idea behind the solution and then throw away the existing code
+    and implement the clean solution.
+    <i>(Difficulty: Medium)</i></p>
+    </li>
   </ul>
   </li>
 
   <li>Bug Reporting 
   <ul>
     <li>Refactor path diagnostic generation in <a href="http://clang.llvm.org/doxygen/BugReporter_8cpp_source.html">BugReporter.cpp</a>.
     <p>It would be great to have more code reuse between "Minimal" and 
     "Extensive" PathDiagnostic generation algorithms. One idea is to create an 
     IR for representing path diagnostics, which would be later be used to 
     generate minimal or extensive report output. <i>(Difficulty: Medium)</i></p>
     </li>
   </ul>
   </li>
 
+  <li>Move checkers out of alpha
+  <p>Because LLVM doesn't have branches, unfinished checkers first land in
+  alpha, and are only moved out once they are production-ready. Howeever, over
+  the years many checkers got stuck in alpha, and their developtment have
+  stalled.
+  <p>Checkers that presumably can't be made to work should be removed from the
+  trunk and the rest should ideally be finished.
+  <ul>
+    <li><code>alpha.security.ArrayBound</code> and <code>
+    alpha.security.ArrayBoundV2</code>
+    <p>Array bounds checker is a very wanted feature, but it doesn’t sound like
+    we can fix all of its false positives without full-featured loop widening
+    support. At the same time, array bound violations based on <b>tainted</b>
+    index values sound like a much more possible task.
+    <i>(Difficulty: Medium)</i></p>
+    </li>
+
+    <li><code>alpha.cplusplus.MisusedMovedObject</code>
+    <p>Something needs to be done about false positives caused by classes that
+    can in fact be used after being moved from, i.e. the empty space that
+    remains after the move has well-defined contents. This is not the case for
+    STL objects, but this is the case for many other user-defined objects.
+    <i>(Difficulty: Easy)</i></p>
+    </li>
+
+    <li><code>alpha.unix.Stream</code>
+    <p>One of the more annoying parts in this is handling state splits for error
+    return values. A “Schrödinger state” technique that was first implemented in
+    the PthreadLockChecker (where a mutex was destroyed and not destroyed at the
+    same time, until the return value of pthread_mutex_destroy was checked by a
+    branch in the code).
+    <i>(Difficulty: Easy)</i></p>
+    </li>
+  
+    <li>Many alpha checks can be turned into opt-in lint-like checks
+    <p>Path-sensitive lint checks are interesting and they can’t be implemented
+    in clang-tidy and there’s clearly an interest in them, but we here aren’t
+    having enough maintenance power to respond to bugs and false positives. If
+    anybody with a maintainer attitude grabs takes responsibility of this part,
+    it may have a much better chance to grow and thrive.
+    <i>(Difficulty: Easy)</i></p>
+    </li>
+  </ul>
+  </li>
+
   <li>Other Infrastructure 
   <ul>
     <li>Rewrite <tt>scan-build</tt> (in Python).
     <p><i>(Difficulty: Easy)</i></p>
     </li>
 
     <li>Do a better job interposing on a compilation.
     <p>Currently, <tt>scan-build</tt> just sets the <tt>CC</tt> and <tt>CXX</tt>
<ul>
     <li>Extend Malloc checker with reasoning about custom allocator, 
     deallocator, and ownership-transfer functions.
     <p>This would require extending the MallocPessimistic checker to reason 
     about annotated functions. It is strongly desired that one would rely on 
     the <tt>analyzer_annotate</tt> attribute, as described above. 
     <i>(Difficulty: Easy)</i></p>
     </li>
 
     <li>Implement a BitwiseMaskingChecker to handle <a href="http://llvm.org/bugs/show_bug.cgi?id=16615">PR16615</a>.
-    <p>Symbolic expressions of the form <code>$sym &amp; CONSTANT</code> can range from 0 to <code>CONSTANT-</code>1 if CONSTANT is <code>2^n-1</code>, e.g. 0xFF (0b11111111), 0x7F (0b01111111), 0x3 (0b0011), 0xFFFF, etc. Even without handling general bitwise operations on symbols, we can at least bound the value of the resulting expression. Bonus points for handling masks followed by shifts, e.g. <code>($sym &amp; 0b1100) >> 2</code>.
+    <p>Symbolic expressions of the form <code>$sym &amp; CONSTANT</code> can
+    range from 0 to <code>CONSTANT-</code>1 if CONSTANT is <code>2^n-1</code>,
+    e.g. 0xFF (0b11111111), 0x7F (0b01111111), 0x3 (0b0011), 0xFFFF, etc. Even
+    without handling general bitwise operations on symbols, we can at least
+    bound the value of the resulting expression. Bonus points for handling masks
+    followed by shifts, e.g. <code>($sym &amp; 0b1100) >> 2</code>.
     <i>(Difficulty: Easy)</i></p>
     </li>
 
     <li>Implement iterators invalidation checker.
     <p><i>(Difficulty: Easy)</i></p>
     </li>
     
     <li>Write checkers which catch Copy and Paste errors.