1 from __future__ import absolute_import
6 import llvmbuild.componentinfo as componentinfo
7 import llvmbuild.configutil as configutil
9 from llvmbuild.util import fatal, note
13 def cmake_quote_string(value):
15 cmake_quote_string(value) -> str
17 Return a quoted form of the given value that is suitable for use in CMake
21 # Currently, we only handle escaping backslashes.
22 value = value.replace("\\", "\\\\")
26 def cmake_quote_path(value):
28 cmake_quote_path(value) -> str
30 Return a quoted form of the given value that is suitable for use in CMake
34 # CMake has a bug in it's Makefile generator that doesn't properly quote
35 # strings it generates. So instead of using proper quoting, we just use "/"
36 # style paths. Currently, we only handle escaping backslashes.
37 value = value.replace("\\", "/")
41 def mk_quote_string_for_target(value):
43 mk_quote_string_for_target(target_name) -> str
45 Return a quoted form of the given target_name suitable for including in a
46 Makefile as a target name.
49 # The only quoting we currently perform is for ':', to support msys users.
50 return value.replace(":", "\\:")
52 def make_install_dir(path):
54 make_install_dir(path) -> None
56 Create the given directory path for installation, including any parents.
59 # os.makedirs considers it an error to be called with an existent path.
60 if not os.path.exists(path):
65 class LLVMProjectInfo(object):
67 def load_infos_from_path(llvmbuild_source_root):
69 # Load the LLVMBuild file.
70 llvmbuild_path = os.path.join(llvmbuild_source_root + subpath,
72 if not os.path.exists(llvmbuild_path):
73 fatal("missing LLVMBuild.txt file at: %r" % (llvmbuild_path,))
75 # Parse the components from it.
76 common,info_iter = componentinfo.load_from_path(llvmbuild_path,
78 for info in info_iter:
81 # Recurse into the specified subdirectories.
82 for subdir in common.get_list("subdirectories"):
83 for item in recurse(os.path.join(subpath, subdir)):
89 def load_from_path(source_root, llvmbuild_source_root):
91 LLVMProjectInfo.load_infos_from_path(llvmbuild_source_root))
93 return LLVMProjectInfo(source_root, infos)
95 def __init__(self, source_root, component_infos):
96 # Store our simple ivars.
97 self.source_root = source_root
98 self.component_infos = list(component_infos)
99 self.component_info_map = None
100 self.ordered_component_infos = None
102 def validate_components(self):
103 """validate_components() -> None
105 Validate that the project components are well-defined. Among other
106 things, this checks that:
107 - Components have valid references.
108 - Components references do not form cycles.
110 We also construct the map from component names to info, and the
111 topological ordering of components.
114 # Create the component info map and validate that component names are
116 self.component_info_map = {}
117 for ci in self.component_infos:
118 existing = self.component_info_map.get(ci.name)
119 if existing is not None:
120 # We found a duplicate component name, report it and error out.
121 fatal("found duplicate component %r (at %r and %r)" % (
122 ci.name, ci.subpath, existing.subpath))
123 self.component_info_map[ci.name] = ci
125 # Disallow 'all' as a component name, which is a special case.
126 if 'all' in self.component_info_map:
127 fatal("project is not allowed to define 'all' component")
129 # Add the root component.
130 if '$ROOT' in self.component_info_map:
131 fatal("project is not allowed to define $ROOT component")
132 self.component_info_map['$ROOT'] = componentinfo.GroupComponentInfo(
134 self.component_infos.append(self.component_info_map['$ROOT'])
136 # Topologically order the component information according to their
137 # component references.
138 def visit_component_info(ci, current_stack, current_set):
139 # Check for a cycles.
140 if ci in current_set:
141 # We found a cycle, report it and error out.
142 cycle_description = ' -> '.join(
143 '%r (%s)' % (ci.name, relation)
144 for relation,ci in current_stack)
145 fatal("found cycle to %r after following: %s -> %s" % (
146 ci.name, cycle_description, ci.name))
148 # If we have already visited this item, we are done.
149 if ci not in components_to_visit:
152 # Otherwise, mark the component info as visited and traverse.
153 components_to_visit.remove(ci)
155 # Validate the parent reference, which we treat specially.
156 if ci.parent is not None:
157 parent = self.component_info_map.get(ci.parent)
159 fatal("component %r has invalid reference %r (via %r)" % (
160 ci.name, ci.parent, 'parent'))
161 ci.set_parent_instance(parent)
163 for relation,referent_name in ci.get_component_references():
164 # Validate that the reference is ok.
165 referent = self.component_info_map.get(referent_name)
167 fatal("component %r has invalid reference %r (via %r)" % (
168 ci.name, referent_name, relation))
170 # Visit the reference.
171 current_stack.append((relation,ci))
173 visit_component_info(referent, current_stack, current_set)
174 current_set.remove(ci)
177 # Finally, add the component info to the ordered list.
178 self.ordered_component_infos.append(ci)
180 # FIXME: We aren't actually correctly checking for cycles along the
181 # parent edges. Haven't decided how I want to handle this -- I thought
182 # about only checking cycles by relation type. If we do that, it falls
183 # out easily. If we don't, we should special case the check.
185 self.ordered_component_infos = []
186 components_to_visit = sorted(
187 set(self.component_infos),
188 key = lambda c: c.name)
189 while components_to_visit:
190 visit_component_info(components_to_visit[0], [], set())
192 # Canonicalize children lists.
193 for c in self.ordered_component_infos:
194 c.children.sort(key = lambda c: c.name)
196 def print_tree(self):
197 def visit(node, depth = 0):
198 print('%s%-40s (%s)' % (' '*depth, node.name, node.type_name))
199 for c in node.children:
201 visit(self.component_info_map['$ROOT'])
203 def write_components(self, output_path):
204 # Organize all the components by the directory their LLVMBuild file
207 for ci in self.component_infos:
208 # Ignore the $ROOT component.
209 if ci.parent is None:
212 info_basedir[ci.subpath] = info_basedir.get(ci.subpath, []) + [ci]
214 # Compute the list of subdirectories to scan.
216 for ci in self.component_infos:
217 # Ignore root components.
218 if ci.subpath == '/':
221 # Otherwise, append this subpath to the parent list.
222 parent_path = os.path.dirname(ci.subpath)
223 subpath_subdirs[parent_path] = parent_list = subpath_subdirs.get(
225 parent_list.add(os.path.basename(ci.subpath))
227 # Generate the build files.
228 for subpath, infos in info_basedir.items():
229 # Order the components by name to have a canonical ordering.
230 infos.sort(key = lambda ci: ci.name)
232 # Format the components into llvmbuild fragments.
235 # Add the common fragments.
236 subdirectories = subpath_subdirs.get(subpath)
240 """ % (" ".join(sorted(subdirectories)),)
241 fragments.append(("common", fragment))
243 # Add the component fragments.
244 num_common_fragments = len(fragments)
246 fragment = ci.get_llvmbuild_fragment()
250 name = "component_%d" % (len(fragments) - num_common_fragments)
251 fragments.append((name, fragment))
256 assert subpath.startswith('/')
257 directory_path = os.path.join(output_path, subpath[1:])
259 # Create the directory if it does not already exist.
260 if not os.path.exists(directory_path):
261 os.makedirs(directory_path)
263 # In an effort to preserve comments (which aren't parsed), read in
264 # the original file and extract the comments. We only know how to
265 # associate comments that prefix a section name.
266 f = open(infos[0]._source_path)
270 if ln.startswith(';'):
272 elif ln.startswith('[') and ln.endswith(']\n'):
273 comments_map[ln[1:-2]] = comment_block
278 # Create the LLVMBuild fil[e.
279 file_path = os.path.join(directory_path, 'LLVMBuild.txt')
280 f = open(file_path, "w")
283 header_fmt = ';===- %s %s-*- Conf -*--===;'
284 header_name = '.' + os.path.join(subpath, 'LLVMBuild.txt')
285 header_pad = '-' * (80 - len(header_fmt % (header_name, '')))
286 header_string = header_fmt % (header_name, header_pad)
290 ; The LLVM Compiler Infrastructure
292 ; This file is distributed under the University of Illinois Open Source
293 ; License. See LICENSE.TXT for details.
295 ;===------------------------------------------------------------------------===;
297 ; This is an LLVMBuild description file for the components in this subdirectory.
299 ; For more information on the LLVMBuild system, please see:
301 ; http://llvm.org/docs/LLVMBuild.html
303 ;===------------------------------------------------------------------------===;
307 # Write out each fragment.each component fragment.
308 for name,fragment in fragments:
309 comment = comments_map.get(name)
310 if comment is not None:
312 f.write("[%s]\n" % name)
314 if fragment is not fragments[-1][1]:
319 def write_library_table(self, output_path, enabled_optional_components):
320 # Write out the mapping from component names to required libraries.
322 # We do this in topological order so that we know we can append the
323 # dependencies for added library groups.
325 for c in self.ordered_component_infos:
326 # Skip optional components which are not enabled.
327 if c.type_name == 'OptionalLibrary' \
328 and c.name not in enabled_optional_components:
331 # Skip target groups which are not enabled.
332 tg = c.get_parent_target_group()
333 if tg and not tg.enabled:
336 # Only certain components are in the table.
337 if c.type_name not in ('Library', 'OptionalLibrary', \
338 'LibraryGroup', 'TargetGroup'):
341 # Compute the llvm-config "component name". For historical reasons,
342 # this is lowercased based on the library name.
343 llvmconfig_component_name = c.get_llvmconfig_component_name()
345 # Get the library name, or None for LibraryGroups.
346 if c.type_name == 'Library' or c.type_name == 'OptionalLibrary':
347 library_name = c.get_prefixed_library_name()
348 is_installed = c.installed
353 # Get the component names of all the required libraries.
354 required_llvmconfig_component_names = [
355 self.component_info_map[dep].get_llvmconfig_component_name()
356 for dep in c.required_libraries]
358 # Insert the entries for library groups we should add to.
359 for dep in c.add_to_library_groups:
360 entries[dep][2].append(llvmconfig_component_name)
363 entries[c.name] = (llvmconfig_component_name, library_name,
364 required_llvmconfig_component_names,
367 # Convert to a list of entries and sort by name.
368 entries = list(entries.values())
370 # Create an 'all' pseudo component. We keep the dependency list small by
371 # only listing entries that have no other dependents.
372 root_entries = set(e[0] for e in entries)
373 for _,_,deps,_ in entries:
374 root_entries -= set(deps)
375 entries.append(('all', None, root_entries, True))
379 # Compute the maximum number of required libraries, plus one so there is
381 max_required_libraries = max(len(deps)
382 for _,_,deps,_ in entries) + 1
384 # Write out the library table.
385 make_install_dir(os.path.dirname(output_path))
386 f = open(output_path+'.new', 'w')
388 //===- llvm-build generated file --------------------------------*- C++ -*-===//
390 // Component Library Depenedency Table
392 // Automatically generated file, do not edit!
394 //===----------------------------------------------------------------------===//
397 f.write('struct AvailableComponent {\n')
398 f.write(' /// The name of the component.\n')
399 f.write(' const char *Name;\n')
401 f.write(' /// The name of the library for this component (or NULL).\n')
402 f.write(' const char *Library;\n')
404 f.write(' /// Whether the component is installed.\n')
405 f.write(' bool IsInstalled;\n')
408 /// The list of libraries required when linking this component.\n')
409 f.write(' const char *RequiredLibraries[%d];\n' % (
410 max_required_libraries))
411 f.write('} AvailableComponents[%d] = {\n' % len(entries))
412 for name,library_name,required_names,is_installed in entries:
413 if library_name is None:
414 library_name_as_cstr = 'nullptr'
416 library_name_as_cstr = '"lib%s.a"' % library_name
418 is_installed_as_cstr = 'true'
420 is_installed_as_cstr = 'false'
421 f.write(' { "%s", %s, %s, { %s } },\n' % (
422 name, library_name_as_cstr, is_installed_as_cstr,
423 ', '.join('"%s"' % dep
424 for dep in required_names)))
428 if not os.path.isfile(output_path):
429 os.rename(output_path+'.new', output_path)
430 elif filecmp.cmp(output_path, output_path+'.new'):
431 os.remove(output_path+'.new')
433 os.remove(output_path)
434 os.rename(output_path+'.new', output_path)
436 def get_required_libraries_for_component(self, ci, traverse_groups = False):
438 get_required_libraries_for_component(component_info) -> iter
440 Given a Library component info descriptor, return an iterator over all
441 of the directly required libraries for linking with this component. If
442 traverse_groups is True, then library and target groups will be
443 traversed to include their required libraries.
446 assert ci.type_name in ('Library', 'OptionalLibrary', 'LibraryGroup', 'TargetGroup')
448 for name in ci.required_libraries:
449 # Get the dependency info.
450 dep = self.component_info_map[name]
452 # If it is a library, yield it.
453 if dep.type_name == 'Library' or dep.type_name == 'OptionalLibrary':
457 # Otherwise if it is a group, yield or traverse depending on what
459 if dep.type_name in ('LibraryGroup', 'TargetGroup'):
460 if not traverse_groups:
464 for res in self.get_required_libraries_for_component(dep, True):
467 def get_fragment_dependencies(self):
469 get_fragment_dependencies() -> iter
471 Compute the list of files (as absolute paths) on which the output
472 fragments depend (i.e., files for which a modification should trigger a
473 rebuild of the fragment).
476 # Construct a list of all the dependencies of the Makefile fragment
477 # itself. These include all the LLVMBuild files themselves, as well as
478 # all of our own sources.
480 # Many components may come from the same file, so we make sure to unique
483 for ci in self.component_infos:
484 p = os.path.join(self.source_root, ci.subpath[1:], 'LLVMBuild.txt')
485 if p not in build_paths:
489 # Gather the list of necessary sources by just finding all loaded
490 # modules that are inside the LLVM source tree.
491 for module in sys.modules.values():
492 # Find the module path.
493 if not hasattr(module, '__file__'):
495 path = getattr(module, '__file__')
499 # Strip off any compiled suffix.
500 if os.path.splitext(path)[1] in ['.pyc', '.pyo', '.pyd']:
503 # If the path exists and is in the source tree, consider it a
505 if (path.startswith(self.source_root) and os.path.exists(path)):
508 def foreach_cmake_library(self, f,
509 enabled_optional_components,
512 for ci in self.ordered_component_infos:
513 # Skip optional components which are not enabled.
514 if ci.type_name == 'OptionalLibrary' \
515 and ci.name not in enabled_optional_components:
518 # We only write the information for libraries currently.
519 if ci.type_name not in ('Library', 'OptionalLibrary'):
522 # Skip disabled targets.
524 tg = ci.get_parent_target_group()
525 if tg and not tg.enabled:
528 # Skip targets that will not be installed
529 if skip_not_installed and not ci.installed:
535 def write_cmake_fragment(self, output_path, enabled_optional_components):
537 write_cmake_fragment(output_path) -> None
539 Generate a CMake fragment which includes all of the collated LLVMBuild
540 information in a format that is easily digestible by a CMake. The exact
541 contents of this are closely tied to how the CMake configuration
542 integrates LLVMBuild, see CMakeLists.txt in the top-level.
545 dependencies = list(self.get_fragment_dependencies())
547 # Write out the CMake fragment.
548 make_install_dir(os.path.dirname(output_path))
549 f = open(output_path, 'w')
553 #===-- %s - LLVMBuild Configuration for LLVM %s-*- CMake -*--===#'
554 header_name = os.path.basename(output_path)
555 header_pad = '-' * (80 - len(header_fmt % (header_name, '')))
556 header_string = header_fmt % (header_name, header_pad)
560 # The LLVM Compiler Infrastructure
562 # This file is distributed under the University of Illinois Open Source
563 # License. See LICENSE.TXT for details.
565 #===------------------------------------------------------------------------===#
567 # This file contains the LLVMBuild project information in a format easily
568 # consumed by the CMake based build system.
570 # This file is autogenerated by llvm-build, do not edit!
572 #===------------------------------------------------------------------------===#
576 # Write the dependency information in the best way we can.
578 # LLVMBuild CMake fragment dependencies.
580 # CMake has no builtin way to declare that the configuration depends on
581 # a particular file. However, a side effect of configure_file is to add
582 # said input file to CMake's internal dependency list. So, we use that
583 # and a dummy output file to communicate the dependency information to
586 # FIXME: File a CMake RFE to get a properly supported version of this
589 for dep in dependencies:
591 configure_file(\"%s\"
592 ${CMAKE_CURRENT_BINARY_DIR}/DummyConfigureOutput)\n""" % (
593 cmake_quote_path(dep),))
595 # Write the properties we use to encode the required library dependency
596 # information in a form CMake can easily use directly.
598 # Explicit library dependency information.
600 # The following property assignments effectively create a map from component
601 # names to required libraries, in a way that is easily accessed from CMake.
603 self.foreach_cmake_library(
606 set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_%s %s)\n""" % (
607 ci.get_prefixed_library_name(), " ".join(sorted(
608 dep.get_prefixed_library_name()
609 for dep in self.get_required_libraries_for_component(ci)))))
611 enabled_optional_components,
612 skip_disabled = False,
613 skip_not_installed = False # Dependency info must be emitted for internals libs too
618 def write_cmake_exports_fragment(self, output_path, enabled_optional_components):
620 write_cmake_exports_fragment(output_path) -> None
622 Generate a CMake fragment which includes LLVMBuild library
623 dependencies expressed similarly to how CMake would write
624 them via install(EXPORT).
627 dependencies = list(self.get_fragment_dependencies())
629 # Write out the CMake exports fragment.
630 make_install_dir(os.path.dirname(output_path))
631 f = open(output_path, 'w')
634 # Explicit library dependency information.
636 # The following property assignments tell CMake about link
637 # dependencies of libraries imported from LLVM.
639 self.foreach_cmake_library(
642 set_property(TARGET %s PROPERTY IMPORTED_LINK_INTERFACE_LIBRARIES %s)\n""" % (
643 ci.get_prefixed_library_name(), " ".join(sorted(
644 dep.get_prefixed_library_name()
645 for dep in self.get_required_libraries_for_component(ci)))))
647 enabled_optional_components,
648 skip_disabled = True,
649 skip_not_installed = True # Do not export internal libraries like gtest
654 def write_make_fragment(self, output_path, enabled_optional_components):
656 write_make_fragment(output_path) -> None
658 Generate a Makefile fragment which includes all of the collated
659 LLVMBuild information in a format that is easily digestible by a
660 Makefile. The exact contents of this are closely tied to how the LLVM
661 Makefiles integrate LLVMBuild, see Makefile.rules in the top-level.
664 dependencies = list(self.get_fragment_dependencies())
666 # Write out the Makefile fragment.
667 make_install_dir(os.path.dirname(output_path))
668 f = open(output_path, 'w')
672 #===-- %s - LLVMBuild Configuration for LLVM %s-*- Makefile -*--===#'
673 header_name = os.path.basename(output_path)
674 header_pad = '-' * (80 - len(header_fmt % (header_name, '')))
675 header_string = header_fmt % (header_name, header_pad)
679 # The LLVM Compiler Infrastructure
681 # This file is distributed under the University of Illinois Open Source
682 # License. See LICENSE.TXT for details.
684 #===------------------------------------------------------------------------===#
686 # This file contains the LLVMBuild project information in a format easily
687 # consumed by the Makefile based build system.
689 # This file is autogenerated by llvm-build, do not edit!
691 #===------------------------------------------------------------------------===#
695 # Write the dependencies for the fragment.
697 # FIXME: Technically, we need to properly quote for Make here.
699 # Clients must explicitly enable LLVMBUILD_INCLUDE_DEPENDENCIES to get
700 # these dependencies. This is a compromise to help improve the
701 # performance of recursive Make systems.
703 f.write('ifeq ($(LLVMBUILD_INCLUDE_DEPENDENCIES),1)\n')
704 f.write("# The dependencies for this Makefile fragment itself.\n")
705 f.write("%s: \\\n" % (mk_quote_string_for_target(output_path),))
706 for dep in dependencies:
707 f.write("\t%s \\\n" % (dep,))
710 # Generate dummy rules for each of the dependencies, so that things
711 # continue to work correctly if any of those files are moved or removed.
713 # The dummy targets to allow proper regeneration even when files are moved or
716 for dep in dependencies:
717 f.write("%s:\n" % (mk_quote_string_for_target(dep),))
721 # List of libraries to be exported for use by applications.
722 # See 'cmake/modules/Makefile'.
723 LLVM_LIBS_TO_EXPORT :=""")
724 self.foreach_cmake_library(
726 f.write(' \\\n %s' % ci.get_prefixed_library_name())
728 enabled_optional_components,
729 skip_disabled = True,
730 skip_not_installed = True # Do not export internal libraries like gtest
735 def add_magic_target_components(parser, project, opts):
736 """add_magic_target_components(project, opts) -> None
738 Add the "magic" target based components to the project, which can only be
739 determined based on the target configuration options.
741 This currently is responsible for populating the required_libraries list of
742 the "all-targets", "Native", "NativeCodeGen", and "Engine" components.
745 # Determine the available targets.
746 available_targets = dict((ci.name,ci)
747 for ci in project.component_infos
748 if ci.type_name == 'TargetGroup')
750 # Find the configured native target.
752 # We handle a few special cases of target names here for historical
753 # reasons, as these are the names configure currently comes up with.
754 native_target_name = { 'x86' : 'X86',
756 'Unknown' : None }.get(opts.native_target,
758 if native_target_name is None:
761 native_target = available_targets.get(native_target_name)
762 if native_target is None:
763 parser.error("invalid native target: %r (not in project)" % (
764 opts.native_target,))
765 if native_target.type_name != 'TargetGroup':
766 parser.error("invalid native target: %r (not a target)" % (
767 opts.native_target,))
769 # Find the list of targets to enable.
770 if opts.enable_targets is None:
771 enable_targets = available_targets.values()
773 # We support both space separated and semi-colon separated lists.
774 if opts.enable_targets == '':
775 enable_target_names = []
776 elif ' ' in opts.enable_targets:
777 enable_target_names = opts.enable_targets.split()
779 enable_target_names = opts.enable_targets.split(';')
782 for name in enable_target_names:
783 target = available_targets.get(name)
785 parser.error("invalid target to enable: %r (not in project)" % (
787 if target.type_name != 'TargetGroup':
788 parser.error("invalid target to enable: %r (not a target)" % (
790 enable_targets.append(target)
792 # Find the special library groups we are going to populate. We enforce that
793 # these appear in the project (instead of just adding them) so that they at
794 # least have an explicit representation in the project LLVMBuild files (and
795 # comments explaining how they are populated).
796 def find_special_group(name):
797 info = info_map.get(name)
799 fatal("expected project to contain special %r component" % (
802 if info.type_name != 'LibraryGroup':
803 fatal("special component %r should be a LibraryGroup" % (
806 if info.required_libraries:
807 fatal("special component %r must have empty %r list" % (
808 name, 'required_libraries'))
809 if info.add_to_library_groups:
810 fatal("special component %r must have empty %r list" % (
811 name, 'add_to_library_groups'))
813 info._is_special_group = True
816 info_map = dict((ci.name, ci) for ci in project.component_infos)
817 all_targets = find_special_group('all-targets')
818 native_group = find_special_group('Native')
819 native_codegen_group = find_special_group('NativeCodeGen')
820 engine_group = find_special_group('Engine')
822 # Set the enabled bit in all the target groups, and append to the
824 for ci in enable_targets:
825 all_targets.required_libraries.append(ci.name)
828 # If we have a native target, then that defines the native and
829 # native_codegen libraries.
830 if native_target and native_target.enabled:
831 native_group.required_libraries.append(native_target.name)
832 native_codegen_group.required_libraries.append(
833 '%sCodeGen' % native_target.name)
835 # If we have a native target with a JIT, use that for the engine. Otherwise,
836 # use the interpreter.
837 if native_target and native_target.enabled and native_target.has_jit:
838 engine_group.required_libraries.append('MCJIT')
839 engine_group.required_libraries.append(native_group.name)
841 engine_group.required_libraries.append('Interpreter')
844 from optparse import OptionParser, OptionGroup
845 parser = OptionParser("usage: %prog [options]")
847 group = OptionGroup(parser, "Input Options")
848 group.add_option("", "--source-root", dest="source_root", metavar="PATH",
849 help="Path to the LLVM source (inferred if not given)",
850 action="store", default=None)
851 group.add_option("", "--llvmbuild-source-root",
852 dest="llvmbuild_source_root",
854 "If given, an alternate path to search for LLVMBuild.txt files"),
855 action="store", default=None, metavar="PATH")
856 group.add_option("", "--build-root", dest="build_root", metavar="PATH",
857 help="Path to the build directory (if needed) [%default]",
858 action="store", default=None)
859 parser.add_option_group(group)
861 group = OptionGroup(parser, "Output Options")
862 group.add_option("", "--print-tree", dest="print_tree",
863 help="Print out the project component tree [%default]",
864 action="store_true", default=False)
865 group.add_option("", "--write-llvmbuild", dest="write_llvmbuild",
866 help="Write out the LLVMBuild.txt files to PATH",
867 action="store", default=None, metavar="PATH")
868 group.add_option("", "--write-library-table",
869 dest="write_library_table", metavar="PATH",
870 help="Write the C++ library dependency table to PATH",
871 action="store", default=None)
872 group.add_option("", "--write-cmake-fragment",
873 dest="write_cmake_fragment", metavar="PATH",
874 help="Write the CMake project information to PATH",
875 action="store", default=None)
876 group.add_option("", "--write-cmake-exports-fragment",
877 dest="write_cmake_exports_fragment", metavar="PATH",
878 help="Write the CMake exports information to PATH",
879 action="store", default=None)
880 group.add_option("", "--write-make-fragment",
881 dest="write_make_fragment", metavar="PATH",
882 help="Write the Makefile project information to PATH",
883 action="store", default=None)
884 group.add_option("", "--configure-target-def-file",
885 dest="configure_target_def_files",
886 help="""Configure the given file at SUBPATH (relative to
887 the inferred or given source root, and with a '.in' suffix) by replacing certain
888 substitution variables with lists of targets that support certain features (for
889 example, targets with AsmPrinters) and write the result to the build root (as
890 given by --build-root) at the same SUBPATH""",
891 metavar="SUBPATH", action="append", default=None)
892 parser.add_option_group(group)
894 group = OptionGroup(parser, "Configuration Options")
895 group.add_option("", "--native-target",
896 dest="native_target", metavar="NAME",
897 help=("Treat the named target as the 'native' one, if "
899 action="store", default=None)
900 group.add_option("", "--enable-targets",
901 dest="enable_targets", metavar="NAMES",
902 help=("Enable the given space or semi-colon separated "
903 "list of targets, or all targets if not present"),
904 action="store", default=None)
905 group.add_option("", "--enable-optional-components",
906 dest="optional_components", metavar="NAMES",
907 help=("Enable the given space or semi-colon separated "
908 "list of optional components"),
909 action="store", default="")
910 parser.add_option_group(group)
912 (opts, args) = parser.parse_args()
914 # Determine the LLVM source path, if not given.
915 source_root = opts.source_root
917 if not os.path.exists(os.path.join(source_root, 'lib', 'IR',
919 parser.error('invalid LLVM source root: %r' % source_root)
921 llvmbuild_path = os.path.dirname(__file__)
922 llvm_build_path = os.path.dirname(llvmbuild_path)
923 utils_path = os.path.dirname(llvm_build_path)
924 source_root = os.path.dirname(utils_path)
925 if not os.path.exists(os.path.join(source_root, 'lib', 'IR',
927 parser.error('unable to infer LLVM source root, please specify')
929 # Construct the LLVM project information.
930 llvmbuild_source_root = opts.llvmbuild_source_root or source_root
931 project_info = LLVMProjectInfo.load_from_path(
932 source_root, llvmbuild_source_root)
934 # Add the magic target based components.
935 add_magic_target_components(parser, project_info, opts)
937 # Validate the project component info.
938 project_info.validate_components()
940 # Print the component tree, if requested.
942 project_info.print_tree()
944 # Write out the components, if requested. This is useful for auto-upgrading
946 if opts.write_llvmbuild:
947 project_info.write_components(opts.write_llvmbuild)
949 # Write out the required library table, if requested.
950 if opts.write_library_table:
951 project_info.write_library_table(opts.write_library_table,
952 opts.optional_components)
954 # Write out the make fragment, if requested.
955 if opts.write_make_fragment:
956 project_info.write_make_fragment(opts.write_make_fragment,
957 opts.optional_components)
959 # Write out the cmake fragment, if requested.
960 if opts.write_cmake_fragment:
961 project_info.write_cmake_fragment(opts.write_cmake_fragment,
962 opts.optional_components)
963 if opts.write_cmake_exports_fragment:
964 project_info.write_cmake_exports_fragment(opts.write_cmake_exports_fragment,
965 opts.optional_components)
967 # Configure target definition files, if requested.
968 if opts.configure_target_def_files:
969 # Verify we were given a build root.
970 if not opts.build_root:
971 parser.error("must specify --build-root when using "
972 "--configure-target-def-file")
974 # Create the substitution list.
975 available_targets = [ci for ci in project_info.component_infos
976 if ci.type_name == 'TargetGroup']
978 ("@LLVM_ENUM_TARGETS@",
979 ' '.join('LLVM_TARGET(%s)' % ci.name
980 for ci in available_targets)),
981 ("@LLVM_ENUM_ASM_PRINTERS@",
982 ' '.join('LLVM_ASM_PRINTER(%s)' % ci.name
983 for ci in available_targets
984 if ci.has_asmprinter)),
985 ("@LLVM_ENUM_ASM_PARSERS@",
986 ' '.join('LLVM_ASM_PARSER(%s)' % ci.name
987 for ci in available_targets
988 if ci.has_asmparser)),
989 ("@LLVM_ENUM_DISASSEMBLERS@",
990 ' '.join('LLVM_DISASSEMBLER(%s)' % ci.name
991 for ci in available_targets
992 if ci.has_disassembler))]
994 # Configure the given files.
995 for subpath in opts.configure_target_def_files:
996 inpath = os.path.join(source_root, subpath + '.in')
997 outpath = os.path.join(opts.build_root, subpath)
998 result = configutil.configure_file(inpath, outpath, substitutions)
1000 note("configured file %r hasn't changed" % outpath)
1002 if __name__=='__main__':