buildtools/wafsamba: use top for waf 2.0
[samba.git] / buildtools / wafsamba / symbols.py
1 # a waf tool to extract symbols from object files or libraries
2 # using nm, producing a set of exposed defined/undefined symbols
3
4 import os, re, subprocess
5 from waflib import Utils, Build, Options, Logs, Errors
6 from waflib.Logs import debug
7 from samba_utils import TO_LIST, LOCAL_CACHE, get_tgt_list, os_path_relpath
8
9 # these are the data structures used in symbols.py:
10 #
11 # bld.env.symbol_map : dictionary mapping public symbol names to list of
12 #                      subsystem names where that symbol exists
13 #
14 # t.in_library       : list of libraries that t is in
15 #
16 # bld.env.public_symbols: set of public symbols for each subsystem
17 # bld.env.used_symbols  : set of used symbols for each subsystem
18 #
19 # bld.env.syslib_symbols: dictionary mapping system library name to set of symbols
20 #                         for that library
21 # bld.env.library_dict  : dictionary mapping built library paths to subsystem names
22 #
23 # LOCAL_CACHE(bld, 'TARGET_TYPE') : dictionary mapping subsystem name to target type
24
25
26 def symbols_extract(bld, objfiles, dynamic=False):
27     '''extract symbols from objfile, returning a dictionary containing
28        the set of undefined and public symbols for each file'''
29
30     ret = {}
31
32     # see if we can get some results from the nm cache
33     if not bld.env.nm_cache:
34         bld.env.nm_cache = {}
35
36     objfiles = set(objfiles).copy()
37
38     remaining = set()
39     for obj in objfiles:
40         if obj in bld.env.nm_cache:
41             ret[obj] = bld.env.nm_cache[obj].copy()
42         else:
43             remaining.add(obj)
44     objfiles = remaining
45
46     if len(objfiles) == 0:
47         return ret
48
49     cmd = ["nm"]
50     if dynamic:
51         # needed for some .so files
52         cmd.append("-D")
53     cmd.extend(list(objfiles))
54
55     nmpipe = subprocess.Popen(cmd, stdout=subprocess.PIPE).stdout
56     if len(objfiles) == 1:
57         filename = list(objfiles)[0]
58         ret[filename] = { "PUBLIC": set(), "UNDEFINED" : set()}
59
60     for line in nmpipe:
61         line = line.strip()
62         if line.endswith(':'):
63             filename = line[:-1]
64             ret[filename] = { "PUBLIC": set(), "UNDEFINED" : set() }
65             continue
66         cols = line.split(" ")
67         if cols == ['']:
68             continue
69         # see if the line starts with an address
70         if len(cols) == 3:
71             symbol_type = cols[1]
72             symbol = cols[2]
73         else:
74             symbol_type = cols[0]
75             symbol = cols[1]
76         if symbol_type in "BDGTRVWSi":
77             # its a public symbol
78             ret[filename]["PUBLIC"].add(symbol)
79         elif symbol_type in "U":
80             ret[filename]["UNDEFINED"].add(symbol)
81
82     # add to the cache
83     for obj in objfiles:
84         if obj in ret:
85             bld.env.nm_cache[obj] = ret[obj].copy()
86         else:
87             bld.env.nm_cache[obj] = { "PUBLIC": set(), "UNDEFINED" : set() }
88
89     return ret
90
91
92 def real_name(name):
93     if name.find(".objlist") != -1:
94         name = name[:-8]
95     return name
96
97
98 def find_ldd_path(bld, libname, binary):
99     '''find the path to the syslib we will link against'''
100     ret = None
101     if not bld.env.syslib_paths:
102         bld.env.syslib_paths = {}
103     if libname in bld.env.syslib_paths:
104         return bld.env.syslib_paths[libname]
105
106     lddpipe = subprocess.Popen(['ldd', binary], stdout=subprocess.PIPE).stdout
107     for line in lddpipe:
108         line = line.strip()
109         cols = line.split(" ")
110         if len(cols) < 3 or cols[1] != "=>":
111             continue
112         if cols[0].startswith("libc."):
113             # save this one too
114             bld.env.libc_path = cols[2]
115         if cols[0].startswith(libname):
116             ret = cols[2]
117     bld.env.syslib_paths[libname] = ret
118     return ret
119
120
121 # some regular expressions for parsing readelf output
122 re_sharedlib = re.compile('Shared library: \[(.*)\]')
123 re_rpath     = re.compile('Library rpath: \[(.*)\]')
124
125 def get_libs(bld, binname):
126     '''find the list of linked libraries for any binary or library
127     binname is the path to the binary/library on disk
128
129     We do this using readelf instead of ldd as we need to avoid recursing
130     into system libraries
131     '''
132
133     # see if we can get the result from the ldd cache
134     if not bld.env.lib_cache:
135         bld.env.lib_cache = {}
136     if binname in bld.env.lib_cache:
137         return bld.env.lib_cache[binname].copy()
138
139     rpath = []
140     libs = set()
141
142     elfpipe = subprocess.Popen(['readelf', '--dynamic', binname], stdout=subprocess.PIPE).stdout
143     for line in elfpipe:
144         m = re_sharedlib.search(line)
145         if m:
146             libs.add(m.group(1))
147         m = re_rpath.search(line)
148         if m:
149             rpath.extend(m.group(1).split(":"))
150
151     ret = set()
152     for lib in libs:
153         found = False
154         for r in rpath:
155             path = os.path.join(r, lib)
156             if os.path.exists(path):
157                 ret.add(os.path.realpath(path))
158                 found = True
159                 break
160         if not found:
161             # we didn't find this lib using rpath. It is probably a system
162             # library, so to find the path to it we either need to use ldd
163             # or we need to start parsing /etc/ld.so.conf* ourselves. We'll
164             # use ldd for now, even though it is slow
165             path = find_ldd_path(bld, lib, binname)
166             if path:
167                 ret.add(os.path.realpath(path))
168
169     bld.env.lib_cache[binname] = ret.copy()
170
171     return ret
172
173
174 def get_libs_recursive(bld, binname, seen):
175     '''find the recursive list of linked libraries for any binary or library
176     binname is the path to the binary/library on disk. seen is a set used
177     to prevent loops
178     '''
179     if binname in seen:
180         return set()
181     ret = get_libs(bld, binname)
182     seen.add(binname)
183     for lib in ret:
184         # we don't want to recurse into system libraries. If a system
185         # library that we use (eg. libcups) happens to use another library
186         # (such as libkrb5) which contains common symbols with our own
187         # libraries, then that is not an error
188         if lib in bld.env.library_dict:
189             ret = ret.union(get_libs_recursive(bld, lib, seen))
190     return ret
191
192
193
194 def find_syslib_path(bld, libname, deps):
195     '''find the path to the syslib we will link against'''
196     # the strategy is to use the targets that depend on the library, and run ldd
197     # on it to find the real location of the library that is used
198
199     linkpath = deps[0].link_task.outputs[0].abspath(bld.env)
200
201     if libname == "python":
202         libname += bld.env.PYTHON_VERSION
203
204     return find_ldd_path(bld, "lib%s" % libname.lower(), linkpath)
205
206
207 def build_symbol_sets(bld, tgt_list):
208     '''build the public_symbols and undefined_symbols attributes for each target'''
209
210     if bld.env.public_symbols:
211         return
212
213     objlist = []  # list of object file
214     objmap = {}   # map from object filename to target (subsystem) name
215
216     for t in tgt_list:
217         t.public_symbols = set()
218         t.undefined_symbols = set()
219         t.used_symbols = set()
220         for tsk in getattr(t, 'compiled_tasks', []):
221             for output in tsk.outputs:
222                 objpath = output.abspath(bld.env)
223                 objlist.append(objpath)
224                 objmap[objpath] = t
225
226     symbols = symbols_extract(bld, objlist)
227     for obj in objlist:
228         t = objmap[obj]
229         t.public_symbols = t.public_symbols.union(symbols[obj]["PUBLIC"])
230         t.undefined_symbols = t.undefined_symbols.union(symbols[obj]["UNDEFINED"])
231         t.used_symbols = t.used_symbols.union(symbols[obj]["UNDEFINED"])
232
233     t.undefined_symbols = t.undefined_symbols.difference(t.public_symbols)
234
235     # and the reverse map of public symbols to subsystem name
236     bld.env.symbol_map = {}
237
238     for t in tgt_list:
239         for s in t.public_symbols:
240             if not s in bld.env.symbol_map:
241                 bld.env.symbol_map[s] = []
242             bld.env.symbol_map[s].append(real_name(t.sname))
243
244     targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
245
246     bld.env.public_symbols = {}
247     for t in tgt_list:
248         name = real_name(t.sname)
249         if name in bld.env.public_symbols:
250             bld.env.public_symbols[name] = bld.env.public_symbols[name].union(t.public_symbols)
251         else:
252             bld.env.public_symbols[name] = t.public_symbols
253         if t.samba_type == 'LIBRARY':
254             for dep in t.add_objects:
255                 t2 = bld.get_tgen_by_name(dep)
256                 bld.ASSERT(t2 is not None, "Library '%s' has unknown dependency '%s'" % (name, dep))
257                 bld.env.public_symbols[name] = bld.env.public_symbols[name].union(t2.public_symbols)
258
259     bld.env.used_symbols = {}
260     for t in tgt_list:
261         name = real_name(t.sname)
262         if name in bld.env.used_symbols:
263             bld.env.used_symbols[name] = bld.env.used_symbols[name].union(t.used_symbols)
264         else:
265             bld.env.used_symbols[name] = t.used_symbols
266         if t.samba_type == 'LIBRARY':
267             for dep in t.add_objects:
268                 t2 = bld.get_tgen_by_name(dep)
269                 bld.ASSERT(t2 is not None, "Library '%s' has unknown dependency '%s'" % (name, dep))
270                 bld.env.used_symbols[name] = bld.env.used_symbols[name].union(t2.used_symbols)
271
272
273 def build_library_dict(bld, tgt_list):
274     '''build the library_dict dictionary'''
275
276     if bld.env.library_dict:
277         return
278
279     bld.env.library_dict = {}
280
281     for t in tgt_list:
282         if t.samba_type in [ 'LIBRARY', 'PYTHON' ]:
283             linkpath = os.path.realpath(t.link_task.outputs[0].abspath(bld.env))
284             bld.env.library_dict[linkpath] = t.sname
285
286
287 def build_syslib_sets(bld, tgt_list):
288     '''build the public_symbols for all syslibs'''
289
290     if bld.env.syslib_symbols:
291         return
292
293     # work out what syslibs we depend on, and what targets those are used in
294     syslibs = {}
295     objmap = {}
296     for t in tgt_list:
297         if getattr(t, 'uselib', []) and t.samba_type in [ 'LIBRARY', 'BINARY', 'PYTHON' ]:
298             for lib in t.uselib:
299                 if lib in ['PYEMBED', 'PYEXT']:
300                     lib = "python"
301                 if not lib in syslibs:
302                     syslibs[lib] = []
303                 syslibs[lib].append(t)
304
305     # work out the paths to each syslib
306     syslib_paths = []
307     for lib in syslibs:
308         path = find_syslib_path(bld, lib, syslibs[lib])
309         if path is None:
310             Logs.warn("Unable to find syslib path for %s" % lib)
311         if path is not None:
312             syslib_paths.append(path)
313             objmap[path] = lib.lower()
314
315     # add in libc
316     syslib_paths.append(bld.env.libc_path)
317     objmap[bld.env.libc_path] = 'c'
318
319     symbols = symbols_extract(bld, syslib_paths, dynamic=True)
320
321     # keep a map of syslib names to public symbols
322     bld.env.syslib_symbols = {}
323     for lib in symbols:
324         bld.env.syslib_symbols[lib] = symbols[lib]["PUBLIC"]
325
326     # add to the map of symbols to dependencies
327     for lib in symbols:
328         for sym in symbols[lib]["PUBLIC"]:
329             if not sym in bld.env.symbol_map:
330                 bld.env.symbol_map[sym] = []
331             bld.env.symbol_map[sym].append(objmap[lib])
332
333     # keep the libc symbols as well, as these are useful for some of the
334     # sanity checks
335     bld.env.libc_symbols = symbols[bld.env.libc_path]["PUBLIC"]
336
337     # add to the combined map of dependency name to public_symbols
338     for lib in bld.env.syslib_symbols:
339         bld.env.public_symbols[objmap[lib]] = bld.env.syslib_symbols[lib]
340
341
342 def build_autodeps(bld, t):
343     '''build the set of dependencies for a target'''
344     deps = set()
345     name = real_name(t.sname)
346
347     targets    = LOCAL_CACHE(bld, 'TARGET_TYPE')
348
349     for sym in t.undefined_symbols:
350         if sym in t.public_symbols:
351             continue
352         if sym in bld.env.symbol_map:
353             depname = bld.env.symbol_map[sym]
354             if depname == [ name ]:
355                 # self dependencies aren't interesting
356                 continue
357             if t.in_library == depname:
358                 # no need to depend on the library we are part of
359                 continue
360             if depname[0] in ['c', 'python']:
361                 # these don't go into autodeps
362                 continue
363             if targets[depname[0]] in [ 'SYSLIB' ]:
364                 deps.add(depname[0])
365                 continue
366             t2 = bld.get_tgen_by_name(depname[0])
367             if len(t2.in_library) != 1:
368                 deps.add(depname[0])
369                 continue
370             if t2.in_library == t.in_library:
371                 # if we're part of the same library, we don't need to autodep
372                 continue
373             deps.add(t2.in_library[0])
374     t.autodeps = deps
375
376
377 def build_library_names(bld, tgt_list):
378     '''add a in_library attribute to all targets that are part of a library'''
379
380     if bld.env.done_build_library_names:
381         return
382
383     for t in tgt_list:
384         t.in_library = []
385
386     for t in tgt_list:
387         if t.samba_type in [ 'LIBRARY' ]:
388             for obj in t.samba_deps_extended:
389                 t2 = bld.get_tgen_by_name(obj)
390                 if t2 and t2.samba_type in [ 'SUBSYSTEM', 'ASN1' ]:
391                     if not t.sname in t2.in_library:
392                         t2.in_library.append(t.sname)
393     bld.env.done_build_library_names = True
394
395
396 def check_library_deps(bld, t):
397     '''check that all the autodeps that have mutual dependency of this
398     target are in the same library as the target'''
399
400     name = real_name(t.sname)
401
402     if len(t.in_library) > 1:
403         Logs.warn("WARNING: Target '%s' in multiple libraries: %s" % (t.sname, t.in_library))
404
405     for dep in t.autodeps:
406         t2 = bld.get_tgen_by_name(dep)
407         if t2 is None:
408             continue
409         for dep2 in t2.autodeps:
410             if dep2 == name and t.in_library != t2.in_library:
411                 Logs.warn("WARNING: mutual dependency %s <=> %s" % (name, real_name(t2.sname)))
412                 Logs.warn("Libraries should match. %s != %s" % (t.in_library, t2.in_library))
413                 # raise Errors.WafError("illegal mutual dependency")
414
415
416 def check_syslib_collisions(bld, tgt_list):
417     '''check if a target has any symbol collisions with a syslib
418
419     We do not want any code in Samba to use a symbol name from a
420     system library. The chance of that causing problems is just too
421     high. Note that libreplace uses a rep_XX approach of renaming
422     symbols via macros
423     '''
424
425     has_error = False
426     for t in tgt_list:
427         for lib in bld.env.syslib_symbols:
428             common = t.public_symbols.intersection(bld.env.syslib_symbols[lib])
429             if common:
430                 Logs.error("ERROR: Target '%s' has symbols '%s' which is also in syslib '%s'" % (t.sname, common, lib))
431                 has_error = True
432     if has_error:
433         raise Errors.WafError("symbols in common with system libraries")
434
435
436 def check_dependencies(bld, t):
437     '''check for depenencies that should be changed'''
438
439     if bld.get_tgen_by_name(t.sname + ".objlist"):
440         return
441
442     targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
443
444     remaining = t.undefined_symbols.copy()
445     remaining = remaining.difference(t.public_symbols)
446
447     sname = real_name(t.sname)
448
449     deps = set(t.samba_deps)
450     for d in t.samba_deps:
451         if targets[d] in [ 'EMPTY', 'DISABLED', 'SYSLIB', 'GENERATOR' ]:
452             continue
453         bld.ASSERT(d in bld.env.public_symbols, "Failed to find symbol list for dependency '%s'" % d)
454         diff = remaining.intersection(bld.env.public_symbols[d])
455         if not diff and targets[sname] != 'LIBRARY':
456             Logs.info("Target '%s' has no dependency on %s" % (sname, d))
457         else:
458             remaining = remaining.difference(diff)
459
460     t.unsatisfied_symbols = set()
461     needed = {}
462     for sym in remaining:
463         if sym in bld.env.symbol_map:
464             dep = bld.env.symbol_map[sym]
465             if not dep[0] in needed:
466                 needed[dep[0]] = set()
467             needed[dep[0]].add(sym)
468         else:
469             t.unsatisfied_symbols.add(sym)
470
471     for dep in needed:
472         Logs.info("Target '%s' should add dep '%s' for symbols %s" % (sname, dep, " ".join(needed[dep])))
473
474
475
476 def check_syslib_dependencies(bld, t):
477     '''check for syslib depenencies'''
478
479     if bld.get_tgen_by_name(t.sname + ".objlist"):
480         return
481
482     sname = real_name(t.sname)
483
484     remaining = set()
485
486     features = TO_LIST(t.features)
487     if 'pyembed' in features or 'pyext' in features:
488         if 'python' in bld.env.public_symbols:
489             t.unsatisfied_symbols = t.unsatisfied_symbols.difference(bld.env.public_symbols['python'])
490
491     needed = {}
492     for sym in t.unsatisfied_symbols:
493         if sym in bld.env.symbol_map:
494             dep = bld.env.symbol_map[sym][0]
495             if dep == 'c':
496                 continue
497             if not dep in needed:
498                 needed[dep] = set()
499             needed[dep].add(sym)
500         else:
501             remaining.add(sym)
502
503     for dep in needed:
504         Logs.info("Target '%s' should add syslib dep '%s' for symbols %s" % (sname, dep, " ".join(needed[dep])))
505
506     if remaining:
507         debug("deps: Target '%s' has unsatisfied symbols: %s" % (sname, " ".join(remaining)))
508
509
510
511 def symbols_symbolcheck(task):
512     '''check the internal dependency lists'''
513     bld = task.env.bld
514     tgt_list = get_tgt_list(bld)
515
516     build_symbol_sets(bld, tgt_list)
517     build_library_names(bld, tgt_list)
518
519     for t in tgt_list:
520         t.autodeps = set()
521         if getattr(t, 'source', ''):
522             build_autodeps(bld, t)
523
524     for t in tgt_list:
525         check_dependencies(bld, t)
526
527     for t in tgt_list:
528         check_library_deps(bld, t)
529
530 def symbols_syslibcheck(task):
531     '''check the syslib dependencies'''
532     bld = task.env.bld
533     tgt_list = get_tgt_list(bld)
534
535     build_syslib_sets(bld, tgt_list)
536     check_syslib_collisions(bld, tgt_list)
537
538     for t in tgt_list:
539         check_syslib_dependencies(bld, t)
540
541
542 def symbols_whyneeded(task):
543     """check why 'target' needs to link to 'subsystem'"""
544     bld = task.env.bld
545     tgt_list = get_tgt_list(bld)
546
547     why = Options.options.WHYNEEDED.split(":")
548     if len(why) != 2:
549         raise Errors.WafError("usage: WHYNEEDED=TARGET:DEPENDENCY")
550     target = why[0]
551     subsystem = why[1]
552
553     build_symbol_sets(bld, tgt_list)
554     build_library_names(bld, tgt_list)
555     build_syslib_sets(bld, tgt_list)
556
557     Logs.info("Checking why %s needs to link to %s" % (target, subsystem))
558     if not target in bld.env.used_symbols:
559         Logs.warn("unable to find target '%s' in used_symbols dict" % target)
560         return
561     if not subsystem in bld.env.public_symbols:
562         Logs.warn("unable to find subsystem '%s' in public_symbols dict" % subsystem)
563         return
564     overlap = bld.env.used_symbols[target].intersection(bld.env.public_symbols[subsystem])
565     if not overlap:
566         Logs.info("target '%s' doesn't use any public symbols from '%s'" % (target, subsystem))
567     else:
568         Logs.info("target '%s' uses symbols %s from '%s'" % (target, overlap, subsystem))
569
570
571 def report_duplicate(bld, binname, sym, libs, fail_on_error):
572     '''report duplicated symbols'''
573     if sym in ['_init', '_fini', '_edata', '_end', '__bss_start']:
574         return
575     libnames = []
576     for lib in libs:
577         if lib in bld.env.library_dict:
578             libnames.append(bld.env.library_dict[lib])
579         else:
580             libnames.append(lib)
581     if fail_on_error:
582         raise Errors.WafError("%s: Symbol %s linked in multiple libraries %s" % (binname, sym, libnames))
583     else:
584         print("%s: Symbol %s linked in multiple libraries %s" % (binname, sym, libnames))
585
586
587 def symbols_dupcheck_binary(bld, binname, fail_on_error):
588     '''check for duplicated symbols in one binary'''
589
590     libs = get_libs_recursive(bld, binname, set())
591     symlist = symbols_extract(bld, libs, dynamic=True)
592
593     symmap = {}
594     for libpath in symlist:
595         for sym in symlist[libpath]['PUBLIC']:
596             if sym == '_GLOBAL_OFFSET_TABLE_':
597                 continue
598             if not sym in symmap:
599                 symmap[sym] = set()
600             symmap[sym].add(libpath)
601     for sym in symmap:
602         if len(symmap[sym]) > 1:
603             for libpath in symmap[sym]:
604                 if libpath in bld.env.library_dict:
605                     report_duplicate(bld, binname, sym, symmap[sym], fail_on_error)
606                     break
607
608 def symbols_dupcheck(task, fail_on_error=False):
609     '''check for symbols defined in two different subsystems'''
610     bld = task.env.bld
611     tgt_list = get_tgt_list(bld)
612
613     targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
614
615     build_library_dict(bld, tgt_list)
616     for t in tgt_list:
617         if t.samba_type == 'BINARY':
618             binname = os_path_relpath(t.link_task.outputs[0].abspath(bld.env), os.getcwd())
619             symbols_dupcheck_binary(bld, binname, fail_on_error)
620
621
622 def symbols_dupcheck_fatal(task):
623     '''check for symbols defined in two different subsystems (and fail if duplicates are found)'''
624     symbols_dupcheck(task, fail_on_error=True)
625
626
627 def SYMBOL_CHECK(bld):
628     '''check our dependency lists'''
629     if Options.options.SYMBOLCHECK:
630         bld.SET_BUILD_GROUP('symbolcheck')
631         task = bld(rule=symbols_symbolcheck, always=True, name='symbol checking')
632         task.env.bld = bld
633
634         bld.SET_BUILD_GROUP('syslibcheck')
635         task = bld(rule=symbols_syslibcheck, always=True, name='syslib checking')
636         task.env.bld = bld
637
638         bld.SET_BUILD_GROUP('syslibcheck')
639         task = bld(rule=symbols_dupcheck, always=True, name='symbol duplicate checking')
640         task.env.bld = bld
641
642     if Options.options.WHYNEEDED:
643         bld.SET_BUILD_GROUP('syslibcheck')
644         task = bld(rule=symbols_whyneeded, always=True, name='check why a dependency is needed')
645         task.env.bld = bld
646
647
648 Build.BuildContext.SYMBOL_CHECK = SYMBOL_CHECK
649
650 def DUP_SYMBOL_CHECK(bld):
651     if Options.options.DUP_SYMBOLCHECK and bld.env.DEVELOPER:
652         '''check for duplicate symbols'''
653         bld.SET_BUILD_GROUP('syslibcheck')
654         task = bld(rule=symbols_dupcheck_fatal, always=True, name='symbol duplicate checking')
655         task.env.bld = bld
656
657 Build.BuildContext.DUP_SYMBOL_CHECK = DUP_SYMBOL_CHECK