contrib/header-tools/reduce-headers

   1 #! /usr/bin/python2
   2 import os.path
   3 import sys
   4 import shlex
   5 import re
   6 import tempfile
   7 import copy
   8
   9 from headerutils import *
  10
  11 requires = { }
  12 provides = { }
  13
  14 no_remove = [ "system.h", "coretypes.h", "config.h" , "bconfig.h", "backend.h" ]
  15
  16 # These targets are the ones which provide "coverage".  Typically, if any
  17 # target is going to fail compilation, it's one of these.  This was determined
  18 # during the initial runs of reduce-headers... On a full set of target builds,
  19 # every failure which occured was triggered by one of these.
  20 # This list is used during target-list construction simply to put any of these
  21 # *first* in the candidate list, increasing the probability that a failure is
  22 # found quickly.
  23 target_priority = [
  24     "aarch64-linux-gnu",
  25     "arm-netbsdelf",
  26     "c6x-elf",
  27     "epiphany-elf",
  28     "hppa2.0-hpux10.1",
  29     "i686-mingw32crt",
  30     "i686-pc-msdosdjgpp",
  31     "mipsel-elf",
  32     "powerpc-eabisimaltivec",
  33     "rs6000-ibm-aix5.1.0",
  34     "sh-superh-elf",
  35     "sparc64-elf",
  36     "spu-elf"
  37 ]
  38
  39
  40 target_dir = ""
  41 build_dir = ""
  42 ignore_list = list()
  43 target_builds = list()
  44
  45 target_dict = { }
  46 header_dict = { }
  47 search_path = [ ".", "../include", "../libcpp/include" ]
  48
  49 remove_count = { }
  50
  51
  52 # Given a header name, normalize it.  ie.  cp/cp-tree.h could be in gcc, while
  53 # the same header could be referenced from within the cp subdirectory as
  54 # just cp-tree.h
  55 # for now, just assume basenames are unique
  56
  57 def normalize_header (header):
  58   return os.path.basename (header)
  59
  60
  61 # Adds a header file and its sub-includes to the global dictionary if they
  62 # aren't already there.  Specify s_path since different build directories may
  63 # append themselves on demand to the global list.
  64 # return entry for the specified header, knowing all sub entries are completed
  65
  66 def get_header_info (header, s_path):
  67   global header_dict
  68   global empty_iinfo
  69   process_list = list ()
  70   location = ""
  71   bname = ""
  72   bname_iinfo = empty_iinfo
  73   for path in s_path:
  74     if os.path.exists (path + "/" + header):
  75       location = path + "/" + header
  76       break
  77
  78   if location:
  79     bname = normalize_header (location)
  80     if header_dict.get (bname):
  81       bname_iinfo = header_dict[bname]
  82       loc2 = ii_path (bname_iinfo)+ "/" + bname
  83       if loc2[:2] == "./":
  84         loc2 = loc2[2:]
  85       if location[:2] == "./":
  86         location = location[2:]
  87       if loc2 != location:
  88         # Don't use the cache if it isnt the right one.
  89         bname_iinfo = process_ii_macro (location)
  90       return bname_iinfo
  91
  92     bname_iinfo = process_ii_macro (location)
  93     header_dict[bname] = bname_iinfo
  94     # now decend into the include tree
  95     for i in ii_include_list (bname_iinfo):
  96       get_header_info (i, s_path)
  97   else:
  98     # if the file isnt in the source directories, look in the build and target
  99     # directories. If it is here, then aggregate all the versions.
 100     location = build_dir + "/gcc/" + header
 101     build_inc = target_inc = False
 102     if os.path.exists (location):
 103       build_inc = True
 104     for x in target_dict:
 105       location = target_dict[x] + "/gcc/" + header
 106       if os.path.exists (location):
 107         target_inc = True
 108         break
 109
 110     if (build_inc or target_inc):
 111       bname = normalize_header(header)
 112       defines = set()
 113       consumes = set()
 114       incl = set()
 115       if build_inc:
 116         iinfo = process_ii_macro (build_dir + "/gcc/" + header)
 117         defines = set (ii_macro_define (iinfo))
 118         consumes = set (ii_macro_consume (iinfo))
 119         incl = set (ii_include_list (iinfo))
 120
 121       if (target_inc):
 122         for x in target_dict:
 123           location = target_dict[x] + "/gcc/" + header
 124           if os.path.exists (location):
 125             iinfo = process_ii_macro (location)
 126             defines.update (ii_macro_define (iinfo))
 127             consumes.update (ii_macro_consume (iinfo))
 128             incl.update (ii_include_list (iinfo))
 129
 130       bname_iinfo = (header, "build", list(incl), list(), list(consumes), list(defines), list(), list())
 131
 132       header_dict[bname] = bname_iinfo
 133       for i in incl:
 134         get_header_info (i, s_path)
 135
 136   return bname_iinfo
 137
 138
 139 # return a list of all headers brought in by this header
 140 def all_headers (fname):
 141   global header_dict
 142   headers_stack = list()
 143   headers_list = list()
 144   if header_dict.get (fname) == None:
 145     return list ()
 146   for y in ii_include_list (header_dict[fname]):
 147     headers_stack.append (y)
 148
 149   while headers_stack:
 150     h = headers_stack.pop ()
 151     hn = normalize_header (h)
 152     if hn not in headers_list:
 153       headers_list.append (hn)
 154       if header_dict.get(hn):
 155         for y in ii_include_list (header_dict[hn]):
 156           if normalize_header (y) not in headers_list:
 157             headers_stack.append (y)
 158
 159   return headers_list
 160
 161
 162
 163
 164 # Search bld_dir for all target tuples, confirm that they have a build path with
 165 # bld_dir/target-tuple/gcc, and build a dictionary of build paths indexed by
 166 # target tuple..
 167
 168 def build_target_dict (bld_dir, just_these):
 169   global target_dict
 170   target_doct = { }
 171   error = False
 172   if os.path.exists (bld_dir):
 173     if just_these:
 174       ls = just_these
 175     else:
 176       ls = os.listdir(bld_dir)
 177     for t in ls:
 178       if t.find("-") != -1:
 179         target = t.strip()
 180         tpath = bld_dir + "/" + target
 181         if not os.path.exists (tpath + "/gcc"):
 182           print "Error: gcc build directory for target " + t + " Does not exist: " + tpath + "/gcc"
 183           error = True
 184         else:
 185           target_dict[target] = tpath
 186
 187   if error:
 188     target_dict = { }
 189
 190 def get_obj_name (src_file):
 191   if src_file[-2:] == ".c":
 192     return src_file.replace (".c", ".o")
 193   elif src_file[-3:] == ".cc":
 194     return src_file.replace (".cc", ".o")
 195   return ""
 196
 197 def target_obj_exists (target, obj_name):
 198   global target_dict
 199   # look in a subdir if src has a subdir, then check gcc base directory.
 200   if target_dict.get(target):
 201     obj = target_dict[target] + "/gcc/" + obj_name
 202     if not os.path.exists (obj):
 203       obj = target_dict[target] + "/gcc/" + os.path.basename(obj_name)
 204     if os.path.exists (obj):
 205       return True
 206   return False
 207
 208 # Given a src file, return a list of targets which may build this file.
 209 def find_targets (src_file):
 210   global target_dict
 211   targ_list = list()
 212   obj_name = get_obj_name (src_file)
 213   if not obj_name:
 214     print "Error: " + src_file + " - Cannot determine object name."
 215     return list()
 216
 217   # Put the high priority targets which tend to trigger failures first
 218   for target in target_priority:
 219     if target_obj_exists (target, obj_name):
 220       targ_list.append ((target, target_dict[target]))
 221
 222   for target in target_dict:
 223     if target not in target_priority and target_obj_exists (target, obj_name):
 224       targ_list.append ((target, target_dict[target]))
 225
 226   return targ_list
 227
 228
 229 def try_to_remove (src_file, h_list, verbose):
 230   global target_dict
 231   global header_dict
 232   global build_dir
 233
 234   # build from scratch each time
 235   header_dict = { }
 236   summary = ""
 237   rmcount = 0
 238
 239   because = { }
 240   src_info = process_ii_macro_src (src_file)
 241   src_data = ii_src (src_info)
 242   if src_data:
 243     inclist = ii_include_list_non_cond (src_info)
 244     # work is done if there are no includes to check
 245     if not inclist:
 246       return src_file + ": No include files to attempt to remove"
 247
 248     # work on the include list in reverse.
 249     inclist.reverse()
 250
 251     # Get the target list
 252     targ_list = list()
 253     targ_list = find_targets (src_file)
 254
 255     spath = search_path
 256     if os.path.dirname (src_file):
 257       spath.append (os.path.dirname (src_file))
 258
 259     hostbuild = True
 260     if src_file.find("config/") != -1:
 261       # config files dont usually build on the host
 262       hostbuild = False
 263       obn = get_obj_name (os.path.basename (src_file))
 264       if obn and os.path.exists (build_dir + "/gcc/" + obn):
 265         hostbuild = True
 266       if not target_dict:
 267         summary = src_file + ": Target builds are required for config files.  None found."
 268         print summary
 269         return summary
 270       if not targ_list:
 271         summary =src_file + ": Cannot find any targets which build this file."
 272         print summary
 273         return summary
 274
 275     if hostbuild:
 276       # confirm it actually builds before we do anything
 277       print "Confirming source file builds"
 278       res = get_make_output (build_dir + "/gcc", "all")
 279       if res[0] != 0:
 280         message = "Error: " + src_file + " does not build currently."
 281         summary = src_file + " does not build on host."
 282         print message
 283         print res[1]
 284         if verbose:
 285           verbose.write (message + "\n")
 286           verbose.write (res[1]+ "\n")
 287         return summary
 288
 289     src_requires = set (ii_macro_consume (src_info))
 290     for macro in src_requires:
 291       because[macro] = src_file
 292     header_seen = list ()
 293
 294     os.rename (src_file, src_file + ".bak")
 295     src_orig = copy.deepcopy (src_data)
 296     src_tmp = copy.deepcopy (src_data)
 297
 298     try:
 299       # process the includes from bottom to top.  This is because we know that
 300       # later includes have are known to be needed, so any dependency from this
 301       # header is a true dependency
 302       for inc_file in inclist:
 303         inc_file_norm = normalize_header (inc_file)
 304
 305         if inc_file in no_remove:
 306           continue
 307         if len (h_list) != 0 and inc_file_norm not in h_list:
 308           continue
 309         if inc_file_norm[0:3] == "gt-":
 310           continue
 311         if inc_file_norm[0:6] == "gtype-":
 312           continue
 313         if inc_file_norm.replace(".h",".c") == os.path.basename(src_file):
 314           continue
 315
 316         lookfor = ii_src_line(src_info)[inc_file]
 317         src_tmp.remove (lookfor)
 318         message = "Trying " + src_file + " without " + inc_file
 319         print message
 320         if verbose:
 321           verbose.write (message + "\n")
 322         out = open(src_file, "w")
 323         for line in src_tmp:
 324           out.write (line)
 325         out.close()
 326
 327         keep = False
 328         if hostbuild:
 329           res = get_make_output (build_dir + "/gcc", "all")
 330         else:
 331           res = (0, "")
 332
 333         rc = res[0]
 334         message = "Passed Host build"
 335         if (rc != 0):
 336           # host build failed
 337           message  = "Compilation failed:\n";
 338           keep = True
 339         else:
 340           if targ_list:
 341             objfile = get_obj_name (src_file)
 342             t1 = targ_list[0]
 343             if objfile and os.path.exists(t1[1] +"/gcc/"+objfile):
 344               res = get_make_output_parallel (targ_list, objfile, 0)
 345             else:
 346               res = get_make_output_parallel (targ_list, "all-gcc", 0)
 347             rc = res[0]
 348             if rc != 0:
 349               message = "Compilation failed on TARGET : " + res[2]
 350               keep = True
 351             else:
 352               message = "Passed host and target builds"
 353
 354         if keep:
 355           print message + "\n"
 356
 357         if (rc != 0):
 358           if verbose:
 359             verbose.write (message + "\n");
 360             verbose.write (res[1])
 361             verbose.write ("\n");
 362             if os.path.exists (inc_file):
 363               ilog = open(inc_file+".log","a")
 364               ilog.write (message + " for " + src_file + ":\n\n");
 365               ilog.write ("============================================\n");
 366               ilog.write (res[1])
 367               ilog.write ("\n");
 368               ilog.close()
 369             if os.path.exists (src_file):
 370               ilog = open(src_file+".log","a")
 371               ilog.write (message + " for " +inc_file + ":\n\n");
 372               ilog.write ("============================================\n");
 373               ilog.write (res[1])
 374               ilog.write ("\n");
 375               ilog.close()
 376
 377         # Given a sequence where :
 378         # #include "tm.h"
 379         # #include "target.h"  // includes tm.h
 380
 381         # target.h was required, and when attempting to remove tm.h we'd see that
 382         # all the macro defintions are "required" since they all look like:
 383         # #ifndef HAVE_blah
 384         # #define HAVE_blah
 385         # endif
 386
 387         # when target.h was found to be required, tm.h will be tagged as included.
 388         # so when we get this far, we know we dont have to check the macros for
 389         # tm.h since we know it is already been included.
 390
 391         if inc_file_norm not in header_seen:
 392           iinfo = get_header_info (inc_file, spath)
 393           newlist = all_headers (inc_file_norm)
 394           if ii_path(iinfo) == "build" and not target_dict:
 395             keep = True
 396             text = message + " : Will not remove a build file without some targets."
 397             print text
 398             ilog = open(src_file+".log","a")
 399             ilog.write (text +"\n")
 400             ilog.write ("============================================\n");
 401             ilog.close()
 402             ilog = open("reduce-headers-kept.log","a")
 403             ilog.write (src_file + " " + text +"\n")
 404             ilog.close()
 405         else:
 406           newlist = list()
 407         if not keep and inc_file_norm not in header_seen:
 408           # now look for any macro requirements.
 409           for h in newlist:
 410             if not h in header_seen:
 411               if header_dict.get(h):
 412                 defined = ii_macro_define (header_dict[h])
 413                 for dep in defined:
 414                   if dep in src_requires and dep not in ignore_list:
 415                     keep = True;
 416                     text = message + ", but must keep " + inc_file + " because it provides " + dep
 417                     if because.get(dep) != None:
 418                       text = text + " Possibly required by " + because[dep]
 419                     print text
 420                     ilog = open(inc_file+".log","a")
 421                     ilog.write (because[dep]+": Requires [dep] in "+src_file+"\n")
 422                     ilog.write ("============================================\n");
 423                     ilog.close()
 424                     ilog = open(src_file+".log","a")
 425                     ilog.write (text +"\n")
 426                     ilog.write ("============================================\n");
 427                     ilog.close()
 428                     ilog = open("reduce-headers-kept.log","a")
 429                     ilog.write (src_file + " " + text +"\n")
 430                     ilog.close()
 431                     if verbose:
 432                       verbose.write (text + "\n")
 433
 434         if keep:
 435           # add all headers 'consumes' to src_requires list, and mark as seen
 436           for h in newlist:
 437             if not h in header_seen:
 438               header_seen.append (h)
 439               if header_dict.get(h):
 440                 consume = ii_macro_consume (header_dict[h])
 441                 for dep in consume:
 442                   if dep not in src_requires:
 443                     src_requires.add (dep)
 444                     if because.get(dep) == None:
 445                       because[dep] = inc_file
 446
 447           src_tmp = copy.deepcopy (src_data)
 448         else:
 449           print message + "  --> removing " + inc_file + "\n"
 450           rmcount += 1
 451           if verbose:
 452             verbose.write (message + "  --> removing " + inc_file + "\n")
 453           if remove_count.get(inc_file) == None:
 454             remove_count[inc_file] = 1
 455           else:
 456             remove_count[inc_file] += 1
 457           src_data = copy.deepcopy (src_tmp)
 458     except:
 459       print "Interuption: restoring original file"
 460       out = open(src_file, "w")
 461       for line in src_orig:
 462         out.write (line)
 463       out.close()
 464       raise
 465
 466     # copy current version, since it is the "right" one now.
 467     out = open(src_file, "w")
 468     for line in src_data:
 469       out.write (line)
 470     out.close()
 471
 472     # Try a final host bootstrap build to make sure everything is kosher.
 473     if hostbuild:
 474       res = get_make_output (build_dir, "all")
 475       rc = res[0]
 476       if (rc != 0):
 477         # host build failed! return to original version
 478         print "Error: " + src_file + " Failed to bootstrap at end!!! restoring."
 479         print "        Bad version at " + src_file + ".bad"
 480         os.rename (src_file, src_file + ".bad")
 481         out = open(src_file, "w")
 482         for line in src_orig:
 483           out.write (line)
 484         out.close()
 485         return src_file + ": failed to build after reduction.  Restored original"
 486
 487     if src_data == src_orig:
 488       summary = src_file + ": No change."
 489     else:
 490       summary = src_file + ": Reduction performed, "+str(rmcount)+" includes removed."
 491   print summary
 492   return summary
 493
 494 only_h = list ()
 495 ignore_cond = False
 496
 497 usage = False
 498 src = list()
 499 only_targs = list ()
 500 for x in sys.argv[1:]:
 501   if x[0:2] == "-b":
 502     build_dir = x[2:]
 503   elif x[0:2] == "-f":
 504     fn = normalize_header (x[2:])
 505     if fn not in only_h:
 506       only_h.append (fn)
 507   elif x[0:2] == "-h":
 508     usage = True
 509   elif x[0:2] == "-d":
 510     ignore_cond = True
 511   elif x[0:2] == "-D":
 512     ignore_list.append(x[2:])
 513   elif x[0:2] == "-T":
 514     only_targs.append(x[2:])
 515   elif x[0:2] == "-t":
 516     target_dir = x[2:]
 517   elif x[0] == "-":
 518     print "Error:  Unrecognized option " + x
 519     usgae = True
 520   else:
 521     if not os.path.exists (x):
 522       print "Error: specified file " + x + " does not exist."
 523       usage = True
 524     else:
 525       src.append (x)
 526
 527 if target_dir:
 528   build_target_dict (target_dir, only_targs)
 529
 530 if build_dir == "" and target_dir == "":
 531   print "Error: Must specify a build directory, and/or a target directory."
 532   usage = True
 533
 534 if build_dir and not os.path.exists (build_dir):
 535     print "Error: specified build directory does not exist : " + build_dir
 536     usage = True
 537
 538 if target_dir and not os.path.exists (target_dir):
 539     print "Error: specified target directory does not exist : " + target_dir
 540     usage = True
 541
 542 if usage:
 543   print "Attempts to remove extraneous include files from source files."
 544   print " "
 545   print "Should be run from the main gcc source directory, and works on a target"
 546   print "directory, as we attempt to make the 'all' target."
 547   print " "
 548   print "By default, gcc-reorder-includes is run on each file before attempting"
 549   print "to remove includes. this removes duplicates and puts some headers in a"
 550   print "canonical ordering"
 551   print " "
 552   print "The build directory should be ready to compile via make. Time is saved"
 553   print "if the build is already complete, so that only changes need to be built."
 554   print " "
 555   print "Usage: [options] file1.c [file2.c] ... [filen.c]"
 556   print "      -bdir    : the root build directory to attempt buiding .o files."
 557   print "      -tdir    : the target build directory"
 558   print "      -d       : Ignore conditional macro dependencies."
 559   print " "
 560   print "      -Dmacro  : Ignore a specific macro for dependencies"
 561   print "      -Ttarget : Only consider target in target directory."
 562   print "      -fheader : Specifies a specific .h file to be considered."
 563   print " "
 564   print "      -D, -T, and -f can be specified mulitple times and are aggregated."
 565   print " "
 566   print "  The original file will be in filen.bak"
 567   print " "
 568   sys.exit (0)
 569
 570 if only_h:
 571   print "Attempting to remove only these files:"
 572   for x in only_h:
 573     print x
 574   print " "
 575
 576 logfile = open("reduce-headers.log","w")
 577
 578 for x in src:
 579   msg = try_to_remove (x, only_h, logfile)
 580   ilog = open("reduce-headers.sum","a")
 581   ilog.write (msg + "\n")
 582   ilog.close()
 583
 584 ilog = open("reduce-headers.sum","a")
 585 ilog.write ("===============================================================\n")
 586 for x in remove_count:
 587   msg = x + ": Removed " + str(remove_count[x]) + " times."
 588   print msg
 589   logfile.write (msg + "\n")
 590   ilog.write (msg + "\n")
 591
 592
 593
 594
 595