7 files changed, 1387 insertions, 0 deletions
diff --git a/utils/llvm-build/README.txt b/utils/llvm-build/README.txt
new file mode 100644
index 0000000..b6bcaae
--- /dev/null
+++ b/utils/llvm-build/README.txt
@@ -0,0 +1,5 @@
+==============================
+ llvm-build - LLVM Build Tool
+==============================
+
+`llvm-build` is a tool for helping build the LLVM project.
diff --git a/utils/llvm-build/llvm-build b/utils/llvm-build/llvm-build
new file mode 100755
index 0000000..7377e3d
--- /dev/null
+++ b/utils/llvm-build/llvm-build
@@ -0,0 +1,6 @@
+#!/usr/bin/env python
+
+import llvmbuild
+
+if __name__ == '__main__':
+   llvmbuild.main()
diff --git a/utils/llvm-build/llvmbuild/__init__.py b/utils/llvm-build/llvmbuild/__init__.py
new file mode 100644
index 0000000..7760218
--- /dev/null
+++ b/utils/llvm-build/llvmbuild/__init__.py
@@ -0,0 +1 @@
+from main import main
diff --git a/utils/llvm-build/llvmbuild/componentinfo.py b/utils/llvm-build/llvmbuild/componentinfo.py
new file mode 100644
index 0000000..230ae21
--- /dev/null
+++ b/utils/llvm-build/llvmbuild/componentinfo.py
@@ -0,0 +1,428 @@
+"""
+Descriptor objects for entities that are part of the LLVM project.
+"""
+
+import ConfigParser
+import StringIO
+import sys
+
+from util import *
+
+class ParseError(Exception):
+    pass
+
+class ComponentInfo(object):
+    """
+    Base class for component descriptions.
+    """
+
+    type_name = None
+
+    @staticmethod
+    def parse_items(items, has_dependencies = True):
+        kwargs = {}
+        kwargs['name'] = items.get_string('name')
+        kwargs['parent'] = items.get_optional_string('parent')
+        if has_dependencies:
+            kwargs['dependencies'] = items.get_list('dependencies')
+        return kwargs
+
+    def __init__(self, subpath, name, dependencies, parent):
+        if not subpath.startswith('/'):
+            raise ValueError,"invalid subpath: %r" % subpath
+        self.subpath = subpath
+        self.name = name
+        self.dependencies = list(dependencies)
+
+        # The name of the parent component to logically group this component
+        # under.
+        self.parent = parent
+
+        # The parent instance, once loaded.
+        self.parent_instance = None
+        self.children = []
+
+        # The original source path.
+        self._source_path = None
+
+        # A flag to mark "special" components which have some amount of magic
+        # handling (generally based on command line options).
+        self._is_special_group = False
+
+    def set_parent_instance(self, parent):
+        assert parent.name == self.parent, "Unexpected parent!"
+        self.parent_instance = parent
+        self.parent_instance.children.append(self)
+
+    def get_component_references(self):
+        """get_component_references() -> iter
+
+        Return an iterator over the named references to other components from
+        this object. Items are of the form (reference-type, component-name).
+        """
+
+        # Parent references are handled specially.
+        for r in self.dependencies:
+            yield ('dependency', r)
+
+    def get_llvmbuild_fragment(self):
+        abstract
+
+class GroupComponentInfo(ComponentInfo):
+    """
+    Group components have no semantics as far as the build system are concerned,
+    but exist to help organize other components into a logical tree structure.
+    """
+
+    type_name = 'Group'
+
+    @staticmethod
+    def parse(subpath, items):
+        kwargs = ComponentInfo.parse_items(items, has_dependencies = False)
+        return GroupComponentInfo(subpath, **kwargs)
+
+    def __init__(self, subpath, name, parent):
+        ComponentInfo.__init__(self, subpath, name, [], parent)
+
+    def get_llvmbuild_fragment(self):
+        result = StringIO.StringIO()
+        print >>result, 'type = %s' % self.type_name
+        print >>result, 'name = %s' % self.name
+        print >>result, 'parent = %s' % self.parent
+        return result.getvalue()
+
+class LibraryComponentInfo(ComponentInfo):
+    type_name = 'Library'
+
+    @staticmethod
+    def parse(subpath, items):
+        kwargs = ComponentInfo.parse_items(items)
+        kwargs['library_name'] = items.get_optional_string('library_name')
+        kwargs['required_libraries'] = items.get_list('required_libraries')
+        kwargs['add_to_library_groups'] = items.get_list(
+            'add_to_library_groups')
+        return LibraryComponentInfo(subpath, **kwargs)
+
+    def __init__(self, subpath, name, dependencies, parent, library_name,
+                 required_libraries, add_to_library_groups):
+        ComponentInfo.__init__(self, subpath, name, dependencies, parent)
+
+        # If given, the name to use for the library instead of deriving it from
+        # the component name.
+        self.library_name = library_name
+
+        # The names of the library components which are required when linking
+        # with this component.
+        self.required_libraries = list(required_libraries)
+
+        # The names of the library group components this component should be
+        # considered part of.
+        self.add_to_library_groups = list(add_to_library_groups)
+
+    def get_component_references(self):
+        for r in ComponentInfo.get_component_references(self):
+            yield r
+        for r in self.required_libraries:
+            yield ('required library', r)
+        for r in self.add_to_library_groups:
+            yield ('library group', r)
+
+    def get_llvmbuild_fragment(self):
+        result = StringIO.StringIO()
+        print >>result, 'type = %s' % self.type_name
+        print >>result, 'name = %s' % self.name
+        print >>result, 'parent = %s' % self.parent
+        if self.library_name is not None:
+            print >>result, 'library_name = %s' % self.library_name
+        if self.required_libraries:
+            print >>result, 'required_libraries = %s' % ' '.join(
+                self.required_libraries)
+        if self.add_to_library_groups:
+            print >>result, 'add_to_library_groups = %s' % ' '.join(
+                self.add_to_library_groups)
+        return result.getvalue()
+
+    def get_library_name(self):
+        return self.library_name or self.name
+
+    def get_prefixed_library_name(self):
+        """
+        get_prefixed_library_name() -> str
+
+        Return the library name prefixed by the project name. This is generally
+        what the library name will be on disk.
+        """
+
+        basename = self.get_library_name()
+
+        # FIXME: We need to get the prefix information from an explicit project
+        # object, or something.
+        if basename in ('gtest', 'gtest_main'):
+            return basename
+
+        return 'LLVM%s' % basename
+
+    def get_llvmconfig_component_name(self):
+        return self.get_library_name().lower()
+
+class LibraryGroupComponentInfo(ComponentInfo):
+    type_name = 'LibraryGroup'
+
+    @staticmethod
+    def parse(subpath, items):
+        kwargs = ComponentInfo.parse_items(items, has_dependencies = False)
+        kwargs['required_libraries'] = items.get_list('required_libraries')
+        kwargs['add_to_library_groups'] = items.get_list(
+            'add_to_library_groups')
+        return LibraryGroupComponentInfo(subpath, **kwargs)
+
+    def __init__(self, subpath, name, parent, required_libraries = [],
+                 add_to_library_groups = []):
+        ComponentInfo.__init__(self, subpath, name, [], parent)
+
+        # The names of the library components which are required when linking
+        # with this component.
+        self.required_libraries = list(required_libraries)
+
+        # The names of the library group components this component should be
+        # considered part of.
+        self.add_to_library_groups = list(add_to_library_groups)
+
+    def get_component_references(self):
+        for r in ComponentInfo.get_component_references(self):
+            yield r
+        for r in self.required_libraries:
+            yield ('required library', r)
+        for r in self.add_to_library_groups:
+            yield ('library group', r)
+
+    def get_llvmbuild_fragment(self):
+        result = StringIO.StringIO()
+        print >>result, 'type = %s' % self.type_name
+        print >>result, 'name = %s' % self.name
+        print >>result, 'parent = %s' % self.parent
+        if self.required_libraries and not self._is_special_group:
+            print >>result, 'required_libraries = %s' % ' '.join(
+                self.required_libraries)
+        if self.add_to_library_groups:
+            print >>result, 'add_to_library_groups = %s' % ' '.join(
+                self.add_to_library_groups)
+        return result.getvalue()
+
+    def get_llvmconfig_component_name(self):
+        return self.name.lower()
+
+class TargetGroupComponentInfo(ComponentInfo):
+    type_name = 'TargetGroup'
+
+    @staticmethod
+    def parse(subpath, items):
+        kwargs = ComponentInfo.parse_items(items, has_dependencies = False)
+        kwargs['required_libraries'] = items.get_list('required_libraries')
+        kwargs['add_to_library_groups'] = items.get_list(
+            'add_to_library_groups')
+        kwargs['has_jit'] = items.get_optional_bool('has_jit', False)
+        kwargs['has_asmprinter'] = items.get_optional_bool('has_asmprinter',
+                                                           False)
+        kwargs['has_asmparser'] = items.get_optional_bool('has_asmparser',
+                                                          False)
+        kwargs['has_disassembler'] = items.get_optional_bool('has_disassembler',
+                                                             False)
+        return TargetGroupComponentInfo(subpath, **kwargs)
+
+    def __init__(self, subpath, name, parent, required_libraries = [],
+                 add_to_library_groups = [], has_jit = False,
+                 has_asmprinter = False, has_asmparser = False,
+                 has_disassembler = False):
+        ComponentInfo.__init__(self, subpath, name, [], parent)
+
+        # The names of the library components which are required when linking
+        # with this component.
+        self.required_libraries = list(required_libraries)
+
+        # The names of the library group components this component should be
+        # considered part of.
+        self.add_to_library_groups = list(add_to_library_groups)
+
+        # Whether or not this target supports the JIT.
+        self.has_jit = bool(has_jit)
+
+        # Whether or not this target defines an assembly printer.
+        self.has_asmprinter = bool(has_asmprinter)
+
+        # Whether or not this target defines an assembly parser.
+        self.has_asmparser = bool(has_asmparser)
+
+        # Whether or not this target defines an disassembler.
+        self.has_disassembler = bool(has_disassembler)
+
+        # Whether or not this target is enabled. This is set in response to
+        # configuration parameters.
+        self.enabled = False
+
+    def get_component_references(self):
+        for r in ComponentInfo.get_component_references(self):
+            yield r
+        for r in self.required_libraries:
+            yield ('required library', r)
+        for r in self.add_to_library_groups:
+            yield ('library group', r)
+
+    def get_llvmbuild_fragment(self):
+        result = StringIO.StringIO()
+        print >>result, 'type = %s' % self.type_name
+        print >>result, 'name = %s' % self.name
+        print >>result, 'parent = %s' % self.parent
+        if self.required_libraries:
+            print >>result, 'required_libraries = %s' % ' '.join(
+                self.required_libraries)
+        if self.add_to_library_groups:
+            print >>result, 'add_to_library_groups = %s' % ' '.join(
+                self.add_to_library_groups)
+        for bool_key in ('has_asmparser', 'has_asmprinter', 'has_disassembler',
+                         'has_jit'):
+            if getattr(self, bool_key):
+                print >>result, '%s = 1' % (bool_key,)
+        return result.getvalue()
+
+    def get_llvmconfig_component_name(self):
+        return self.name.lower()
+
+class ToolComponentInfo(ComponentInfo):
+    type_name = 'Tool'
+
+    @staticmethod
+    def parse(subpath, items):
+        kwargs = ComponentInfo.parse_items(items)
+        kwargs['required_libraries'] = items.get_list('required_libraries')
+        return ToolComponentInfo(subpath, **kwargs)
+
+    def __init__(self, subpath, name, dependencies, parent,
+                 required_libraries):
+        ComponentInfo.__init__(self, subpath, name, dependencies, parent)
+
+        # The names of the library components which are required to link this
+        # tool.
+        self.required_libraries = list(required_libraries)
+
+    def get_component_references(self):
+        for r in ComponentInfo.get_component_references(self):
+            yield r
+        for r in self.required_libraries:
+            yield ('required library', r)
+
+    def get_llvmbuild_fragment(self):
+        result = StringIO.StringIO()
+        print >>result, 'type = %s' % self.type_name
+        print >>result, 'name = %s' % self.name
+        print >>result, 'parent = %s' % self.parent
+        print >>result, 'required_libraries = %s' % ' '.join(
+            self.required_libraries)
+        return result.getvalue()
+
+class BuildToolComponentInfo(ToolComponentInfo):
+    type_name = 'BuildTool'
+
+    @staticmethod
+    def parse(subpath, items):
+        kwargs = ComponentInfo.parse_items(items)
+        kwargs['required_libraries'] = items.get_list('required_libraries')
+        return BuildToolComponentInfo(subpath, **kwargs)
+
+###
+
+class IniFormatParser(dict):
+    def get_list(self, key):
+        # Check if the value is defined.
+        value = self.get(key)
+        if value is None:
+            return []
+
+        # Lists are just whitespace separated strings.
+        return value.split()
+
+    def get_optional_string(self, key):
+        value = self.get_list(key)
+        if not value:
+            return None
+        if len(value) > 1:
+            raise ParseError("multiple values for scalar key: %r" % key)
+        return value[0]
+
+    def get_string(self, key):
+        value = self.get_optional_string(key)
+        if not value:
+            raise ParseError("missing value for required string: %r" % key)
+        return value
+
+    def get_optional_bool(self, key, default = None):
+        value = self.get_optional_string(key)
+        if not value:
+            return default
+        if value not in ('0', '1'):
+            raise ParseError("invalid value(%r) for boolean property: %r" % (
+                    value, key))
+        return bool(int(value))
+
+    def get_bool(self, key):
+        value = self.get_optional_bool(key)
+        if value is None:
+            raise ParseError("missing value for required boolean: %r" % key)
+        return value
+
+_component_type_map = dict(
+    (t.type_name, t)
+    for t in (GroupComponentInfo,
+              LibraryComponentInfo, LibraryGroupComponentInfo,
+              ToolComponentInfo, BuildToolComponentInfo,
+              TargetGroupComponentInfo))
+def load_from_path(path, subpath):
+    # Load the LLVMBuild.txt file as an .ini format file.
+    parser = ConfigParser.RawConfigParser()
+    parser.read(path)
+
+    # Extract the common section.
+    if parser.has_section("common"):
+        common = IniFormatParser(parser.items("common"))
+        parser.remove_section("common")
+    else:
+        common = IniFormatParser({})
+
+    return common, _read_components_from_parser(parser, path, subpath)
+
+def _read_components_from_parser(parser, path, subpath):
+    # We load each section which starts with 'component' as a distinct component
+    # description (so multiple components can be described in one file).
+    for section in parser.sections():
+        if not section.startswith('component'):
+            # We don't expect arbitrary sections currently, warn the user.
+            warning("ignoring unknown section %r in %r" % (section, path))
+            continue
+
+        # Determine the type of the component to instantiate.
+        if not parser.has_option(section, 'type'):
+            fatal("invalid component %r in %r: %s" % (
+                    section, path, "no component type"))
+
+        type_name = parser.get(section, 'type')
+        type_class = _component_type_map.get(type_name)
+        if type_class is None:
+            fatal("invalid component %r in %r: %s" % (
+                    section, path, "invalid component type: %r" % type_name))
+
+        # Instantiate the component based on the remaining values.
+        try:
+            info = type_class.parse(subpath,
+                                    IniFormatParser(parser.items(section)))
+        except TypeError:
+            print >>sys.stderr, "error: invalid component %r in %r: %s" % (
+                section, path, "unable to instantiate: %r" % type_name)
+            import traceback
+            traceback.print_exc()
+            raise SystemExit, 1
+        except ParseError,e:
+            fatal("unable to load component %r in %r: %s" % (
+                    section, path, e.message))
+
+        info._source_path = path
+        yield info
diff --git a/utils/llvm-build/llvmbuild/configutil.py b/utils/llvm-build/llvmbuild/configutil.py
new file mode 100644
index 0000000..b5582c3
--- /dev/null
+++ b/utils/llvm-build/llvmbuild/configutil.py
@@ -0,0 +1,66 @@
+"""
+Defines utilities useful for performing standard "configuration" style tasks.
+"""
+
+import re
+import os
+
+def configure_file(input_path, output_path, substitutions):
+    """configure_file(input_path, output_path, substitutions) -> bool
+
+    Given an input and output path, "configure" the file at the given input path
+    by replacing variables in the file with those given in the substitutions
+    list. Returns true if the output file was written.
+
+    The substitutions list should be given as a list of tuples (regex string,
+    replacement), where the regex and replacement will be used as in 're.sub' to
+    execute the variable replacement.
+
+    The output path's parent directory need not exist (it will be created).
+
+    If the output path does exist and the configured data is not different than
+    it's current contents, the output file will not be modified. This is
+    designed to limit the impact of configured files on build dependencies.
+    """
+
+    # Read in the input data.
+    f = open(input_path, "rb")
+    try:
+        data = f.read()
+    finally:
+        f.close()
+
+    # Perform the substitutions.
+    for regex_string,replacement in substitutions:
+        regex = re.compile(regex_string)
+        data = regex.sub(replacement, data)
+
+    # Ensure the output parent directory exists.
+    output_parent_path = os.path.dirname(os.path.abspath(output_path))
+    if not os.path.exists(output_parent_path):
+        os.makedirs(output_parent_path)
+
+    # If the output path exists, load it and compare to the configured contents.
+    if os.path.exists(output_path):
+        current_data = None
+        try:
+            f = open(output_path, "rb")
+            try:
+                current_data = f.read()
+            except:
+                current_data = None
+            f.close()
+        except:
+            current_data = None
+
+        if current_data is not None and current_data == data:
+            return False
+
+    # Write the output contents.
+    f = open(output_path, "wb")
+    try:
+        f.write(data)
+    finally:
+        f.close()
+
+    return True
diff --git a/utils/llvm-build/llvmbuild/main.py b/utils/llvm-build/llvmbuild/main.py
new file mode 100644
index 0000000..36bca87
--- /dev/null
+++ b/utils/llvm-build/llvmbuild/main.py
@@ -0,0 +1,868 @@
+import StringIO
+import os
+import sys
+
+import componentinfo
+import configutil
+
+from util import *
+
+###
+
+def cmake_quote_string(value):
+    """
+    cmake_quote_string(value) -> str
+
+    Return a quoted form of the given value that is suitable for use in CMake
+    language files.
+    """
+
+    # Currently, we only handle escaping backslashes.
+    value = value.replace("\\", "\\\\")
+
+    return value
+
+def cmake_quote_path(value):
+    """
+    cmake_quote_path(value) -> str
+
+    Return a quoted form of the given value that is suitable for use in CMake
+    language files.
+    """
+
+    # CMake has a bug in it's Makefile generator that doesn't properly quote
+    # strings it generates. So instead of using proper quoting, we just use "/"
+    # style paths.  Currently, we only handle escaping backslashes.
+    value = value.replace("\\", "/")
+
+    return value
+
+def mk_quote_string_for_target(value):
+    """
+    mk_quote_string_for_target(target_name) -> str
+
+    Return a quoted form of the given target_name suitable for including in a 
+    Makefile as a target name.
+    """
+
+    # The only quoting we currently perform is for ':', to support msys users.
+    return value.replace(":", "\\:")
+
+def make_install_dir(path):
+    """
+    make_install_dir(path) -> None
+
+    Create the given directory path for installation, including any parents.
+    """
+
+    # os.makedirs considers it an error to be called with an existant path.
+    if not os.path.exists(path):
+        os.makedirs(path)
+
+###
+
+class LLVMProjectInfo(object):
+    @staticmethod
+    def load_infos_from_path(llvmbuild_source_root):
+        def recurse(subpath):
+            # Load the LLVMBuild file.
+            llvmbuild_path = os.path.join(llvmbuild_source_root + subpath,
+                                          'LLVMBuild.txt')
+            if not os.path.exists(llvmbuild_path):
+                fatal("missing LLVMBuild.txt file at: %r" % (llvmbuild_path,))
+
+            # Parse the components from it.
+            common,info_iter = componentinfo.load_from_path(llvmbuild_path,
+                                                            subpath)
+            for info in info_iter:
+                yield info
+
+            # Recurse into the specified subdirectories.
+            for subdir in common.get_list("subdirectories"):
+                for item in recurse(os.path.join(subpath, subdir)):
+                    yield item
+
+        return recurse("/")
+
+    @staticmethod
+    def load_from_path(source_root, llvmbuild_source_root):
+        infos = list(
+            LLVMProjectInfo.load_infos_from_path(llvmbuild_source_root))
+
+        return LLVMProjectInfo(source_root, infos)
+
+    def __init__(self, source_root, component_infos):
+        # Store our simple ivars.
+        self.source_root = source_root
+        self.component_infos = list(component_infos)
+        self.component_info_map = None
+        self.ordered_component_infos = None
+
+    def validate_components(self):
+        """validate_components() -> None
+
+        Validate that the project components are well-defined. Among other
+        things, this checks that:
+          - Components have valid references.
+          - Components references do not form cycles.
+
+        We also construct the map from component names to info, and the
+        topological ordering of components.
+        """
+
+        # Create the component info map and validate that component names are
+        # unique.
+        self.component_info_map = {}
+        for ci in self.component_infos:
+            existing = self.component_info_map.get(ci.name)
+            if existing is not None:
+                # We found a duplicate component name, report it and error out.
+                fatal("found duplicate component %r (at %r and %r)" % (
+                        ci.name, ci.subpath, existing.subpath))
+            self.component_info_map[ci.name] = ci
+
+        # Disallow 'all' as a component name, which is a special case.
+        if 'all' in self.component_info_map:
+            fatal("project is not allowed to define 'all' component")
+
+        # Add the root component.
+        if '$ROOT' in self.component_info_map:
+            fatal("project is not allowed to define $ROOT component")
+        self.component_info_map['$ROOT'] = componentinfo.GroupComponentInfo(
+            '/', '$ROOT', None)
+        self.component_infos.append(self.component_info_map['$ROOT'])
+
+        # Topologically order the component information according to their
+        # component references.
+        def visit_component_info(ci, current_stack, current_set):
+            # Check for a cycles.
+            if ci in current_set:
+                # We found a cycle, report it and error out.
+                cycle_description = ' -> '.join(
+                    '%r (%s)' % (ci.name, relation)
+                    for relation,ci in current_stack)
+                fatal("found cycle to %r after following: %s -> %s" % (
+                        ci.name, cycle_description, ci.name))
+
+            # If we have already visited this item, we are done.
+            if ci not in components_to_visit:
+                return
+
+            # Otherwise, mark the component info as visited and traverse.
+            components_to_visit.remove(ci)
+
+            # Validate the parent reference, which we treat specially.
+            if ci.parent is not None:
+                parent = self.component_info_map.get(ci.parent)
+                if parent is None:
+                    fatal("component %r has invalid reference %r (via %r)" % (
+                            ci.name, ci.parent, 'parent'))
+                ci.set_parent_instance(parent)
+
+            for relation,referent_name in ci.get_component_references():
+                # Validate that the reference is ok.
+                referent = self.component_info_map.get(referent_name)
+                if referent is None:
+                    fatal("component %r has invalid reference %r (via %r)" % (
+                            ci.name, referent_name, relation))
+
+                # Visit the reference.
+                current_stack.append((relation,ci))
+                current_set.add(ci)
+                visit_component_info(referent, current_stack, current_set)
+                current_set.remove(ci)
+                current_stack.pop()
+
+            # Finally, add the component info to the ordered list.
+            self.ordered_component_infos.append(ci)
+
+        # FIXME: We aren't actually correctly checking for cycles along the
+        # parent edges. Haven't decided how I want to handle this -- I thought
+        # about only checking cycles by relation type. If we do that, it falls
+        # out easily. If we don't, we should special case the check.
+
+        self.ordered_component_infos = []
+        components_to_visit = set(self.component_infos)
+        while components_to_visit:
+            visit_component_info(iter(components_to_visit).next(), [], set())
+
+        # Canonicalize children lists.
+        for c in self.ordered_component_infos:
+            c.children.sort(key = lambda c: c.name)
+
+    def print_tree(self):
+        def visit(node, depth = 0):
+            print '%s%-40s (%s)' % ('  '*depth, node.name, node.type_name)
+            for c in node.children:
+                visit(c, depth + 1)
+        visit(self.component_info_map['$ROOT'])
+
+    def write_components(self, output_path):
+        # Organize all the components by the directory their LLVMBuild file
+        # should go in.
+        info_basedir = {}
+        for ci in self.component_infos:
+            # Ignore the $ROOT component.
+            if ci.parent is None:
+                continue
+
+            info_basedir[ci.subpath] = info_basedir.get(ci.subpath, []) + [ci]
+
+        # Compute the list of subdirectories to scan.
+        subpath_subdirs = {}
+        for ci in self.component_infos:
+            # Ignore root components.
+            if ci.subpath == '/':
+                continue
+
+            # Otherwise, append this subpath to the parent list.
+            parent_path = os.path.dirname(ci.subpath)
+            subpath_subdirs[parent_path] = parent_list = subpath_subdirs.get(
+                parent_path, set())
+            parent_list.add(os.path.basename(ci.subpath))
+
+        # Generate the build files.
+        for subpath, infos in info_basedir.items():
+            # Order the components by name to have a canonical ordering.
+            infos.sort(key = lambda ci: ci.name)
+
+            # Format the components into llvmbuild fragments.
+            fragments = []
+
+            # Add the common fragments.
+            subdirectories = subpath_subdirs.get(subpath)
+            if subdirectories:
+                fragment = """\
+subdirectories = %s
+""" % (" ".join(sorted(subdirectories)),)
+                fragments.append(("common", fragment))
+
+            # Add the component fragments.
+            num_common_fragments = len(fragments)
+            for ci in infos:
+                fragment = ci.get_llvmbuild_fragment()
+                if fragment is None:
+                    continue
+
+                name = "component_%d" % (len(fragments) - num_common_fragments)
+                fragments.append((name, fragment))
+
+            if not fragments:
+                continue
+
+            assert subpath.startswith('/')
+            directory_path = os.path.join(output_path, subpath[1:])
+
+            # Create the directory if it does not already exist.
+            if not os.path.exists(directory_path):
+                os.makedirs(directory_path)
+
+            # In an effort to preserve comments (which aren't parsed), read in
+            # the original file and extract the comments. We only know how to
+            # associate comments that prefix a section name.
+            f = open(infos[0]._source_path)
+            comments_map = {}
+            comment_block = ""
+            for ln in f:
+                if ln.startswith(';'):
+                    comment_block += ln
+                elif ln.startswith('[') and ln.endswith(']\n'):
+                    comments_map[ln[1:-2]] = comment_block
+                else:
+                    comment_block = ""
+            f.close()
+
+            # Create the LLVMBuild fil[e.
+            file_path = os.path.join(directory_path, 'LLVMBuild.txt')
+            f = open(file_path, "w")
+
+            # Write the header.
+            header_fmt = ';===- %s %s-*- Conf -*--===;'
+            header_name = '.' + os.path.join(subpath, 'LLVMBuild.txt')
+            header_pad = '-' * (80 - len(header_fmt % (header_name, '')))
+            header_string = header_fmt % (header_name, header_pad)
+            print >>f, """\
+%s
+;
+;                     The LLVM Compiler Infrastructure
+;
+; This file is distributed under the University of Illinois Open Source
+; License. See LICENSE.TXT for details.
+;
+;===------------------------------------------------------------------------===;
+;
+; This is an LLVMBuild description file for the components in this subdirectory.
+;
+; For more information on the LLVMBuild system, please see:
+;
+;   http://llvm.org/docs/LLVMBuild.html
+;
+;===------------------------------------------------------------------------===;
+""" % header_string
+
+            # Write out each fragment.each component fragment.
+            for name,fragment in fragments:
+                comment = comments_map.get(name)
+                if comment is not None:
+                    f.write(comment)
+                print >>f, "[%s]" % name
+                f.write(fragment)
+                if fragment is not fragments[-1][1]:
+                    print >>f
+
+            f.close()
+
+    def write_library_table(self, output_path):
+        # Write out the mapping from component names to required libraries.
+        #
+        # We do this in topological order so that we know we can append the
+        # dependencies for added library groups.
+        entries = {}
+        for c in self.ordered_component_infos:
+            # Only certain components are in the table.
+            if c.type_name not in ('Library', 'LibraryGroup', 'TargetGroup'):
+                continue
+
+            # Compute the llvm-config "component name". For historical reasons,
+            # this is lowercased based on the library name.
+            llvmconfig_component_name = c.get_llvmconfig_component_name()
+            
+            # Get the library name, or None for LibraryGroups.
+            if c.type_name == 'Library':
+                library_name = c.get_prefixed_library_name()
+            else:
+                library_name = None
+
+            # Get the component names of all the required libraries.
+            required_llvmconfig_component_names = [
+                self.component_info_map[dep].get_llvmconfig_component_name()
+                for dep in c.required_libraries]
+
+            # Insert the entries for library groups we should add to.
+            for dep in c.add_to_library_groups:
+                entries[dep][2].append(llvmconfig_component_name)
+
+            # Add the entry.
+            entries[c.name] = (llvmconfig_component_name, library_name,
+                               required_llvmconfig_component_names)
+
+        # Convert to a list of entries and sort by name.
+        entries = entries.values()
+
+        # Create an 'all' pseudo component. We keep the dependency list small by
+        # only listing entries that have no other dependents.
+        root_entries = set(e[0] for e in entries)
+        for _,_,deps in entries:
+            root_entries -= set(deps)
+        entries.append(('all', None, root_entries))
+
+        entries.sort()
+
+        # Compute the maximum number of required libraries, plus one so there is
+        # always a sentinel.
+        max_required_libraries = max(len(deps)
+                                     for _,_,deps in entries) + 1
+
+        # Write out the library table.
+        make_install_dir(os.path.dirname(output_path))
+        f = open(output_path, 'w')
+        print >>f, """\
+//===- llvm-build generated file --------------------------------*- C++ -*-===//
+//
+// Component Library Depenedency Table
+//
+// Automatically generated file, do not edit!
+//
+//===----------------------------------------------------------------------===//
+"""
+        print >>f, 'struct AvailableComponent {'
+        print >>f, '  /// The name of the component.'
+        print >>f, '  const char *Name;'
+        print >>f, ''
+        print >>f, '  /// The name of the library for this component (or NULL).'
+        print >>f, '  const char *Library;'
+        print >>f, ''
+        print >>f, '\
+  /// The list of libraries required when linking this component.'
+        print >>f, '  const char *RequiredLibraries[%d];' % (
+            max_required_libraries)
+        print >>f, '} AvailableComponents[%d] = {' % len(entries)
+        for name,library_name,required_names in entries:
+            if library_name is None:
+                library_name_as_cstr = '0'
+            else:
+                library_name_as_cstr = '"lib%s.a"' % library_name
+            print >>f, '  { "%s", %s, { %s } },' % (
+                name, library_name_as_cstr,
+                ', '.join('"%s"' % dep
+                          for dep in required_names))
+        print >>f, '};'
+        f.close()
+
+    def get_required_libraries_for_component(self, ci, traverse_groups = False):
+        """
+        get_required_libraries_for_component(component_info) -> iter
+
+        Given a Library component info descriptor, return an iterator over all
+        of the directly required libraries for linking with this component. If
+        traverse_groups is True, then library and target groups will be
+        traversed to include their required libraries.
+        """
+
+        assert ci.type_name in ('Library', 'LibraryGroup', 'TargetGroup')
+
+        for name in ci.required_libraries:
+            # Get the dependency info.
+            dep = self.component_info_map[name]
+
+            # If it is a library, yield it.
+            if dep.type_name == 'Library':
+                yield dep
+                continue
+
+            # Otherwise if it is a group, yield or traverse depending on what
+            # was requested.
+            if dep.type_name in ('LibraryGroup', 'TargetGroup'):
+                if not traverse_groups:
+                    yield dep
+                    continue
+
+                for res in self.get_required_libraries_for_component(dep, True):
+                    yield res
+
+    def get_fragment_dependencies(self):
+        """
+        get_fragment_dependencies() -> iter
+
+        Compute the list of files (as absolute paths) on which the output
+        fragments depend (i.e., files for which a modification should trigger a
+        rebuild of the fragment).
+        """
+
+        # Construct a list of all the dependencies of the Makefile fragment
+        # itself. These include all the LLVMBuild files themselves, as well as
+        # all of our own sources.
+        #
+        # Many components may come from the same file, so we make sure to unique
+        # these.
+        build_paths = set()
+        for ci in self.component_infos:
+            p = os.path.join(self.source_root, ci.subpath[1:], 'LLVMBuild.txt')
+            if p not in build_paths:
+                yield p
+                build_paths.add(p)
+
+        # Gather the list of necessary sources by just finding all loaded
+        # modules that are inside the LLVM source tree.
+        for module in sys.modules.values():
+            # Find the module path.
+            if not hasattr(module, '__file__'):
+                continue
+            path = getattr(module, '__file__')
+            if not path:
+                continue
+
+            # Strip off any compiled suffix.
+            if os.path.splitext(path)[1] in ['.pyc', '.pyo', '.pyd']:
+                path = path[:-1]
+
+            # If the path exists and is in the source tree, consider it a
+            # dependency.
+            if (path.startswith(self.source_root) and os.path.exists(path)):
+                yield path
+
+    def write_cmake_fragment(self, output_path):
+        """
+        write_cmake_fragment(output_path) -> None
+
+        Generate a CMake fragment which includes all of the collated LLVMBuild
+        information in a format that is easily digestible by a CMake. The exact
+        contents of this are closely tied to how the CMake configuration
+        integrates LLVMBuild, see CMakeLists.txt in the top-level.
+        """
+
+        dependencies = list(self.get_fragment_dependencies())
+
+        # Write out the CMake fragment.
+        make_install_dir(os.path.dirname(output_path))
+        f = open(output_path, 'w')
+
+        # Write the header.
+        header_fmt = '\
+#===-- %s - LLVMBuild Configuration for LLVM %s-*- CMake -*--===#'
+        header_name = os.path.basename(output_path)
+        header_pad = '-' * (80 - len(header_fmt % (header_name, '')))
+        header_string = header_fmt % (header_name, header_pad)
+        print >>f, """\
+%s
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+#
+# This file contains the LLVMBuild project information in a format easily
+# consumed by the CMake based build system.
+#
+# This file is autogenerated by llvm-build, do not edit!
+#
+#===------------------------------------------------------------------------===#
+""" % header_string
+
+        # Write the dependency information in the best way we can.
+        print >>f, """
+# LLVMBuild CMake fragment dependencies.
+#
+# CMake has no builtin way to declare that the configuration depends on
+# a particular file. However, a side effect of configure_file is to add
+# said input file to CMake's internal dependency list. So, we use that
+# and a dummy output file to communicate the dependency information to
+# CMake.
+#
+# FIXME: File a CMake RFE to get a properly supported version of this
+# feature."""
+        for dep in dependencies:
+            print >>f, """\
+configure_file(\"%s\"
+               ${CMAKE_CURRENT_BINARY_DIR}/DummyConfigureOutput)""" % (
+                cmake_quote_path(dep),)
+
+        # Write the properties we use to encode the required library dependency
+        # information in a form CMake can easily use directly.
+        print >>f, """
+# Explicit library dependency information.
+#
+# The following property assignments effectively create a map from component
+# names to required libraries, in a way that is easily accessed from CMake."""
+        for ci in self.ordered_component_infos:
+            # We only write the information for libraries currently.
+            if ci.type_name != 'Library':
+                continue
+
+            print >>f, """\
+set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_%s %s)""" % (
+                ci.get_prefixed_library_name(), " ".join(sorted(
+                     dep.get_prefixed_library_name()
+                     for dep in self.get_required_libraries_for_component(ci))))
+
+        f.close()
+
+    def write_make_fragment(self, output_path):
+        """
+        write_make_fragment(output_path) -> None
+
+        Generate a Makefile fragment which includes all of the collated
+        LLVMBuild information in a format that is easily digestible by a
+        Makefile. The exact contents of this are closely tied to how the LLVM
+        Makefiles integrate LLVMBuild, see Makefile.rules in the top-level.
+        """
+
+        dependencies = list(self.get_fragment_dependencies())
+
+        # Write out the Makefile fragment.
+        make_install_dir(os.path.dirname(output_path))
+        f = open(output_path, 'w')
+
+        # Write the header.
+        header_fmt = '\
+#===-- %s - LLVMBuild Configuration for LLVM %s-*- Makefile -*--===#'
+        header_name = os.path.basename(output_path)
+        header_pad = '-' * (80 - len(header_fmt % (header_name, '')))
+        header_string = header_fmt % (header_name, header_pad)
+        print >>f, """\
+%s
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+#
+# This file contains the LLVMBuild project information in a format easily
+# consumed by the Makefile based build system.
+#
+# This file is autogenerated by llvm-build, do not edit!
+#
+#===------------------------------------------------------------------------===#
+""" % header_string
+
+        # Write the dependencies for the fragment.
+        #
+        # FIXME: Technically, we need to properly quote for Make here.
+        print >>f, """\
+# Clients must explicitly enable LLVMBUILD_INCLUDE_DEPENDENCIES to get
+# these dependencies. This is a compromise to help improve the
+# performance of recursive Make systems.""" 
+        print >>f, 'ifeq ($(LLVMBUILD_INCLUDE_DEPENDENCIES),1)'
+        print >>f, "# The dependencies for this Makefile fragment itself."
+        print >>f, "%s: \\" % (mk_quote_string_for_target(output_path),)
+        for dep in dependencies:
+            print >>f, "\t%s \\" % (dep,)
+        print >>f
+
+        # Generate dummy rules for each of the dependencies, so that things
+        # continue to work correctly if any of those files are moved or removed.
+        print >>f, """\
+# The dummy targets to allow proper regeneration even when files are moved or
+# removed."""
+        for dep in dependencies:
+            print >>f, "%s:" % (mk_quote_string_for_target(dep),)
+        print >>f, 'endif'
+
+        f.close()
+
+def add_magic_target_components(parser, project, opts):
+    """add_magic_target_components(project, opts) -> None
+
+    Add the "magic" target based components to the project, which can only be
+    determined based on the target configuration options.
+
+    This currently is responsible for populating the required_libraries list of
+    the "all-targets", "Native", "NativeCodeGen", and "Engine" components.
+    """
+
+    # Determine the available targets.
+    available_targets = dict((ci.name,ci)
+                             for ci in project.component_infos
+                             if ci.type_name == 'TargetGroup')
+
+    # Find the configured native target.
+
+    # We handle a few special cases of target names here for historical
+    # reasons, as these are the names configure currently comes up with.
+    native_target_name = { 'x86' : 'X86',
+                           'x86_64' : 'X86',
+                           'Unknown' : None }.get(opts.native_target,
+                                                  opts.native_target)
+    if native_target_name is None:
+        native_target = None
+    else:
+        native_target = available_targets.get(native_target_name)
+        if native_target is None:
+            parser.error("invalid native target: %r (not in project)" % (
+                    opts.native_target,))
+        if native_target.type_name != 'TargetGroup':
+            parser.error("invalid native target: %r (not a target)" % (
+                    opts.native_target,))
+
+    # Find the list of targets to enable.
+    if opts.enable_targets is None:
+        enable_targets = available_targets.values()
+    else:
+        # We support both space separated and semi-colon separated lists.
+        if ' ' in opts.enable_targets:
+            enable_target_names = opts.enable_targets.split()
+        else:
+            enable_target_names = opts.enable_targets.split(';')
+
+        enable_targets = []
+        for name in enable_target_names:
+            target = available_targets.get(name)
+            if target is None:
+                parser.error("invalid target to enable: %r (not in project)" % (
+                        name,))
+            if target.type_name != 'TargetGroup':
+                parser.error("invalid target to enable: %r (not a target)" % (
+                        name,))
+            enable_targets.append(target)
+
+    # Find the special library groups we are going to populate. We enforce that
+    # these appear in the project (instead of just adding them) so that they at
+    # least have an explicit representation in the project LLVMBuild files (and
+    # comments explaining how they are populated).
+    def find_special_group(name):
+        info = info_map.get(name)
+        if info is None:
+            fatal("expected project to contain special %r component" % (
+                    name,))
+
+        if info.type_name != 'LibraryGroup':
+            fatal("special component %r should be a LibraryGroup" % (
+                    name,))
+
+        if info.required_libraries:
+            fatal("special component %r must have empty %r list" % (
+                    name, 'required_libraries'))
+        if info.add_to_library_groups:
+            fatal("special component %r must have empty %r list" % (
+                    name, 'add_to_library_groups'))
+
+        info._is_special_group = True
+        return info
+
+    info_map = dict((ci.name, ci) for ci in project.component_infos)
+    all_targets = find_special_group('all-targets')
+    native_group = find_special_group('Native')
+    native_codegen_group = find_special_group('NativeCodeGen')
+    engine_group = find_special_group('Engine')
+
+    # Set the enabled bit in all the target groups, and append to the
+    # all-targets list.
+    for ci in enable_targets:
+        all_targets.required_libraries.append(ci.name)
+        ci.enabled = True
+
+    # If we have a native target, then that defines the native and
+    # native_codegen libraries.
+    if native_target and native_target.enabled:
+        native_group.required_libraries.append(native_target.name)
+        native_codegen_group.required_libraries.append(
+            '%sCodeGen' % native_target.name)
+
+    # If we have a native target with a JIT, use that for the engine. Otherwise,
+    # use the interpreter.
+    if native_target and native_target.enabled and native_target.has_jit:
+        engine_group.required_libraries.append('JIT')
+        engine_group.required_libraries.append(native_group.name)
+    else:
+        engine_group.required_libraries.append('Interpreter')
+
+def main():
+    from optparse import OptionParser, OptionGroup
+    parser = OptionParser("usage: %prog [options]")
+
+    group = OptionGroup(parser, "Input Options")
+    group.add_option("", "--source-root", dest="source_root", metavar="PATH",
+                      help="Path to the LLVM source (inferred if not given)",
+                      action="store", default=None)
+    group.add_option("", "--llvmbuild-source-root",
+                     dest="llvmbuild_source_root",
+                     help=(
+            "If given, an alternate path to search for LLVMBuild.txt files"),
+                     action="store", default=None, metavar="PATH")
+    group.add_option("", "--build-root", dest="build_root", metavar="PATH",
+                      help="Path to the build directory (if needed) [%default]",
+                      action="store", default=None)
+    parser.add_option_group(group)
+
+    group = OptionGroup(parser, "Output Options")
+    group.add_option("", "--print-tree", dest="print_tree",
+                     help="Print out the project component tree [%default]",
+                     action="store_true", default=False)
+    group.add_option("", "--write-llvmbuild", dest="write_llvmbuild",
+                      help="Write out the LLVMBuild.txt files to PATH",
+                      action="store", default=None, metavar="PATH")
+    group.add_option("", "--write-library-table",
+                     dest="write_library_table", metavar="PATH",
+                     help="Write the C++ library dependency table to PATH",
+                     action="store", default=None)
+    group.add_option("", "--write-cmake-fragment",
+                     dest="write_cmake_fragment", metavar="PATH",
+                     help="Write the CMake project information to PATH",
+                     action="store", default=None)
+    group.add_option("", "--write-make-fragment",
+                      dest="write_make_fragment", metavar="PATH",
+                     help="Write the Makefile project information to PATH",
+                     action="store", default=None)
+    group.add_option("", "--configure-target-def-file",
+                     dest="configure_target_def_files",
+                     help="""Configure the given file at SUBPATH (relative to
+the inferred or given source root, and with a '.in' suffix) by replacing certain
+substitution variables with lists of targets that support certain features (for
+example, targets with AsmPrinters) and write the result to the build root (as
+given by --build-root) at the same SUBPATH""",
+                     metavar="SUBPATH", action="append", default=None)
+    parser.add_option_group(group)
+
+    group = OptionGroup(parser, "Configuration Options")
+    group.add_option("", "--native-target",
+                      dest="native_target", metavar="NAME",
+                      help=("Treat the named target as the 'native' one, if "
+                            "given [%default]"),
+                      action="store", default=None)
+    group.add_option("", "--enable-targets",
+                      dest="enable_targets", metavar="NAMES",
+                      help=("Enable the given space or semi-colon separated "
+                            "list of targets, or all targets if not present"),
+                      action="store", default=None)
+    parser.add_option_group(group)
+
+    (opts, args) = parser.parse_args()
+
+    # Determine the LLVM source path, if not given.
+    source_root = opts.source_root
+    if source_root:
+        if not os.path.exists(os.path.join(source_root, 'lib', 'VMCore',
+                                           'Function.cpp')):
+            parser.error('invalid LLVM source root: %r' % source_root)
+    else:
+        llvmbuild_path = os.path.dirname(__file__)
+        llvm_build_path = os.path.dirname(llvmbuild_path)
+        utils_path = os.path.dirname(llvm_build_path)
+        source_root = os.path.dirname(utils_path)
+        if not os.path.exists(os.path.join(source_root, 'lib', 'VMCore',
+                                           'Function.cpp')):
+            parser.error('unable to infer LLVM source root, please specify')
+
+    # Construct the LLVM project information.
+    llvmbuild_source_root = opts.llvmbuild_source_root or source_root
+    project_info = LLVMProjectInfo.load_from_path(
+        source_root, llvmbuild_source_root)
+
+    # Add the magic target based components.
+    add_magic_target_components(parser, project_info, opts)
+
+    # Validate the project component info.
+    project_info.validate_components()
+
+    # Print the component tree, if requested.
+    if opts.print_tree:
+        project_info.print_tree()
+
+    # Write out the components, if requested. This is useful for auto-upgrading
+    # the schema.
+    if opts.write_llvmbuild:
+        project_info.write_components(opts.write_llvmbuild)
+
+    # Write out the required library table, if requested.
+    if opts.write_library_table:
+        project_info.write_library_table(opts.write_library_table)
+
+    # Write out the make fragment, if requested.
+    if opts.write_make_fragment:
+        project_info.write_make_fragment(opts.write_make_fragment)
+
+    # Write out the cmake fragment, if requested.
+    if opts.write_cmake_fragment:
+        project_info.write_cmake_fragment(opts.write_cmake_fragment)
+
+    # Configure target definition files, if requested.
+    if opts.configure_target_def_files:
+        # Verify we were given a build root.
+        if not opts.build_root:
+            parser.error("must specify --build-root when using "
+                         "--configure-target-def-file")
+
+        # Create the substitution list.
+        available_targets = [ci for ci in project_info.component_infos
+                             if ci.type_name == 'TargetGroup']
+        substitutions = [
+            ("@LLVM_ENUM_TARGETS@",
+             ' '.join('LLVM_TARGET(%s)' % ci.name
+                      for ci in available_targets)),
+            ("@LLVM_ENUM_ASM_PRINTERS@",
+             ' '.join('LLVM_ASM_PRINTER(%s)' % ci.name
+                      for ci in available_targets
+                      if ci.has_asmprinter)),
+            ("@LLVM_ENUM_ASM_PARSERS@",
+             ' '.join('LLVM_ASM_PARSER(%s)' % ci.name
+                      for ci in available_targets
+                      if ci.has_asmparser)),
+            ("@LLVM_ENUM_DISASSEMBLERS@",
+             ' '.join('LLVM_DISASSEMBLER(%s)' % ci.name
+                      for ci in available_targets
+                      if ci.has_disassembler))]
+
+        # Configure the given files.
+        for subpath in opts.configure_target_def_files:
+            inpath = os.path.join(source_root, subpath + '.in')
+            outpath = os.path.join(opts.build_root, subpath)
+            result = configutil.configure_file(inpath, outpath, substitutions)
+            if not result:
+                note("configured file %r hasn't changed" % outpath)
+
+if __name__=='__main__':
+    main()
diff --git a/utils/llvm-build/llvmbuild/util.py b/utils/llvm-build/llvmbuild/util.py
new file mode 100644
index 0000000..e581af2
--- /dev/null
+++ b/utils/llvm-build/llvmbuild/util.py
@@ -0,0 +1,13 @@
+import os
+import sys
+
+def _write_message(kind, message):
+    program = os.path.basename(sys.argv[0])
+    print >>sys.stderr, '%s: %s: %s' % (program, kind, message)
+
+note = lambda message: _write_message('note', message)
+warning = lambda message: _write_message('warning', message)
+error = lambda message: _write_message('error', message)
+fatal = lambda message: (_write_message('fatal error', message), sys.exit(1))
+
+__all__ = ['note', 'warning', 'error', 'fatal']