contrib/header-tools/gcc-order-headers

   1 #! /usr/bin/python2
   2 import os
   3 import sys
   4 import shlex
   5 import re
   6
   7 from headerutils import *
   8 import Queue
   9
  10 file_list = list ()
  11 usage = False
  12
  13 ignore_conditional = False
  14
  15 order = [
  16   "system.h",
  17   "coretypes.h",
  18   "backend.h",
  19   "target.h",
  20   "rtl.h",
  21   "c-family/c-target.h",
  22   "c-family/c-target-def.h",
  23   "tree.h",
  24   "cp/cp-tree.h",
  25   "c-family/c-common.h",  # these must come before diagnostic.h
  26   "c/c-tree.h",
  27   "fortran/gfortran.h",
  28   "gimple.h",
  29   "cfghooks.h",
  30   "df.h",
  31   "tm_p.h",
  32   "gimple-iterators.h",
  33   "ssa.h",
  34   "expmed.h",
  35   "optabs.h",
  36   "regs.h",
  37   "ira.h",
  38   "ira-int.h",
  39   "gimple-streamer.h"
  40
  41 ]
  42
  43 exclude_special = [  "bversion.h", "obstack.h", "insn-codes.h", "hooks.h" ]
  44
  45 # includes is a dictionary indexed by a header files basename.
  46 # it consists of a 2 element tuple:
  47 # [0] - Name of header file which included this header.
  48 # [1] - vector of header file names included by this file.
  49
  50 includes = { }
  51
  52 # when a header is included multiple times, indexing this dictionary will
  53 # return a vector of all the headers which included it.
  54 dups = { }
  55
  56 # When creating the master list, do not descend into these files for what
  57 # they include. Simply put the file itself in the list.  This is primarily
  58 # required because the front end files inlcude orders tend to be at odds with
  59 # the order of middle end files, and its impossible to synchronize them.\
  60 # They are ordered such that everything resolves properly.
  61 exclude_processing = [ "tree-vectorizer.h" , "c-target.h", "c-target-def.h", "cp-tree.h", "c-common.h", "c-tree.h", "gfortran.h" ]
  62
  63 master_list = list ()
  64 # where include file comes from in src
  65 h_from = { }
  66
  67 # create the master ordering list... this is the desired order of headers
  68 def create_master_list (fn, verbose):
  69   if fn not in exclude_processing:
  70     for x in includes[fn][1]:
  71       create_master_list (x, verbose)
  72   if not fn in master_list:
  73     # Don't put diagnostic*.h into the ordering list. It is special since
  74     # various front ends have to set GCC_DIAG_STYLE before including it.
  75     # for each file, we'll tailor where it belongs by looking at the include
  76     # list and determine its position appropriately.
  77     if fn != "diagnostic.h" and fn != "diagnostic-core.h":
  78       master_list.append (fn)
  79       if (verbose):
  80         print fn + "      included by: " + includes[fn][0]
  81
  82
  83
  84 def print_dups ():
  85   if dups:
  86     print "\nduplicated includes"
  87   for i in dups:
  88     string =  "dup : " + i + " : "
  89     string += includes[i][0]
  90     for i2 in dups[i]:
  91       string += ", "+i2
  92     print string
  93
  94
  95 def process_known_dups ():
  96   # rtl.h gets tagged as a duplicate includer for all of coretypes.h, but that
  97   # is really for only generator files
  98   rtl_remove = includes["coretypes.h"][1] + ["statistics.h", "vec.h"]
  99   if dups:
 100     for i in rtl_remove:
 101       if dups[i] and "rtl.h" in dups[i]:
 102         dups[i].remove("rtl.h")
 103       if not dups[i]:
 104         dups.pop (i, None)
 105
 106   # make sure diagnostic.h is the owner of diagnostic-core.h
 107   if includes["diagnostic-core.h"][0] != "diagnostic.h":
 108     dups["diagnostic-core.h"].append (includes["diagnostic-core.h"][0])
 109     includes["diagnostic-core.h"] = ("diagnostic.h", includes["diagnostic-core.h"][1])
 110
 111 # This function scans back thorugh the list of headers which included other
 112 # headers to determine what file in HEADER_LIST brought 'HEADER' in.
 113 def indirectly_included (header, header_list):
 114   nm = os.path.basename (header)
 115   while nm and includes.get(nm):
 116     if includes[nm][0] in header_list:
 117       return includes[nm][0]
 118     nm = includes[nm][0]
 119
 120   # diagnostic.h and diagnostic-core.h may not show up because we removed them
 121   # from the header list to manually position in an appropriate place. They have
 122   # specific requirements that they need to occur after certain FE files which
 123   # may overide the definition of GCC_DIAG_STYLE.
 124   # Check the dup list for whete they may have been included from and return
 125   # that header.
 126   if header == "diagnostic-core.h":
 127     if dups.get("diagnostic-core.h"):
 128       for f in dups["diagnostic-core.h"]:
 129         if f in header_list:
 130           return f
 131     else:
 132       if header in header_list:
 133         return header
 134     # Now check if diagnostics is included indirectly anywhere
 135     header = "diagnostic.h"
 136
 137   if header == "diagnostic.h":
 138     if dups.get("diagnostic.h"):
 139       for f in dups["diagnostic.h"]:
 140         if f in header_list:
 141           return f
 142     else:
 143       if header in header_list:
 144         return header
 145
 146   return ""
 147
 148
 149 # This function will take a list of headers from a source file and return
 150 # the desired new new order of the canonical headers in DESIRED_ORDER.
 151 def get_new_order (src_h, desired_order):
 152   new_order = list ()
 153   for h in desired_order:
 154     if h in master_list:
 155       # Create the list of nested headers which included this file.
 156       iclist = list ()
 157       ib = includes[h][0]
 158       while ib:
 159         iclist.insert(0, ib)
 160         ib = includes[ib][0]
 161       if iclist:
 162         for x in iclist:
 163           # If header is in the source code, and we are allowed to look inside
 164           if x in src_h and x not in exclude_processing:
 165             if x not in new_order and x[:10] != "diagnostic" and h not in exclude_special:
 166               new_order.append (x)
 167               break;
 168       else:
 169         if h not in new_order:
 170           new_order.append (h)
 171
 172   f = ""
 173   if "diagnostic.h" in src_h:
 174     f = "diagnostic.h"
 175   elif "diagnostic-core.h" in src_h:
 176     f = "diagnostic-core.h"
 177
 178
 179   # If either diagnostic header was directly included in the main file, check to
 180   # see if its already included indirectly, or whether we need to add it to the
 181   # end of the canonically orders headers.
 182   if f:
 183     ii = indirectly_included (f, src_h)
 184     if not ii or ii == f:
 185       new_order.append (f)
 186
 187   return new_order
 188
 189
 190
 191 # stack of files to process
 192 process_stack = list ()
 193
 194 def process_one (info):
 195   i = info[0]
 196   owner = info[1]
 197   name = os.path.basename(i)
 198   if os.path.exists (i):
 199     if includes.get(name) == None:
 200       l = find_unique_include_list (i)
 201       # create a list which has just basenames in it
 202       new_list = list ()
 203       for x in l:
 204         new_list.append (os.path.basename (x))
 205         process_stack.append((x, name))
 206       includes[name] = (owner, new_list)
 207     elif owner:
 208       if dups.get(name) == None:
 209         dups[name] = [ owner ]
 210       else:
 211         dups[name].append (owner)
 212   else:
 213     # seed tm.h with options.h since it is a build file and won't be seen.
 214     if not includes.get(name):
 215       if name == "tm.h":
 216         includes[name] = (owner, [ "options.h" ])
 217         includes["options.h"] = ("tm.h", list ())
 218       else:
 219         includes[name] = (owner, list ())
 220
 221
 222 show_master = False
 223
 224 for arg in sys.argv[1:]:
 225   if arg[0:1] == "-":
 226     if arg[0:2] == "-h":
 227       usage = True
 228     elif arg[0:2] == "-i":
 229       ignore_conditional = True
 230     elif arg[0:2] == "-v":
 231       show_master = True
 232     else:
 233       print "Error: unrecognized option " + arg
 234   elif os.path.exists(arg):
 235     file_list.append (arg)
 236   else:
 237     print "Error: file " + arg + " Does not exist."
 238     usage = True
 239
 240 if not file_list and not show_master:
 241   usage = True
 242
 243 if not usage and not os.path.exists ("coretypes.h"):
 244   usage = True
 245   print "Error: Must run command in main gcc source directory containing coretypes.h\n"
 246
 247 # process diagnostic.h first.. it's special since GCC_DIAG_STYLE can be
 248 # overridden by languages, but must be done so by a file included BEFORE it.
 249 # so make sure it isn't seen as included by one of those files by making it
 250 # appear to be included by the src file.
 251 process_stack.insert (0, ("diagnostic.h", ""))
 252
 253 # Add the list of files in reverse order since it is processed as a stack later
 254 for i in order:
 255   process_stack.insert (0, (i, "") )
 256
 257 # build up the library of what header files include what other files.
 258 while process_stack:
 259   info = process_stack.pop ()
 260   process_one (info)
 261
 262 # Now create the master ordering list
 263 for i in order:
 264   create_master_list (os.path.basename (i), show_master)
 265
 266 # handle warts in the duplicate list
 267 process_known_dups ()
 268 desired_order = master_list
 269
 270 if show_master:
 271   print " Canonical order of gcc include files: "
 272   for x in master_list:
 273     print x
 274   print " "
 275
 276 if usage:
 277   print "gcc-order-headers [-i] [-v] file1 [filen]"
 278   print "    Ensures gcc's headers files are included in a normalized form with"
 279   print "    redundant headers removed.  The original files are saved in filename.bak"
 280   print "    Outputs a list of files which changed."
 281   print " -i ignore conditional compilation."
 282   print "    Use after examining the file to be sure includes within #ifs are safe"
 283   print "    Any headers within conditional sections will be ignored."
 284   print " -v Show the canonical order of known headers"
 285   sys.exit(0)
 286
 287
 288 didnt_do = list ()
 289
 290 for fn in file_list:
 291   nest = 0
 292   src_h = list ()
 293   src_line = { }
 294
 295   master_list = list ()
 296
 297   includes = { }
 298   dups = { }
 299
 300   iinfo = process_ii_src (fn)
 301   src = ii_src (iinfo)
 302   include_list = ii_include_list (iinfo)
 303
 304   if ii_include_list_cond (iinfo):
 305     if not ignore_conditional:
 306       print fn + ": Cannot process due to conditional compilation of includes"
 307       didnt_do.append (fn)
 308       src = list ()
 309
 310   if not src:
 311     continue
 312
 313   process_stack = list ()
 314   # prime the stack with headers in the main ordering list so we get them in
 315   # this order.
 316   for d in order:
 317     if d in include_list:
 318       process_stack.insert (0, (d, ""))
 319
 320   for d in include_list:
 321       nm = os.path.basename(d)
 322       src_h.append (nm)
 323       iname = d
 324       iname2 = os.path.dirname (fn) + "/" + d
 325       if not os.path.exists (d) and os.path.exists (iname2):
 326         iname = iname2
 327       if iname not in process_stack:
 328         process_stack.insert (0, (iname, ""))
 329       src_line[nm] = ii_src_line(iinfo)[d]
 330       if src_line[nm].find("/*") != -1 and src_line[nm].find("*/") == -1:
 331         # this means we have a multi line comment, abort!'
 332         print fn + ": Cannot process due to a multi-line comment :"
 333         print "        " + src_line[nm]
 334         if fn not in didnt_do:
 335           didnt_do.append (fn)
 336         src = list ()
 337
 338   if not src:
 339     continue
 340
 341   # Now create the list of includes as seen by the source file.
 342   while process_stack:
 343     info = process_stack.pop ()
 344     process_one (info)
 345
 346   for i in include_list:
 347     create_master_list (os.path.basename (i), False)
 348
 349   new_src = list ()
 350   header_added = list ()
 351   new_order = list ()
 352   for line in src:
 353     d = find_pound_include (line, True, True)
 354     if not d or d[-2:] != ".h":
 355       new_src.append (line)
 356     else:
 357       if d == order[0] and not new_order:
 358         new_order = get_new_order (src_h, desired_order)
 359         for i in new_order:
 360           new_src.append (src_line[i])
 361           # if not seen, add it.
 362           if i not in header_added:
 363             header_added.append (i)
 364       else:
 365         nm = os.path.basename(d)
 366         if nm not in header_added:
 367           iby = indirectly_included (nm, src_h)
 368           if not iby:
 369             new_src.append (line)
 370             header_added.append (nm)
 371
 372   if src != new_src:
 373     os.rename (fn, fn + ".bak")
 374     fl = open(fn,"w")
 375     for line in new_src:
 376       fl.write (line)
 377     fl.close ()
 378     print fn
 379
 380
 381 if didnt_do:
 382   print "\n\n Did not process the following files due to conditional dependencies:"
 383   str = ""
 384   for x in didnt_do:
 385     str += x + " "
 386   print str
 387   print "\n"
 388   print "Please examine to see if they are safe to process, and re-try with -i. "
 389   print "Safeness is determined by checking whether any of the reordered headers are"
 390   print "within a conditional and could be hauled out of the conditional, thus changing"
 391   print "what the compiler will see."
 392   print "Multi-line comments after a #include can also cause failuer, they must be turned"
 393   print "into single line comments or removed."
 394
 395
 396
 397