1) Stack-use-after-scope detector in AddressSanitizer - Vitaly Buka
Stack-use-after-scope is the check in AddressSanitizer which detects access to variables from outside the scope it was declared. This talk covers issues we had to resolve to make the feature usable, results of applying the check to the Google code, and examples of bugs it detected.
2) How compiler frontend is different from what IDE needs? - Ilya Biryukov
We’ve been writing our own C++ frontends at JetBrains for a few years now. Given that most people use clang these days, this may come as a surprise that we don’t. In this small talk we’ll cover the reasons that were driving our decision to roll out our own implementation and try to highlight how it’s different from what’s being done in clang.
3) Enabling Polyhedral Optimizations in Julia - Matthias Reisinger
Julia is a relatively young programming language with a focus on technical computing. While being dynamic it is designed to achieve high performance comparable to that of statically compiled languages. The execution of Julia programs is driven by a just-in-time compiler that relies on LLVM to produce efficient code at run-time. This talk highlights the recent integration of Polly into this environment which has enabled the use of polyhedral optimization in Julia programs.
4) Extending Clang AST Matchers to Preprocessor Constructs - Jeff Trull
Clang's libTooling provides powerful mechanisms for identifying and modifying source code via the AST. However, parts of the source code are hidden or obfuscated from these tools due to the action of the preprocessor. This is particularly true of legacy code, where applying refactoring tools is highly desirable. The speaker will demonstrate how to write an AST Matcher that identifies sections of code associated with preprocessor conditional directives, and will make suggestions on how to improve tooling in this area.
5) SMACK Software Verification Toolchain - Zvonimir Rakamaric
Tool prototyping is an essential step in developing novel software verification algorithms and techniques. However, implementing a verifier prototype that can handle real-world programs is a large endeavor. In this talk, we present the SMACK software verification toolchain. SMACK provides a modular and extensible software verification ecosystem that decouples the front-end source language details from back-end verification algorithms. It achieves that by translating from the LLVM compiler intermediate representation into the Boogie intermediate verification language. SMACK offers the following benefits: (1) it can be used as an automated off-the-shelf software verifier in an applied software verification project, (2) it enables researchers to rapidly develop and release new verification algorithms, and (3) it allows for adding support for new languages in its front-end. We have used SMACK to verify numerous C/C++ programs, including industry examples, showing it is mature and competitive. Likewise, SMACK is already being used in several existing verification projects.
6) Finding code clones in the AST with clang - Raphael Isemann
This talk will introduce clang’s new clone detection framework that uses hash-code comparison to search for groups of AST nodes that are similar in a certain configurable sense.
