Use a faster rolling fixed Clang revision for ASan on Windows

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.
 
 """Windows can't run .sh files, so this is a Python implementation of
 update.sh. This script should replace update.sh on all platforms eventually."""
 
 import os
 import re
 import shutil
 import subprocess
 import sys
 
 # Do NOT CHANGE this if you don't know what you're doing -- see
 # https://code.google.com/p/chromium/wiki/UpdatingClang
 # Reverting problematic clang rolls is safe, though.
 # Note: this revision is only used for Windows. Other platforms use update.sh.
-LLVM_WIN_REVISION = 'HEAD'
+CLANG_REVISION = os.environ.get('LLVM_WIN_REVISION', '209387')

[Nico, 2014/06/18 17:56:57]

The bots should continue building HEAD, right? So I'd keep this at 'HEAD' (?)

[Reid Kleckner, 2014/06/18 19:44:33]

Yes.  They have LLVM_WIN_REVISION=HEAD in the environment, so they'll keep going
at HEAD either way.  I wrote it this way as a step towards putting everything in
update.py.  Is that not a long term goal?  I notice that update.sh has grown
since the C++11-pocalypse.

[Nico, 2014/06/18 19:54:01]

Yes, that's a long-term goal. It's strange to put a revision here if that isn't
used anywhere though (and Hans and I either forget to update this number during
rolls as it has no effect, or we remember and this is useless busywork for us),
and if you keep this 'HEAD", then the whole LLVM_WIN_REVISION bot config stuff
isn't needed.

[Reid Kleckner, 2014/06/18 20:11:26]

OK, I'll do that.

+
+# Use a more quickly rolling Clang revision for ASan on Windows.

[Nico, 2014/06/18 17:56:57]

I'd say something like

# ASan on Windows is useful enough to use it even while the clang/win is still
in bringup. Use a pinned
# revision to make it slightly more stable.

[Reid Kleckner, 2014/06/18 19:44:33]

I'll do this if we decide to go back to 'HEAD' as the default revision.

+# TODO(timurrrr): Use the standard Clang revision above when ASan on Windows has
+# stabilized.
+if (sys.platform in ['win32', 'cygwin'] and
+    re.search(r'\b(asan)=1', os.environ.get('GYP_DEFINES', ''))):
+  CLANG_REVISION = '210586'
 
 # Path constants. (All of these should be absolute paths.)
 THIS_DIR = os.path.abspath(os.path.dirname(__file__))
 CHROMIUM_DIR = os.path.abspath(os.path.join(THIS_DIR, '..', '..', '..'))
 LLVM_DIR = os.path.join(CHROMIUM_DIR, 'third_party', 'llvm')
 LLVM_BUILD_DIR = os.path.join(CHROMIUM_DIR, 'third_party', 'llvm-build',
                               'Release+Asserts')
 COMPILER_RT_BUILD_DIR = os.path.join(LLVM_BUILD_DIR, '32bit-compiler-rt')
 CLANG_DIR = os.path.join(LLVM_DIR, 'tools', 'clang')
 COMPILER_RT_DIR = os.path.join(LLVM_DIR, 'projects', 'compiler-rt')
@@ skipping 51 matching lines @@
     print 'Failed.'
   sys.exit(1)
 
 def CopyFile(src, dst):
   """Copy a file from src to dst."""
   shutil.copy(src, dst)
   print "Copying %s to %s" % (src, dst)
 
 def Checkout(name, url, dir):
   """Checkout the SVN module at url into dir. Use name for the log message."""
-  print "Checking out %s r%s into '%s'" % (name, LLVM_WIN_REVISION, dir)
+  print "Checking out %s r%s into '%s'" % (name, CLANG_REVISION, dir)
   RunCommand(['svn', 'checkout', '--force',
-              url + '@' + LLVM_WIN_REVISION, dir], tries=2)
+              url + '@' + CLANG_REVISION, dir], tries=2)
 
 
 vs_version = None
 def GetVSVersion():
   global vs_version
   if not vs_version:
     # TODO(hans): Find a less hacky way to find the MSVS installation.
     sys.path.append(os.path.join(CHROMIUM_DIR, 'tools', 'gyp', 'pylib'))
     import gyp.MSVSVersion
     # We request VS 2013 because Clang won't build with 2010, and 2013 will be
     # the default for Chromium soon anyway.
     vs_version = gyp.MSVSVersion.SelectVisualStudioVersion('2013')
   return vs_version
 
 
 def UpdateClang():
-  print 'Updating Clang to %s...' % (LLVM_WIN_REVISION)
-  if LLVM_WIN_REVISION != 'HEAD' and ReadStampFile() == LLVM_WIN_REVISION:
+  print 'Updating Clang to %s...' % CLANG_REVISION
+  if CLANG_REVISION != 'HEAD' and ReadStampFile() == CLANG_REVISION:
     print 'Already up to date.'
     return 0
 
   ClobberChromiumBuildFiles()
 
   # Reset the stamp file in case the build is unsuccessful.
   WriteStampFile('')
 
   Checkout('LLVM', LLVM_REPO_URL + '/llvm/trunk', LLVM_DIR)
   Checkout('Clang', LLVM_REPO_URL + '/cfe/trunk', CLANG_DIR)
@@ skipping 45 matching lines @@
   aux_sanitizer_include_dir = os.path.join(LLVM_BUILD_DIR, 'lib', 'clang',
                                            '3.5.0', 'include_sanitizer',
                                            'sanitizer')
   if not os.path.exists(aux_sanitizer_include_dir):
     os.makedirs(aux_sanitizer_include_dir)
   for _, _, files in os.walk(sanitizer_include_dir):
     for f in files:
       CopyFile(os.path.join(sanitizer_include_dir, f),
                aux_sanitizer_include_dir)
 
-  WriteStampFile(LLVM_WIN_REVISION)
+  WriteStampFile(CLANG_REVISION)
   print 'Clang update was successful.'
   return 0
 
 
 def main():
   if not sys.platform in ['win32', 'cygwin']:
     # For non-Windows, fall back to update.sh.
     # TODO(hans): Make update.py replace update.sh completely.
 
     # This script is called by gclient. gclient opens its hooks subprocesses
@@ skipping 15 matching lines @@
 
   if re.search(r'\b(make_clang_dir)=', os.environ.get('GYP_DEFINES', '')):
     print 'Skipping Clang update (make_clang_dir= was set in GYP_DEFINES).'
     return 0
 
   return UpdateClang()
 
 
 if __name__ == '__main__':
   sys.exit(main())