buildtools/wafsamba/samba_deps.py

   1 # Samba automatic dependency handling and project rules
   2
   3 import os, sys, re, time
   4
   5 import Build, Environment, Options, Logs, Utils
   6 from Logs import debug
   7 from Configure import conf
   8
   9 from samba_bundled import BUILTIN_LIBRARY
  10 from samba_utils import LOCAL_CACHE, TO_LIST, get_tgt_list, unique_list, os_path_relpath
  11 from samba_autoconf import library_flags
  12
  13 @conf
  14 def ADD_GLOBAL_DEPENDENCY(ctx, dep):
  15     '''add a dependency for all binaries and libraries'''
  16     if not 'GLOBAL_DEPENDENCIES' in ctx.env:
  17         ctx.env.GLOBAL_DEPENDENCIES = []
  18     ctx.env.GLOBAL_DEPENDENCIES.append(dep)
  19
  20
  21 @conf
  22 def BREAK_CIRCULAR_LIBRARY_DEPENDENCIES(ctx):
  23     '''indicate that circular dependencies between libraries should be broken.'''
  24     ctx.env.ALLOW_CIRCULAR_LIB_DEPENDENCIES = True
  25
  26
  27 @conf
  28 def SET_SYSLIB_DEPS(conf, target, deps):
  29     '''setup some implied dependencies for a SYSLIB'''
  30     cache = LOCAL_CACHE(conf, 'SYSLIB_DEPS')
  31     cache[target] = deps
  32
  33
  34 def expand_subsystem_deps(bld):
  35     '''expand the reverse dependencies resulting from subsystem
  36        attributes of modules. This is walking over the complete list
  37        of declared subsystems, and expands the samba_deps_extended list for any
  38        module<->subsystem dependencies'''
  39
  40     subsystem_list = LOCAL_CACHE(bld, 'INIT_FUNCTIONS')
  41     targets    = LOCAL_CACHE(bld, 'TARGET_TYPE')
  42
  43     for subsystem_name in subsystem_list:
  44         bld.ASSERT(subsystem_name in targets, "Subsystem target %s not declared" % subsystem_name)
  45         type = targets[subsystem_name]
  46         if type == 'DISABLED' or type == 'EMPTY':
  47             continue
  48
  49         # for example,
  50         #    subsystem_name = dcerpc_server (a subsystem)
  51         #    subsystem      = dcerpc_server (a subsystem object)
  52         #    module_name    = rpc_epmapper (a module within the dcerpc_server subsystem)
  53         #    module         = rpc_epmapper (a module object within the dcerpc_server subsystem)
  54
  55         subsystem = bld.get_tgen_by_name(subsystem_name)
  56         bld.ASSERT(subsystem is not None, "Unable to find subsystem %s" % subsystem_name)
  57         for d in subsystem_list[subsystem_name]:
  58             module_name = d['TARGET']
  59             module_type = targets[module_name]
  60             if module_type in ['DISABLED', 'EMPTY']:
  61                 continue
  62             bld.ASSERT(subsystem is not None,
  63                        "Subsystem target %s for %s (%s) not found" % (subsystem_name, module_name, module_type))
  64             if module_type in ['SUBSYSTEM']:
  65                 # if a module is a plain object type (not a library) then the
  66                 # subsystem it is part of needs to have it as a dependency, so targets
  67                 # that depend on this subsystem get the modules of that subsystem
  68                 subsystem.samba_deps_extended.append(module_name)
  69         subsystem.samba_deps_extended = unique_list(subsystem.samba_deps_extended)
  70
  71
  72
  73 def build_dependencies(self):
  74     '''This builds the dependency list for a target. It runs after all the targets are declared
  75
  76     The reason this is not just done in the SAMBA_*() rules is that we have no way of knowing
  77     the full dependency list for a target until we have all of the targets declared.
  78     '''
  79
  80     if self.samba_type in ['LIBRARY', 'BINARY', 'PYTHON']:
  81         self.uselib        = list(self.final_syslibs)
  82         self.uselib_local  = list(self.final_libs)
  83         self.add_objects   = list(self.final_objects)
  84
  85         # extra link flags from pkg_config
  86         libs = self.final_syslibs.copy()
  87
  88         (ccflags, ldflags, cpppath) = library_flags(self, list(libs))
  89         new_ldflags        = getattr(self, 'samba_ldflags', [])[:]
  90         new_ldflags.extend(ldflags)
  91         self.ldflags       = new_ldflags
  92
  93         if getattr(self, 'allow_undefined_symbols', False) and self.env.undefined_ldflags:
  94             for f in self.env.undefined_ldflags:
  95                 self.ldflags.remove(f)
  96
  97         if getattr(self, 'allow_undefined_symbols', False) and self.env.undefined_ignore_ldflags:
  98             for f in self.env.undefined_ignore_ldflags:
  99                 self.ldflags.append(f)
 100
 101         debug('deps: computed dependencies for target %s: uselib=%s uselib_local=%s add_objects=%s',
 102               self.sname, self.uselib, self.uselib_local, self.add_objects)
 103
 104     if self.samba_type in ['SUBSYSTEM']:
 105         # this is needed for the ccflags of libs that come from pkg_config
 106         self.uselib = list(self.final_syslibs)
 107         self.uselib.extend(list(self.direct_syslibs))
 108         for lib in self.final_libs:
 109             t = self.bld.get_tgen_by_name(lib)
 110             self.uselib.extend(list(t.final_syslibs))
 111         self.uselib = unique_list(self.uselib)
 112
 113     if getattr(self, 'uselib', None):
 114         up_list = []
 115         for l in self.uselib:
 116            up_list.append(l.upper())
 117         self.uselib = up_list
 118
 119
 120 def build_includes(self):
 121     '''This builds the right set of includes for a target.
 122
 123     One tricky part of this is that the includes= attribute for a
 124     target needs to use paths which are relative to that targets
 125     declaration directory (which we can get at via t.path).
 126
 127     The way this works is the includes list gets added as
 128     samba_includes in the main build task declaration. Then this
 129     function runs after all of the tasks are declared, and it
 130     processes the samba_includes attribute to produce a includes=
 131     attribute
 132     '''
 133
 134     if getattr(self, 'samba_includes', None) is None:
 135         return
 136
 137     bld = self.bld
 138
 139     inc_deps = includes_objects(bld, self, set(), {})
 140
 141     includes = []
 142
 143     # maybe add local includes
 144     if getattr(self, 'local_include', True) and getattr(self, 'local_include_first', True):
 145         includes.append('.')
 146
 147     includes.extend(self.samba_includes_extended)
 148
 149     if 'EXTRA_INCLUDES' in bld.env and getattr(self, 'global_include', True):
 150         includes.extend(bld.env['EXTRA_INCLUDES'])
 151
 152     includes.append('#')
 153
 154     inc_set = set()
 155     inc_abs = []
 156
 157     for d in inc_deps:
 158         t = bld.get_tgen_by_name(d)
 159         bld.ASSERT(t is not None, "Unable to find dependency %s for %s" % (d, self.sname))
 160         inclist = getattr(t, 'samba_includes_extended', [])[:]
 161         if getattr(t, 'local_include', True):
 162             inclist.append('.')
 163         if inclist == []:
 164             continue
 165         tpath = t.samba_abspath
 166         for inc in inclist:
 167             npath = tpath + '/' + inc
 168             if not npath in inc_set:
 169                 inc_abs.append(npath)
 170                 inc_set.add(npath)
 171
 172     mypath = self.path.abspath(bld.env)
 173     for inc in inc_abs:
 174         relpath = os_path_relpath(inc, mypath)
 175         includes.append(relpath)
 176
 177     if getattr(self, 'local_include', True) and not getattr(self, 'local_include_first', True):
 178         includes.append('.')
 179
 180     # now transform the includes list to be relative to the top directory
 181     # which is represented by '#' in waf. This allows waf to cache the
 182     # includes lists more efficiently
 183     includes_top = []
 184     for i in includes:
 185         if i[0] == '#':
 186             # some are already top based
 187             includes_top.append(i)
 188             continue
 189         absinc = os.path.join(self.path.abspath(), i)
 190         relinc = os_path_relpath(absinc, self.bld.srcnode.abspath())
 191         includes_top.append('#' + relinc)
 192
 193     self.includes = unique_list(includes_top)
 194     debug('deps: includes for target %s: includes=%s',
 195           self.sname, self.includes)
 196
 197
 198 def add_init_functions(self):
 199     '''This builds the right set of init functions'''
 200
 201     bld = self.bld
 202
 203     subsystems = LOCAL_CACHE(bld, 'INIT_FUNCTIONS')
 204
 205     # cope with the separated object lists from BINARY and LIBRARY targets
 206     sname = self.sname
 207     if sname.endswith('.objlist'):
 208         sname = sname[0:-8]
 209
 210     modules = []
 211     if sname in subsystems:
 212         modules.append(sname)
 213
 214     m = getattr(self, 'samba_modules', None)
 215     if m is not None:
 216         modules.extend(TO_LIST(m))
 217
 218     m = getattr(self, 'samba_subsystem', None)
 219     if m is not None:
 220         modules.append(m)
 221
 222     if 'pyembed' in self.features:
 223         return
 224
 225     sentinel = getattr(self, 'init_function_sentinel', 'NULL')
 226
 227     targets    = LOCAL_CACHE(bld, 'TARGET_TYPE')
 228     cflags = getattr(self, 'samba_cflags', [])[:]
 229
 230     if modules == []:
 231         sname = sname.replace('-','_')
 232         sname = sname.replace('.','_')
 233         sname = sname.replace('/','_')
 234         cflags.append('-DSTATIC_%s_MODULES=%s' % (sname, sentinel))
 235         if sentinel == 'NULL':
 236             proto = "extern void __%s_dummy_module_proto(void)" % (sname)
 237             cflags.append('-DSTATIC_%s_MODULES_PROTO=%s' % (sname, proto))
 238         self.ccflags = cflags
 239         return
 240
 241     for m in modules:
 242         bld.ASSERT(m in subsystems,
 243                    "No init_function defined for module '%s' in target '%s'" % (m, self.sname))
 244         init_fn_list = []
 245         for d in subsystems[m]:
 246             if targets[d['TARGET']] != 'DISABLED':
 247                 init_fn_list.append(d['INIT_FUNCTION'])
 248         if init_fn_list == []:
 249             cflags.append('-DSTATIC_%s_MODULES=%s' % (m, sentinel))
 250             if sentinel == 'NULL':
 251                 proto = "extern void __%s_dummy_module_proto(void)" % (m)
 252                 cflags.append('-DSTATIC_%s_MODULES_PROTO=%s' % (m, proto))
 253         else:
 254             cflags.append('-DSTATIC_%s_MODULES=%s' % (m, ','.join(init_fn_list) + ',' + sentinel))
 255             proto=''
 256             for f in init_fn_list:
 257                 proto += '_MODULE_PROTO(%s)' % f
 258             proto += "extern void __%s_dummy_module_proto(void)" % (m)
 259             cflags.append('-DSTATIC_%s_MODULES_PROTO=%s' % (m, proto))
 260     self.ccflags = cflags
 261
 262
 263 def check_duplicate_sources(bld, tgt_list):
 264     '''see if we are compiling the same source file more than once'''
 265
 266     debug('deps: checking for duplicate sources')
 267     targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
 268
 269     for t in tgt_list:
 270         source_list = TO_LIST(getattr(t, 'source', ''))
 271         tpath = os.path.normpath(os_path_relpath(t.path.abspath(bld.env), t.env.BUILD_DIRECTORY + '/default'))
 272         obj_sources = set()
 273         for s in source_list:
 274             p = os.path.normpath(os.path.join(tpath, s))
 275             if p in obj_sources:
 276                 Logs.error("ERROR: source %s appears twice in target '%s'" % (p, t.sname))
 277                 sys.exit(1)
 278             obj_sources.add(p)
 279         t.samba_source_set = obj_sources
 280
 281     subsystems = {}
 282
 283     # build a list of targets that each source file is part of
 284     for t in tgt_list:
 285         if not targets[t.sname] in [ 'LIBRARY', 'BINARY', 'PYTHON' ]:
 286             continue
 287         for obj in t.add_objects:
 288             t2 = t.bld.get_tgen_by_name(obj)
 289             source_set = getattr(t2, 'samba_source_set', set())
 290             for s in source_set:
 291                 if not s in subsystems:
 292                     subsystems[s] = {}
 293                 if not t.sname in subsystems[s]:
 294                     subsystems[s][t.sname] = []
 295                 subsystems[s][t.sname].append(t2.sname)
 296
 297     for s in subsystems:
 298         if len(subsystems[s]) > 1 and Options.options.SHOW_DUPLICATES:
 299             Logs.warn("WARNING: source %s is in more than one target: %s" % (s, subsystems[s].keys()))
 300         for tname in subsystems[s]:
 301             if len(subsystems[s][tname]) > 1:
 302                 raise Utils.WafError("ERROR: source %s is in more than one subsystem of target '%s': %s" % (s, tname, subsystems[s][tname]))
 303
 304     return True
 305
 306 def check_group_ordering(bld, tgt_list):
 307     '''see if we have any dependencies that violate the group ordering
 308
 309     It is an error for a target to depend on a target from a later
 310     build group
 311     '''
 312
 313     def group_name(g):
 314         tm = bld.task_manager
 315         return [x for x in tm.groups_names if id(tm.groups_names[x]) == id(g)][0]
 316
 317     for g in bld.task_manager.groups:
 318         gname = group_name(g)
 319         for t in g.tasks_gen:
 320             t.samba_group = gname
 321
 322     grp_map = {}
 323     idx = 0
 324     for g in bld.task_manager.groups:
 325         name = group_name(g)
 326         grp_map[name] = idx
 327         idx += 1
 328
 329     targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
 330
 331     ret = True
 332     for t in tgt_list:
 333         tdeps = getattr(t, 'add_objects', []) + getattr(t, 'uselib_local', [])
 334         for d in tdeps:
 335             t2 = bld.get_tgen_by_name(d)
 336             if t2 is None:
 337                 continue
 338             map1 = grp_map[t.samba_group]
 339             map2 = grp_map[t2.samba_group]
 340
 341             if map2 > map1:
 342                 Logs.error("Target %r in build group %r depends on target %r from later build group %r" % (
 343                            t.sname, t.samba_group, t2.sname, t2.samba_group))
 344                 ret = False
 345
 346     return ret
 347 Build.BuildContext.check_group_ordering = check_group_ordering
 348
 349 def show_final_deps(bld, tgt_list):
 350     '''show the final dependencies for all targets'''
 351
 352     targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
 353
 354     for t in tgt_list:
 355         if not targets[t.sname] in ['LIBRARY', 'BINARY', 'PYTHON', 'SUBSYSTEM']:
 356             continue
 357         debug('deps: final dependencies for target %s: uselib=%s uselib_local=%s add_objects=%s',
 358               t.sname, t.uselib, getattr(t, 'uselib_local', []), getattr(t, 'add_objects', []))
 359
 360
 361 def add_samba_attributes(bld, tgt_list):
 362     '''ensure a target has a the required samba attributes'''
 363
 364     targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
 365
 366     for t in tgt_list:
 367         if t.name != '':
 368             t.sname = t.name
 369         else:
 370             t.sname = t.target
 371         t.samba_type = targets[t.sname]
 372         t.samba_abspath = t.path.abspath(bld.env)
 373         t.samba_deps_extended = t.samba_deps[:]
 374         t.samba_includes_extended = TO_LIST(t.samba_includes)[:]
 375         t.ccflags = getattr(t, 'samba_cflags', '')
 376
 377 def replace_grouping_libraries(bld, tgt_list):
 378     '''replace dependencies based on grouping libraries
 379
 380     If a library is marked as a grouping library, then any target that
 381     depends on a subsystem that is part of that grouping library gets
 382     that dependency replaced with a dependency on the grouping library
 383     '''
 384
 385     targets  = LOCAL_CACHE(bld, 'TARGET_TYPE')
 386
 387     grouping = {}
 388
 389     # find our list of grouping libraries, mapped from the subsystems they depend on
 390     for t in tgt_list:
 391         if not getattr(t, 'grouping_library', False):
 392             continue
 393         for dep in t.samba_deps_extended:
 394             bld.ASSERT(dep in targets, "grouping library target %s not declared in %s" % (dep, t.sname))
 395             if targets[dep] == 'SUBSYSTEM':
 396                 grouping[dep] = t.sname
 397
 398     # now replace any dependencies on elements of grouping libraries
 399     for t in tgt_list:
 400         for i in range(len(t.samba_deps_extended)):
 401             dep = t.samba_deps_extended[i]
 402             if dep in grouping:
 403                 if t.sname != grouping[dep]:
 404                     debug("deps: target %s: replacing dependency %s with grouping library %s" % (t.sname, dep, grouping[dep]))
 405                     t.samba_deps_extended[i] = grouping[dep]
 406
 407
 408
 409 def build_direct_deps(bld, tgt_list):
 410     '''build the direct_objects and direct_libs sets for each target'''
 411
 412     targets  = LOCAL_CACHE(bld, 'TARGET_TYPE')
 413     syslib_deps  = LOCAL_CACHE(bld, 'SYSLIB_DEPS')
 414
 415     global_deps = bld.env.GLOBAL_DEPENDENCIES
 416     global_deps_exclude = set()
 417     for dep in global_deps:
 418         t = bld.get_tgen_by_name(dep)
 419         for d in t.samba_deps:
 420             # prevent loops from the global dependencies list
 421             global_deps_exclude.add(d)
 422             global_deps_exclude.add(d + '.objlist')
 423
 424     for t in tgt_list:
 425         t.direct_objects = set()
 426         t.direct_libs = set()
 427         t.direct_syslibs = set()
 428         deps = t.samba_deps_extended[:]
 429         if getattr(t, 'samba_use_global_deps', False) and not t.sname in global_deps_exclude:
 430             deps.extend(global_deps)
 431         for d in deps:
 432             if d == t.sname: continue
 433             if not d in targets:
 434                 Logs.error("Unknown dependency '%s' in '%s'" % (d, t.sname))
 435                 sys.exit(1)
 436             if targets[d] in [ 'EMPTY', 'DISABLED' ]:
 437                 continue
 438             if targets[d] == 'PYTHON' and targets[t.sname] != 'PYTHON' and t.sname.find('.objlist') == -1:
 439                 # this check should be more restrictive, but for now we have pidl-generated python
 440                 # code that directly depends on other python modules
 441                 Logs.error('ERROR: Target %s has dependency on python module %s' % (t.sname, d))
 442                 sys.exit(1)
 443             if targets[d] == 'SYSLIB':
 444                 t.direct_syslibs.add(d)
 445                 if d in syslib_deps:
 446                     for implied in TO_LIST(syslib_deps[d]):
 447                         if BUILTIN_LIBRARY(bld, implied):
 448                             t.direct_objects.add(implied)
 449                         elif targets[implied] == 'SYSLIB':
 450                             t.direct_syslibs.add(implied)
 451                         elif targets[implied] in ['LIBRARY', 'MODULE']:
 452                             t.direct_libs.add(implied)
 453                         else:
 454                             Logs.error('Implied dependency %s in %s is of type %s' % (
 455                                 implied, t.sname, targets[implied]))
 456                             sys.exit(1)
 457                 continue
 458             t2 = bld.get_tgen_by_name(d)
 459             if t2 is None:
 460                 Logs.error("no task %s of type %s in %s" % (d, targets[d], t.sname))
 461                 sys.exit(1)
 462             if t2.samba_type in [ 'LIBRARY', 'MODULE' ]:
 463                 t.direct_libs.add(d)
 464             elif t2.samba_type in [ 'SUBSYSTEM', 'ASN1', 'PYTHON' ]:
 465                 t.direct_objects.add(d)
 466     debug('deps: built direct dependencies')
 467
 468
 469 def dependency_loop(loops, t, target):
 470     '''add a dependency loop to the loops dictionary'''
 471     if t.sname == target:
 472         return
 473     if not target in loops:
 474         loops[target] = set()
 475     if not t.sname in loops[target]:
 476         loops[target].add(t.sname)
 477
 478
 479 def indirect_libs(bld, t, chain, loops):
 480     '''recursively calculate the indirect library dependencies for a target
 481
 482     An indirect library is a library that results from a dependency on
 483     a subsystem
 484     '''
 485
 486     ret = getattr(t, 'indirect_libs', None)
 487     if ret is not None:
 488         return ret
 489
 490     ret = set()
 491     for obj in t.direct_objects:
 492         if obj in chain:
 493             dependency_loop(loops, t, obj)
 494             continue
 495         chain.add(obj)
 496         t2 = bld.get_tgen_by_name(obj)
 497         r2 = indirect_libs(bld, t2, chain, loops)
 498         chain.remove(obj)
 499         ret = ret.union(t2.direct_libs)
 500         ret = ret.union(r2)
 501
 502     for obj in indirect_objects(bld, t, set(), loops):
 503         if obj in chain:
 504             dependency_loop(loops, t, obj)
 505             continue
 506         chain.add(obj)
 507         t2 = bld.get_tgen_by_name(obj)
 508         r2 = indirect_libs(bld, t2, chain, loops)
 509         chain.remove(obj)
 510         ret = ret.union(t2.direct_libs)
 511         ret = ret.union(r2)
 512
 513     t.indirect_libs = ret
 514
 515     return ret
 516
 517
 518 def indirect_objects(bld, t, chain, loops):
 519     '''recursively calculate the indirect object dependencies for a target
 520
 521     indirect objects are the set of objects from expanding the
 522     subsystem dependencies
 523     '''
 524
 525     ret = getattr(t, 'indirect_objects', None)
 526     if ret is not None: return ret
 527
 528     ret = set()
 529     for lib in t.direct_objects:
 530         if lib in chain:
 531             dependency_loop(loops, t, lib)
 532             continue
 533         chain.add(lib)
 534         t2 = bld.get_tgen_by_name(lib)
 535         r2 = indirect_objects(bld, t2, chain, loops)
 536         chain.remove(lib)
 537         ret = ret.union(t2.direct_objects)
 538         ret = ret.union(r2)
 539
 540     t.indirect_objects = ret
 541     return ret
 542
 543
 544 def extended_objects(bld, t, chain):
 545     '''recursively calculate the extended object dependencies for a target
 546
 547     extended objects are the union of:
 548        - direct objects
 549        - indirect objects
 550        - direct and indirect objects of all direct and indirect libraries
 551     '''
 552
 553     ret = getattr(t, 'extended_objects', None)
 554     if ret is not None: return ret
 555
 556     ret = set()
 557     ret = ret.union(t.final_objects)
 558
 559     for lib in t.final_libs:
 560         if lib in chain:
 561             continue
 562         t2 = bld.get_tgen_by_name(lib)
 563         chain.add(lib)
 564         r2 = extended_objects(bld, t2, chain)
 565         chain.remove(lib)
 566         ret = ret.union(t2.final_objects)
 567         ret = ret.union(r2)
 568
 569     t.extended_objects = ret
 570     return ret
 571
 572
 573 def includes_objects(bld, t, chain, inc_loops):
 574     '''recursively calculate the includes object dependencies for a target
 575
 576     includes dependencies come from either library or object dependencies
 577     '''
 578     ret = getattr(t, 'includes_objects', None)
 579     if ret is not None:
 580         return ret
 581
 582     ret = t.direct_objects.copy()
 583     ret = ret.union(t.direct_libs)
 584
 585     for obj in t.direct_objects:
 586         if obj in chain:
 587             dependency_loop(inc_loops, t, obj)
 588             continue
 589         chain.add(obj)
 590         t2 = bld.get_tgen_by_name(obj)
 591         r2 = includes_objects(bld, t2, chain, inc_loops)
 592         chain.remove(obj)
 593         ret = ret.union(t2.direct_objects)
 594         ret = ret.union(r2)
 595
 596     for lib in t.direct_libs:
 597         if lib in chain:
 598             dependency_loop(inc_loops, t, lib)
 599             continue
 600         chain.add(lib)
 601         t2 = bld.get_tgen_by_name(lib)
 602         if t2 is None:
 603             targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
 604             Logs.error('Target %s of type %s not found in direct_libs for %s' % (
 605                 lib, targets[lib], t.sname))
 606             sys.exit(1)
 607         r2 = includes_objects(bld, t2, chain, inc_loops)
 608         chain.remove(lib)
 609         ret = ret.union(t2.direct_objects)
 610         ret = ret.union(r2)
 611
 612     t.includes_objects = ret
 613     return ret
 614
 615
 616 def break_dependency_loops(bld, tgt_list):
 617     '''find and break dependency loops'''
 618     loops = {}
 619     inc_loops = {}
 620
 621     # build up the list of loops
 622     for t in tgt_list:
 623         indirect_objects(bld, t, set(), loops)
 624         indirect_libs(bld, t, set(), loops)
 625         includes_objects(bld, t, set(), inc_loops)
 626
 627     # break the loops
 628     for t in tgt_list:
 629         if t.sname in loops:
 630             for attr in ['direct_objects', 'indirect_objects', 'direct_libs', 'indirect_libs']:
 631                 objs = getattr(t, attr, set())
 632                 setattr(t, attr, objs.difference(loops[t.sname]))
 633
 634     for loop in loops:
 635         debug('deps: Found dependency loops for target %s : %s', loop, loops[loop])
 636
 637     for loop in inc_loops:
 638         debug('deps: Found include loops for target %s : %s', loop, inc_loops[loop])
 639
 640     # expand the loops mapping by one level
 641     for loop in loops.copy():
 642         for tgt in loops[loop]:
 643             if tgt in loops:
 644                 loops[loop] = loops[loop].union(loops[tgt])
 645
 646     for loop in inc_loops.copy():
 647         for tgt in inc_loops[loop]:
 648             if tgt in inc_loops:
 649                 inc_loops[loop] = inc_loops[loop].union(inc_loops[tgt])
 650
 651
 652     # expand indirect subsystem and library loops
 653     for loop in loops.copy():
 654         t = bld.get_tgen_by_name(loop)
 655         if t.samba_type in ['SUBSYSTEM']:
 656             loops[loop] = loops[loop].union(t.indirect_objects)
 657             loops[loop] = loops[loop].union(t.direct_objects)
 658         if t.samba_type in ['LIBRARY','PYTHON']:
 659             loops[loop] = loops[loop].union(t.indirect_libs)
 660             loops[loop] = loops[loop].union(t.direct_libs)
 661         if loop in loops[loop]:
 662             loops[loop].remove(loop)
 663
 664     # expand indirect includes loops
 665     for loop in inc_loops.copy():
 666         t = bld.get_tgen_by_name(loop)
 667         inc_loops[loop] = inc_loops[loop].union(t.includes_objects)
 668         if loop in inc_loops[loop]:
 669             inc_loops[loop].remove(loop)
 670
 671     # add in the replacement dependencies
 672     for t in tgt_list:
 673         for loop in loops:
 674             for attr in ['indirect_objects', 'indirect_libs']:
 675                 objs = getattr(t, attr, set())
 676                 if loop in objs:
 677                     diff = loops[loop].difference(objs)
 678                     if t.sname in diff:
 679                         diff.remove(t.sname)
 680                     if diff:
 681                         debug('deps: Expanded target %s of type %s from loop %s by %s', t.sname, t.samba_type, loop, diff)
 682                         objs = objs.union(diff)
 683                 setattr(t, attr, objs)
 684
 685         for loop in inc_loops:
 686             objs = getattr(t, 'includes_objects', set())
 687             if loop in objs:
 688                 diff = inc_loops[loop].difference(objs)
 689                 if t.sname in diff:
 690                     diff.remove(t.sname)
 691                 if diff:
 692                     debug('deps: Expanded target %s includes of type %s from loop %s by %s', t.sname, t.samba_type, loop, diff)
 693                     objs = objs.union(diff)
 694             setattr(t, 'includes_objects', objs)
 695
 696
 697 def reduce_objects(bld, tgt_list):
 698     '''reduce objects by looking for indirect object dependencies'''
 699     rely_on = {}
 700
 701     for t in tgt_list:
 702         t.extended_objects = None
 703
 704     changed = False
 705
 706     for type in ['BINARY', 'PYTHON', 'LIBRARY']:
 707         for t in tgt_list:
 708             if t.samba_type != type: continue
 709             # if we will indirectly link to a target then we don't need it
 710             new = t.final_objects.copy()
 711             for l in t.final_libs:
 712                 t2 = bld.get_tgen_by_name(l)
 713                 t2_obj = extended_objects(bld, t2, set())
 714                 dup = new.intersection(t2_obj)
 715                 if t.sname in rely_on:
 716                     dup = dup.difference(rely_on[t.sname])
 717                 if dup:
 718                     debug('deps: removing dups from %s of type %s: %s also in %s %s',
 719                           t.sname, t.samba_type, dup, t2.samba_type, l)
 720                     new = new.difference(dup)
 721                     changed = True
 722                     if not l in rely_on:
 723                         rely_on[l] = set()
 724                     rely_on[l] = rely_on[l].union(dup)
 725             t.final_objects = new
 726
 727     if not changed:
 728         return False
 729
 730     # add back in any objects that were relied upon by the reduction rules
 731     for r in rely_on:
 732         t = bld.get_tgen_by_name(r)
 733         t.final_objects = t.final_objects.union(rely_on[r])
 734
 735     return True
 736
 737
 738 def show_library_loop(bld, lib1, lib2, path, seen):
 739     '''show the detailed path of a library loop between lib1 and lib2'''
 740
 741     t = bld.get_tgen_by_name(lib1)
 742     if not lib2 in getattr(t, 'final_libs', set()):
 743         return
 744
 745     for d in t.samba_deps_extended:
 746         if d in seen:
 747             continue
 748         seen.add(d)
 749         path2 = path + '=>' + d
 750         if d == lib2:
 751             Logs.warn('library loop path: ' + path2)
 752             return
 753         show_library_loop(bld, d, lib2, path2, seen)
 754         seen.remove(d)
 755
 756
 757 def calculate_final_deps(bld, tgt_list, loops):
 758     '''calculate the final library and object dependencies'''
 759     for t in tgt_list:
 760         # start with the maximum possible list
 761         t.final_libs    = t.direct_libs.union(indirect_libs(bld, t, set(), loops))
 762         t.final_objects = t.direct_objects.union(indirect_objects(bld, t, set(), loops))
 763
 764     for t in tgt_list:
 765         # don't depend on ourselves
 766         if t.sname in t.final_libs:
 767             t.final_libs.remove(t.sname)
 768         if t.sname in t.final_objects:
 769             t.final_objects.remove(t.sname)
 770
 771     # handle any non-shared binaries
 772     for t in tgt_list:
 773         if t.samba_type == 'BINARY' and bld.NONSHARED_BINARY(t.sname):
 774             subsystem_list = LOCAL_CACHE(bld, 'INIT_FUNCTIONS')
 775             targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
 776
 777             # replace lib deps with objlist deps
 778             for l in t.final_libs:
 779                 objname = l + '.objlist'
 780                 t2 = bld.get_tgen_by_name(objname)
 781                 if t2 is None:
 782                     Logs.error('ERROR: subsystem %s not found' % objname)
 783                     sys.exit(1)
 784                 t.final_objects.add(objname)
 785                 t.final_objects = t.final_objects.union(extended_objects(bld, t2, set()))
 786                 if l in subsystem_list:
 787                     # its a subsystem - we also need the contents of any modules
 788                     for d in subsystem_list[l]:
 789                         module_name = d['TARGET']
 790                         if targets[module_name] == 'LIBRARY':
 791                             objname = module_name + '.objlist'
 792                         elif targets[module_name] == 'SUBSYSTEM':
 793                             objname = module_name
 794                         else:
 795                             continue
 796                         t2 = bld.get_tgen_by_name(objname)
 797                         if t2 is None:
 798                             Logs.error('ERROR: subsystem %s not found' % objname)
 799                             sys.exit(1)
 800                         t.final_objects.add(objname)
 801                         t.final_objects = t.final_objects.union(extended_objects(bld, t2, set()))
 802             t.final_libs = set()
 803
 804     # find any library loops
 805     for t in tgt_list:
 806         if t.samba_type in ['LIBRARY', 'PYTHON']:
 807             for l in t.final_libs.copy():
 808                 t2 = bld.get_tgen_by_name(l)
 809                 if t.sname in t2.final_libs:
 810                     if getattr(bld.env, "ALLOW_CIRCULAR_LIB_DEPENDENCIES", False):
 811                         # we could break this in either direction. If one of the libraries
 812                         # has a version number, and will this be distributed publicly, then
 813                         # we should make it the lower level library in the DAG
 814                         Logs.warn('deps: removing library loop %s from %s' % (t.sname, t2.sname))
 815                         dependency_loop(loops, t, t2.sname)
 816                         t2.final_libs.remove(t.sname)
 817                     else:
 818                         Logs.error('ERROR: circular library dependency between %s and %s'
 819                             % (t.sname, t2.sname))
 820                         show_library_loop(bld, t.sname, t2.sname, t.sname, set())
 821                         show_library_loop(bld, t2.sname, t.sname, t2.sname, set())
 822                         sys.exit(1)
 823
 824     for loop in loops:
 825         debug('deps: Found dependency loops for target %s : %s', loop, loops[loop])
 826
 827     # we now need to make corrections for any library loops we broke up
 828     # any target that depended on the target of the loop and doesn't
 829     # depend on the source of the loop needs to get the loop source added
 830     for type in ['BINARY','PYTHON','LIBRARY','BINARY']:
 831         for t in tgt_list:
 832             if t.samba_type != type: continue
 833             for loop in loops:
 834                 if loop in t.final_libs:
 835                     diff = loops[loop].difference(t.final_libs)
 836                     if t.sname in diff:
 837                         diff.remove(t.sname)
 838                     if t.sname in diff:
 839                         diff.remove(t.sname)
 840                     # make sure we don't recreate the loop again!
 841                     for d in diff.copy():
 842                         t2 = bld.get_tgen_by_name(d)
 843                         if t2.samba_type == 'LIBRARY':
 844                             if t.sname in t2.final_libs:
 845                                 debug('deps: removing expansion %s from %s', d, t.sname)
 846                                 diff.remove(d)
 847                     if diff:
 848                         debug('deps: Expanded target %s by loop %s libraries (loop %s) %s', t.sname, loop,
 849                               loops[loop], diff)
 850                         t.final_libs = t.final_libs.union(diff)
 851
 852     # remove objects that are also available in linked libs
 853     count = 0
 854     while reduce_objects(bld, tgt_list):
 855         count += 1
 856         if count > 100:
 857             Logs.warn("WARNING: Unable to remove all inter-target object duplicates")
 858             break
 859     debug('deps: Object reduction took %u iterations', count)
 860
 861     # add in any syslib dependencies
 862     for t in tgt_list:
 863         if not t.samba_type in ['BINARY','PYTHON','LIBRARY','SUBSYSTEM']:
 864             continue
 865         syslibs = set()
 866         for d in t.final_objects:
 867             t2 = bld.get_tgen_by_name(d)
 868             syslibs = syslibs.union(t2.direct_syslibs)
 869         # this adds the indirect syslibs as well, which may not be needed
 870         # depending on the linker flags
 871         for d in t.final_libs:
 872             t2 = bld.get_tgen_by_name(d)
 873             syslibs = syslibs.union(t2.direct_syslibs)
 874         t.final_syslibs = syslibs
 875
 876
 877     # find any unresolved library loops
 878     lib_loop_error = False
 879     for t in tgt_list:
 880         if t.samba_type in ['LIBRARY', 'PYTHON']:
 881             for l in t.final_libs.copy():
 882                 t2 = bld.get_tgen_by_name(l)
 883                 if t.sname in t2.final_libs:
 884                     Logs.error('ERROR: Unresolved library loop %s from %s' % (t.sname, t2.sname))
 885                     lib_loop_error = True
 886     if lib_loop_error:
 887         sys.exit(1)
 888
 889     debug('deps: removed duplicate dependencies')
 890
 891
 892 def show_dependencies(bld, target, seen):
 893     '''recursively show the dependencies of target'''
 894
 895     if target in seen:
 896         return
 897
 898     t = bld.get_tgen_by_name(target)
 899     if t is None:
 900         Logs.error("ERROR: Unable to find target '%s'" % target)
 901         sys.exit(1)
 902
 903     Logs.info('%s(OBJECTS): %s' % (target, t.direct_objects))
 904     Logs.info('%s(LIBS): %s' % (target, t.direct_libs))
 905     Logs.info('%s(SYSLIBS): %s' % (target, t.direct_syslibs))
 906
 907     seen.add(target)
 908
 909     for t2 in t.direct_objects:
 910         show_dependencies(bld, t2, seen)
 911
 912
 913 def show_object_duplicates(bld, tgt_list):
 914     '''show a list of object files that are included in more than
 915     one library or binary'''
 916
 917     targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
 918
 919     used_by = {}
 920
 921     Logs.info("showing duplicate objects")
 922
 923     for t in tgt_list:
 924         if not targets[t.sname] in [ 'LIBRARY', 'PYTHON' ]:
 925             continue
 926         for n in getattr(t, 'final_objects', set()):
 927             t2 = bld.get_tgen_by_name(n)
 928             if not n in used_by:
 929                 used_by[n] = set()
 930             used_by[n].add(t.sname)
 931
 932     for n in used_by:
 933         if len(used_by[n]) > 1:
 934             Logs.info("target '%s' is used by %s" % (n, used_by[n]))
 935
 936     Logs.info("showing indirect dependency counts (sorted by count)")
 937
 938     def indirect_count(t1, t2):
 939         return len(t2.indirect_objects) - len(t1.indirect_objects)
 940
 941     sorted_list = sorted(tgt_list, cmp=indirect_count)
 942     for t in sorted_list:
 943         if len(t.indirect_objects) > 1:
 944             Logs.info("%s depends on %u indirect objects" % (t.sname, len(t.indirect_objects)))
 945
 946
 947 ######################################################################
 948 # this provides a way to save our dependency calculations between runs
 949 savedeps_version = 3
 950 savedeps_inputs  = ['samba_deps', 'samba_includes', 'local_include', 'local_include_first', 'samba_cflags',
 951                     'source', 'grouping_library', 'samba_ldflags', 'allow_undefined_symbols',
 952                     'use_global_deps', 'global_include' ]
 953 savedeps_outputs = ['uselib', 'uselib_local', 'add_objects', 'includes',
 954                     'ccflags', 'ldflags', 'samba_deps_extended', 'final_libs']
 955 savedeps_outenv  = ['INC_PATHS']
 956 savedeps_envvars = ['NONSHARED_BINARIES', 'GLOBAL_DEPENDENCIES', 'EXTRA_CFLAGS', 'EXTRA_LDFLAGS', 'EXTRA_INCLUDES' ]
 957 savedeps_caches  = ['GLOBAL_DEPENDENCIES', 'TARGET_TYPE', 'INIT_FUNCTIONS', 'SYSLIB_DEPS']
 958 savedeps_files   = ['buildtools/wafsamba/samba_deps.py']
 959
 960 def save_samba_deps(bld, tgt_list):
 961     '''save the dependency calculations between builds, to make
 962        further builds faster'''
 963     denv = Environment.Environment()
 964
 965     denv.version = savedeps_version
 966     denv.savedeps_inputs = savedeps_inputs
 967     denv.savedeps_outputs = savedeps_outputs
 968     denv.input = {}
 969     denv.output = {}
 970     denv.outenv = {}
 971     denv.caches = {}
 972     denv.envvar = {}
 973     denv.files  = {}
 974
 975     for f in savedeps_files:
 976         denv.files[f] = os.stat(os.path.join(bld.srcnode.abspath(), f)).st_mtime
 977
 978     for c in savedeps_caches:
 979         denv.caches[c] = LOCAL_CACHE(bld, c)
 980
 981     for e in savedeps_envvars:
 982         denv.envvar[e] = bld.env[e]
 983
 984     for t in tgt_list:
 985         # save all the input attributes for each target
 986         tdeps = {}
 987         for attr in savedeps_inputs:
 988             v = getattr(t, attr, None)
 989             if v is not None:
 990                 tdeps[attr] = v
 991         if tdeps != {}:
 992             denv.input[t.sname] = tdeps
 993
 994         # save all the output attributes for each target
 995         tdeps = {}
 996         for attr in savedeps_outputs:
 997             v = getattr(t, attr, None)
 998             if v is not None:
 999                 tdeps[attr] = v
1000         if tdeps != {}:
1001             denv.output[t.sname] = tdeps
1002
1003         tdeps = {}
1004         for attr in savedeps_outenv:
1005             if attr in t.env:
1006                 tdeps[attr] = t.env[attr]
1007         if tdeps != {}:
1008             denv.outenv[t.sname] = tdeps
1009
1010     depsfile = os.path.join(bld.bdir, "sambadeps")
1011     denv.store_fast(depsfile)
1012
1013
1014
1015 def load_samba_deps(bld, tgt_list):
1016     '''load a previous set of build dependencies if possible'''
1017     depsfile = os.path.join(bld.bdir, "sambadeps")
1018     denv = Environment.Environment()
1019     try:
1020         debug('deps: checking saved dependencies')
1021         denv.load_fast(depsfile)
1022         if (denv.version != savedeps_version or
1023             denv.savedeps_inputs != savedeps_inputs or
1024             denv.savedeps_outputs != savedeps_outputs):
1025             return False
1026     except Exception:
1027         return False
1028
1029     # check if critical files have changed
1030     for f in savedeps_files:
1031         if f not in denv.files:
1032             return False
1033         if denv.files[f] != os.stat(os.path.join(bld.srcnode.abspath(), f)).st_mtime:
1034             return False
1035
1036     # check if caches are the same
1037     for c in savedeps_caches:
1038         if c not in denv.caches or denv.caches[c] != LOCAL_CACHE(bld, c):
1039             return False
1040
1041     # check if caches are the same
1042     for e in savedeps_envvars:
1043         if e not in denv.envvar or denv.envvar[e] != bld.env[e]:
1044             return False
1045
1046     # check inputs are the same
1047     for t in tgt_list:
1048         tdeps = {}
1049         for attr in savedeps_inputs:
1050             v = getattr(t, attr, None)
1051             if v is not None:
1052                 tdeps[attr] = v
1053         if t.sname in denv.input:
1054             olddeps = denv.input[t.sname]
1055         else:
1056             olddeps = {}
1057         if tdeps != olddeps:
1058             #print '%s: \ntdeps=%s \nodeps=%s' % (t.sname, tdeps, olddeps)
1059             return False
1060
1061     # put outputs in place
1062     for t in tgt_list:
1063         if not t.sname in denv.output: continue
1064         tdeps = denv.output[t.sname]
1065         for a in tdeps:
1066             setattr(t, a, tdeps[a])
1067
1068     # put output env vars in place
1069     for t in tgt_list:
1070         if not t.sname in denv.outenv: continue
1071         tdeps = denv.outenv[t.sname]
1072         for a in tdeps:
1073             t.env[a] = tdeps[a]
1074
1075     debug('deps: loaded saved dependencies')
1076     return True
1077
1078
1079
1080 def check_project_rules(bld):
1081     '''check the project rules - ensuring the targets are sane'''
1082
1083     loops = {}
1084     inc_loops = {}
1085
1086     tgt_list = get_tgt_list(bld)
1087
1088     add_samba_attributes(bld, tgt_list)
1089
1090     force_project_rules = (Options.options.SHOWDEPS or
1091                            Options.options.SHOW_DUPLICATES)
1092
1093     if not force_project_rules and load_samba_deps(bld, tgt_list):
1094         return
1095
1096     global tstart
1097     tstart = time.clock()
1098
1099     bld.new_rules = True
1100     Logs.info("Checking project rules ...")
1101
1102     debug('deps: project rules checking started')
1103
1104     expand_subsystem_deps(bld)
1105
1106     debug("deps: expand_subsystem_deps: %f" % (time.clock() - tstart))
1107
1108     replace_grouping_libraries(bld, tgt_list)
1109
1110     debug("deps: replace_grouping_libraries: %f" % (time.clock() - tstart))
1111
1112     build_direct_deps(bld, tgt_list)
1113
1114     debug("deps: build_direct_deps: %f" % (time.clock() - tstart))
1115
1116     break_dependency_loops(bld, tgt_list)
1117
1118     debug("deps: break_dependency_loops: %f" % (time.clock() - tstart))
1119
1120     if Options.options.SHOWDEPS:
1121             show_dependencies(bld, Options.options.SHOWDEPS, set())
1122
1123     calculate_final_deps(bld, tgt_list, loops)
1124
1125     debug("deps: calculate_final_deps: %f" % (time.clock() - tstart))
1126
1127     if Options.options.SHOW_DUPLICATES:
1128             show_object_duplicates(bld, tgt_list)
1129
1130     # run the various attribute generators
1131     for f in [ build_dependencies, build_includes, add_init_functions ]:
1132         debug('deps: project rules checking %s', f)
1133         for t in tgt_list: f(t)
1134         debug("deps: %s: %f" % (f, time.clock() - tstart))
1135
1136     debug('deps: project rules stage1 completed')
1137
1138     if not check_duplicate_sources(bld, tgt_list):
1139         Logs.error("Duplicate sources present - aborting")
1140         sys.exit(1)
1141
1142     debug("deps: check_duplicate_sources: %f" % (time.clock() - tstart))
1143
1144     if not bld.check_group_ordering(tgt_list):
1145         Logs.error("Bad group ordering - aborting")
1146         sys.exit(1)
1147
1148     debug("deps: check_group_ordering: %f" % (time.clock() - tstart))
1149
1150     show_final_deps(bld, tgt_list)
1151
1152     debug("deps: show_final_deps: %f" % (time.clock() - tstart))
1153
1154     debug('deps: project rules checking completed - %u targets checked',
1155           len(tgt_list))
1156
1157     if not bld.is_install:
1158         save_samba_deps(bld, tgt_list)
1159
1160     debug("deps: save_samba_deps: %f" % (time.clock() - tstart))
1161
1162     Logs.info("Project rules pass")
1163
1164
1165 def CHECK_PROJECT_RULES(bld):
1166     '''enable checking of project targets for sanity'''
1167     if bld.env.added_project_rules:
1168         return
1169     bld.env.added_project_rules = True
1170     bld.add_pre_fun(check_project_rules)
1171 Build.BuildContext.CHECK_PROJECT_RULES = CHECK_PROJECT_RULES
1172
1173