| Copyright 2004 Linus Torvalds | |
| Copyright 2004 Pavel Machek <pavel@suse.cz> | |
| Using sparse for typechecking | |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| "__bitwise" is a type attribute, so you have to do something like this: | |
| typedef int __bitwise pm_request_t; | |
| enum pm_request { | |
| PM_SUSPEND = (__force pm_request_t) 1, | |
| PM_RESUME = (__force pm_request_t) 2 | |
| }; | |
| which makes PM_SUSPEND and PM_RESUME "bitwise" integers (the "__force" is | |
| there because sparse will complain about casting to/from a bitwise type, | |
| but in this case we really _do_ want to force the conversion). And because | |
| the enum values are all the same type, now "enum pm_request" will be that | |
| type too. | |
| And with gcc, all the __bitwise/__force stuff goes away, and it all ends | |
| up looking just like integers to gcc. | |
| Quite frankly, you don't need the enum there. The above all really just | |
| boils down to one special "int __bitwise" type. | |
| So the simpler way is to just do | |
| typedef int __bitwise pm_request_t; | |
| #define PM_SUSPEND ((__force pm_request_t) 1) | |
| #define PM_RESUME ((__force pm_request_t) 2) | |
| and you now have all the infrastructure needed for strict typechecking. | |
| One small note: the constant integer "0" is special. You can use a | |
| constant zero as a bitwise integer type without sparse ever complaining. | |
| This is because "bitwise" (as the name implies) was designed for making | |
| sure that bitwise types don't get mixed up (little-endian vs big-endian | |
| vs cpu-endian vs whatever), and there the constant "0" really _is_ | |
| special. | |
| Use | |
| make C=[12] CF=-Wbitwise | |
| or you don't get any checking at all. | |
| Where to get sparse | |
| ~~~~~~~~~~~~~~~~~~~ | |
| With git, you can just get it from | |
| rsync://rsync.kernel.org/pub/scm/devel/sparse/sparse.git | |
| and DaveJ has tar-balls at | |
| http://www.codemonkey.org.uk/projects/git-snapshots/sparse/ | |
| Once you have it, just do | |
| make | |
| make install | |
| as your regular user, and it will install sparse in your ~/bin directory. | |
| After that, doing a kernel make with "make C=1" will run sparse on all the | |
| C files that get recompiled, or with "make C=2" will run sparse on the | |
| files whether they need to be recompiled or not (ie the latter is fast way | |
| to check the whole tree if you have already built it). |