config/check_vanilla_allocations.py

   1 # vim: set ts=8 sts=4 et sw=4 tw=79:
   2 # This Source Code Form is subject to the terms of the Mozilla Public
   3 # License, v. 2.0. If a copy of the MPL was not distributed with this
   4 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
   5
   6 # ----------------------------------------------------------------------------
   7 # All heap allocations in SpiderMonkey must go through js_malloc, js_calloc,
   8 # js_realloc, and js_free.  This is so that any embedder who uses a custom
   9 # allocator (by defining JS_USE_CUSTOM_ALLOCATOR) will see all heap allocation
  10 # go through that custom allocator.
  11 #
  12 # Therefore, the presence of any calls to "vanilla" allocation/free functions
  13 # from within SpiderMonkey itself (e.g. malloc(), free()) is a bug.  Calls from
  14 # within mozglue and non-SpiderMonkey locations are fine; there is a list of
  15 # exceptions that can be added to as the need arises.
  16 #
  17 # This script checks for the presence of such disallowed vanilla
  18 # allocation/free function in SpiderMonkey when it's built as a library.  It
  19 # relies on |nm| from the GNU binutils, and so only works on Linux, but one
  20 # platform is good enough to catch almost all violations.
  21 #
  22 # This checking is only 100% reliable in a JS_USE_CUSTOM_ALLOCATOR build in
  23 # which the default definitions of js_malloc et al (in Utility.h) -- which call
  24 # malloc et al -- are replaced with empty definitions.  This is because the
  25 # presence and possible inlining of the default js_malloc et al can cause
  26 # malloc/calloc/realloc/free calls show up in unpredictable places.
  27 #
  28 # Unfortunately, that configuration cannot be tested on Mozilla's standard
  29 # testing infrastructure.  Instead, by default this script only tests that none
  30 # of the other vanilla allocation/free functions (operator new, memalign, etc)
  31 # are present.  If given the --aggressive flag, it will also check for
  32 # malloc/calloc/realloc/free.
  33 #
  34 # Note:  We don't check for |operator delete| and |operator delete[]|.  These
  35 # can be present somehow due to virtual destructors, but this is not too
  36 # because vanilla delete/delete[] calls don't make sense without corresponding
  37 # vanilla new/new[] calls, and any explicit calls will be caught by Valgrind's
  38 # mismatched alloc/free checking.
  39 # ----------------------------------------------------------------------------
  40
  41 from __future__ import absolute_import
  42 from __future__ import print_function
  43
  44 import argparse
  45 import re
  46 import subprocess
  47 import sys
  48 import buildconfig
  49
  50 # The obvious way to implement this script is to search for occurrences of
  51 # malloc et al, succeed if none are found, and fail is some are found.
  52 # However, "none are found" does not necessarily mean "none are present" --
  53 # this script could be buggy.  (Or the output format of |nm| might change in
  54 # the future.)
  55 #
  56 # So util/Utility.cpp deliberately contains a (never-called) function that
  57 # contains a single use of all the vanilla allocation/free functions.  And this
  58 # script fails if it (a) finds uses of those functions in files other than
  59 # util/Utility.cpp, *or* (b) fails to find them in util/Utility.cpp.
  60
  61 # Tracks overall success of the test.
  62 has_failed = False
  63
  64
  65 def fail(msg):
  66     print('TEST-UNEXPECTED-FAIL | check_vanilla_allocations.py |', msg)
  67     global has_failed
  68     has_failed = True
  69
  70
  71 def main():
  72     parser = argparse.ArgumentParser()
  73     parser.add_argument('--aggressive', action='store_true',
  74                         help='also check for malloc, calloc, realloc and free')
  75     parser.add_argument('file', type=str,
  76                         help='name of the file to check')
  77     args = parser.parse_args()
  78
  79     # Run |nm|.  Options:
  80     # -u: show only undefined symbols
  81     # -C: demangle symbol names
  82     # -A: show an object filename for each undefined symbol
  83     nm = buildconfig.substs.get('NM') or 'nm'
  84     cmd = [nm, '-u', '-C', '-A', args.file]
  85     lines = subprocess.check_output(cmd, universal_newlines=True,
  86                                     stderr=subprocess.PIPE).split('\n')
  87
  88     # alloc_fns contains all the vanilla allocation/free functions that we look
  89     # for. Regexp chars are escaped appropriately.
  90
  91     alloc_fns = [
  92         # Matches |operator new(unsigned T)|, where |T| is |int| or |long|.
  93         r'operator new\(unsigned',
  94
  95         # Matches |operator new[](unsigned T)|, where |T| is |int| or |long|.
  96         r'operator new\[\]\(unsigned',
  97
  98         r'memalign',
  99         # These three aren't available on all Linux configurations.
 100         # r'posix_memalign',
 101         # r'aligned_alloc',
 102         # r'valloc',
 103     ]
 104
 105     if args.aggressive:
 106         alloc_fns += [
 107             r'malloc',
 108             r'calloc',
 109             r'realloc',
 110             r'free',
 111             r'strdup'
 112         ]
 113
 114     # This is like alloc_fns, but regexp chars are not escaped.
 115     alloc_fns_unescaped = [fn.translate(None, r'\\') for fn in alloc_fns]
 116
 117     # This regexp matches the relevant lines in the output of |nm|, which look
 118     # like the following.
 119     #
 120     #   js/src/libjs_static.a:Utility.o:              U malloc
 121     #
 122     alloc_fns_re = r'([^:/ ]+):\s+U (' + r'|'.join(alloc_fns) + r')'
 123
 124     # This tracks which allocation/free functions have been seen in
 125     # util/Utility.cpp.
 126     util_Utility_cpp = set([])
 127
 128     # Would it be helpful to emit detailed line number information after a failure?
 129     emit_line_info = False
 130
 131     for line in lines:
 132         m = re.search(alloc_fns_re, line)
 133         if m is None:
 134             continue
 135
 136         filename = m.group(1)
 137
 138         # The stdc++compat library has an implicit call to operator new in
 139         # thread::_M_start_thread.
 140         if 'stdc++compat' in filename:
 141             continue
 142
 143         # The memory allocator code contains calls to memalign. These are ok, so
 144         # we whitelist them.
 145         if "_memory_" in filename:
 146             continue
 147
 148         # Ignore the fuzzing code imported from m-c
 149         if "Fuzzer" in filename:
 150             continue
 151
 152         # Ignore the profiling pseudo-stack, since it needs to run even when
 153         # SpiderMonkey's allocator isn't initialized.
 154         if "ProfilingStack" in filename:
 155             continue
 156
 157         # Ignore implicit call to operator new in std::condition_variable_any.
 158         #
 159         # From intl/icu/source/common/umutex.h:
 160         # On Linux, the default constructor of std::condition_variable_any
 161         # produces an in-line reference to global operator new(), [...].
 162         if filename == 'umutex.o':
 163             continue
 164
 165         # Ignore allocations from decimal conversion functions inside mozglue.
 166         if filename == 'Decimal.o':
 167             continue
 168
 169         fn = m.group(2)
 170         if filename == 'Utility.o':
 171             util_Utility_cpp.add(fn)
 172         else:
 173             # An allocation is present in a non-special file.  Fail!
 174             fail("'" + fn + "' present in " + filename)
 175             # Try to give more precise information about the offending code.
 176             emit_line_info = True
 177
 178     # Check that all functions we expect are used in util/Utility.cpp.  (This
 179     # will fail if the function-detection code breaks at any point.)
 180     for fn in alloc_fns_unescaped:
 181         if fn not in util_Utility_cpp:
 182             fail("'" + fn + "' isn't used as expected in util/Utility.cpp")
 183         else:
 184             util_Utility_cpp.remove(fn)
 185
 186     # This should never happen, but check just in case.
 187     if util_Utility_cpp:
 188         fail('unexpected allocation fns used in util/Utility.cpp: ' +
 189              ', '.join(util_Utility_cpp))
 190
 191     # If we found any improper references to allocation functions, try to use
 192     # DWARF debug info to get more accurate line number information about the
 193     # bad calls. This is a lot slower than 'nm -A', and it is not always
 194     # precise when building with --enable-optimized.
 195     if emit_line_info:
 196         print('check_vanilla_allocations.py: Source lines with allocation calls:')
 197         print('check_vanilla_allocations.py: Accurate in unoptimized builds; '
 198               'util/Utility.cpp expected.')
 199
 200         # Run |nm|.  Options:
 201         # -u: show only undefined symbols
 202         # -C: demangle symbol names
 203         # -l: show line number information for each undefined symbol
 204         cmd = ['nm', '-u', '-C', '-l', args.file]
 205         lines = subprocess.check_output(cmd, universal_newlines=True,
 206                                         stderr=subprocess.PIPE).split('\n')
 207
 208         # This regexp matches the relevant lines in the output of |nm -l|,
 209         # which look like the following.
 210         #
 211         #       U malloc util/Utility.cpp:117
 212         #
 213         alloc_lines_re = r'U ((' + r'|'.join(alloc_fns) + r').*)\s+(\S+:\d+)$'
 214
 215         for line in lines:
 216             m = re.search(alloc_lines_re, line)
 217             if m:
 218                 print('check_vanilla_allocations.py:',
 219                       m.group(1), 'called at', m.group(3))
 220
 221     if has_failed:
 222         sys.exit(1)
 223
 224     print('TEST-PASS | check_vanilla_allocations.py | ok')
 225     sys.exit(0)
 226
 227
 228 if __name__ == '__main__':
 229     main()