Imported Upstream version 6.10.0.49

Former-commit-id: 1d6753294b2993e1fbf92de9366bb9544db4189b

external/llvm-project/lldb/scripts/Xcode/build-llvm.py

@@ -0,0 +1,459 @@
+#!/usr/bin/env python
+
+import errno
+import hashlib
+import fnmatch
+import os
+import platform
+import re
+import repo
+import subprocess
+import sys
+
+from lldbbuild import *
+
+#### SETTINGS ####
+
+def LLVM_HASH_INCLUDES_DIFFS():
+    return False
+
+# For use with Xcode-style builds
+
+def process_vcs(vcs):
+    return {
+        "svn": VCS.svn,
+        "git": VCS.git
+    }[vcs]
+
+def process_root(name):
+    return {
+        "llvm": llvm_source_path(),
+        "clang": clang_source_path(),
+        "ninja": ninja_source_path()
+    }[name]
+
+def process_repo(r):
+    return {
+        'name': r["name"],
+        'vcs': process_vcs(r["vcs"]),
+        'root': process_root(r["name"]),
+        'url': r["url"],
+        'ref': r["ref"]
+    }
+
+def fallback_repo(name):
+    return {
+        'name': name,
+        'vcs': None,
+        'root': process_root(name),
+        'url': None,
+        'ref': None
+    }
+
+def dirs_exist(names):
+    for name in names:
+        if not os.path.isdir(process_root(name)):
+            return False
+    return True
+
+def XCODE_REPOSITORIES():
+    names = ["llvm", "clang", "ninja"]
+    if dirs_exist(names):
+        return [fallback_repo(n) for n in names]
+    override = repo.get_override()
+    if override:
+        return [process_repo(r) for r in override]
+    identifier = repo.identifier()
+    if identifier == None:
+        identifier = "<invalid>" # repo.find will just use the fallback file
+    set = repo.find(identifier)
+    return [process_repo(r) for r in set]
+
+
+def get_c_compiler():
+    return subprocess.check_output([
+        'xcrun',
+        '--sdk', 'macosx',
+        '-find', 'clang'
+    ]).rstrip()
+
+
+def get_cxx_compiler():
+    return subprocess.check_output([
+        'xcrun',
+        '--sdk', 'macosx',
+        '-find', 'clang++'
+    ]).rstrip()
+
+#                 CFLAGS="-isysroot $(xcrun --sdk macosx --show-sdk-path) -mmacosx-version-min=${DARWIN_DEPLOYMENT_VERSION_OSX}" \
+#                        LDFLAGS="-mmacosx-version-min=${DARWIN_DEPLOYMENT_VERSION_OSX}" \
+
+
+def get_deployment_target():
+    return os.environ.get('MACOSX_DEPLOYMENT_TARGET', None)
+
+
+def get_c_flags():
+    cflags = ''
+    # sdk_path = subprocess.check_output([
+    #     'xcrun',
+    #     '--sdk', 'macosx',
+    #     '--show-sdk-path']).rstrip()
+    # cflags += '-isysroot {}'.format(sdk_path)
+
+    deployment_target = get_deployment_target()
+    if deployment_target:
+        # cflags += ' -mmacosx-version-min={}'.format(deployment_target)
+        pass
+
+    return cflags
+
+
+def get_cxx_flags():
+    return get_c_flags()
+
+
+def get_common_linker_flags():
+    linker_flags = ""
+    deployment_target = get_deployment_target()
+    if deployment_target:
+        # if len(linker_flags) > 0:
+        #     linker_flags += ' '
+        # linker_flags += '-mmacosx-version-min={}'.format(deployment_target)
+        pass
+
+    return linker_flags
+
+
+def get_exe_linker_flags():
+    return get_common_linker_flags()
+
+
+def get_shared_linker_flags():
+    return get_common_linker_flags()
+
+
+def CMAKE_FLAGS():
+    return {
+        "Debug": [
+            "-DCMAKE_BUILD_TYPE=RelWithDebInfo",
+            "-DLLVM_ENABLE_ASSERTIONS=ON",
+        ],
+        "DebugClang": [
+            "-DCMAKE_BUILD_TYPE=Debug",
+            "-DLLVM_ENABLE_ASSERTIONS=ON",
+        ],
+        "Release": [
+            "-DCMAKE_BUILD_TYPE=Release",
+            "-DLLVM_ENABLE_ASSERTIONS=ON",
+        ],
+        "BuildAndIntegration": [
+            "-DCMAKE_BUILD_TYPE=Release",
+            "-DLLVM_ENABLE_ASSERTIONS=OFF",
+        ],
+    }
+
+
+def CMAKE_ENVIRONMENT():
+    return {
+    }
+
+#### COLLECTING ALL ARCHIVES ####
+
+
+def collect_archives_in_path(path):
+    files = os.listdir(path)
+    # Only use libclang and libLLVM archives, and exclude libclang_rt
+    regexp = "^lib(clang[^_]|LLVM|gtest).*$"
+    return [
+        os.path.join(
+            path,
+            file) for file in files if file.endswith(".a") and re.match(
+            regexp,
+            file)]
+
+
+def archive_list():
+    paths = library_paths()
+    archive_lists = [collect_archives_in_path(path) for path in paths]
+    return [archive for archive_list in archive_lists for archive in archive_list]
+
+
+def write_archives_txt():
+    f = open(archives_txt(), 'w')
+    for archive in archive_list():
+        f.write(archive + "\n")
+    f.close()
+
+#### COLLECTING REPOSITORY MD5S ####
+
+
+def source_control_status(spec):
+    vcs_for_spec = vcs(spec)
+    if LLVM_HASH_INCLUDES_DIFFS():
+        return vcs_for_spec.status() + vcs_for_spec.diff()
+    else:
+        return vcs_for_spec.status()
+
+
+def source_control_status_for_specs(specs):
+    statuses = [source_control_status(spec) for spec in specs]
+    return "".join(statuses)
+
+
+def all_source_control_status():
+    return source_control_status_for_specs(XCODE_REPOSITORIES())
+
+
+def md5(string):
+    m = hashlib.md5()
+    m.update(string)
+    return m.hexdigest()
+
+
+def all_source_control_status_md5():
+    return md5(all_source_control_status())
+
+#### CHECKING OUT AND BUILDING LLVM ####
+
+
+def apply_patches(spec):
+    files = os.listdir(os.path.join(lldb_source_path(), 'scripts'))
+    patches = [
+        f for f in files if fnmatch.fnmatch(
+            f, spec['name'] + '.*.diff')]
+    for p in patches:
+        run_in_directory(["patch",
+                          "-p1",
+                          "-i",
+                          os.path.join(lldb_source_path(),
+                                       'scripts',
+                                       p)],
+                         spec['root'])
+
+
+def check_out_if_needed(spec):
+    if not os.path.isdir(spec['root']):
+        vcs(spec).check_out()
+        apply_patches(spec)
+
+
+def all_check_out_if_needed():
+    map(check_out_if_needed, XCODE_REPOSITORIES())
+
+
+def should_build_llvm():
+    if build_type() == BuildType.Xcode:
+        # TODO use md5 sums
+        return True
+
+
+def do_symlink(source_path, link_path):
+    print "Symlinking " + source_path + " to " + link_path
+    if os.path.islink(link_path):
+        os.remove(link_path)
+    if not os.path.exists(link_path):
+        os.symlink(source_path, link_path)
+
+
+def setup_source_symlink(repo):
+    source_path = repo["root"]
+    link_path = os.path.join(lldb_source_path(), os.path.basename(source_path))
+    do_symlink(source_path, link_path)
+
+
+def setup_source_symlinks():
+    map(setup_source_symlink, XCODE_REPOSITORIES())
+
+
+def setup_build_symlink():
+    # We don't use the build symlinks in llvm.org Xcode-based builds.
+    if build_type() != BuildType.Xcode:
+        source_path = package_build_path()
+        link_path = expected_package_build_path()
+        do_symlink(source_path, link_path)
+
+
+def should_run_cmake(cmake_build_dir):
+    # We need to run cmake if our llvm build directory doesn't yet exist.
+    if not os.path.exists(cmake_build_dir):
+        return True
+
+    # Wee also need to run cmake if for some reason we don't have a ninja
+    # build file.  (Perhaps the cmake invocation failed, which this current
+    # build may have fixed).
+    ninja_path = os.path.join(cmake_build_dir, "build.ninja")
+    return not os.path.exists(ninja_path)
+
+
+def cmake_environment():
+    cmake_env = join_dicts(os.environ, CMAKE_ENVIRONMENT())
+    return cmake_env
+
+
+def is_executable(path):
+    return os.path.isfile(path) and os.access(path, os.X_OK)
+
+
+def find_executable_in_paths(program, paths_to_check):
+    program_dir, program_name = os.path.split(program)
+    if program_dir:
+        if is_executable(program):
+            return program
+    else:
+        for path_dir in paths_to_check:
+            path_dir = path_dir.strip('"')
+            executable_file = os.path.join(path_dir, program)
+            if is_executable(executable_file):
+                return executable_file
+    return None
+
+
+def find_cmake():
+    # First check the system PATH env var for cmake
+    cmake_binary = find_executable_in_paths(
+        "cmake", os.environ["PATH"].split(os.pathsep))
+    if cmake_binary:
+        # We found it there, use it.
+        return cmake_binary
+
+    # Check a few more common spots.  Xcode launched from Finder
+    # will have the default environment, and may not have
+    # all the normal places present.
+    extra_cmake_dirs = [
+        "/usr/local/bin",
+        "/opt/local/bin",
+        os.path.join(os.path.expanduser("~"), "bin")
+    ]
+
+    if platform.system() == "Darwin":
+        # Add locations where an official CMake.app package may be installed.
+        extra_cmake_dirs.extend([
+            os.path.join(
+                os.path.expanduser("~"),
+                "Applications",
+                "CMake.app",
+                "Contents",
+                "bin"),
+            os.path.join(
+                os.sep,
+                "Applications",
+                "CMake.app",
+                "Contents",
+                "bin")])
+
+    cmake_binary = find_executable_in_paths("cmake", extra_cmake_dirs)
+    if cmake_binary:
+        # We found it in one of the usual places.  Use that.
+        return cmake_binary
+
+    # We couldn't find cmake.  Tell the user what to do.
+    raise Exception(
+        "could not find cmake in PATH ({}) or in any of these locations ({}), "
+        "please install cmake or add a link to it in one of those locations".format(
+            os.environ["PATH"], extra_cmake_dirs))
+
+
+def cmake_flags():
+    cmake_flags = CMAKE_FLAGS()[lldb_configuration()]
+    cmake_flags += ["-GNinja",
+                    "-DCMAKE_C_COMPILER={}".format(get_c_compiler()),
+                    "-DCMAKE_CXX_COMPILER={}".format(get_cxx_compiler()),
+                    "-DCMAKE_INSTALL_PREFIX={}".format(expected_package_build_path_for("llvm")),
+                    "-DCMAKE_C_FLAGS={}".format(get_c_flags()),
+                    "-DCMAKE_CXX_FLAGS={}".format(get_cxx_flags()),
+                    "-DCMAKE_EXE_LINKER_FLAGS={}".format(get_exe_linker_flags()),
+                    "-DCMAKE_SHARED_LINKER_FLAGS={}".format(get_shared_linker_flags()),
+                    "-DHAVE_CRASHREPORTER_INFO=1"]
+    deployment_target = get_deployment_target()
+    if deployment_target:
+        cmake_flags.append(
+            "-DCMAKE_OSX_DEPLOYMENT_TARGET={}".format(deployment_target))
+    return cmake_flags
+
+
+def run_cmake(cmake_build_dir, ninja_binary_path):
+    cmake_binary = find_cmake()
+    print "found cmake binary: using \"{}\"".format(cmake_binary)
+
+    command_line = [cmake_binary] + cmake_flags() + [
+        "-DCMAKE_MAKE_PROGRAM={}".format(ninja_binary_path),
+        llvm_source_path()]
+    print "running cmake like so: ({}) in dir ({})".format(command_line, cmake_build_dir)
+
+    subprocess.check_call(
+        command_line,
+        cwd=cmake_build_dir,
+        env=cmake_environment())
+
+
+def create_directories_as_needed(path):
+    try:
+        os.makedirs(path)
+    except OSError as error:
+        # An error indicating that the directory exists already is fine.
+        # Anything else should be passed along.
+        if error.errno != errno.EEXIST:
+            raise error
+
+
+def run_cmake_if_needed(ninja_binary_path):
+    cmake_build_dir = package_build_path()
+    if should_run_cmake(cmake_build_dir):
+        # Create the build directory as needed
+        create_directories_as_needed(cmake_build_dir)
+        run_cmake(cmake_build_dir, ninja_binary_path)
+
+
+def build_ninja_if_needed():
+    # First check if ninja is in our path.  If so, there's nothing to do.
+    ninja_binary_path = find_executable_in_paths(
+        "ninja", os.environ["PATH"].split(os.pathsep))
+    if ninja_binary_path:
+        # It's on the path.  cmake will find it.  We're good.
+        print "found ninja here: \"{}\"".format(ninja_binary_path)
+        return ninja_binary_path
+
+    # Figure out if we need to build it.
+    ninja_build_dir = ninja_source_path()
+    ninja_binary_path = os.path.join(ninja_build_dir, "ninja")
+    if not is_executable(ninja_binary_path):
+        # Build ninja
+        command_line = ["python", "configure.py", "--bootstrap"]
+        print "building ninja like so: ({}) in dir ({})".format(command_line, ninja_build_dir)
+        subprocess.check_call(
+            command_line,
+            cwd=ninja_build_dir,
+            env=os.environ)
+
+    return ninja_binary_path
+
+
+def join_dicts(dict1, dict2):
+    d = dict1.copy()
+    d.update(dict2)
+    return d
+
+
+def build_llvm(ninja_binary_path):
+    cmake_build_dir = package_build_path()
+    subprocess.check_call(
+        [ninja_binary_path],
+        cwd=cmake_build_dir,
+        env=cmake_environment())
+
+
+def build_llvm_if_needed():
+    if should_build_llvm():
+        ninja_binary_path = build_ninja_if_needed()
+        run_cmake_if_needed(ninja_binary_path)
+        build_llvm(ninja_binary_path)
+        setup_build_symlink()
+
+#### MAIN LOGIC ####
+
+if __name__ == "__main__":
+    all_check_out_if_needed()
+    build_llvm_if_needed()
+    write_archives_txt()
+    sys.exit(0)

external/llvm-project/lldb/scripts/Xcode/lldbbuild.py

@@ -0,0 +1,193 @@
+import os
+import subprocess
+import sys
+
+#### UTILITIES ####
+
+
+def enum(*sequential, **named):
+    enums = dict(zip(sequential, range(len(sequential))), **named)
+    return type('Enum', (), enums)
+
+#### SETTINGS ####
+
+#### INTERFACE TO THE XCODEPROJ ####
+
+
+def lldb_source_path():
+    path = os.environ.get('SRCROOT')
+    if path:
+         return path
+    else:
+         return "./"
+
+
+def expected_llvm_build_path():
+    if build_type() == BuildType.Xcode:
+        return package_build_path()
+    else:
+        return os.path.join(
+            os.environ.get('LLDB_PATH_TO_LLVM_BUILD'),
+            package_build_dir_name("llvm"))
+
+
+def archives_txt():
+    return os.path.join(expected_package_build_path(), "archives.txt")
+
+
+def expected_package_build_path():
+    return os.path.abspath(os.path.join(expected_llvm_build_path(), ".."))
+
+def is_host_build():
+    rc_project_name = os.environ.get('RC_ProjectName')
+    if rc_project_name:
+      if rc_project_name == 'lldb_host': return True
+    return False
+
+def rc_release_target():
+  return os.environ.get('RC_RELEASE', '')
+
+def rc_platform_name():
+  return os.environ.get('RC_PLATFORM_NAME', 'macOS')
+
+def architecture():
+    if is_host_build(): return 'macosx'
+    platform_name = os.environ.get('RC_PLATFORM_NAME')
+    if not platform_name:
+        platform_name = os.environ.get('PLATFORM_NAME')
+    platform_arch = os.environ.get('ARCHS').split()[-1]
+    return platform_name + "-" + platform_arch
+
+
+def lldb_configuration():
+    return os.environ.get('CONFIGURATION')
+
+
+def llvm_configuration():
+    return os.environ.get('LLVM_CONFIGURATION')
+
+
+def llvm_build_dirtree():
+    return os.environ.get('LLVM_BUILD_DIRTREE')
+
+# Edit the code below when adding build styles.
+
+BuildType = enum('Xcode')                # (Debug,DebugClang,Release)
+
+
+def build_type():
+    return BuildType.Xcode
+
+#### VCS UTILITIES ####
+
+VCS = enum('git',
+           'svn')
+
+
+def run_in_directory(args, path):
+    return subprocess.check_output([str(arg) for arg in args], cwd=path)
+
+
+class Git:
+
+    def __init__(self, spec):
+        self.spec = spec
+
+    def status(self):
+        return run_in_directory(["git", "branch", "-v"], self.spec['root'])
+
+    def diff(self):
+        return run_in_directory(["git", "diff"], self.spec['root'])
+
+    def check_out(self):
+        run_in_directory(["git",
+                          "clone",
+                          "--depth=1",
+                          self.spec['url'],
+                          self.spec['root']],
+                         lldb_source_path())
+        run_in_directory(["git", "fetch", "--all"], self.spec['root'])
+        run_in_directory(["git", "checkout", self.spec[
+                         'ref']], self.spec['root'])
+
+
+class SVN:
+
+    def __init__(self, spec):
+        self.spec = spec
+
+    def status(self):
+        return run_in_directory(["svn", "info"], self.spec['root'])
+
+    def diff(self):
+        return run_in_directory(["svn", "diff"], self.spec['root'])
+    # TODO implement check_out
+
+
+def vcs(spec):
+    if spec['vcs'] == VCS.git:
+        return Git(spec)
+    elif spec['vcs'] == VCS.svn:
+        return SVN(spec)
+    else:
+        return None
+
+#### SOURCE PATHS ####
+
+
+def llvm_source_path():
+    if build_type() == BuildType.Xcode:
+        return os.path.join(lldb_source_path(), "llvm")
+
+
+def clang_source_path():
+    if build_type() == BuildType.Xcode:
+        return os.path.join(llvm_source_path(), "tools", "clang")
+
+
+def ninja_source_path():
+    if build_type() == BuildType.Xcode:
+        return os.path.join(lldb_source_path(), "ninja")
+
+#### BUILD PATHS ####
+
+
+def packages():
+    return ["llvm"]
+
+
+def package_build_dir_name(package):
+    return package + "-" + architecture()
+
+
+def expected_package_build_path_for(package):
+    if build_type() == BuildType.Xcode:
+        if package != "llvm":
+            raise "On Xcode build, we only support the llvm package: requested {}"
+        return package_build_path()
+    return os.path.join(
+        expected_package_build_path(),
+        package_build_dir_name(package))
+
+
+def expected_package_build_paths():
+    return [expected_package_build_path_for(package) for package in packages()]
+
+
+def library_path(build_path):
+    return build_path + "/lib"
+
+
+def library_paths():
+    if build_type() == BuildType.Xcode:
+        package_build_paths = [package_build_path()]
+    else:
+        package_build_paths = expected_package_build_paths()
+    return [library_path(build_path) for build_path in package_build_paths]
+
+
+def package_build_path():
+    return os.path.join(
+        llvm_build_dirtree(),
+        os.environ["LLVM_CONFIGURATION"],
+        os.environ["CURRENT_ARCH"])

external/llvm-project/lldb/scripts/Xcode/package-clang-headers.py

@@ -0,0 +1,82 @@
+#! /usr/bin/env python
+
+# package-clang-headers.py
+#
+# The Clang module loader depends on built-in headers for the Clang compiler.
+# We grab these from the Clang build and move them into the LLDB module.
+
+# TARGET_DIR is where the lldb framework/shared library gets put.
+# LLVM_BUILD_DIR is where LLVM and Clang got built
+# LLVM_BUILD_DIR/lib/clang should exist and contain headers
+
+import os
+import re
+import shutil
+import sys
+
+import lldbbuild
+
+if len(sys.argv) != 3:
+    print "usage: " + sys.argv[0] + " TARGET_DIR LLVM_BUILD_DIR"
+    sys.exit(1)
+
+target_dir = sys.argv[1]
+llvm_build_dir = lldbbuild.expected_package_build_path_for("llvm")
+
+if not os.path.isdir(target_dir):
+    print target_dir + " doesn't exist"
+    sys.exit(1)
+
+if not os.path.isdir(llvm_build_dir):
+    llvm_build_dir = re.sub("-macosx-", "-iphoneos-", llvm_build_dir)
+
+if not os.path.isdir(llvm_build_dir):
+    llvm_build_dir = re.sub("-iphoneos-", "-appletvos-", llvm_build_dir)
+
+if not os.path.isdir(llvm_build_dir):
+    llvm_build_dir = re.sub("-appletvos-", "-watchos-", llvm_build_dir)
+
+if not os.path.isdir(llvm_build_dir):
+    print llvm_build_dir + " doesn't exist"
+    sys.exit(1)
+
+resources = os.path.join(target_dir, "LLDB.framework", "Resources")
+
+if not os.path.isdir(resources):
+    print resources + " must exist"
+    sys.exit(1)
+
+clang_dir = os.path.join(llvm_build_dir, "lib", "clang")
+
+if not os.path.isdir(clang_dir):
+    print clang_dir + " must exist"
+    sys.exit(1)
+
+version_dir = None
+
+for subdir in os.listdir(clang_dir):
+    if (re.match("^[0-9]+(\.[0-9]+)*$", subdir)):
+        version_dir = os.path.join(clang_dir, subdir)
+        break
+
+if version_dir is None:
+    print "Couldn't find a subdirectory of the form #(.#)... in " + clang_dir
+    sys.exit(1)
+
+if not os.path.isdir(version_dir):
+    print version_dir + " is not a directory"
+    sys.exit(1)
+
+# Just checking... we're actually going to copy all of version_dir
+include_dir = os.path.join(version_dir, "include")
+
+if not os.path.isdir(include_dir):
+    print version_dir + " is not a directory"
+    sys.exit(1)
+
+clang_resources = os.path.join(resources, "Clang")
+
+if os.path.isdir(clang_resources):
+    shutil.rmtree(clang_resources)
+
+shutil.copytree(version_dir, clang_resources)

external/llvm-project/lldb/scripts/Xcode/prepare-gtest-run-dir.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+RUNTIME_INPUTS_DIR="${TARGET_BUILD_DIR}/Inputs"
+echo "Making runtime Inputs directory: $RUNTIME_INPUTS_DIR"
+mkdir -p "$RUNTIME_INPUTS_DIR"
+
+for input_dir in $(find unittests -type d -name Inputs); do
+    echo "Copying $input_dir into $RUNTIME_INPUTS_DIR"
+    cp -r "${input_dir}"/* "${RUNTIME_INPUTS_DIR}/"
+done

external/llvm-project/lldb/scripts/Xcode/repo.py

@@ -0,0 +1,54 @@
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+
+def identifier():
+	try:
+		svn_output = subprocess.check_output(["svn", "info", "--show-item", "url"], stderr=subprocess.STDOUT).rstrip()
+		return svn_output
+	except:
+		pass
+	try:
+		git_remote_and_branch = subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], stderr=subprocess.STDOUT).rstrip()
+		git_remote = git_remote_and_branch.split("/")[0]
+		git_branch = "/".join(git_remote_and_branch.split("/")[1:])
+		git_url = subprocess.check_output(["git", "remote", "get-url", git_remote]).rstrip()
+		return git_url + ":" + git_branch
+	except:
+		pass
+	return None
+
+def get_override():
+	dir = os.path.dirname(os.path.realpath(__file__))
+	repos_dir = os.path.join(dir, "repos")
+	json_regex = re.compile(r"^.*.json$")
+	override_path = os.path.join(repos_dir, "OVERRIDE")
+	if os.path.isfile(override_path):
+		override_set = json.load(open(override_path))
+		return override_set["repos"]
+        else:
+		return None
+
+def find(identifier):
+	dir = os.path.dirname(os.path.realpath(__file__))
+	repos_dir = os.path.join(dir, "repos")
+	json_regex = re.compile(r"^.*.json$")
+	override_path = os.path.join(repos_dir, "OVERRIDE")
+	if os.path.isfile(override_path):
+		override_set = json.load(open(override_path))
+		return override_set["repos"]
+	fallback_path = os.path.join(repos_dir, "FALLBACK")
+	for path in [os.path.join(repos_dir, f) for f in filter(json_regex.match, os.listdir(repos_dir))]:
+		fd = open(path)
+		set = json.load(fd)
+		fd.close()
+		if any(re.match(set_regex, identifier) for set_regex in set["regexs"]):
+			shutil.copyfile(path, fallback_path)
+			return set["repos"]
+	if os.path.isfile(fallback_path):
+		fallback_set = json.load(open(fallback_path))
+		return fallback_set["repos"]
+	sys.exit("Couldn't find a branch configuration for " + identifier + " and there was no " + fallback_path)

external/llvm-project/lldb/scripts/Xcode/repos/FALLBACK

@@ -0,0 +1,19 @@
+{
+    "regexs" : [".*llvm\\.org.*"],
+    "repos" : [
+        {"name": "llvm",
+         "vcs": "git",
+         "url": "http://llvm.org/git/llvm.git",
+         "ref": "master"},
+
+        {"name": "clang",
+         "vcs": "git",
+         "url": "http://llvm.org/git/clang.git",
+         "ref": "master"},
+
+        {"name": "ninja",
+         "vcs": "git",
+         "url": "https://github.com/ninja-build/ninja.git",
+         "ref": "master"}
+    ]
+}

external/llvm-project/lldb/scripts/Xcode/repos/svn-trunk.json

@@ -0,0 +1,19 @@
+{
+    "regexs" : [".*llvm\\.org.*"],
+    "repos" : [
+        {"name": "llvm",
+         "vcs": "git",
+         "url": "http://llvm.org/git/llvm.git",
+         "ref": "master"},
+
+        {"name": "clang",
+         "vcs": "git",
+         "url": "http://llvm.org/git/clang.git",
+         "ref": "master"},
+
+        {"name": "ninja",
+         "vcs": "git",
+         "url": "https://github.com/ninja-build/ninja.git",
+         "ref": "master"}
+    ]
+}