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 = set(self.component_infos)
186 while components_to_visit:
187 visit_component_info(iter(components_to_visit).next(), [], set())
189 # Canonicalize children lists.
190 for c in self.ordered_component_infos:
191 c.children.sort(key = lambda c: c.name)
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:
198 visit(self.component_info_map['$ROOT'])
200 def write_components(self, output_path):
201 # Organize all the components by the directory their LLVMBuild file
204 for ci in self.component_infos:
205 # Ignore the $ROOT component.
206 if ci.parent is None:
209 info_basedir[ci.subpath] = info_basedir.get(ci.subpath, []) + [ci]
211 # Compute the list of subdirectories to scan.
213 for ci in self.component_infos:
214 # Ignore root components.
215 if ci.subpath == '/':
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(
222 parent_list.add(os.path.basename(ci.subpath))
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)
229 # Format the components into llvmbuild fragments.
232 # Add the common fragments.
233 subdirectories = subpath_subdirs.get(subpath)
237 """ % (" ".join(sorted(subdirectories)),)
238 fragments.append(("common", fragment))
240 # Add the component fragments.
241 num_common_fragments = len(fragments)
243 fragment = ci.get_llvmbuild_fragment()
247 name = "component_%d" % (len(fragments) - num_common_fragments)
248 fragments.append((name, fragment))
253 assert subpath.startswith('/')
254 directory_path = os.path.join(output_path, subpath[1:])
256 # Create the directory if it does not already exist.
257 if not os.path.exists(directory_path):
258 os.makedirs(directory_path)
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)
267 if ln.startswith(';'):
269 elif ln.startswith('[') and ln.endswith(']\n'):
270 comments_map[ln[1:-2]] = comment_block
275 # Create the LLVMBuild fil[e.
276 file_path = os.path.join(directory_path, 'LLVMBuild.txt')
277 f = open(file_path, "w")
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)
287 ; The LLVM Compiler Infrastructure
289 ; This file is distributed under the University of Illinois Open Source
290 ; License. See LICENSE.TXT for details.
292 ;===------------------------------------------------------------------------===;
294 ; This is an LLVMBuild description file for the components in this subdirectory.
296 ; For more information on the LLVMBuild system, please see:
298 ; http://llvm.org/docs/LLVMBuild.html
300 ;===------------------------------------------------------------------------===;
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:
308 print >>f, "[%s]" % name
310 if fragment is not fragments[-1][1]:
315 def write_library_table(self, output_path, enabled_optional_components):
316 # Write out the mapping from component names to required libraries.
318 # We do this in topological order so that we know we can append the
319 # dependencies for added library groups.
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:
327 # Skip target groups which are not enabled.
328 tg = c.get_parent_target_group()
329 if tg and not tg.enabled:
332 # Only certain components are in the table.
333 if c.type_name not in ('Library', 'OptionalLibrary', \
334 'LibraryGroup', 'TargetGroup'):
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()
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
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]
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)
359 entries[c.name] = (llvmconfig_component_name, library_name,
360 required_llvmconfig_component_names,
363 # Convert to a list of entries and sort by name.
364 entries = entries.values()
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))
375 # Compute the maximum number of required libraries, plus one so there is
377 max_required_libraries = max(len(deps)
378 for _,_,deps,_ in entries) + 1
380 # Write out the library table.
381 make_install_dir(os.path.dirname(output_path))
382 f = open(output_path, 'w')
384 //===- llvm-build generated file --------------------------------*- C++ -*-===//
386 // Component Library Depenedency Table
388 // Automatically generated file, do not edit!
390 //===----------------------------------------------------------------------===//
392 print >>f, 'struct AvailableComponent {'
393 print >>f, ' /// The name of the component.'
394 print >>f, ' const char *Name;'
396 print >>f, ' /// The name of the library for this component (or NULL).'
397 print >>f, ' const char *Library;'
399 print >>f, ' /// Whether the component is installed.'
400 print >>f, ' bool IsInstalled;'
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'
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))
419 def get_required_libraries_for_component(self, ci, traverse_groups = False):
421 get_required_libraries_for_component(component_info) -> iter
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.
429 assert ci.type_name in ('Library', 'LibraryGroup', 'TargetGroup')
431 for name in ci.required_libraries:
432 # Get the dependency info.
433 dep = self.component_info_map[name]
435 # If it is a library, yield it.
436 if dep.type_name == 'Library':
440 # Otherwise if it is a group, yield or traverse depending on what
442 if dep.type_name in ('LibraryGroup', 'TargetGroup'):
443 if not traverse_groups:
447 for res in self.get_required_libraries_for_component(dep, True):
450 def get_fragment_dependencies(self):
452 get_fragment_dependencies() -> iter
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).
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.
463 # Many components may come from the same file, so we make sure to unique
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:
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__'):
478 path = getattr(module, '__file__')
482 # Strip off any compiled suffix.
483 if os.path.splitext(path)[1] in ['.pyc', '.pyo', '.pyd']:
486 # If the path exists and is in the source tree, consider it a
488 if (path.startswith(self.source_root) and os.path.exists(path)):
491 def write_cmake_fragment(self, output_path):
493 write_cmake_fragment(output_path) -> None
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.
501 dependencies = list(self.get_fragment_dependencies())
503 # Write out the CMake fragment.
504 make_install_dir(os.path.dirname(output_path))
505 f = open(output_path, 'w')
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)
516 # The LLVM Compiler Infrastructure
518 # This file is distributed under the University of Illinois Open Source
519 # License. See LICENSE.TXT for details.
521 #===------------------------------------------------------------------------===#
523 # This file contains the LLVMBuild project information in a format easily
524 # consumed by the CMake based build system.
526 # This file is autogenerated by llvm-build, do not edit!
528 #===------------------------------------------------------------------------===#
531 # Write the dependency information in the best way we can.
533 # LLVMBuild CMake fragment dependencies.
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
541 # FIXME: File a CMake RFE to get a properly supported version of this
543 for dep in dependencies:
545 configure_file(\"%s\"
546 ${CMAKE_CURRENT_BINARY_DIR}/DummyConfigureOutput)""" % (
547 cmake_quote_path(dep),)
549 # Write the properties we use to encode the required library dependency
550 # information in a form CMake can easily use directly.
552 # Explicit library dependency information.
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':
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))))
569 def write_make_fragment(self, output_path):
571 write_make_fragment(output_path) -> None
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.
579 dependencies = list(self.get_fragment_dependencies())
581 # Write out the Makefile fragment.
582 make_install_dir(os.path.dirname(output_path))
583 f = open(output_path, 'w')
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)
594 # The LLVM Compiler Infrastructure
596 # This file is distributed under the University of Illinois Open Source
597 # License. See LICENSE.TXT for details.
599 #===------------------------------------------------------------------------===#
601 # This file contains the LLVMBuild project information in a format easily
602 # consumed by the Makefile based build system.
604 # This file is autogenerated by llvm-build, do not edit!
606 #===------------------------------------------------------------------------===#
609 # Write the dependencies for the fragment.
611 # FIXME: Technically, we need to properly quote for Make here.
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,)
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.
626 # The dummy targets to allow proper regeneration even when files are moved or
628 for dep in dependencies:
629 print >>f, "%s:" % (mk_quote_string_for_target(dep),)
634 def add_magic_target_components(parser, project, opts):
635 """add_magic_target_components(project, opts) -> None
637 Add the "magic" target based components to the project, which can only be
638 determined based on the target configuration options.
640 This currently is responsible for populating the required_libraries list of
641 the "all-targets", "Native", "NativeCodeGen", and "Engine" components.
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')
649 # Find the configured native target.
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',
655 'Unknown' : None }.get(opts.native_target,
657 if native_target_name is None:
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,))
668 # Find the list of targets to enable.
669 if opts.enable_targets is None:
670 enable_targets = available_targets.values()
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()
676 enable_target_names = opts.enable_targets.split(';')
679 for name in enable_target_names:
680 target = available_targets.get(name)
682 parser.error("invalid target to enable: %r (not in project)" % (
684 if target.type_name != 'TargetGroup':
685 parser.error("invalid target to enable: %r (not a target)" % (
687 enable_targets.append(target)
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)
696 fatal("expected project to contain special %r component" % (
699 if info.type_name != 'LibraryGroup':
700 fatal("special component %r should be a LibraryGroup" % (
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'))
710 info._is_special_group = True
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')
719 # Set the enabled bit in all the target groups, and append to the
721 for ci in enable_targets:
722 all_targets.required_libraries.append(ci.name)
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)
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)
738 engine_group.required_libraries.append('Interpreter')
741 from optparse import OptionParser, OptionGroup
742 parser = OptionParser("usage: %prog [options]")
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",
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)
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)
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 "
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)
805 (opts, args) = parser.parse_args()
807 # Determine the LLVM source path, if not given.
808 source_root = opts.source_root
810 if not os.path.exists(os.path.join(source_root, 'lib', 'VMCore',
812 parser.error('invalid LLVM source root: %r' % source_root)
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',
820 parser.error('unable to infer LLVM source root, please specify')
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)
827 # Add the magic target based components.
828 add_magic_target_components(parser, project_info, opts)
830 # Validate the project component info.
831 project_info.validate_components()
833 # Print the component tree, if requested.
835 project_info.print_tree()
837 # Write out the components, if requested. This is useful for auto-upgrading
839 if opts.write_llvmbuild:
840 project_info.write_components(opts.write_llvmbuild)
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)
847 # Write out the make fragment, if requested.
848 if opts.write_make_fragment:
849 project_info.write_make_fragment(opts.write_make_fragment)
851 # Write out the cmake fragment, if requested.
852 if opts.write_cmake_fragment:
853 project_info.write_cmake_fragment(opts.write_cmake_fragment)
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")
862 # Create the substitution list.
863 available_targets = [ci for ci in project_info.component_infos
864 if ci.type_name == 'TargetGroup']
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))]
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)
888 note("configured file %r hasn't changed" % outpath)
890 if __name__=='__main__':