Update from https://crrev.com/329939

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 argparse
 import os
 import re
 import shutil
 import subprocess
 import stat
 import sys
 import time
 
 # 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'
 
 # 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.
-if (re.search(r'\b(asan)=1', os.environ.get('GYP_DEFINES', '')) and
-    not 'LLVM_FORCE_HEAD_REVISION' in os.environ):
+use_head_revision = ('LLVM_FORCE_HEAD_REVISION' in os.environ or
+  not re.search(r'\b(asan)=1', os.environ.get('GYP_DEFINES', '')))
+
+if not use_head_revision:
   LLVM_WIN_REVISION = '235968'
 
 # 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')
 CHROME_TOOLS_SHIM_DIR = os.path.join(LLVM_DIR, 'tools', 'chrometools')
 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')
@@ skipping 18 matching lines @@
 
 
 def WriteStampFile(s):
   """Write s to the stamp file."""
   if not os.path.exists(LLVM_BUILD_DIR):
     os.makedirs(LLVM_BUILD_DIR)
   with open(STAMP_FILE, 'w') as f:
     f.write(s)
 
 
+def PrintRevision():
+  """Print the current Clang revision."""
+  # gyp runs update.py --print-revision even when clang isn't used.
+  # It won't use the value, but we must not error.
+  if not os.path.exists(LLVM_DIR):
+    print "0"
+    return
+
+  # TODO(hans): This needs an update when we move to prebuilt Clang binaries.
+  svn_info = subprocess.check_output(['svn', 'info', LLVM_DIR], shell=True)
+  m = re.search(r'Revision: (\d+)', svn_info)
+  assert m
+  print m.group(1)
+
+
 def RmTree(dir):
   """Delete dir."""
   def ChmodAndRetry(func, path, _):
     # Subversion can leave read-only files around.
     if not os.access(path, os.W_OK):
       os.chmod(path, stat.S_IWUSR)
       return func(path)
     raise
 
   shutil.rmtree(dir, onerror=ChmodAndRetry)
 
 
-def ClobberChromiumBuildFiles():
-  """Clobber Chomium build files."""
-  print 'Clobbering Chromium build files...'
-  out_dir = os.path.join(CHROMIUM_DIR, 'out')
-  if os.path.isdir(out_dir):
-    RmTree(out_dir)
-    print 'Removed Chromium out dir: %s.' % (out_dir)
-
-
 def RunCommand(command, fail_hard=True):
   """Run command and return success (True) or failure; or if fail_hard is
      True, exit on failure."""
 
   print 'Running %s' % (str(command))
   if subprocess.call(command, shell=True) == 0:
     return True
   print 'Failed.'
   if fail_hard:
     sys.exit(1)
@@ skipping 63 matching lines @@
 def AddCMakeToPath():
   """Look for CMake and add it to PATH if it's not there already."""
   try:
     # First check if cmake is already on PATH.
     subprocess.call(['cmake', '--version'])
     return
   except OSError as e:
     if e.errno != os.errno.ENOENT:
       raise
 
-  cmake_locations = ['C:\\Program Files (x86)\\CMake\\bin',
-                     'C:\\Program Files (x86)\\CMake 2.8\\bin']
-  for d in cmake_locations:
-    if os.path.isdir(d):
-      os.environ['PATH'] = os.environ.get('PATH', '') + os.pathsep + d
-      return
+  cmake_dir = 'C:\\Program Files (x86)\\CMake\\bin'
+  if os.path.isdir(cmake_dir):
+    os.environ['PATH'] = os.environ.get('PATH', '') + os.pathsep + cmake_dir
+    return
   print 'Failed to find CMake!'
   sys.exit(1)
 
 
 vs_version = None
 def GetVSVersion():
   global vs_version
   if vs_version:
     return vs_version
 
@@ skipping 23 matching lines @@
   return ''
 
 
 def UpdateClang(args):
   print 'Updating Clang to %s...' % (LLVM_WIN_REVISION)
   if LLVM_WIN_REVISION != 'HEAD' and ReadStampFile() == LLVM_WIN_REVISION:
     print 'Already up to date.'
     return 0
 
   AddCMakeToPath()
-  if args.clobber:
-    ClobberChromiumBuildFiles()
-
   # Reset the stamp file in case the build is unsuccessful.
   WriteStampFile('')
 
   DeleteChromeToolsShim();
   Checkout('LLVM', LLVM_REPO_URL + '/llvm/trunk', LLVM_DIR)
   Checkout('Clang', LLVM_REPO_URL + '/cfe/trunk', CLANG_DIR)
   Checkout('LLD', LLVM_REPO_URL + '/lld/trunk', LLD_DIR)
   Checkout('compiler-rt', LLVM_REPO_URL + '/compiler-rt/trunk', COMPILER_RT_DIR)
   CreateChromeToolsShim();
 
   if not os.path.exists(LLVM_BUILD_DIR):
     os.makedirs(LLVM_BUILD_DIR)
   os.chdir(LLVM_BUILD_DIR)
 
+  # If building at head, define a macro that plugins can use for #ifdefing
+  # out code that builds at head, but not at CLANG_REVISION or vice versa.
+  cflags = cxxflags = ''
+
+  # TODO(thakis): Set this only conditionally if use_head_revision once posix
+  # and win clang are in sync. At the moment, the plugins only build at clang
+  # head on posix, but they build at both head and the pinned win version :-/
+  cflags += ' -DLLVM_FORCE_HEAD_REVISION'
+  cxxflags += ' -DLLVM_FORCE_HEAD_REVISION'
+
   cmake_args = ['-GNinja', '-DCMAKE_BUILD_TYPE=Release',
                 '-DLLVM_ENABLE_ASSERTIONS=ON', SubversionCmakeArg(),
+                '-DCMAKE_C_FLAGS=' + cflags,
+                '-DCMAKE_CXX_FLAGS=' + cxxflags,
                 '-DCHROMIUM_TOOLS_SRC=%s' % os.path.join(
                     CHROMIUM_DIR, 'tools', 'clang'),
                 '-DCHROMIUM_TOOLS=%s' % ';'.join(args.tools)]
 
   RunCommand(GetVSVersion().SetupScript('x64') +
              ['&&', 'cmake'] + cmake_args + [LLVM_DIR])
   RunCommand(GetVSVersion().SetupScript('x64') + ['&&', 'ninja', 'all'])
 
   # Do an x86 build of compiler-rt to get the 32-bit ASan run-time.
   # TODO(hans): Remove once the regular build above produces this.
@@ skipping 25 matching lines @@
   aux_sanitizer_include_dir = os.path.join(LLVM_BUILD_DIR, 'lib', 'clang',
                                            VERSION, '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)
 
+  if args.run_tests:
+    os.chdir(LLVM_BUILD_DIR)
+    RunCommand(GetVSVersion().SetupScript('x64') +
+               ['&&', 'ninja', 'cr-check-all'])
+
   WriteStampFile(LLVM_WIN_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
     # with (stdout=subprocess.PIPE, stderr=subprocess.STDOUT) and then does
     # custom output processing that breaks printing '\r' characters for
     # single-line updating status messages as printed by curl and wget.
     # Work around this by setting stderr of the update.sh process to stdin (!):
     # gclient doesn't redirect stdin, and while stdin itself is read-only, a
     # dup()ed sys.stdin is writable, try
     #   fd2 = os.dup(sys.stdin.fileno()); os.write(fd2, 'hi')
     # TODO: Fix gclient instead, http://crbug.com/95350
+    try:
+      stderr = os.fdopen(os.dup(sys.stdin.fileno()))
+    except:
+      stderr = sys.stderr
     return subprocess.call(
-        [os.path.join(os.path.dirname(__file__), 'update.sh')] +  sys.argv[1:],
-        stderr=os.fdopen(os.dup(sys.stdin.fileno())))
+        [os.path.join(os.path.dirname(__file__), 'update.sh')] + sys.argv[1:],
+        stderr=stderr)
+
+  parser = argparse.ArgumentParser(description='Build Clang.')
+  parser.add_argument('--tools', nargs='*',
+                      default=['plugins', 'blink_gc_plugin'])
+  # For now, this flag is only used for the non-Windows flow, but argparser gets
+  # mad if it sees a flag it doesn't recognize.
+  parser.add_argument('--if-needed', action='store_true')
+  parser.add_argument('--print-revision', action='store_true')
+  parser.add_argument('--run-tests', action='store_true')
+
+  args = parser.parse_args()
+
+  if args.print_revision:
+    PrintRevision()
+    return 0
 
   if not re.search(r'\b(clang|asan)=1', os.environ.get('GYP_DEFINES', '')):
     print 'Skipping Clang update (clang=1 was not set in GYP_DEFINES).'
     return 0
 
   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
 
-  parser = argparse.ArgumentParser(description='Build Clang.')
-  parser.add_argument('--no-clobber', dest='clobber', action='store_false')
-  parser.add_argument('--tools', nargs='*', default=['plugins'])
-  # For now, this flag is only used for the non-Windows flow, but argparser gets
-  # mad if it sees a flag it doesn't recognize.
-  parser.add_argument('--if-needed', action='store_true')
-  return UpdateClang(parser.parse_args())
+  return UpdateClang(args)
 
 
 if __name__ == '__main__':
   sys.exit(main())