utils/llvm-build/llvmbuild/main.py

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