[llvmbuild] Allow OptionalLibrary's to be enabled by default and disabled

[dsanders]

Summary

As part of this, clean up the duplicated code where each writer independently
implemented the effects of --enable-optional-components. Also, clean up the
pseudo-isinstance() in case I find I need to add OptionalLibraryGroup later.

[dsanders]

Just to give you some context and an overview of the direction, we have some hacks we use to make our LLVM dylib smaller by omitting subcomponents of LLVM that we don't actually use in practice. This is part of a small series of patches to try to eliminate these hacks by rounding out llvmbuild's support for optional libraries. This patch allows libraries to be included by default and optionally disabled, and it will be followed by a small bugfix for --enable-optional-components, and then the addition of an optional_libraries to go with the existing required_libraries.

[dsanders]

Remove a bit of the next patch that snuck into this one while organizing the patches

llvm/test/LLVMBuild/enabled/Input/LLVMBuild.txt

+;===- ./LLVMBuild.txt ------------------------------------------*- Conf -*--===;
+;
+; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+; See https://llvm.org/LICENSE.txt for license information.
+; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+;
+;===------------------------------------------------------------------------===;
+;
+; 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
+;
+;===------------------------------------------------------------------------===;
+
+[common]
+subdirectories = lib
+
+[component_0]
+type = LibraryGroup
+name = Engine
+parent = $ROOT
+
+[component_1]
+type = Library
+name = Interpreter
+parent = $ROOT
+
+[component_2]
+type = Group
+name = Miscellaneous
+parent = $ROOT
+
+[component_3]
+type = LibraryGroup
+name = Native
+parent = $ROOT
+
+[component_4]
+type = LibraryGroup
+name = NativeCodeGen
+parent = $ROOT
+
+[component_5]
+type = LibraryGroup
+name = all-targets
+parent = $ROOT

llvm/test/LLVMBuild/enabled/Input/lib/LLVMBuild.txt

+;===- ./LLVMBuild.txt ------------------------------------------*- Conf -*--===;
+;
+; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+; See https://llvm.org/LICENSE.txt for license information.
+; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+;
+;===------------------------------------------------------------------------===;
+;
+; 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
+;
+;===------------------------------------------------------------------------===;
+
+[component_0]
+type = OptionalLibrary
+name = DisabledByCmdLib
+enabled_component = 1
+parent = $ROOT
+
+[component_1]
+type = OptionalLibrary
+name = DisabledDefaultLib
+parent = $ROOT
+
+[component_2]
+type = OptionalLibrary
+name = EnabledByCmdLib
+parent = $ROOT
+
+[component_3]
+type = OptionalLibrary
+name = EnabledDefaultLib
+enabled_component = 1
+parent = $ROOT

llvm/test/LLVMBuild/enabled/enabled.test

+RUN: %llvmbuild --source-root=%S/Input --write-llvmbuild=%T --enable-optional-components=EnabledByCmdLib
+RUN: FileCheck %s < %T/lib/LLVMBuild.txt
+
+; CHECK:      [component_0]
+; CHECK-NEXT: type = OptionalLibrary
+; CHECK-NEXT: name = DisabledByCmdLib
+; CHECK-NEXT: parent = $ROOT
+
+; CHECK:      [component_1]
+; CHECK-NEXT: type = OptionalLibrary
+; CHECK-NEXT: name = DisabledDefaultLib
+; CHECK-NEXT: parent = $ROOT
+
+; CHECK:      [component_2]
+; CHECK-NEXT: type = OptionalLibrary
+; CHECK-NEXT: name = EnabledByCmdLib
+; CHECK-NEXT: parent = $ROOT
+; CHECK-NEXT: enabled_component = 1
+
+; CHECK:      [component_3]
+; CHECK-NEXT: type = OptionalLibrary
+; CHECK-NEXT: name = EnabledDefaultLib
+; CHECK-NEXT: parent = $ROOT
+; CHECK-NEXT: enabled_component = 1

llvm/test/LLVMBuild/lit.local.cfg

+config.substitutions.append(
+  ('%llvmbuild', os.path.join(config.root.llvm_src_root, 'utils', 'llvm-build',
+                              'llvm-build')))
+config.suffixes = ['.test']

llvm/utils/llvm-build/llvmbuild/componentinfo.py

def parse_items(items, has_dependencies = True):
         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)
+        self.optional_component = False
+        self.enabled_component = True
 
         # 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 = []
def get_llvmconfig_component_name(self):
         return self.get_library_name().lower()
 
 class OptionalLibraryComponentInfo(LibraryComponentInfo):
     type_name = "OptionalLibrary"
 
     @staticmethod
     def parse(subpath, items):
       kwargs = LibraryComponentInfo.parse_items(items)
+      kwargs['enabled_component'] = \
+          items.get_optional_bool('enabled_component', False)
       return OptionalLibraryComponentInfo(subpath, **kwargs)
 
     def __init__(self, subpath, name, dependencies, parent, library_name,
-                 required_libraries, add_to_library_groups, installed):
+                 required_libraries, add_to_library_groups, installed,
+                 enabled_component):
       LibraryComponentInfo.__init__(self, subpath, name, dependencies, parent,
                                     library_name, required_libraries,
                                     add_to_library_groups, installed)
+      self.enabled_component = enabled_component
+      self.optional_component = True
+
+    def get_llvmbuild_fragment(self):
+        result = super(OptionalLibraryComponentInfo,
+                       self).get_llvmbuild_fragment()
+        if self.enabled_component:
+            result += 'enabled_component = 1\n'
+        return result
 
 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')

llvm/utils/llvm-build/llvmbuild/main.py

 from __future__ import absolute_import
 import filecmp
 import os
 import sys
 
 import llvmbuild.componentinfo as componentinfo
 
 from llvmbuild.util import fatal, note
 
 ###
 
+def space_or_semicolon_list(x):
+    # We support both space separated and semi-colon separated lists.
+    if x == '':
+        return []
+    elif ' ' in x:
+        return x.split()
+    else:
+        return x.split(';')
+
 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.
     """
 
""" % header_string)
                     f.write(comment)
                 f.write("[%s]\n" % name)
                 f.write(fragment)
                 if fragment is not fragments[-1][1]:
                     f.write('\n')
 
             f.close()
 
-    def write_library_table(self, output_path, enabled_optional_components):
+    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:
             # Skip optional components which are not enabled.
-            if c.type_name == 'OptionalLibrary' \
-                and c.name not in enabled_optional_components:
+            if not c.enabled_component:
                 continue
 
             # Skip target groups which are not enabled.
             tg = c.get_parent_target_group()
             if tg and not tg.enabled:
                 continue
 
             # Only certain components are in the table.
def get_fragment_dependencies(self):
                 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 foreach_cmake_library(self, f,
-                              enabled_optional_components,
                               skip_disabled,
                               skip_not_installed):
         for ci in self.ordered_component_infos:
             # Skip optional components which are not enabled.
-            if ci.type_name == 'OptionalLibrary' \
-                and ci.name not in enabled_optional_components:
+            if not ci.enabled_component:
                 continue
 
             # We only write the information for libraries currently.
             if ci.type_name not in ('Library', 'OptionalLibrary'):
                 continue
 
             # Skip disabled targets.
             if skip_disabled:
                 tg = ci.get_parent_target_group()
                 if tg and not tg.enabled:
                     continue
 
             # Skip targets that will not be installed
             if skip_not_installed and not ci.installed:
                 continue
 
             f(ci)
 
 
-    def write_cmake_fragment(self, output_path, enabled_optional_components):
+    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.
         """
""")
         self.foreach_cmake_library(
             lambda ci:
               f.write("""\
 set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_%s %s)\n""" % (
                 ci.get_prefixed_library_name(), " ".join(sorted(
                      dep.get_prefixed_library_name()
                      for dep in self.get_required_libraries_for_component(ci)))))
             ,
-            enabled_optional_components,
             skip_disabled = False,
             skip_not_installed = False # Dependency info must be emitted for internals libs too
             )
 
         f.close()
 
-    def write_cmake_exports_fragment(self, output_path, enabled_optional_components):
+    def write_cmake_exports_fragment(self, output_path):
         """
         write_cmake_exports_fragment(output_path) -> None
 
         Generate a CMake fragment which includes LLVMBuild library
         dependencies expressed similarly to how CMake would write
         them via install(EXPORT).
         """
 
""")
         self.foreach_cmake_library(
             lambda ci:
               f.write("""\
 set_property(TARGET %s PROPERTY IMPORTED_LINK_INTERFACE_LIBRARIES %s)\n""" % (
                 ci.get_prefixed_library_name(), " ".join(sorted(
                      dep.get_prefixed_library_name()
                      for dep in self.get_required_libraries_for_component(ci)))))
             ,
-            enabled_optional_components,
             skip_disabled = True,
             skip_not_installed = True # Do not export internal libraries like gtest
             )
 
         f.close()
 
 def add_magic_target_components(parser, project, opts):
     """add_magic_target_components(project, opts) -> None
else:
         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 opts.enable_targets == '':
-            enable_target_names = []
-        elif ' ' in opts.enable_targets:
-            enable_target_names = opts.enable_targets.split()
-        else:
-            enable_target_names = opts.enable_targets.split(';')
+        enable_target_names = space_or_semicolon_list(opts.enable_targets)
 
         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':
group.add_option("", "--native-target",
                             "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)
     group.add_option("", "--enable-optional-components",
-                      dest="optional_components", metavar="NAMES",
+                      dest="enable_optional_components", metavar="NAMES",
                       help=("Enable the given space or semi-colon separated "
                             "list of optional components"),
                       action="store", default="")
+    group.add_option("", "--disable-optional-components",
+                      dest="disable_optional_components", metavar="NAMES",
+                      help=("Disable the given space or semi-colon separated "
+                            "list of optional components"),
+                      action="store", default="")
     parser.add_option_group(group)
 
     (opts, args) = parser.parse_args()
+    opts.enable_optional_components = \
+        space_or_semicolon_list(opts.enable_optional_components)
 
     # 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', 'IR',
                                            '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', 'IR',
                                            '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)
 
+    # Apply options that change component.enabled_component
+    for c in project_info.component_infos:
+        if c.name in opts.enable_optional_components:
+            if c.optional_component:
+                c.enabled_component = True
+            else:
+                parser.error('component `%s` is not optional' % c.name)
+        if c.name in opts.disable_optional_components:
+            if c.optional_component:
+                c.enabled_component = False
+            else:
+                parser.error('component `%s` is not optional' % c.name)
+
     # 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,
-                                         opts.optional_components)
+        project_info.write_library_table(opts.write_library_table)
 
     # Write out the cmake fragment, if requested.
     if opts.write_cmake_fragment:
-        project_info.write_cmake_fragment(opts.write_cmake_fragment,
-                                          opts.optional_components)
+        project_info.write_cmake_fragment(opts.write_cmake_fragment)
     if opts.write_cmake_exports_fragment:
-        project_info.write_cmake_exports_fragment(opts.write_cmake_exports_fragment,
-                                                  opts.optional_components)
+        project_info.write_cmake_exports_fragment(opts.write_cmake_exports_fragment)
 
 if __name__=='__main__':
     main()