1 from __future__ import absolute_import
5 import llvmbuild.componentinfo as componentinfo
6 import llvmbuild.configutil as configutil
8 from llvmbuild.util import *
12 def cmake_quote_string(value):
14 cmake_quote_string(value) -> str
16 Return a quoted form of the given value that is suitable for use in CMake
20 # Currently, we only handle escaping backslashes.
21 value = value.replace("\\", "\\\\")
25 def cmake_quote_path(value):
27 cmake_quote_path(value) -> str
29 Return a quoted form of the given value that is suitable for use in CMake
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("\\", "/")
40 def mk_quote_string_for_target(value):
42 mk_quote_string_for_target(target_name) -> str
44 Return a quoted form of the given target_name suitable for including in a
45 Makefile as a target name.
48 # The only quoting we currently perform is for ':', to support msys users.
49 return value.replace(":", "\\:")
51 def make_install_dir(path):
53 make_install_dir(path) -> None
55 Create the given directory path for installation, including any parents.
58 # os.makedirs considers it an error to be called with an existent path.
59 if not os.path.exists(path):
64 class LLVMProjectInfo(object):
66 def load_infos_from_path(llvmbuild_source_root):
68 # Load the LLVMBuild file.
69 llvmbuild_path = os.path.join(llvmbuild_source_root + subpath,
71 if not os.path.exists(llvmbuild_path):
72 fatal("missing LLVMBuild.txt file at: %r" % (llvmbuild_path,))
74 # Parse the components from it.
75 common,info_iter = componentinfo.load_from_path(llvmbuild_path,
77 for info in info_iter:
80 # Recurse into the specified subdirectories.
81 for subdir in common.get_list("subdirectories"):
82 for item in recurse(os.path.join(subpath, subdir)):
88 def load_from_path(source_root, llvmbuild_source_root):
90 LLVMProjectInfo.load_infos_from_path(llvmbuild_source_root))
92 return LLVMProjectInfo(source_root, infos)
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
101 def validate_components(self):
102 """validate_components() -> None
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.
109 We also construct the map from component names to info, and the
110 topological ordering of components.
113 # Create the component info map and validate that component names are
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
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")
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(
133 self.component_infos.append(self.component_info_map['$ROOT'])
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))
147 # If we have already visited this item, we are done.
148 if ci not in components_to_visit:
151 # Otherwise, mark the component info as visited and traverse.
152 components_to_visit.remove(ci)
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)
158 fatal("component %r has invalid reference %r (via %r)" % (
159 ci.name, ci.parent, 'parent'))
160 ci.set_parent_instance(parent)
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)
166 fatal("component %r has invalid reference %r (via %r)" % (
167 ci.name, referent_name, relation))
169 # Visit the reference.
170 current_stack.append((relation,ci))
172 visit_component_info(referent, current_stack, current_set)
173 current_set.remove(ci)
176 # Finally, add the component info to the ordered list.
177 self.ordered_component_infos.append(ci)
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.
184 self.ordered_component_infos = []
185 components_to_visit = sorted(
186 set(self.component_infos),
187 key = lambda c: c.name)
188 while components_to_visit:
189 visit_component_info(components_to_visit[0], [], set())
191 # Canonicalize children lists.
192 for c in self.ordered_component_infos:
193 c.children.sort(key = lambda c: c.name)
195 def print_tree(self):
196 def visit(node, depth = 0):
197 print('%s%-40s (%s)' % (' '*depth, node.name, node.type_name))
198 for c in node.children:
200 visit(self.component_info_map['$ROOT'])
202 def write_components(self, output_path):
203 # Organize all the components by the directory their LLVMBuild file
206 for ci in self.component_infos:
207 # Ignore the $ROOT component.
208 if ci.parent is None:
211 info_basedir[ci.subpath] = info_basedir.get(ci.subpath, []) + [ci]
213 # Compute the list of subdirectories to scan.
215 for ci in self.component_infos:
216 # Ignore root components.
217 if ci.subpath == '/':
220 # Otherwise, append this subpath to the parent list.
221 parent_path = os.path.dirname(ci.subpath)
222 subpath_subdirs[parent_path] = parent_list = subpath_subdirs.get(
224 parent_list.add(os.path.basename(ci.subpath))
226 # Generate the build files.
227 for subpath, infos in info_basedir.items():
228 # Order the components by name to have a canonical ordering.
229 infos.sort(key = lambda ci: ci.name)
231 # Format the components into llvmbuild fragments.
234 # Add the common fragments.
235 subdirectories = subpath_subdirs.get(subpath)
239 """ % (" ".join(sorted(subdirectories)),)
240 fragments.append(("common", fragment))
242 # Add the component fragments.
243 num_common_fragments = len(fragments)
245 fragment = ci.get_llvmbuild_fragment()
249 name = "component_%d" % (len(fragments) - num_common_fragments)
250 fragments.append((name, fragment))
255 assert subpath.startswith('/')
256 directory_path = os.path.join(output_path, subpath[1:])
258 # Create the directory if it does not already exist.
259 if not os.path.exists(directory_path):
260 os.makedirs(directory_path)
262 # In an effort to preserve comments (which aren't parsed), read in
263 # the original file and extract the comments. We only know how to
264 # associate comments that prefix a section name.
265 f = open(infos[0]._source_path)
269 if ln.startswith(';'):
271 elif ln.startswith('[') and ln.endswith(']\n'):
272 comments_map[ln[1:-2]] = comment_block
277 # Create the LLVMBuild fil[e.
278 file_path = os.path.join(directory_path, 'LLVMBuild.txt')
279 f = open(file_path, "w")
282 header_fmt = ';===- %s %s-*- Conf -*--===;'
283 header_name = '.' + os.path.join(subpath, 'LLVMBuild.txt')
284 header_pad = '-' * (80 - len(header_fmt % (header_name, '')))
285 header_string = header_fmt % (header_name, header_pad)
289 ; The LLVM Compiler Infrastructure
291 ; This file is distributed under the University of Illinois Open Source
292 ; License. See LICENSE.TXT for details.
294 ;===------------------------------------------------------------------------===;
296 ; This is an LLVMBuild description file for the components in this subdirectory.
298 ; For more information on the LLVMBuild system, please see:
300 ; http://llvm.org/docs/LLVMBuild.html
302 ;===------------------------------------------------------------------------===;
306 # Write out each fragment.each component fragment.
307 for name,fragment in fragments:
308 comment = comments_map.get(name)
309 if comment is not None:
311 f.write("[%s]\n" % name)
313 if fragment is not fragments[-1][1]:
318 def write_library_table(self, output_path, enabled_optional_components):
319 # Write out the mapping from component names to required libraries.
321 # We do this in topological order so that we know we can append the
322 # dependencies for added library groups.
324 for c in self.ordered_component_infos:
325 # Skip optional components which are not enabled.
326 if c.type_name == 'OptionalLibrary' \
327 and c.name not in enabled_optional_components:
330 # Skip target groups which are not enabled.
331 tg = c.get_parent_target_group()
332 if tg and not tg.enabled:
335 # Only certain components are in the table.
336 if c.type_name not in ('Library', 'OptionalLibrary', \
337 'LibraryGroup', 'TargetGroup'):
340 # Compute the llvm-config "component name". For historical reasons,
341 # this is lowercased based on the library name.
342 llvmconfig_component_name = c.get_llvmconfig_component_name()
344 # Get the library name, or None for LibraryGroups.
345 if c.type_name == 'Library' or c.type_name == 'OptionalLibrary':
346 library_name = c.get_prefixed_library_name()
347 is_installed = c.installed
352 # Get the component names of all the required libraries.
353 required_llvmconfig_component_names = [
354 self.component_info_map[dep].get_llvmconfig_component_name()
355 for dep in c.required_libraries]
357 # Insert the entries for library groups we should add to.
358 for dep in c.add_to_library_groups:
359 entries[dep][2].append(llvmconfig_component_name)
362 entries[c.name] = (llvmconfig_component_name, library_name,
363 required_llvmconfig_component_names,
366 # Convert to a list of entries and sort by name.
367 entries = list(entries.values())
369 # Create an 'all' pseudo component. We keep the dependency list small by
370 # only listing entries that have no other dependents.
371 root_entries = set(e[0] for e in entries)
372 for _,_,deps,_ in entries:
373 root_entries -= set(deps)
374 entries.append(('all', None, root_entries, True))
378 # Compute the maximum number of required libraries, plus one so there is
380 max_required_libraries = max(len(deps)
381 for _,_,deps,_ in entries) + 1
383 # Write out the library table.
384 make_install_dir(os.path.dirname(output_path))
385 f = open(output_path, 'w')
387 //===- llvm-build generated file --------------------------------*- C++ -*-===//
389 // Component Library Depenedency Table
391 // Automatically generated file, do not edit!
393 //===----------------------------------------------------------------------===//
396 f.write('struct AvailableComponent {\n')
397 f.write(' /// The name of the component.\n')
398 f.write(' const char *Name;\n')
400 f.write(' /// The name of the library for this component (or NULL).\n')
401 f.write(' const char *Library;\n')
403 f.write(' /// Whether the component is installed.\n')
404 f.write(' bool IsInstalled;\n')
407 /// The list of libraries required when linking this component.\n')
408 f.write(' const char *RequiredLibraries[%d];\n' % (
409 max_required_libraries))
410 f.write('} AvailableComponents[%d] = {\n' % len(entries))
411 for name,library_name,required_names,is_installed in entries:
412 if library_name is None:
413 library_name_as_cstr = '0'
415 library_name_as_cstr = '"lib%s.a"' % library_name
416 f.write(' { "%s", %s, %d, { %s } },\n' % (
417 name, library_name_as_cstr, is_installed,
418 ', '.join('"%s"' % dep
419 for dep in required_names)))
423 def get_required_libraries_for_component(self, ci, traverse_groups = False):
425 get_required_libraries_for_component(component_info) -> iter
427 Given a Library component info descriptor, return an iterator over all
428 of the directly required libraries for linking with this component. If
429 traverse_groups is True, then library and target groups will be
430 traversed to include their required libraries.
433 assert ci.type_name in ('Library', 'LibraryGroup', 'TargetGroup')
435 for name in ci.required_libraries:
436 # Get the dependency info.
437 dep = self.component_info_map[name]
439 # If it is a library, yield it.
440 if dep.type_name == 'Library':
444 # Otherwise if it is a group, yield or traverse depending on what
446 if dep.type_name in ('LibraryGroup', 'TargetGroup'):
447 if not traverse_groups:
451 for res in self.get_required_libraries_for_component(dep, True):
454 def get_fragment_dependencies(self):
456 get_fragment_dependencies() -> iter
458 Compute the list of files (as absolute paths) on which the output
459 fragments depend (i.e., files for which a modification should trigger a
460 rebuild of the fragment).
463 # Construct a list of all the dependencies of the Makefile fragment
464 # itself. These include all the LLVMBuild files themselves, as well as
465 # all of our own sources.
467 # Many components may come from the same file, so we make sure to unique
470 for ci in self.component_infos:
471 p = os.path.join(self.source_root, ci.subpath[1:], 'LLVMBuild.txt')
472 if p not in build_paths:
476 # Gather the list of necessary sources by just finding all loaded
477 # modules that are inside the LLVM source tree.
478 for module in sys.modules.values():
479 # Find the module path.
480 if not hasattr(module, '__file__'):
482 path = getattr(module, '__file__')
486 # Strip off any compiled suffix.
487 if os.path.splitext(path)[1] in ['.pyc', '.pyo', '.pyd']:
490 # If the path exists and is in the source tree, consider it a
492 if (path.startswith(self.source_root) and os.path.exists(path)):
495 def write_cmake_fragment(self, output_path):
497 write_cmake_fragment(output_path) -> None
499 Generate a CMake fragment which includes all of the collated LLVMBuild
500 information in a format that is easily digestible by a CMake. The exact
501 contents of this are closely tied to how the CMake configuration
502 integrates LLVMBuild, see CMakeLists.txt in the top-level.
505 dependencies = list(self.get_fragment_dependencies())
507 # Write out the CMake fragment.
508 make_install_dir(os.path.dirname(output_path))
509 f = open(output_path, 'w')
513 #===-- %s - LLVMBuild Configuration for LLVM %s-*- CMake -*--===#'
514 header_name = os.path.basename(output_path)
515 header_pad = '-' * (80 - len(header_fmt % (header_name, '')))
516 header_string = header_fmt % (header_name, header_pad)
520 # The LLVM Compiler Infrastructure
522 # This file is distributed under the University of Illinois Open Source
523 # License. See LICENSE.TXT for details.
525 #===------------------------------------------------------------------------===#
527 # This file contains the LLVMBuild project information in a format easily
528 # consumed by the CMake based build system.
530 # This file is autogenerated by llvm-build, do not edit!
532 #===------------------------------------------------------------------------===#
536 # Write the dependency information in the best way we can.
538 # LLVMBuild CMake fragment dependencies.
540 # CMake has no builtin way to declare that the configuration depends on
541 # a particular file. However, a side effect of configure_file is to add
542 # said input file to CMake's internal dependency list. So, we use that
543 # and a dummy output file to communicate the dependency information to
546 # FIXME: File a CMake RFE to get a properly supported version of this
549 for dep in dependencies:
551 configure_file(\"%s\"
552 ${CMAKE_CURRENT_BINARY_DIR}/DummyConfigureOutput)\n""" % (
553 cmake_quote_path(dep),))
555 # Write the properties we use to encode the required library dependency
556 # information in a form CMake can easily use directly.
558 # Explicit library dependency information.
560 # The following property assignments effectively create a map from component
561 # names to required libraries, in a way that is easily accessed from CMake.
563 for ci in self.ordered_component_infos:
564 # We only write the information for libraries currently.
565 if ci.type_name != 'Library':
569 set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_%s %s)\n""" % (
570 ci.get_prefixed_library_name(), " ".join(sorted(
571 dep.get_prefixed_library_name()
572 for dep in self.get_required_libraries_for_component(ci)))))
576 def write_cmake_exports_fragment(self, output_path):
578 write_cmake_exports_fragment(output_path) -> None
580 Generate a CMake fragment which includes LLVMBuild library
581 dependencies expressed similarly to how CMake would write
582 them via install(EXPORT).
585 dependencies = list(self.get_fragment_dependencies())
587 # Write out the CMake exports fragment.
588 make_install_dir(os.path.dirname(output_path))
589 f = open(output_path, 'w')
592 # Explicit library dependency information.
594 # The following property assignments tell CMake about link
595 # dependencies of libraries imported from LLVM.
597 for ci in self.ordered_component_infos:
598 # We only write the information for libraries currently.
599 if ci.type_name != 'Library':
602 # Skip disabled targets.
603 tg = ci.get_parent_target_group()
604 if tg and not tg.enabled:
608 set_property(TARGET %s PROPERTY IMPORTED_LINK_INTERFACE_LIBRARIES %s)\n""" % (
609 ci.get_prefixed_library_name(), " ".join(sorted(
610 dep.get_prefixed_library_name()
611 for dep in self.get_required_libraries_for_component(ci)))))
615 def write_make_fragment(self, output_path):
617 write_make_fragment(output_path) -> None
619 Generate a Makefile fragment which includes all of the collated
620 LLVMBuild information in a format that is easily digestible by a
621 Makefile. The exact contents of this are closely tied to how the LLVM
622 Makefiles integrate LLVMBuild, see Makefile.rules in the top-level.
625 dependencies = list(self.get_fragment_dependencies())
627 # Write out the Makefile fragment.
628 make_install_dir(os.path.dirname(output_path))
629 f = open(output_path, 'w')
633 #===-- %s - LLVMBuild Configuration for LLVM %s-*- Makefile -*--===#'
634 header_name = os.path.basename(output_path)
635 header_pad = '-' * (80 - len(header_fmt % (header_name, '')))
636 header_string = header_fmt % (header_name, header_pad)
640 # The LLVM Compiler Infrastructure
642 # This file is distributed under the University of Illinois Open Source
643 # License. See LICENSE.TXT for details.
645 #===------------------------------------------------------------------------===#
647 # This file contains the LLVMBuild project information in a format easily
648 # consumed by the Makefile based build system.
650 # This file is autogenerated by llvm-build, do not edit!
652 #===------------------------------------------------------------------------===#
656 # Write the dependencies for the fragment.
658 # FIXME: Technically, we need to properly quote for Make here.
660 # Clients must explicitly enable LLVMBUILD_INCLUDE_DEPENDENCIES to get
661 # these dependencies. This is a compromise to help improve the
662 # performance of recursive Make systems.
664 f.write('ifeq ($(LLVMBUILD_INCLUDE_DEPENDENCIES),1)\n')
665 f.write("# The dependencies for this Makefile fragment itself.\n")
666 f.write("%s: \\\n" % (mk_quote_string_for_target(output_path),))
667 for dep in dependencies:
668 f.write("\t%s \\\n" % (dep,))
671 # Generate dummy rules for each of the dependencies, so that things
672 # continue to work correctly if any of those files are moved or removed.
674 # The dummy targets to allow proper regeneration even when files are moved or
677 for dep in dependencies:
678 f.write("%s:\n" % (mk_quote_string_for_target(dep),))
683 def add_magic_target_components(parser, project, opts):
684 """add_magic_target_components(project, opts) -> None
686 Add the "magic" target based components to the project, which can only be
687 determined based on the target configuration options.
689 This currently is responsible for populating the required_libraries list of
690 the "all-targets", "Native", "NativeCodeGen", and "Engine" components.
693 # Determine the available targets.
694 available_targets = dict((ci.name,ci)
695 for ci in project.component_infos
696 if ci.type_name == 'TargetGroup')
698 # Find the configured native target.
700 # We handle a few special cases of target names here for historical
701 # reasons, as these are the names configure currently comes up with.
702 native_target_name = { 'x86' : 'X86',
704 'Unknown' : None }.get(opts.native_target,
706 if native_target_name is None:
709 native_target = available_targets.get(native_target_name)
710 if native_target is None:
711 parser.error("invalid native target: %r (not in project)" % (
712 opts.native_target,))
713 if native_target.type_name != 'TargetGroup':
714 parser.error("invalid native target: %r (not a target)" % (
715 opts.native_target,))
717 # Find the list of targets to enable.
718 if opts.enable_targets is None:
719 enable_targets = available_targets.values()
721 # We support both space separated and semi-colon separated lists.
722 if ' ' in opts.enable_targets:
723 enable_target_names = opts.enable_targets.split()
725 enable_target_names = opts.enable_targets.split(';')
728 for name in enable_target_names:
729 target = available_targets.get(name)
731 parser.error("invalid target to enable: %r (not in project)" % (
733 if target.type_name != 'TargetGroup':
734 parser.error("invalid target to enable: %r (not a target)" % (
736 enable_targets.append(target)
738 # Find the special library groups we are going to populate. We enforce that
739 # these appear in the project (instead of just adding them) so that they at
740 # least have an explicit representation in the project LLVMBuild files (and
741 # comments explaining how they are populated).
742 def find_special_group(name):
743 info = info_map.get(name)
745 fatal("expected project to contain special %r component" % (
748 if info.type_name != 'LibraryGroup':
749 fatal("special component %r should be a LibraryGroup" % (
752 if info.required_libraries:
753 fatal("special component %r must have empty %r list" % (
754 name, 'required_libraries'))
755 if info.add_to_library_groups:
756 fatal("special component %r must have empty %r list" % (
757 name, 'add_to_library_groups'))
759 info._is_special_group = True
762 info_map = dict((ci.name, ci) for ci in project.component_infos)
763 all_targets = find_special_group('all-targets')
764 native_group = find_special_group('Native')
765 native_codegen_group = find_special_group('NativeCodeGen')
766 engine_group = find_special_group('Engine')
768 # Set the enabled bit in all the target groups, and append to the
770 for ci in enable_targets:
771 all_targets.required_libraries.append(ci.name)
774 # If we have a native target, then that defines the native and
775 # native_codegen libraries.
776 if native_target and native_target.enabled:
777 native_group.required_libraries.append(native_target.name)
778 native_codegen_group.required_libraries.append(
779 '%sCodeGen' % native_target.name)
781 # If we have a native target with a JIT, use that for the engine. Otherwise,
782 # use the interpreter.
783 if native_target and native_target.enabled and native_target.has_jit:
784 engine_group.required_libraries.append('JIT')
785 engine_group.required_libraries.append(native_group.name)
787 engine_group.required_libraries.append('Interpreter')
790 from optparse import OptionParser, OptionGroup
791 parser = OptionParser("usage: %prog [options]")
793 group = OptionGroup(parser, "Input Options")
794 group.add_option("", "--source-root", dest="source_root", metavar="PATH",
795 help="Path to the LLVM source (inferred if not given)",
796 action="store", default=None)
797 group.add_option("", "--llvmbuild-source-root",
798 dest="llvmbuild_source_root",
800 "If given, an alternate path to search for LLVMBuild.txt files"),
801 action="store", default=None, metavar="PATH")
802 group.add_option("", "--build-root", dest="build_root", metavar="PATH",
803 help="Path to the build directory (if needed) [%default]",
804 action="store", default=None)
805 parser.add_option_group(group)
807 group = OptionGroup(parser, "Output Options")
808 group.add_option("", "--print-tree", dest="print_tree",
809 help="Print out the project component tree [%default]",
810 action="store_true", default=False)
811 group.add_option("", "--write-llvmbuild", dest="write_llvmbuild",
812 help="Write out the LLVMBuild.txt files to PATH",
813 action="store", default=None, metavar="PATH")
814 group.add_option("", "--write-library-table",
815 dest="write_library_table", metavar="PATH",
816 help="Write the C++ library dependency table to PATH",
817 action="store", default=None)
818 group.add_option("", "--write-cmake-fragment",
819 dest="write_cmake_fragment", metavar="PATH",
820 help="Write the CMake project information to PATH",
821 action="store", default=None)
822 group.add_option("", "--write-cmake-exports-fragment",
823 dest="write_cmake_exports_fragment", metavar="PATH",
824 help="Write the CMake exports information to PATH",
825 action="store", default=None)
826 group.add_option("", "--write-make-fragment",
827 dest="write_make_fragment", metavar="PATH",
828 help="Write the Makefile project information to PATH",
829 action="store", default=None)
830 group.add_option("", "--configure-target-def-file",
831 dest="configure_target_def_files",
832 help="""Configure the given file at SUBPATH (relative to
833 the inferred or given source root, and with a '.in' suffix) by replacing certain
834 substitution variables with lists of targets that support certain features (for
835 example, targets with AsmPrinters) and write the result to the build root (as
836 given by --build-root) at the same SUBPATH""",
837 metavar="SUBPATH", action="append", default=None)
838 parser.add_option_group(group)
840 group = OptionGroup(parser, "Configuration Options")
841 group.add_option("", "--native-target",
842 dest="native_target", metavar="NAME",
843 help=("Treat the named target as the 'native' one, if "
845 action="store", default=None)
846 group.add_option("", "--enable-targets",
847 dest="enable_targets", metavar="NAMES",
848 help=("Enable the given space or semi-colon separated "
849 "list of targets, or all targets if not present"),
850 action="store", default=None)
851 group.add_option("", "--enable-optional-components",
852 dest="optional_components", metavar="NAMES",
853 help=("Enable the given space or semi-colon separated "
854 "list of optional components"),
855 action="store", default="")
856 parser.add_option_group(group)
858 (opts, args) = parser.parse_args()
860 # Determine the LLVM source path, if not given.
861 source_root = opts.source_root
863 if not os.path.exists(os.path.join(source_root, 'lib', 'IR',
865 parser.error('invalid LLVM source root: %r' % source_root)
867 llvmbuild_path = os.path.dirname(__file__)
868 llvm_build_path = os.path.dirname(llvmbuild_path)
869 utils_path = os.path.dirname(llvm_build_path)
870 source_root = os.path.dirname(utils_path)
871 if not os.path.exists(os.path.join(source_root, 'lib', 'IR',
873 parser.error('unable to infer LLVM source root, please specify')
875 # Construct the LLVM project information.
876 llvmbuild_source_root = opts.llvmbuild_source_root or source_root
877 project_info = LLVMProjectInfo.load_from_path(
878 source_root, llvmbuild_source_root)
880 # Add the magic target based components.
881 add_magic_target_components(parser, project_info, opts)
883 # Validate the project component info.
884 project_info.validate_components()
886 # Print the component tree, if requested.
888 project_info.print_tree()
890 # Write out the components, if requested. This is useful for auto-upgrading
892 if opts.write_llvmbuild:
893 project_info.write_components(opts.write_llvmbuild)
895 # Write out the required library table, if requested.
896 if opts.write_library_table:
897 project_info.write_library_table(opts.write_library_table,
898 opts.optional_components)
900 # Write out the make fragment, if requested.
901 if opts.write_make_fragment:
902 project_info.write_make_fragment(opts.write_make_fragment)
904 # Write out the cmake fragment, if requested.
905 if opts.write_cmake_fragment:
906 project_info.write_cmake_fragment(opts.write_cmake_fragment)
907 if opts.write_cmake_exports_fragment:
908 project_info.write_cmake_exports_fragment(opts.write_cmake_exports_fragment)
910 # Configure target definition files, if requested.
911 if opts.configure_target_def_files:
912 # Verify we were given a build root.
913 if not opts.build_root:
914 parser.error("must specify --build-root when using "
915 "--configure-target-def-file")
917 # Create the substitution list.
918 available_targets = [ci for ci in project_info.component_infos
919 if ci.type_name == 'TargetGroup']
921 ("@LLVM_ENUM_TARGETS@",
922 ' '.join('LLVM_TARGET(%s)' % ci.name
923 for ci in available_targets)),
924 ("@LLVM_ENUM_ASM_PRINTERS@",
925 ' '.join('LLVM_ASM_PRINTER(%s)' % ci.name
926 for ci in available_targets
927 if ci.has_asmprinter)),
928 ("@LLVM_ENUM_ASM_PARSERS@",
929 ' '.join('LLVM_ASM_PARSER(%s)' % ci.name
930 for ci in available_targets
931 if ci.has_asmparser)),
932 ("@LLVM_ENUM_DISASSEMBLERS@",
933 ' '.join('LLVM_DISASSEMBLER(%s)' % ci.name
934 for ci in available_targets
935 if ci.has_disassembler))]
937 # Configure the given files.
938 for subpath in opts.configure_target_def_files:
939 inpath = os.path.join(source_root, subpath + '.in')
940 outpath = os.path.join(opts.build_root, subpath)
941 result = configutil.configure_file(inpath, outpath, substitutions)
943 note("configured file %r hasn't changed" % outpath)
945 if __name__=='__main__':