[compiler-rt] Respect CMAKE_NM

[smeenai]

Summary

The default nm executable may not be able to handle the architecture
we're building the sanitizers for. Respect CMAKE_NM if it's set to
ensure we're using the correct nm tool. Preserve the existing NM
environment variable override to not break its users.

compiler-rt/trunk/cmake/Modules/SanitizerUtils.cmake

 include(CompilerRTUtils)
 
 set(SANITIZER_GEN_DYNAMIC_LIST
   ${COMPILER_RT_SOURCE_DIR}/lib/sanitizer_common/scripts/gen_dynamic_list.py)
 
 set(SANITIZER_LINT_SCRIPT
   ${COMPILER_RT_SOURCE_DIR}/lib/sanitizer_common/scripts/check_lint.sh)
 
+if(CMAKE_NM)
+  set(SANITIZER_NM "${CMAKE_NM}")
+else()
+  set(SANITIZER_NM nm)
+endif()
+
 # Create a target "<name>-<arch>-symbols" that would generate the list of
 # symbols that need to be exported from sanitizer runtime "<name>". Function
 # interceptors are exported automatically, user can also provide files with
 # symbol names that should be exported as well.
 #   add_sanitizer_rt_symbols(<name>
 #                            ARCHS <architectures>
 #                            PARENT_TARGET <convenience parent target>
 #                            EXTRA <files with extra symbols to export>)
 macro(add_sanitizer_rt_symbols name)
   cmake_parse_arguments(ARG
     ""
     "PARENT_TARGET"
     "ARCHS;EXTRA"
     ${ARGN})
   foreach(arch ${ARG_ARCHS})
     set(target_name ${name}-${arch})
     set(stamp ${CMAKE_CURRENT_BINARY_DIR}/${target_name}.syms-stamp)
     set(extra_args)
     foreach(arg ${ARG_EXTRA})
       list(APPEND extra_args "--extra" ${arg})
     endforeach()
     add_custom_command(OUTPUT ${stamp}
       COMMAND ${PYTHON_EXECUTABLE}
         ${SANITIZER_GEN_DYNAMIC_LIST} ${extra_args} $<TARGET_FILE:${target_name}>
-        -o $<TARGET_FILE:${target_name}>.syms
+        --nm-executable "${SANITIZER_NM}" -o $<TARGET_FILE:${target_name}>.syms
       COMMAND ${CMAKE_COMMAND} -E touch ${stamp}
       DEPENDS ${target_name} ${SANITIZER_GEN_DYNAMIC_LIST} ${ARG_EXTRA}
       WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
       COMMENT "Generating exported symbols for ${target_name}"
       VERBATIM)
     add_custom_target(${target_name}-symbols ALL
       DEPENDS ${stamp}
       SOURCES ${SANITIZER_GEN_DYNAMIC_LIST} ${ARG_EXTRA})
foreach(arg ${ARG_EXTRA})
     list(APPEND args "--extra" ${arg})
   endforeach()
   foreach(arg ${ARG_LIBS})
     list(APPEND args "$<TARGET_FILE:${arg}>")
   endforeach()
   add_custom_command(OUTPUT ${vers}
     COMMAND ${PYTHON_EXECUTABLE}
       ${SANITIZER_GEN_DYNAMIC_LIST} --version-list ${args}
-      -o ${vers}
+      --nm-executable "${SANITIZER_NM}" -o ${vers}
     DEPENDS ${SANITIZER_GEN_DYNAMIC_LIST} ${ARG_EXTRA} ${ARG_LIBS}
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
     COMMENT "Generating version list for ${name}"
     VERBATIM)
 
   add_custom_target(${name}-version-list ALL
     DEPENDS ${vers})
 endmacro()

compiler-rt/trunk/lib/sanitizer_common/scripts/gen_dynamic_list.py

 
 versioned_functions = set(['memcpy', 'pthread_attr_getaffinity_np',
                            'pthread_cond_broadcast',
                            'pthread_cond_destroy', 'pthread_cond_init',
                            'pthread_cond_signal', 'pthread_cond_timedwait',
                            'pthread_cond_wait', 'realpath',
                            'sched_getaffinity'])
 
-def get_global_functions(library):
+def get_global_functions(nm_executable, library):
   functions = []
-  nm = os.environ.get('NM', 'nm')
+  nm = os.environ.get('NM', nm_executable)
   nm_proc = subprocess.Popen([nm, library], stdout=subprocess.PIPE,
                              stderr=subprocess.PIPE)
   nm_out = nm_proc.communicate()[0].decode().split('\n')
   if nm_proc.returncode != 0:
     raise subprocess.CalledProcessError(nm_proc.returncode, nm)
   func_symbols = ['T', 'W']
   # On PowerPC, nm prints function descriptors from .data section.
   if platform.uname()[4] in ["powerpc", "ppc64"]:
     func_symbols += ['D']
   for line in nm_out:
     cols = line.split(' ')
     if len(cols) == 3 and cols[1] in func_symbols :
       functions.append(cols[2])
   return functions
 
 def main(argv):
   parser = argparse.ArgumentParser()
   parser.add_argument('--version-list', action='store_true')
   parser.add_argument('--extra', default=[], action='append')
   parser.add_argument('libraries', default=[], nargs='+')
+  parser.add_argument('--nm-executable', required=True)
   parser.add_argument('-o', '--output', required=True)
   args = parser.parse_args()
 
   result = []
 
   all_functions = []
   for library in args.libraries:
-    all_functions.extend(get_global_functions(library))
+    all_functions.extend(get_global_functions(args.nm_executable, library))
   function_set = set(all_functions)
   for func in all_functions:
     # Export new/delete operators.
     if func in new_delete:
       result.append(func)
       continue
     # Export interceptors.
     match = re.match('__interceptor_(.*)', func)