10 def cmake_quote_string(value):
12 cmake_quote_string(value) -> str
14 Return a quoted form of the given value that is suitable for use in CMake
18 # Currently, we only handle escaping backslashes.
19 value = value.replace("\\", "\\\\")
23 def mk_quote_string_for_target(value):
25 mk_quote_string_for_target(target_name) -> str
27 Return a quoted form of the given target_name suitable for including in a
28 Makefile as a target name.
31 # The only quoting we currently perform is for ':', to support msys users.
32 return value.replace(":", "\\:")
34 def make_install_dir(path):
36 make_install_dir(path) -> None
38 Create the given directory path for installation, including any parents.
41 # os.makedirs considers it an error to be called with an existant path.
42 if not os.path.exists(path):
47 class LLVMProjectInfo(object):
49 def load_infos_from_path(llvmbuild_source_root):
50 # FIXME: Implement a simple subpath file list cache, so we don't restat
51 # directories we have already traversed.
53 # First, discover all the LLVMBuild.txt files.
55 # FIXME: We would like to use followlinks=True here, but that isn't
56 # compatible with Python 2.4. Instead, we will either have to special
57 # case projects we would expect to possibly be linked to, or implement
58 # our own walk that can follow links. For now, it doesn't matter since
59 # we haven't picked up the LLVMBuild system in any other LLVM projects.
60 for dirpath,dirnames,filenames in os.walk(llvmbuild_source_root):
61 # If there is no LLVMBuild.txt file in a directory, we don't recurse
62 # past it. This is a simple way to prune our search, although it
63 # makes it easy for users to add LLVMBuild.txt files in places they
65 if 'LLVMBuild.txt' not in filenames:
69 # Otherwise, load the LLVMBuild file in this directory.
70 assert dirpath.startswith(llvmbuild_source_root)
71 subpath = '/' + dirpath[len(llvmbuild_source_root)+1:]
72 llvmbuild_path = os.path.join(dirpath, 'LLVMBuild.txt')
73 for info in componentinfo.load_from_path(llvmbuild_path, subpath):
77 def load_from_path(source_root, llvmbuild_source_root):
79 LLVMProjectInfo.load_infos_from_path(llvmbuild_source_root))
81 return LLVMProjectInfo(source_root, infos)
83 def __init__(self, source_root, component_infos):
84 # Store our simple ivars.
85 self.source_root = source_root
86 self.component_infos = list(component_infos)
87 self.component_info_map = None
88 self.ordered_component_infos = None
90 def validate_components(self):
91 """validate_components() -> None
93 Validate that the project components are well-defined. Among other
94 things, this checks that:
95 - Components have valid references.
96 - Components references do not form cycles.
98 We also construct the map from component names to info, and the
99 topological ordering of components.
102 # Create the component info map and validate that component names are
104 self.component_info_map = {}
105 for ci in self.component_infos:
106 existing = self.component_info_map.get(ci.name)
107 if existing is not None:
108 # We found a duplicate component name, report it and error out.
109 fatal("found duplicate component %r (at %r and %r)" % (
110 ci.name, ci.subpath, existing.subpath))
111 self.component_info_map[ci.name] = ci
113 # Disallow 'all' as a component name, which is a special case.
114 if 'all' in self.component_info_map:
115 fatal("project is not allowed to define 'all' component")
117 # Add the root component.
118 if '$ROOT' in self.component_info_map:
119 fatal("project is not allowed to define $ROOT component")
120 self.component_info_map['$ROOT'] = componentinfo.GroupComponentInfo(
122 self.component_infos.append(self.component_info_map['$ROOT'])
124 # Topologically order the component information according to their
125 # component references.
126 def visit_component_info(ci, current_stack, current_set):
127 # Check for a cycles.
128 if ci in current_set:
129 # We found a cycle, report it and error out.
130 cycle_description = ' -> '.join(
131 '%r (%s)' % (ci.name, relation)
132 for relation,ci in current_stack)
133 fatal("found cycle to %r after following: %s -> %s" % (
134 ci.name, cycle_description, ci.name))
136 # If we have already visited this item, we are done.
137 if ci not in components_to_visit:
140 # Otherwise, mark the component info as visited and traverse.
141 components_to_visit.remove(ci)
143 # Validate the parent reference, which we treat specially.
144 if ci.parent is not None:
145 parent = self.component_info_map.get(ci.parent)
147 fatal("component %r has invalid reference %r (via %r)" % (
148 ci.name, ci.parent, 'parent'))
149 ci.set_parent_instance(parent)
151 for relation,referent_name in ci.get_component_references():
152 # Validate that the reference is ok.
153 referent = self.component_info_map.get(referent_name)
155 fatal("component %r has invalid reference %r (via %r)" % (
156 ci.name, referent_name, relation))
158 # Visit the reference.
159 current_stack.append((relation,ci))
161 visit_component_info(referent, current_stack, current_set)
162 current_set.remove(ci)
165 # Finally, add the component info to the ordered list.
166 self.ordered_component_infos.append(ci)
168 # FIXME: We aren't actually correctly checking for cycles along the
169 # parent edges. Haven't decided how I want to handle this -- I thought
170 # about only checking cycles by relation type. If we do that, it falls
171 # out easily. If we don't, we should special case the check.
173 self.ordered_component_infos = []
174 components_to_visit = set(self.component_infos)
175 while components_to_visit:
176 visit_component_info(iter(components_to_visit).next(), [], set())
178 # Canonicalize children lists.
179 for c in self.ordered_component_infos:
180 c.children.sort(key = lambda c: c.name)
182 def print_tree(self):
183 def visit(node, depth = 0):
184 print '%s%-40s (%s)' % (' '*depth, node.name, node.type_name)
185 for c in node.children:
187 visit(self.component_info_map['$ROOT'])
189 def write_components(self, output_path):
190 # Organize all the components by the directory their LLVMBuild file
193 for ci in self.component_infos:
194 # Ignore the $ROOT component.
195 if ci.parent is None:
198 info_basedir[ci.subpath] = info_basedir.get(ci.subpath, []) + [ci]
200 # Generate the build files.
201 for subpath, infos in info_basedir.items():
202 # Order the components by name to have a canonical ordering.
203 infos.sort(key = lambda ci: ci.name)
205 # Format the components into llvmbuild fragments.
206 fragments = filter(None, [ci.get_llvmbuild_fragment()
211 assert subpath.startswith('/')
212 directory_path = os.path.join(output_path, subpath[1:])
214 # Create the directory if it does not already exist.
215 if not os.path.exists(directory_path):
216 os.makedirs(directory_path)
218 # Create the LLVMBuild file.
219 file_path = os.path.join(directory_path, 'LLVMBuild.txt')
220 f = open(file_path, "w")
223 header_fmt = ';===- %s %s-*- Conf -*--===;'
224 header_name = '.' + os.path.join(subpath, 'LLVMBuild.txt')
225 header_pad = '-' * (80 - len(header_fmt % (header_name, '')))
226 header_string = header_fmt % (header_name, header_pad)
230 ; The LLVM Compiler Infrastructure
232 ; This file is distributed under the University of Illinois Open Source
233 ; License. See LICENSE.TXT for details.
235 ;===------------------------------------------------------------------------===;
237 ; This is an LLVMBuild description file for the components in this subdirectory.
239 ; For more information on the LLVMBuild system, please see:
241 ; http://llvm.org/docs/LLVMBuild.html
243 ;===------------------------------------------------------------------------===;
246 for i,fragment in enumerate(fragments):
247 print >>f, '[component_%d]' % i
252 def write_library_table(self, output_path):
253 # Write out the mapping from component names to required libraries.
255 # We do this in topological order so that we know we can append the
256 # dependencies for added library groups.
258 for c in self.ordered_component_infos:
259 # Only certain components are in the table.
260 if c.type_name not in ('Library', 'LibraryGroup', 'TargetGroup'):
263 # Compute the llvm-config "component name". For historical reasons,
264 # this is lowercased based on the library name.
265 llvmconfig_component_name = c.get_llvmconfig_component_name()
267 # Get the library name, or None for LibraryGroups.
268 if c.type_name == 'Library':
269 library_name = c.get_library_name()
273 # Get the component names of all the required libraries.
274 required_llvmconfig_component_names = [
275 self.component_info_map[dep].get_llvmconfig_component_name()
276 for dep in c.required_libraries]
278 # Insert the entries for library groups we should add to.
279 for dep in c.add_to_library_groups:
280 entries[dep][2].append(llvmconfig_component_name)
283 entries[c.name] = (llvmconfig_component_name, library_name,
284 required_llvmconfig_component_names)
286 # Convert to a list of entries and sort by name.
287 entries = entries.values()
289 # Create an 'all' pseudo component. We keep the dependency list small by
290 # only listing entries that have no other dependents.
291 root_entries = set(e[0] for e in entries)
292 for _,_,deps in entries:
293 root_entries -= set(deps)
294 entries.append(('all', None, root_entries))
298 # Compute the maximum number of required libraries, plus one so there is
300 max_required_libraries = max(len(deps)
301 for _,_,deps in entries) + 1
303 # Write out the library table.
304 make_install_dir(os.path.dirname(output_path))
305 f = open(output_path, 'w')
307 //===- llvm-build generated file --------------------------------*- C++ -*-===//
309 // Component Library Depenedency Table
311 // Automatically generated file, do not edit!
313 //===----------------------------------------------------------------------===//
315 print >>f, 'struct AvailableComponent {'
316 print >>f, ' /// The name of the component.'
317 print >>f, ' const char *Name;'
319 print >>f, ' /// The name of the library for this component (or NULL).'
320 print >>f, ' const char *Library;'
323 /// The list of libraries required when linking this component.'
324 print >>f, ' const char *RequiredLibraries[%d];' % (
325 max_required_libraries)
326 print >>f, '} AvailableComponents[%d] = {' % len(entries)
327 for name,library_name,required_names in entries:
328 if library_name is None:
329 library_name_as_cstr = '0'
331 # If we had a project level component, we could derive the
333 library_name_as_cstr = '"libLLVM%s.a"' % library_name
334 print >>f, ' { "%s", %s, { %s } },' % (
335 name, library_name_as_cstr,
336 ', '.join('"%s"' % dep
337 for dep in required_names))
341 def get_fragment_dependencies(self):
343 get_fragment_dependencies() -> iter
345 Compute the list of files (as absolute paths) on which the output
346 fragments depend (i.e., files for which a modification should trigger a
347 rebuild of the fragment).
350 # Construct a list of all the dependencies of the Makefile fragment
351 # itself. These include all the LLVMBuild files themselves, as well as
352 # all of our own sources.
353 for ci in self.component_infos:
354 yield os.path.join(self.source_root, ci.subpath[1:],
357 # Gather the list of necessary sources by just finding all loaded
358 # modules that are inside the LLVM source tree.
359 for module in sys.modules.values():
360 # Find the module path.
361 if not hasattr(module, '__file__'):
363 path = getattr(module, '__file__')
367 # Strip off any compiled suffix.
368 if os.path.splitext(path)[1] in ['.pyc', '.pyo', '.pyd']:
371 # If the path exists and is in the source tree, consider it a
373 if (path.startswith(self.source_root) and os.path.exists(path)):
376 def write_cmake_fragment(self, output_path):
378 write_cmake_fragment(output_path) -> None
380 Generate a CMake fragment which includes all of the collated LLVMBuild
381 information in a format that is easily digestible by a CMake. The exact
382 contents of this are closely tied to how the CMake configuration
383 integrates LLVMBuild, see CMakeLists.txt in the top-level.
386 dependencies = list(self.get_fragment_dependencies())
388 # Write out the CMake fragment.
389 make_install_dir(os.path.dirname(output_path))
390 f = open(output_path, 'w')
394 #===-- %s - LLVMBuild Configuration for LLVM %s-*- CMake -*--===#'
395 header_name = os.path.basename(output_path)
396 header_pad = '-' * (80 - len(header_fmt % (header_name, '')))
397 header_string = header_fmt % (header_name, header_pad)
401 # The LLVM Compiler Infrastructure
403 # This file is distributed under the University of Illinois Open Source
404 # License. See LICENSE.TXT for details.
406 #===------------------------------------------------------------------------===#
408 # This file contains the LLVMBuild project information in a format easily
409 # consumed by the CMake based build system.
411 # This file is autogenerated by llvm-build, do not edit!
413 #===------------------------------------------------------------------------===#
416 # Write the dependency information in the best way we can.
418 # LLVMBuild CMake fragment dependencies.
420 # CMake has no builtin way to declare that the configuration depends on
421 # a particular file. However, a side effect of configure_file is to add
422 # said input file to CMake's internal dependency list. So, we use that
423 # and a dummy output file to communicate the dependency information to
426 # FIXME: File a CMake RFE to get a properly supported version of this
428 for dep in dependencies:
430 configure_file(\"%s\"
431 ${CMAKE_CURRENT_BINARY_DIR}/DummyConfigureOutput)""" % (
432 cmake_quote_string(dep),)
436 def write_make_fragment(self, output_path):
438 write_make_fragment(output_path) -> None
440 Generate a Makefile fragment which includes all of the collated
441 LLVMBuild information in a format that is easily digestible by a
442 Makefile. The exact contents of this are closely tied to how the LLVM
443 Makefiles integrate LLVMBuild, see Makefile.rules in the top-level.
446 dependencies = list(self.get_fragment_dependencies())
448 # Write out the Makefile fragment.
449 make_install_dir(os.path.dirname(output_path))
450 f = open(output_path, 'w')
454 #===-- %s - LLVMBuild Configuration for LLVM %s-*- Makefile -*--===#'
455 header_name = os.path.basename(output_path)
456 header_pad = '-' * (80 - len(header_fmt % (header_name, '')))
457 header_string = header_fmt % (header_name, header_pad)
461 # The LLVM Compiler Infrastructure
463 # This file is distributed under the University of Illinois Open Source
464 # License. See LICENSE.TXT for details.
466 #===------------------------------------------------------------------------===#
468 # This file contains the LLVMBuild project information in a format easily
469 # consumed by the Makefile based build system.
471 # This file is autogenerated by llvm-build, do not edit!
473 #===------------------------------------------------------------------------===#
476 # Write the dependencies for the fragment.
478 # FIXME: Technically, we need to properly quote for Make here.
480 # Clients must explicitly enable LLVMBUILD_INCLUDE_DEPENDENCIES to get
481 # these dependencies. This is a compromise to help improve the
482 # performance of recursive Make systems."""
483 print >>f, 'ifeq ($(LLVMBUILD_INCLUDE_DEPENDENCIES),1)'
484 print >>f, "# The dependencies for this Makefile fragment itself."
485 print >>f, "%s: \\" % (mk_quote_string_for_target(output_path),)
486 for dep in dependencies:
487 print >>f, "\t%s \\" % (dep,)
490 # Generate dummy rules for each of the dependencies, so that things
491 # continue to work correctly if any of those files are moved or removed.
493 # The dummy targets to allow proper regeneration even when files are moved or
495 for dep in dependencies:
496 print >>f, "%s:" % (mk_quote_string_for_target(dep),)
502 from optparse import OptionParser, OptionGroup
503 parser = OptionParser("usage: %prog [options]")
505 group = OptionGroup(parser, "Input Options")
506 group.add_option("", "--source-root", dest="source_root", metavar="PATH",
507 help="Path to the LLVM source (inferred if not given)",
508 action="store", default=None)
509 group.add_option("", "--llvmbuild-source-root",
510 dest="llvmbuild_source_root",
512 "If given, an alternate path to search for LLVMBuild.txt files"),
513 action="store", default=None, metavar="PATH")
514 parser.add_option_group(group)
516 group = OptionGroup(parser, "Output Options")
517 group.add_option("", "--print-tree", dest="print_tree",
518 help="Print out the project component tree [%default]",
519 action="store_true", default=False)
520 group.add_option("", "--write-llvmbuild", dest="write_llvmbuild",
521 help="Write out the LLVMBuild.txt files to PATH",
522 action="store", default=None, metavar="PATH")
523 group.add_option("", "--write-library-table",
524 dest="write_library_table", metavar="PATH",
525 help="Write the C++ library dependency table to PATH",
526 action="store", default=None)
527 group.add_option("", "--write-cmake-fragment",
528 dest="write_cmake_fragment", metavar="PATH",
529 help="Write the CMake project information to PATH",
530 action="store", default=None)
531 group.add_option("", "--write-make-fragment",
532 dest="write_make_fragment", metavar="PATH",
533 help="Write the Makefile project information to PATH",
534 action="store", default=None)
535 parser.add_option_group(group)
536 action="store", default=None)
537 parser.add_option_group(group)
539 (opts, args) = parser.parse_args()
541 # Determine the LLVM source path, if not given.
542 source_root = opts.source_root
544 if not os.path.exists(os.path.join(source_root, 'lib', 'VMCore',
546 parser.error('invalid LLVM source root: %r' % source_root)
548 llvmbuild_path = os.path.dirname(__file__)
549 llvm_build_path = os.path.dirname(llvmbuild_path)
550 utils_path = os.path.dirname(llvm_build_path)
551 source_root = os.path.dirname(utils_path)
552 if not os.path.exists(os.path.join(source_root, 'lib', 'VMCore',
554 parser.error('unable to infer LLVM source root, please specify')
556 # Construct the LLVM project information.
557 llvmbuild_source_root = opts.llvmbuild_source_root or source_root
558 project_info = LLVMProjectInfo.load_from_path(
559 source_root, llvmbuild_source_root)
561 # Validate the project component info.
562 project_info.validate_components()
564 # Print the component tree, if requested.
566 project_info.print_tree()
568 # Write out the components, if requested. This is useful for auto-upgrading
570 if opts.write_llvmbuild:
571 project_info.write_components(opts.write_llvmbuild)
573 # Write out the required library table, if requested.
574 if opts.write_library_table:
575 project_info.write_library_table(opts.write_library_table)
577 # Write out the make fragment, if requested.
578 if opts.write_make_fragment:
579 project_info.write_make_fragment(opts.write_make_fragment)
581 # Write out the cmake fragment, if requested.
582 if opts.write_cmake_fragment:
583 project_info.write_cmake_fragment(opts.write_cmake_fragment)
585 if __name__=='__main__':