Abe Skolnik. Presentation #1: An Introduction to MyGCC

Size: px

Start display at page:

Download "Abe Skolnik. Presentation #1: An Introduction to MyGCC"

Branden Bridges
5 years ago
Views:

1 Abe Skolnik Presentation #1: An Introduction to MyGCC

2 What is MyGCC? MyGCC is a variation on GCC which adds customizable intraprocedural verification abilities to the existing abilities of GCC. What is GCC? The GNU Compiler Collection (formerly the GNU C Compiler) The #1 Open Source and Free Software compiler [collection] A crucial component of all GNU/Linux and BSD operating systems produced to date GNU stands for GNU is Not Unix Like all official GNU projects, GCC is governed by the Free Software Foundation GNU

3 Who, When, and Where MyGCC was started in 2004 by Dr. Nic Volanschi Dr. Sebastian Pop joined Dr. Volanschi in 2006 MyGCC was developed in France Nic Volanschi Sebastian Pop

4 Why Implementing software verification inside GCC allows us to: leverage the language front ends for lexical and syntactic analysis (resulting in a verifier for more than one language) create a software verifier that does not depend on a specific target CPU or OS (the system for running the new program) create a software verifier that does not depend on a specific host CPU or OS (the system for running the verifier) How MyGCC operates on GCC's GIMPLE intermediate representation A domain-specific language called Condate is used to specify the code attributes to be tested Simple Condate expressions may be entered on the same command line that is used for requesting compilation and/or verification More complex Condate rules may be entered into text files and used later The expressions and rules define Constrained Reachability Queries

5 Some of the Pros and Cons of MyGCC Pros Open Source Free (both as in zero-cost and as in freedom) Based on a proven, time-tested system (GCC) Able to be applied to multiple source-code languages Extensible Designed for eventual inclusion into normal GCC Cons Not suitable as the basis for a commercial product Does not include a library of pre-defined tests Knowledge of Condate is needed for full effectiveness

6 How to get MyGCC working on your system (1) For an x86-based machine (or virtual machine) with GNU/Linux installed Download the precompiled tarball, extract it to your location of choice (recommendation: use /opt/mygcc if you can), and it should just work. (2) For all other POSIX/UNIX-compatible environments Download the source tarball, extract it to your location of choice (recommendation: use /usr/src/mygcc if you can), and compile. (3) For a machine afflicted with Microsoft Windows and lacking CygWin Download and install CygWin, then proceed to (2). (4) For all other environments Download and install an x86 emulator/simulator/virtualizer (as appropriate), then either download a ready-made GNU/Linux virtual machine (e.g. from or from or install your preferred GNU/Linux distribution as for a real machine, then proceed to (1).

7 A trivial example of using MyGCC To have MyGCC report every assignment in a C program as if it were an error, we can use the following command: mygcc_installed_path/bin/gcc --tree-check="%x=%y" example.c which will cause output similar to the following: example.c:7: warning: user-defined warning %X=%Y:. example.c:7: instance = {X <- i, Y <- 0}, example.c:7: reached: i = 0. if the file example.c contains the assignment i=0 on line 7. A non-trivial Condate rule Here is an example of a rule that catches the case of a subroutine returning without releasing a lock that it acquired. condate missing_unlock { from "flockfile (%X)" to ("return" or "return %_") avoid "funlockfile (%X)" } warning("unreleased lock on file X"); If this rule is stored in a file named unlock.check, then it can be used like so: mygcc_installed_path/bin/gcc --tree-checks="unlock.check" example.c

8 Proven effectiveness when used expertly The author[s] of MyGCC used it to check parts of the Linux kernel, analyzing the source code of version at a time when that was already an old version, to see which of the already-reported bugs it found, how many false positives it generated, and also to compare its performance to that of another (much more complex) software verifier. This more-complex verifier, formerly the Meta-level Compilation (MC) project of Stanford University, which is now [a] commercial product[s] sold by Coverity Incorporated, had already been used on the same source code, and the results of that analysis had already been published. Here is a summary of the results from the MyGCC analysis. Number of known bugs: >100 Number of false negatives: 4 Number of false positives: 2 Number of new bugs found by MyGCC that had not been found by MC: 4 Source:

9 Web domains for further reading MyGCC: mygcc.free.fr Normal GCC: gcc.gnu.org GNU: The Free Software Foundation:

Checking System Rules Using System-Specific, Programmer- Written Compiler Extensions

Motivation for using Checking System Rules Using System-Specific, Programmer- Written Compiler Extensions Dawson Engler Benjamin Chelf Andy Chou Seth Hallem 1 Computer Systems Laboratory Stanford University