clang update.py: When running tests on Windows, make sure DIA works.

tools/clang/scripts/update.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """This script is used to download prebuilt clang binaries.
 
 It is also used by package.py to build the prebuilt clang binaries."""
 
 import argparse
@@ skipping 203 matching lines @@
     return True
   print 'Failed.'
   if fail_hard:
     sys.exit(1)
   return False
 
 
 def CopyFile(src, dst):
   """Copy a file from src to dst."""
   shutil.copy(src, dst)
   print "Copying %s to %s" % (src, dst)

[hans, 2016/04/12 16:47:23]

Hmm, why do we print *after* calling shutil.copy?

This is my fault, but maybe you can swap these around while you're here?
Otherwise I'll do it.

[Nico, 2016/04/12 17:00:57]

Done.

 
 
 def CopyDirectoryContents(src, dst, filename_filter=None):
   """Copy the files from directory src to dst
   with an optional filename filter."""
   dst = os.path.realpath(dst)  # realpath() in case dst ends in /..
   EnsureDirExists(dst)
   for root, _, files in os.walk(src):
     for f in files:
       if filename_filter and not re.match(filename_filter, f):
@@ skipping 109 matching lines @@
 
   # Use gyp to find the MSVS installation, either in depot_tools as per above,
   # or a system-wide installation otherwise.
   sys.path.append(os.path.join(CHROMIUM_DIR, 'tools', 'gyp', 'pylib'))
   import gyp.MSVSVersion
   vs_version = gyp.MSVSVersion.SelectVisualStudioVersion(
       vs_toolchain.GetVisualStudioVersion())
   return vs_version
 
 
+def CopyDiaDllTo(target_dir):
+  # This script always wants to use the 64-bit msdia*.dll.
+  dia_path = os.path.join(GetVSVersion().Path(), 'DIA SDK', 'bin', 'amd64')
+  dia_dll = os.path.join(dia_path, 'msdia140.dll')  # Bump after VC updates.
+  CopyFile(dia_dll, target_dir)
+
+
 def UpdateClang(args):
   print 'Updating Clang to %s...' % PACKAGE_VERSION
 
   need_gold_plugin = 'LLVM_DOWNLOAD_GOLD_PLUGIN' in os.environ or (
       sys.platform.startswith('linux') and
       'buildtype=Official' in os.environ.get('GYP_DEFINES', '') and
       'branding=Chrome' in os.environ.get('GYP_DEFINES', ''))
 
   if ReadStampFile() == PACKAGE_VERSION and not args.force_local_build:
     print 'Clang is already up to date.'
@@ skipping 13 matching lines @@
     else:
       assert sys.platform.startswith('linux')
       cds_full_url = CDS_URL + '/Linux_x64/' + cds_file
 
     print 'Downloading prebuilt clang'
     if os.path.exists(LLVM_BUILD_DIR):
       RmTree(LLVM_BUILD_DIR)
     try:
       DownloadAndUnpack(cds_full_url, LLVM_BUILD_DIR)
       print 'clang %s unpacked' % PACKAGE_VERSION
+      if sys.platform == 'win32':
+        CopyDiaDllTo(os.path.join(LLVM_BUILD_DIR, 'bin'))
       # Download the gold plugin if requested to by an environment variable.
       # This is used by the CFI ClusterFuzz bot, and it's required for official
       # builds on linux.
       if need_gold_plugin:
         RunCommand(['python', CHROMIUM_DIR+'/build/download_gold_plugin.py'])
       WriteStampFile(PACKAGE_VERSION)
       return 0
     except urllib2.URLError:
       print 'Failed to download prebuilt clang %s' % cds_file
       print 'Use --force-local-build if you want to build locally.'
@@ skipping 72 matching lines @@
         '-DCMAKE_INSTALL_PREFIX=' + LLVM_BOOTSTRAP_INSTALL_DIR,
         '-DCMAKE_C_FLAGS=' + ' '.join(cflags),
         '-DCMAKE_CXX_FLAGS=' + ' '.join(cxxflags),
         ]
     if cc is not None:  bootstrap_args.append('-DCMAKE_C_COMPILER=' + cc)
     if cxx is not None: bootstrap_args.append('-DCMAKE_CXX_COMPILER=' + cxx)
     RmCmakeCache('.')
     RunCommand(['cmake'] + bootstrap_args + [LLVM_DIR], msvc_arch='x64')
     RunCommand(['ninja'], msvc_arch='x64')
     if args.run_tests:
+      if sys.platform == 'win32':
+        CopyDiaDllTo(os.path.join(LLVM_BOOTSTRAP_DIR, 'bin'))
       RunCommand(['ninja', 'check-all'], msvc_arch='x64')
     RunCommand(['ninja', 'install'], msvc_arch='x64')
     if args.gcc_toolchain:
       # Copy that gcc's stdlibc++.so.6 to the build dir, so the bootstrap
       # compiler can start.
       CopyFile(libstdcpp, os.path.join(LLVM_BOOTSTRAP_INSTALL_DIR, 'lib'))
 
     if sys.platform == 'win32':
       cc = os.path.join(LLVM_BOOTSTRAP_INSTALL_DIR, 'bin', 'clang-cl.exe')
       cxx = os.path.join(LLVM_BOOTSTRAP_INSTALL_DIR, 'bin', 'clang-cl.exe')
@@ skipping 264 matching lines @@
       runtime = 'libclang_rt.asan-%s-android.so' % target_arch
       for root, _, files in os.walk(build_dir):
         if runtime in files:
           shutil.copy(os.path.join(root, runtime), asan_rt_lib_dst_dir)
 
   # Run tests.
   if args.run_tests or use_head_revision:
     os.chdir(LLVM_BUILD_DIR)
     RunCommand(['ninja', 'cr-check-all'], msvc_arch='x64')
   if args.run_tests:
+    if sys.platform == 'win32':
+      CopyDiaDllTo(os.path.join(LLVM_BUILD_DIR, 'bin'))
     os.chdir(LLVM_BUILD_DIR)
     RunCommand(['ninja', 'check-all'], msvc_arch='x64')
 
   WriteStampFile(PACKAGE_VERSION)
   print 'Clang update was successful.'
   return 0
 
 
 def main():
   parser = argparse.ArgumentParser(description='Build Clang.')
@@ skipping 75 matching lines @@
     args.force_local_build = True
     if 'OS=android' not in os.environ.get('GYP_DEFINES', ''):
       # Only build the Android ASan rt on ToT bots when targetting Android.
       args.with_android = False
 
   return UpdateClang(args)
 
 
 if __name__ == '__main__':
   sys.exit(main())