utils/llvm-build/llvmbuild/main.py

   1 import StringIO
   2 import os
   3 import sys
   4
   5 import componentinfo
   6 import configutil
   7
   8 from util import *
   9
  10 ###
  11
  12 def cmake_quote_string(value):
  13     """
  14     cmake_quote_string(value) -> str
  15
  16     Return a quoted form of the given value that is suitable for use in CMake
  17     language files.
  18     """
  19
  20     # Currently, we only handle escaping backslashes.
  21     value = value.replace("\\", "\\\\")
  22
  23     return value
  24
  25 def cmake_quote_path(value):
  26     """
  27     cmake_quote_path(value) -> str
  28
  29     Return a quoted form of the given value that is suitable for use in CMake
  30     language files.
  31     """
  32
  33     # CMake has a bug in it's Makefile generator that doesn't properly quote
  34     # strings it generates. So instead of using proper quoting, we just use "/"
  35     # style paths.  Currently, we only handle escaping backslashes.
  36     value = value.replace("\\", "/")
  37
  38     return value
  39
  40 def mk_quote_string_for_target(value):
  41     """
  42     mk_quote_string_for_target(target_name) -> str
  43
  44     Return a quoted form of the given target_name suitable for including in a
  45     Makefile as a target name.
  46     """
  47
  48     # The only quoting we currently perform is for ':', to support msys users.
  49     return value.replace(":", "\\:")
  50
  51 def make_install_dir(path):
  52     """
  53     make_install_dir(path) -> None
  54
  55     Create the given directory path for installation, including any parents.
  56     """
  57
  58     # os.makedirs considers it an error to be called with an existant path.
  59     if not os.path.exists(path):
  60         os.makedirs(path)
  61
  62 ###
  63
  64 class LLVMProjectInfo(object):
  65     @staticmethod
  66     def load_infos_from_path(llvmbuild_source_root):
  67         def recurse(subpath):
  68             # Load the LLVMBuild file.
  69             llvmbuild_path = os.path.join(llvmbuild_source_root + subpath,
  70                                           'LLVMBuild.txt')
  71             if not os.path.exists(llvmbuild_path):
  72                 fatal("missing LLVMBuild.txt file at: %r" % (llvmbuild_path,))
  73
  74             # Parse the components from it.
  75             common,info_iter = componentinfo.load_from_path(llvmbuild_path,
  76                                                             subpath)
  77             for info in info_iter:
  78                 yield info
  79
  80             # Recurse into the specified subdirectories.
  81             for subdir in common.get_list("subdirectories"):
  82                 for item in recurse(os.path.join(subpath, subdir)):
  83                     yield item
  84
  85         return recurse("/")
  86
  87     @staticmethod
  88     def load_from_path(source_root, llvmbuild_source_root):
  89         infos = list(
  90             LLVMProjectInfo.load_infos_from_path(llvmbuild_source_root))
  91
  92         return LLVMProjectInfo(source_root, infos)
  93
  94     def __init__(self, source_root, component_infos):
  95         # Store our simple ivars.
  96         self.source_root = source_root
  97         self.component_infos = list(component_infos)
  98         self.component_info_map = None
  99         self.ordered_component_infos = None
 100
 101     def validate_components(self):
 102         """validate_components() -> None
 103
 104         Validate that the project components are well-defined. Among other
 105         things, this checks that:
 106           - Components have valid references.
 107           - Components references do not form cycles.
 108
 109         We also construct the map from component names to info, and the
 110         topological ordering of components.
 111         """
 112
 113         # Create the component info map and validate that component names are
 114         # unique.
 115         self.component_info_map = {}
 116         for ci in self.component_infos:
 117             existing = self.component_info_map.get(ci.name)
 118             if existing is not None:
 119                 # We found a duplicate component name, report it and error out.
 120                 fatal("found duplicate component %r (at %r and %r)" % (
 121                         ci.name, ci.subpath, existing.subpath))
 122             self.component_info_map[ci.name] = ci
 123
 124         # Disallow 'all' as a component name, which is a special case.
 125         if 'all' in self.component_info_map:
 126             fatal("project is not allowed to define 'all' component")
 127
 128         # Add the root component.
 129         if '$ROOT' in self.component_info_map:
 130             fatal("project is not allowed to define $ROOT component")
 131         self.component_info_map['$ROOT'] = componentinfo.GroupComponentInfo(
 132             '/', '$ROOT', None)
 133         self.component_infos.append(self.component_info_map['$ROOT'])
 134
 135         # Topologically order the component information according to their
 136         # component references.
 137         def visit_component_info(ci, current_stack, current_set):
 138             # Check for a cycles.
 139             if ci in current_set:
 140                 # We found a cycle, report it and error out.
 141                 cycle_description = ' -> '.join(
 142                     '%r (%s)' % (ci.name, relation)
 143                     for relation,ci in current_stack)
 144                 fatal("found cycle to %r after following: %s -> %s" % (
 145                         ci.name, cycle_description, ci.name))
 146
 147             # If we have already visited this item, we are done.
 148             if ci not in components_to_visit:
 149                 return
 150
 151             # Otherwise, mark the component info as visited and traverse.
 152             components_to_visit.remove(ci)
 153
 154             # Validate the parent reference, which we treat specially.
 155             if ci.parent is not None:
 156                 parent = self.component_info_map.get(ci.parent)
 157                 if parent is None:
 158                     fatal("component %r has invalid reference %r (via %r)" % (
 159                             ci.name, ci.parent, 'parent'))
 160                 ci.set_parent_instance(parent)
 161
 162             for relation,referent_name in ci.get_component_references():
 163                 # Validate that the reference is ok.
 164                 referent = self.component_info_map.get(referent_name)
 165                 if referent is None:
 166                     fatal("component %r has invalid reference %r (via %r)" % (
 167                             ci.name, referent_name, relation))
 168
 169                 # Visit the reference.
 170                 current_stack.append((relation,ci))
 171                 current_set.add(ci)
 172                 visit_component_info(referent, current_stack, current_set)
 173                 current_set.remove(ci)
 174                 current_stack.pop()
 175
 176             # Finally, add the component info to the ordered list.
 177             self.ordered_component_infos.append(ci)
 178
 179         # FIXME: We aren't actually correctly checking for cycles along the
 180         # parent edges. Haven't decided how I want to handle this -- I thought
 181         # about only checking cycles by relation type. If we do that, it falls
 182         # out easily. If we don't, we should special case the check.
 183
 184         self.ordered_component_infos = []
 185         components_to_visit = set(self.component_infos)
 186         while components_to_visit:
 187             visit_component_info(iter(components_to_visit).next(), [], set())
 188
 189         # Canonicalize children lists.
 190         for c in self.ordered_component_infos:
 191             c.children.sort(key = lambda c: c.name)
 192
 193     def print_tree(self):
 194         def visit(node, depth = 0):
 195             print '%s%-40s (%s)' % ('  '*depth, node.name, node.type_name)
 196             for c in node.children:
 197                 visit(c, depth + 1)
 198         visit(self.component_info_map['$ROOT'])
 199
 200     def write_components(self, output_path):
 201         # Organize all the components by the directory their LLVMBuild file
 202         # should go in.
 203         info_basedir = {}
 204         for ci in self.component_infos:
 205             # Ignore the $ROOT component.
 206             if ci.parent is None:
 207                 continue
 208
 209             info_basedir[ci.subpath] = info_basedir.get(ci.subpath, []) + [ci]
 210
 211         # Compute the list of subdirectories to scan.
 212         subpath_subdirs = {}
 213         for ci in self.component_infos:
 214             # Ignore root components.
 215             if ci.subpath == '/':
 216                 continue
 217
 218             # Otherwise, append this subpath to the parent list.
 219             parent_path = os.path.dirname(ci.subpath)
 220             subpath_subdirs[parent_path] = parent_list = subpath_subdirs.get(
 221                 parent_path, set())
 222             parent_list.add(os.path.basename(ci.subpath))
 223
 224         # Generate the build files.
 225         for subpath, infos in info_basedir.items():
 226             # Order the components by name to have a canonical ordering.
 227             infos.sort(key = lambda ci: ci.name)
 228
 229             # Format the components into llvmbuild fragments.
 230             fragments = []
 231
 232             # Add the common fragments.
 233             subdirectories = subpath_subdirs.get(subpath)
 234             if subdirectories:
 235                 fragment = """\
 236 subdirectories = %s
 237 """ % (" ".join(sorted(subdirectories)),)
 238                 fragments.append(("common", fragment))
 239
 240             # Add the component fragments.
 241             num_common_fragments = len(fragments)
 242             for ci in infos:
 243                 fragment = ci.get_llvmbuild_fragment()
 244                 if fragment is None:
 245                     continue
 246
 247                 name = "component_%d" % (len(fragments) - num_common_fragments)
 248                 fragments.append((name, fragment))
 249
 250             if not fragments:
 251                 continue
 252
 253             assert subpath.startswith('/')
 254             directory_path = os.path.join(output_path, subpath[1:])
 255
 256             # Create the directory if it does not already exist.
 257             if not os.path.exists(directory_path):
 258                 os.makedirs(directory_path)
 259
 260             # In an effort to preserve comments (which aren't parsed), read in
 261             # the original file and extract the comments. We only know how to
 262             # associate comments that prefix a section name.
 263             f = open(infos[0]._source_path)
 264             comments_map = {}
 265             comment_block = ""
 266             for ln in f:
 267                 if ln.startswith(';'):
 268                     comment_block += ln
 269                 elif ln.startswith('[') and ln.endswith(']\n'):
 270                     comments_map[ln[1:-2]] = comment_block
 271                 else:
 272                     comment_block = ""
 273             f.close()
 274
 275             # Create the LLVMBuild fil[e.
 276             file_path = os.path.join(directory_path, 'LLVMBuild.txt')
 277             f = open(file_path, "w")
 278
 279             # Write the header.
 280             header_fmt = ';===- %s %s-*- Conf -*--===;'
 281             header_name = '.' + os.path.join(subpath, 'LLVMBuild.txt')
 282             header_pad = '-' * (80 - len(header_fmt % (header_name, '')))
 283             header_string = header_fmt % (header_name, header_pad)
 284             print >>f, """\
 285 %s
 286 ;
 287 ;                     The LLVM Compiler Infrastructure
 288 ;
 289 ; This file is distributed under the University of Illinois Open Source
 290 ; License. See LICENSE.TXT for details.
 291 ;
 292 ;===------------------------------------------------------------------------===;
 293 ;
 294 ; This is an LLVMBuild description file for the components in this subdirectory.
 295 ;
 296 ; For more information on the LLVMBuild system, please see:
 297 ;
 298 ;   http://llvm.org/docs/LLVMBuild.html
 299 ;
 300 ;===------------------------------------------------------------------------===;
 301 """ % header_string
 302
 303             # Write out each fragment.each component fragment.
 304             for name,fragment in fragments:
 305                 comment = comments_map.get(name)
 306                 if comment is not None:
 307                     f.write(comment)
 308                 print >>f, "[%s]" % name
 309                 f.write(fragment)
 310                 if fragment is not fragments[-1][1]:
 311                     print >>f
 312
 313             f.close()
 314
 315     def write_library_table(self, output_path, enabled_optional_components):
 316         # Write out the mapping from component names to required libraries.
 317         #
 318         # We do this in topological order so that we know we can append the
 319         # dependencies for added library groups.
 320         entries = {}
 321         for c in self.ordered_component_infos:
 322             # Skip optional components which are not enabled.
 323             if c.type_name == 'OptionalLibrary' \
 324                 and c.name not in enabled_optional_components:
 325                 continue
 326
 327             # Skip target groups which are not enabled.
 328             tg = c.get_parent_target_group()
 329             if tg and not tg.enabled:
 330                 continue
 331
 332             # Only certain components are in the table.
 333             if c.type_name not in ('Library', 'OptionalLibrary', \
 334                                    'LibraryGroup', 'TargetGroup'):
 335                 continue
 336
 337             # Compute the llvm-config "component name". For historical reasons,
 338             # this is lowercased based on the library name.
 339             llvmconfig_component_name = c.get_llvmconfig_component_name()
 340
 341             # Get the library name, or None for LibraryGroups.
 342             if c.type_name == 'Library' or c.type_name == 'OptionalLibrary':
 343                 library_name = c.get_prefixed_library_name()
 344                 is_installed = c.installed
 345             else:
 346                 library_name = None
 347                 is_installed = True
 348
 349             # Get the component names of all the required libraries.
 350             required_llvmconfig_component_names = [
 351                 self.component_info_map[dep].get_llvmconfig_component_name()
 352                 for dep in c.required_libraries]
 353
 354             # Insert the entries for library groups we should add to.
 355             for dep in c.add_to_library_groups:
 356                 entries[dep][2].append(llvmconfig_component_name)
 357
 358             # Add the entry.
 359             entries[c.name] = (llvmconfig_component_name, library_name,
 360                                required_llvmconfig_component_names,
 361                                is_installed)
 362
 363         # Convert to a list of entries and sort by name.
 364         entries = entries.values()
 365
 366         # Create an 'all' pseudo component. We keep the dependency list small by
 367         # only listing entries that have no other dependents.
 368         root_entries = set(e[0] for e in entries)
 369         for _,_,deps,_ in entries:
 370             root_entries -= set(deps)
 371         entries.append(('all', None, root_entries, True))
 372
 373         entries.sort()
 374
 375         # Compute the maximum number of required libraries, plus one so there is
 376         # always a sentinel.
 377         max_required_libraries = max(len(deps)
 378                                      for _,_,deps,_ in entries) + 1
 379
 380         # Write out the library table.
 381         make_install_dir(os.path.dirname(output_path))
 382         f = open(output_path, 'w')
 383         print >>f, """\
 384 //===- llvm-build generated file --------------------------------*- C++ -*-===//
 385 //
 386 // Component Library Depenedency Table
 387 //
 388 // Automatically generated file, do not edit!
 389 //
 390 //===----------------------------------------------------------------------===//
 391 """
 392         print >>f, 'struct AvailableComponent {'
 393         print >>f, '  /// The name of the component.'
 394         print >>f, '  const char *Name;'
 395         print >>f, ''
 396         print >>f, '  /// The name of the library for this component (or NULL).'
 397         print >>f, '  const char *Library;'
 398         print >>f, ''
 399         print >>f, '  /// Whether the component is installed.'
 400         print >>f, '  bool IsInstalled;'
 401         print >>f, ''
 402         print >>f, '\
 403   /// The list of libraries required when linking this component.'
 404         print >>f, '  const char *RequiredLibraries[%d];' % (
 405             max_required_libraries)
 406         print >>f, '} AvailableComponents[%d] = {' % len(entries)
 407         for name,library_name,required_names,is_installed in entries:
 408             if library_name is None:
 409                 library_name_as_cstr = '0'
 410             else:
 411                 library_name_as_cstr = '"lib%s.a"' % library_name
 412             print >>f, '  { "%s", %s, %d, { %s } },' % (
 413                 name, library_name_as_cstr, is_installed,
 414                 ', '.join('"%s"' % dep
 415                           for dep in required_names))
 416         print >>f, '};'
 417         f.close()
 418
 419     def get_required_libraries_for_component(self, ci, traverse_groups = False):
 420         """
 421         get_required_libraries_for_component(component_info) -> iter
 422
 423         Given a Library component info descriptor, return an iterator over all
 424         of the directly required libraries for linking with this component. If
 425         traverse_groups is True, then library and target groups will be
 426         traversed to include their required libraries.
 427         """
 428
 429         assert ci.type_name in ('Library', 'LibraryGroup', 'TargetGroup')
 430
 431         for name in ci.required_libraries:
 432             # Get the dependency info.
 433             dep = self.component_info_map[name]
 434
 435             # If it is a library, yield it.
 436             if dep.type_name == 'Library':
 437                 yield dep
 438                 continue
 439
 440             # Otherwise if it is a group, yield or traverse depending on what
 441             # was requested.
 442             if dep.type_name in ('LibraryGroup', 'TargetGroup'):
 443                 if not traverse_groups:
 444                     yield dep
 445                     continue
 446
 447                 for res in self.get_required_libraries_for_component(dep, True):
 448                     yield res
 449
 450     def get_fragment_dependencies(self):
 451         """
 452         get_fragment_dependencies() -> iter
 453
 454         Compute the list of files (as absolute paths) on which the output
 455         fragments depend (i.e., files for which a modification should trigger a
 456         rebuild of the fragment).
 457         """
 458
 459         # Construct a list of all the dependencies of the Makefile fragment
 460         # itself. These include all the LLVMBuild files themselves, as well as
 461         # all of our own sources.
 462         #
 463         # Many components may come from the same file, so we make sure to unique
 464         # these.
 465         build_paths = set()
 466         for ci in self.component_infos:
 467             p = os.path.join(self.source_root, ci.subpath[1:], 'LLVMBuild.txt')
 468             if p not in build_paths:
 469                 yield p
 470                 build_paths.add(p)
 471
 472         # Gather the list of necessary sources by just finding all loaded
 473         # modules that are inside the LLVM source tree.
 474         for module in sys.modules.values():
 475             # Find the module path.
 476             if not hasattr(module, '__file__'):
 477                 continue
 478             path = getattr(module, '__file__')
 479             if not path:
 480                 continue
 481
 482             # Strip off any compiled suffix.
 483             if os.path.splitext(path)[1] in ['.pyc', '.pyo', '.pyd']:
 484                 path = path[:-1]
 485
 486             # If the path exists and is in the source tree, consider it a
 487             # dependency.
 488             if (path.startswith(self.source_root) and os.path.exists(path)):
 489                 yield path
 490
 491     def write_cmake_fragment(self, output_path):
 492         """
 493         write_cmake_fragment(output_path) -> None
 494
 495         Generate a CMake fragment which includes all of the collated LLVMBuild
 496         information in a format that is easily digestible by a CMake. The exact
 497         contents of this are closely tied to how the CMake configuration
 498         integrates LLVMBuild, see CMakeLists.txt in the top-level.
 499         """
 500
 501         dependencies = list(self.get_fragment_dependencies())
 502
 503         # Write out the CMake fragment.
 504         make_install_dir(os.path.dirname(output_path))
 505         f = open(output_path, 'w')
 506
 507         # Write the header.
 508         header_fmt = '\
 509 #===-- %s - LLVMBuild Configuration for LLVM %s-*- CMake -*--===#'
 510         header_name = os.path.basename(output_path)
 511         header_pad = '-' * (80 - len(header_fmt % (header_name, '')))
 512         header_string = header_fmt % (header_name, header_pad)
 513         print >>f, """\
 514 %s
 515 #
 516 #                     The LLVM Compiler Infrastructure
 517 #
 518 # This file is distributed under the University of Illinois Open Source
 519 # License. See LICENSE.TXT for details.
 520 #
 521 #===------------------------------------------------------------------------===#
 522 #
 523 # This file contains the LLVMBuild project information in a format easily
 524 # consumed by the CMake based build system.
 525 #
 526 # This file is autogenerated by llvm-build, do not edit!
 527 #
 528 #===------------------------------------------------------------------------===#
 529 """ % header_string
 530
 531         # Write the dependency information in the best way we can.
 532         print >>f, """
 533 # LLVMBuild CMake fragment dependencies.
 534 #
 535 # CMake has no builtin way to declare that the configuration depends on
 536 # a particular file. However, a side effect of configure_file is to add
 537 # said input file to CMake's internal dependency list. So, we use that
 538 # and a dummy output file to communicate the dependency information to
 539 # CMake.
 540 #
 541 # FIXME: File a CMake RFE to get a properly supported version of this
 542 # feature."""
 543         for dep in dependencies:
 544             print >>f, """\
 545 configure_file(\"%s\"
 546                ${CMAKE_CURRENT_BINARY_DIR}/DummyConfigureOutput)""" % (
 547                 cmake_quote_path(dep),)
 548
 549         # Write the properties we use to encode the required library dependency
 550         # information in a form CMake can easily use directly.
 551         print >>f, """
 552 # Explicit library dependency information.
 553 #
 554 # The following property assignments effectively create a map from component
 555 # names to required libraries, in a way that is easily accessed from CMake."""
 556         for ci in self.ordered_component_infos:
 557             # We only write the information for libraries currently.
 558             if ci.type_name != 'Library':
 559                 continue
 560
 561             print >>f, """\
 562 set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_%s %s)""" % (
 563                 ci.get_prefixed_library_name(), " ".join(sorted(
 564                      dep.get_prefixed_library_name()
 565                      for dep in self.get_required_libraries_for_component(ci))))
 566
 567         f.close()
 568
 569     def write_make_fragment(self, output_path):
 570         """
 571         write_make_fragment(output_path) -> None
 572
 573         Generate a Makefile fragment which includes all of the collated
 574         LLVMBuild information in a format that is easily digestible by a
 575         Makefile. The exact contents of this are closely tied to how the LLVM
 576         Makefiles integrate LLVMBuild, see Makefile.rules in the top-level.
 577         """
 578
 579         dependencies = list(self.get_fragment_dependencies())
 580
 581         # Write out the Makefile fragment.
 582         make_install_dir(os.path.dirname(output_path))
 583         f = open(output_path, 'w')
 584
 585         # Write the header.
 586         header_fmt = '\
 587 #===-- %s - LLVMBuild Configuration for LLVM %s-*- Makefile -*--===#'
 588         header_name = os.path.basename(output_path)
 589         header_pad = '-' * (80 - len(header_fmt % (header_name, '')))
 590         header_string = header_fmt % (header_name, header_pad)
 591         print >>f, """\
 592 %s
 593 #
 594 #                     The LLVM Compiler Infrastructure
 595 #
 596 # This file is distributed under the University of Illinois Open Source
 597 # License. See LICENSE.TXT for details.
 598 #
 599 #===------------------------------------------------------------------------===#
 600 #
 601 # This file contains the LLVMBuild project information in a format easily
 602 # consumed by the Makefile based build system.
 603 #
 604 # This file is autogenerated by llvm-build, do not edit!
 605 #
 606 #===------------------------------------------------------------------------===#
 607 """ % header_string
 608
 609         # Write the dependencies for the fragment.
 610         #
 611         # FIXME: Technically, we need to properly quote for Make here.
 612         print >>f, """\
 613 # Clients must explicitly enable LLVMBUILD_INCLUDE_DEPENDENCIES to get
 614 # these dependencies. This is a compromise to help improve the
 615 # performance of recursive Make systems."""
 616         print >>f, 'ifeq ($(LLVMBUILD_INCLUDE_DEPENDENCIES),1)'
 617         print >>f, "# The dependencies for this Makefile fragment itself."
 618         print >>f, "%s: \\" % (mk_quote_string_for_target(output_path),)
 619         for dep in dependencies:
 620             print >>f, "\t%s \\" % (dep,)
 621         print >>f
 622
 623         # Generate dummy rules for each of the dependencies, so that things
 624         # continue to work correctly if any of those files are moved or removed.
 625         print >>f, """\
 626 # The dummy targets to allow proper regeneration even when files are moved or
 627 # removed."""
 628         for dep in dependencies:
 629             print >>f, "%s:" % (mk_quote_string_for_target(dep),)
 630         print >>f, 'endif'
 631
 632         f.close()
 633
 634 def add_magic_target_components(parser, project, opts):
 635     """add_magic_target_components(project, opts) -> None
 636
 637     Add the "magic" target based components to the project, which can only be
 638     determined based on the target configuration options.
 639
 640     This currently is responsible for populating the required_libraries list of
 641     the "all-targets", "Native", "NativeCodeGen", and "Engine" components.
 642     """
 643
 644     # Determine the available targets.
 645     available_targets = dict((ci.name,ci)
 646                              for ci in project.component_infos
 647                              if ci.type_name == 'TargetGroup')
 648
 649     # Find the configured native target.
 650
 651     # We handle a few special cases of target names here for historical
 652     # reasons, as these are the names configure currently comes up with.
 653     native_target_name = { 'x86' : 'X86',
 654                            'x86_64' : 'X86',
 655                            'Unknown' : None }.get(opts.native_target,
 656                                                   opts.native_target)
 657     if native_target_name is None:
 658         native_target = None
 659     else:
 660         native_target = available_targets.get(native_target_name)
 661         if native_target is None:
 662             parser.error("invalid native target: %r (not in project)" % (
 663                     opts.native_target,))
 664         if native_target.type_name != 'TargetGroup':
 665             parser.error("invalid native target: %r (not a target)" % (
 666                     opts.native_target,))
 667
 668     # Find the list of targets to enable.
 669     if opts.enable_targets is None:
 670         enable_targets = available_targets.values()
 671     else:
 672         # We support both space separated and semi-colon separated lists.
 673         if ' ' in opts.enable_targets:
 674             enable_target_names = opts.enable_targets.split()
 675         else:
 676             enable_target_names = opts.enable_targets.split(';')
 677
 678         enable_targets = []
 679         for name in enable_target_names:
 680             target = available_targets.get(name)
 681             if target is None:
 682                 parser.error("invalid target to enable: %r (not in project)" % (
 683                         name,))
 684             if target.type_name != 'TargetGroup':
 685                 parser.error("invalid target to enable: %r (not a target)" % (
 686                         name,))
 687             enable_targets.append(target)
 688
 689     # Find the special library groups we are going to populate. We enforce that
 690     # these appear in the project (instead of just adding them) so that they at
 691     # least have an explicit representation in the project LLVMBuild files (and
 692     # comments explaining how they are populated).
 693     def find_special_group(name):
 694         info = info_map.get(name)
 695         if info is None:
 696             fatal("expected project to contain special %r component" % (
 697                     name,))
 698
 699         if info.type_name != 'LibraryGroup':
 700             fatal("special component %r should be a LibraryGroup" % (
 701                     name,))
 702
 703         if info.required_libraries:
 704             fatal("special component %r must have empty %r list" % (
 705                     name, 'required_libraries'))
 706         if info.add_to_library_groups:
 707             fatal("special component %r must have empty %r list" % (
 708                     name, 'add_to_library_groups'))
 709
 710         info._is_special_group = True
 711         return info
 712
 713     info_map = dict((ci.name, ci) for ci in project.component_infos)
 714     all_targets = find_special_group('all-targets')
 715     native_group = find_special_group('Native')
 716     native_codegen_group = find_special_group('NativeCodeGen')
 717     engine_group = find_special_group('Engine')
 718
 719     # Set the enabled bit in all the target groups, and append to the
 720     # all-targets list.
 721     for ci in enable_targets:
 722         all_targets.required_libraries.append(ci.name)
 723         ci.enabled = True
 724
 725     # If we have a native target, then that defines the native and
 726     # native_codegen libraries.
 727     if native_target and native_target.enabled:
 728         native_group.required_libraries.append(native_target.name)
 729         native_codegen_group.required_libraries.append(
 730             '%sCodeGen' % native_target.name)
 731
 732     # If we have a native target with a JIT, use that for the engine. Otherwise,
 733     # use the interpreter.
 734     if native_target and native_target.enabled and native_target.has_jit:
 735         engine_group.required_libraries.append('JIT')
 736         engine_group.required_libraries.append(native_group.name)
 737     else:
 738         engine_group.required_libraries.append('Interpreter')
 739
 740 def main():
 741     from optparse import OptionParser, OptionGroup
 742     parser = OptionParser("usage: %prog [options]")
 743
 744     group = OptionGroup(parser, "Input Options")
 745     group.add_option("", "--source-root", dest="source_root", metavar="PATH",
 746                       help="Path to the LLVM source (inferred if not given)",
 747                       action="store", default=None)
 748     group.add_option("", "--llvmbuild-source-root",
 749                      dest="llvmbuild_source_root",
 750                      help=(
 751             "If given, an alternate path to search for LLVMBuild.txt files"),
 752                      action="store", default=None, metavar="PATH")
 753     group.add_option("", "--build-root", dest="build_root", metavar="PATH",
 754                       help="Path to the build directory (if needed) [%default]",
 755                       action="store", default=None)
 756     parser.add_option_group(group)
 757
 758     group = OptionGroup(parser, "Output Options")
 759     group.add_option("", "--print-tree", dest="print_tree",
 760                      help="Print out the project component tree [%default]",
 761                      action="store_true", default=False)
 762     group.add_option("", "--write-llvmbuild", dest="write_llvmbuild",
 763                       help="Write out the LLVMBuild.txt files to PATH",
 764                       action="store", default=None, metavar="PATH")
 765     group.add_option("", "--write-library-table",
 766                      dest="write_library_table", metavar="PATH",
 767                      help="Write the C++ library dependency table to PATH",
 768                      action="store", default=None)
 769     group.add_option("", "--write-cmake-fragment",
 770                      dest="write_cmake_fragment", metavar="PATH",
 771                      help="Write the CMake project information to PATH",
 772                      action="store", default=None)
 773     group.add_option("", "--write-make-fragment",
 774                       dest="write_make_fragment", metavar="PATH",
 775                      help="Write the Makefile project information to PATH",
 776                      action="store", default=None)
 777     group.add_option("", "--configure-target-def-file",
 778                      dest="configure_target_def_files",
 779                      help="""Configure the given file at SUBPATH (relative to
 780 the inferred or given source root, and with a '.in' suffix) by replacing certain
 781 substitution variables with lists of targets that support certain features (for
 782 example, targets with AsmPrinters) and write the result to the build root (as
 783 given by --build-root) at the same SUBPATH""",
 784                      metavar="SUBPATH", action="append", default=None)
 785     parser.add_option_group(group)
 786
 787     group = OptionGroup(parser, "Configuration Options")
 788     group.add_option("", "--native-target",
 789                       dest="native_target", metavar="NAME",
 790                       help=("Treat the named target as the 'native' one, if "
 791                             "given [%default]"),
 792                       action="store", default=None)
 793     group.add_option("", "--enable-targets",
 794                       dest="enable_targets", metavar="NAMES",
 795                       help=("Enable the given space or semi-colon separated "
 796                             "list of targets, or all targets if not present"),
 797                       action="store", default=None)
 798     group.add_option("", "--enable-optional-components",
 799                       dest="optional_components", metavar="NAMES",
 800                       help=("Enable the given space or semi-colon separated "
 801                             "list of optional components"),
 802                       action="store", default=None)
 803     parser.add_option_group(group)
 804
 805     (opts, args) = parser.parse_args()
 806
 807     # Determine the LLVM source path, if not given.
 808     source_root = opts.source_root
 809     if source_root:
 810         if not os.path.exists(os.path.join(source_root, 'lib', 'VMCore',
 811                                            'Function.cpp')):
 812             parser.error('invalid LLVM source root: %r' % source_root)
 813     else:
 814         llvmbuild_path = os.path.dirname(__file__)
 815         llvm_build_path = os.path.dirname(llvmbuild_path)
 816         utils_path = os.path.dirname(llvm_build_path)
 817         source_root = os.path.dirname(utils_path)
 818         if not os.path.exists(os.path.join(source_root, 'lib', 'VMCore',
 819                                            'Function.cpp')):
 820             parser.error('unable to infer LLVM source root, please specify')
 821
 822     # Construct the LLVM project information.
 823     llvmbuild_source_root = opts.llvmbuild_source_root or source_root
 824     project_info = LLVMProjectInfo.load_from_path(
 825         source_root, llvmbuild_source_root)
 826
 827     # Add the magic target based components.
 828     add_magic_target_components(parser, project_info, opts)
 829
 830     # Validate the project component info.
 831     project_info.validate_components()
 832
 833     # Print the component tree, if requested.
 834     if opts.print_tree:
 835         project_info.print_tree()
 836
 837     # Write out the components, if requested. This is useful for auto-upgrading
 838     # the schema.
 839     if opts.write_llvmbuild:
 840         project_info.write_components(opts.write_llvmbuild)
 841
 842     # Write out the required library table, if requested.
 843     if opts.write_library_table:
 844         project_info.write_library_table(opts.write_library_table,
 845                                          opts.optional_components)
 846
 847     # Write out the make fragment, if requested.
 848     if opts.write_make_fragment:
 849         project_info.write_make_fragment(opts.write_make_fragment)
 850
 851     # Write out the cmake fragment, if requested.
 852     if opts.write_cmake_fragment:
 853         project_info.write_cmake_fragment(opts.write_cmake_fragment)
 854
 855     # Configure target definition files, if requested.
 856     if opts.configure_target_def_files:
 857         # Verify we were given a build root.
 858         if not opts.build_root:
 859             parser.error("must specify --build-root when using "
 860                          "--configure-target-def-file")
 861
 862         # Create the substitution list.
 863         available_targets = [ci for ci in project_info.component_infos
 864                              if ci.type_name == 'TargetGroup']
 865         substitutions = [
 866             ("@LLVM_ENUM_TARGETS@",
 867              ' '.join('LLVM_TARGET(%s)' % ci.name
 868                       for ci in available_targets)),
 869             ("@LLVM_ENUM_ASM_PRINTERS@",
 870              ' '.join('LLVM_ASM_PRINTER(%s)' % ci.name
 871                       for ci in available_targets
 872                       if ci.has_asmprinter)),
 873             ("@LLVM_ENUM_ASM_PARSERS@",
 874              ' '.join('LLVM_ASM_PARSER(%s)' % ci.name
 875                       for ci in available_targets
 876                       if ci.has_asmparser)),
 877             ("@LLVM_ENUM_DISASSEMBLERS@",
 878              ' '.join('LLVM_DISASSEMBLER(%s)' % ci.name
 879                       for ci in available_targets
 880                       if ci.has_disassembler))]
 881
 882         # Configure the given files.
 883         for subpath in opts.configure_target_def_files:
 884             inpath = os.path.join(source_root, subpath + '.in')
 885             outpath = os.path.join(opts.build_root, subpath)
 886             result = configutil.configure_file(inpath, outpath, substitutions)
 887             if not result:
 888                 note("configured file %r hasn't changed" % outpath)
 889
 890 if __name__=='__main__':
 891     main()