tools/tools/kerninclude/kerninclude.sh

   1 #!/bin/sh
   2 # ----------------------------------------------------------------------------
   3 # "THE BEER-WARE LICENSE" (Revision 42):
   4 # <phk@FreeBSD.ORG> wrote this file.  As long as you retain this notice you
   5 # can do whatever you want with this stuff. If we meet some day, and you think
   6 # this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
   7 # ----------------------------------------------------------------------------
   8 #
   9 # $FreeBSD$
  10 #
  11 # This script tries to find #include statements which are not needed in
  12 # the FreeBSD kernel tree.
  13 #
  14
  15 set -e
  16
  17 # Base of the kernel sources you want to work on
  18 cd /sys
  19
  20 # Set to true to start from scratch, false to resume
  21 init=false
  22
  23 # Which kernels you want to check
  24 kernels="LINT GENERIC GENERIC98"
  25
  26 NO_MODULES=yes
  27 export NO_MODULES
  28
  29 if $init ; then
  30         (
  31         echo "Cleaning modules"
  32         cd modules
  33         make clean > /dev/null 2>&1
  34         make cleandir > /dev/null 2>&1
  35         make cleandir > /dev/null 2>&1
  36         make clean > /dev/null 2>&1
  37         make clean > /dev/null 2>&1
  38         )
  39
  40         (
  41         echo "Cleaning compile"
  42         cd compile
  43         ls | grep -v CVS | xargs rm -rf
  44         )
  45 fi
  46
  47 (
  48 echo "Cleaning temp files"
  49 find . -name '*.h_' -print | xargs rm -f
  50 find . -name '::*' -print | xargs rm -f
  51 find . -name '*.o' -size 0 -print | xargs rm -f
  52 )
  53
  54 echo "Configuring kernels"
  55 (
  56         cd i386/conf
  57         make LINT
  58         if $init ; then
  59                 rm -rf ../../compile/LINT ../../compile/GENERIC
  60         fi
  61         config LINT
  62         config GENERIC
  63 )
  64 (
  65         cd pc98/conf
  66         cp -f GENERIC GENERIC98
  67         if $init ; then
  68                 rm -rf ../../compile/GENERIC98
  69         fi
  70         config GENERIC98
  71 )
  72
  73 for i in $kernels
  74 do
  75         (
  76         echo "Compiling $i"
  77         cd compile/$i
  78         make > x.0 2>&1
  79         tail -4 x.0
  80         if [ ! -f kernel ] ; then
  81                 echo "Error: No $i kernel built"
  82                 exit 1
  83         fi
  84         )
  85 done
  86
  87 (
  88 echo "Compiling modules"
  89 cd modules
  90 make > x.0 2>&1
  91 )
  92
  93 # Generate the list of object files we want to check
  94 # you can put a convenient grep right before the sort
  95 # if you want just some specific subset of files checked
  96 (
  97 cd modules
  98 for i in *
  99 do
 100         if [ -d $i -a $i != CVS ] ; then
 101                 ( cd $i ; ls *.o 2>/dev/null || true)
 102         fi
 103 done
 104 cd ../compile
 105 for i in $kernels
 106 do
 107         ( cd $i ; ls *.o 2>/dev/null )
 108 done
 109 ) | sed '
 110 /aicasm/d
 111 /genassym/d
 112 /vers.o/d
 113 /setdef0.o/d
 114 /setdef1.o/d
 115 ' | sort -u > _
 116
 117 objlist=`cat _`
 118
 119
 120 for o in $objlist
 121 do
 122         l=""
 123         src=""
 124         for k in $kernels
 125         do
 126                 if [ ! -f compile/$k/$o ] ; then
 127                         continue;
 128                 fi
 129                 l="$l compile/$k"
 130                 if [ "x$src" = "x" ] ; then
 131                         cd compile/$k
 132                         mv $o ${o}_
 133                         make -n $o > _
 134                         mv ${o}_ $o
 135                         src=compile/$k/`awk '$1 == "cc" {print $NF}' _`
 136                         cd ../..
 137                         if expr "x$src" : 'x.*\.c$' > /dev/null ; then
 138                                 true
 139                         else
 140                                 echo NO SRC $o
 141                                 src=""
 142                         fi
 143                 fi
 144         done
 145         for m in modules/*
 146         do
 147                 if [ ! -d $m -o ! -f $m/$o ] ; then
 148                         continue;
 149                 fi
 150                 l="$l $m"
 151                 if [ "x$src" = "x" ] ; then
 152                         cd $m
 153                         mv $o ${o}_
 154                         make -n $o > _
 155                         mv ${o}_ $o
 156                         src=`awk '$1 == "cc" {print $NF}' _`
 157                         cd ../..
 158                         if expr "x$src" : 'x.*\.c$' > /dev/null ; then
 159                                 if [ "`dirname $src`" = "." ] ; then
 160                                         src="$m/$src"
 161                                 fi
 162                                 true
 163                         else
 164                                 echo NO SRC $o
 165                                 src=""
 166                         fi
 167                 fi
 168         done
 169         if [ "x$src" = "x" ] ; then
 170                 echo "NO SOURCE $o"
 171                 continue
 172         fi
 173         echo "OBJ       $o"
 174         echo "  SRC     $src"
 175
 176         grep -n '^[     ]*#[    ]*include' $src | sed '
 177         s/^\([0-9]*\):[         ]*#[    ]*include[      ]*[<"]/\1 /
 178         s/[">].*//
 179         / opt_/d
 180         ' | sort -rn | while read lin incl
 181         do
 182                 S=""
 183                 echo "          INCL    $lin    $incl"
 184                 cp $src ${src}_
 185
 186                 # Check if we can compile without this #include line.
 187
 188                 sed "${lin}s/.*//" ${src}_ > ${src}
 189                 for t in $l
 190                 do
 191                         cd $t
 192                         mv ${o} ${o}_
 193                         if make ${o} > _log 2>&1 ; then
 194                                 if cmp -s ${o} ${o}_ ; then
 195                                         echo "                  $t      same object"
 196                                 else
 197                                         echo "                  $t      changed object"
 198                                         S=TAG
 199                                 fi
 200                         else
 201                                 echo "                  $t      used"
 202                                 S=TAG
 203                         fi
 204                         mv ${o}_ ${o}
 205                         cd ../..
 206                         if [ "x$S" != "x" ] ; then
 207                                 break
 208                         fi
 209                 done
 210                 if [ "x$S" != "x" ] ; then
 211                         mv ${src}_ ${src}
 212                         continue
 213                 fi
 214
 215                 # Check if this is because it is a nested #include
 216                 for t in $l
 217                 do
 218                         cd $t
 219                         rm -rf foo
 220                         mkdir -p foo/${incl}
 221                         rmdir foo/${incl}
 222                         touch foo/${incl}
 223                         mv ${o} ${o}_
 224                         if make INCLMAGIC=-Ifoo ${o} > _log2 2>&1 ; then
 225                                 if cmp -s ${o} ${o}_ ; then
 226                                         echo "                  $t      still same object"
 227                                 else
 228                                         echo "                  $t      changed object"
 229                                         S=TAG
 230                                 fi
 231                         else
 232                                 echo "                  $t      nested include"
 233                                 S=TAG
 234                         fi
 235                         rm -rf foo
 236                         mv ${o}_ ${o}
 237                         cd ../..
 238                         if [ "x$S" != "x" ] ; then
 239                                 break
 240                         fi
 241                 done
 242                 if [ "x$S" != "x" ] ; then
 243                         mv ${src}_ ${src}
 244                         continue
 245                 fi
 246
 247                 # Check if this is because it is #ifdef'ed out
 248
 249                 sed "${lin}s/.*/#error \"BARF\"/" ${src}_ > ${src}
 250                 for t in $l
 251                 do
 252                         cd $t
 253                         mv ${o} ${o}_
 254                         if make ${o} > /dev/null 2>&1 ; then
 255                                 echo "                  $t      line not read"
 256                                 S=TAG
 257                         fi
 258                         mv ${o}_ ${o}
 259                         cd ../..
 260                         if [ "x$S" != "x" ] ; then
 261                                 break
 262                         fi
 263                 done
 264
 265                 mv ${src}_ ${src}
 266                 if [ "x$S" != "x" ] ; then
 267                         continue
 268                 fi
 269
 270                 # Check if the warnings changed.
 271
 272                 for t in $l
 273                 do
 274                         cd $t
 275                         mv ${o} ${o}_
 276                         if make ${o} > _ref 2>&1 ; then
 277                                 if cmp -s _ref _log ; then
 278                                         echo "                  $t      same warnings"
 279                                 else
 280                                         echo "                  $t      changed warnings"
 281                                         S=TAG
 282                                 fi
 283                         else
 284                                 echo "ARGHH!!!"
 285                                 exit 9
 286                         fi
 287
 288                         mv ${o}_ ${o}
 289                         cd ../..
 290                         if [ "x$S" != "x" ] ; then
 291                                 break
 292                         fi
 293                 done
 294                 if [ "x$S" != "x" ] ; then
 295                         continue
 296                 fi
 297                 cp $src ${src}_
 298                 sed "${lin}d" ${src}_ > ${src}
 299                 rm ${src}_
 300                 touch _again
 301                 echo "BINGO $src $lin $incl $obj $l"
 302         done
 303 done