1import StringIO 2import os 3import sys 4 5import componentinfo 6import configutil 7 8from util import * 9 10### 11 12def cmake_quote_string(value): 13 """ 14 cmake_quote_string(value) -> str 15 16 Return a quoted form of the given value that is suitable for use in CMake 17 language files. 18 """ 19 20 # Currently, we only handle escaping backslashes. 21 value = value.replace("\\", "\\\\") 22 23 return value 24 25def cmake_quote_path(value): 26 """ 27 cmake_quote_path(value) -> str 28 29 Return a quoted form of the given value that is suitable for use in CMake 30 language files. 31 """ 32 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("\\", "/") 37 38 return value 39 40def mk_quote_string_for_target(value): 41 """ 42 mk_quote_string_for_target(target_name) -> str 43 44 Return a quoted form of the given target_name suitable for including in a 45 Makefile as a target name. 46 """ 47 48 # The only quoting we currently perform is for ':', to support msys users. 49 return value.replace(":", "\\:") 50 51def make_install_dir(path): 52 """ 53 make_install_dir(path) -> None 54 55 Create the given directory path for installation, including any parents. 56 """ 57 58 # os.makedirs considers it an error to be called with an existent path. 59 if not os.path.exists(path): 60 os.makedirs(path) 61 62### 63 64class LLVMProjectInfo(object): 65 @staticmethod 66 def load_infos_from_path(llvmbuild_source_root): 67 def recurse(subpath): 68 # Load the LLVMBuild file. 69 llvmbuild_path = os.path.join(llvmbuild_source_root + subpath, 70 'LLVMBuild.txt') 71 if not os.path.exists(llvmbuild_path): 72 fatal("missing LLVMBuild.txt file at: %r" % (llvmbuild_path,)) 73 74 # Parse the components from it. 75 common,info_iter = componentinfo.load_from_path(llvmbuild_path, 76 subpath) 77 for info in info_iter: 78 yield info 79 80 # Recurse into the specified subdirectories. 81 for subdir in common.get_list("subdirectories"): 82 for item in recurse(os.path.join(subpath, subdir)): 83 yield item 84 85 return recurse("/") 86 87 @staticmethod 88 def load_from_path(source_root, llvmbuild_source_root): 89 infos = list( 90 LLVMProjectInfo.load_infos_from_path(llvmbuild_source_root)) 91 92 return LLVMProjectInfo(source_root, infos) 93 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 100 101 def validate_components(self): 102 """validate_components() -> None 103 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. 108 109 We also construct the map from component names to info, and the 110 topological ordering of components. 111 """ 112 113 # Create the component info map and validate that component names are 114 # unique. 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 123 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") 127 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( 132 '/', '$ROOT', None) 133 self.component_infos.append(self.component_info_map['$ROOT']) 134 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)) 146 147 # If we have already visited this item, we are done. 148 if ci not in components_to_visit: 149 return 150 151 # Otherwise, mark the component info as visited and traverse. 152 components_to_visit.remove(ci) 153 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) 157 if parent is None: 158 fatal("component %r has invalid reference %r (via %r)" % ( 159 ci.name, ci.parent, 'parent')) 160 ci.set_parent_instance(parent) 161 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) 165 if referent is None: 166 fatal("component %r has invalid reference %r (via %r)" % ( 167 ci.name, referent_name, relation)) 168 169 # Visit the reference. 170 current_stack.append((relation,ci)) 171 current_set.add(ci) 172 visit_component_info(referent, current_stack, current_set) 173 current_set.remove(ci) 174 current_stack.pop() 175 176 # Finally, add the component info to the ordered list. 177 self.ordered_component_infos.append(ci) 178 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. 183 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()) 188 189 # Canonicalize children lists. 190 for c in self.ordered_component_infos: 191 c.children.sort(key = lambda c: c.name) 192 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: 197 visit(c, depth + 1) 198 visit(self.component_info_map['$ROOT']) 199 200 def write_components(self, output_path): 201 # Organize all the components by the directory their LLVMBuild file 202 # should go in. 203 info_basedir = {} 204 for ci in self.component_infos: 205 # Ignore the $ROOT component. 206 if ci.parent is None: 207 continue 208 209 info_basedir[ci.subpath] = info_basedir.get(ci.subpath, []) + [ci] 210 211 # Compute the list of subdirectories to scan. 212 subpath_subdirs = {} 213 for ci in self.component_infos: 214 # Ignore root components. 215 if ci.subpath == '/': 216 continue 217 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( 221 parent_path, set()) 222 parent_list.add(os.path.basename(ci.subpath)) 223 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) 228 229 # Format the components into llvmbuild fragments. 230 fragments = [] 231 232 # Add the common fragments. 233 subdirectories = subpath_subdirs.get(subpath) 234 if subdirectories: 235 fragment = """\ 236subdirectories = %s 237""" % (" ".join(sorted(subdirectories)),) 238 fragments.append(("common", fragment)) 239 240 # Add the component fragments. 241 num_common_fragments = len(fragments) 242 for ci in infos: 243 fragment = ci.get_llvmbuild_fragment() 244 if fragment is None: 245 continue 246 247 name = "component_%d" % (len(fragments) - num_common_fragments) 248 fragments.append((name, fragment)) 249 250 if not fragments: 251 continue 252 253 assert subpath.startswith('/') 254 directory_path = os.path.join(output_path, subpath[1:]) 255 256 # Create the directory if it does not already exist. 257 if not os.path.exists(directory_path): 258 os.makedirs(directory_path) 259 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) 264 comments_map = {} 265 comment_block = "" 266 for ln in f: 267 if ln.startswith(';'): 268 comment_block += ln 269 elif ln.startswith('[') and ln.endswith(']\n'): 270 comments_map[ln[1:-2]] = comment_block 271 else: 272 comment_block = "" 273 f.close() 274 275 # Create the LLVMBuild fil[e. 276 file_path = os.path.join(directory_path, 'LLVMBuild.txt') 277 f = open(file_path, "w") 278 279 # Write the header. 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) 284 print >>f, """\ 285%s 286; 287; The LLVM Compiler Infrastructure 288; 289; This file is distributed under the University of Illinois Open Source 290; License. See LICENSE.TXT for details. 291; 292;===------------------------------------------------------------------------===; 293; 294; This is an LLVMBuild description file for the components in this subdirectory. 295; 296; For more information on the LLVMBuild system, please see: 297; 298; http://llvm.org/docs/LLVMBuild.html 299; 300;===------------------------------------------------------------------------===; 301""" % header_string 302 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: 307 f.write(comment) 308 print >>f, "[%s]" % name 309 f.write(fragment) 310 if fragment is not fragments[-1][1]: 311 print >>f 312 313 f.close() 314 315 def write_library_table(self, output_path, enabled_optional_components): 316 # Write out the mapping from component names to required libraries. 317 # 318 # We do this in topological order so that we know we can append the 319 # dependencies for added library groups. 320 entries = {} 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: 325 continue 326 327 # Skip target groups which are not enabled. 328 tg = c.get_parent_target_group() 329 if tg and not tg.enabled: 330 continue 331 332 # Only certain components are in the table. 333 if c.type_name not in ('Library', 'OptionalLibrary', \ 334 'LibraryGroup', 'TargetGroup'): 335 continue 336 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() 340 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 345 else: 346 library_name = None 347 is_installed = True 348 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] 353 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) 357 358 # Add the entry. 359 entries[c.name] = (llvmconfig_component_name, library_name, 360 required_llvmconfig_component_names, 361 is_installed) 362 363 # Convert to a list of entries and sort by name. 364 entries = entries.values() 365 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)) 372 373 entries.sort() 374 375 # Compute the maximum number of required libraries, plus one so there is 376 # always a sentinel. 377 max_required_libraries = max(len(deps) 378 for _,_,deps,_ in entries) + 1 379 380 # Write out the library table. 381 make_install_dir(os.path.dirname(output_path)) 382 f = open(output_path, 'w') 383 print >>f, """\ 384//===- llvm-build generated file --------------------------------*- C++ -*-===// 385// 386// Component Library Depenedency Table 387// 388// Automatically generated file, do not edit! 389// 390//===----------------------------------------------------------------------===// 391""" 392 print >>f, 'struct AvailableComponent {' 393 print >>f, ' /// The name of the component.' 394 print >>f, ' const char *Name;' 395 print >>f, '' 396 print >>f, ' /// The name of the library for this component (or NULL).' 397 print >>f, ' const char *Library;' 398 print >>f, '' 399 print >>f, ' /// Whether the component is installed.' 400 print >>f, ' bool IsInstalled;' 401 print >>f, '' 402 print >>f, '\ 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' 410 else: 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)) 416 print >>f, '};' 417 f.close() 418 419 def get_required_libraries_for_component(self, ci, traverse_groups = False): 420 """ 421 get_required_libraries_for_component(component_info) -> iter 422 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. 427 """ 428 429 assert ci.type_name in ('Library', 'LibraryGroup', 'TargetGroup') 430 431 for name in ci.required_libraries: 432 # Get the dependency info. 433 dep = self.component_info_map[name] 434 435 # If it is a library, yield it. 436 if dep.type_name == 'Library': 437 yield dep 438 continue 439 440 # Otherwise if it is a group, yield or traverse depending on what 441 # was requested. 442 if dep.type_name in ('LibraryGroup', 'TargetGroup'): 443 if not traverse_groups: 444 yield dep 445 continue 446 447 for res in self.get_required_libraries_for_component(dep, True): 448 yield res 449 450 def get_fragment_dependencies(self): 451 """ 452 get_fragment_dependencies() -> iter 453 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). 457 """ 458 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. 462 # 463 # Many components may come from the same file, so we make sure to unique 464 # these. 465 build_paths = set() 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: 469 yield p 470 build_paths.add(p) 471 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__'): 477 continue 478 path = getattr(module, '__file__') 479 if not path: 480 continue 481 482 # Strip off any compiled suffix. 483 if os.path.splitext(path)[1] in ['.pyc', '.pyo', '.pyd']: 484 path = path[:-1] 485 486 # If the path exists and is in the source tree, consider it a 487 # dependency. 488 if (path.startswith(self.source_root) and os.path.exists(path)): 489 yield path 490 491 def write_cmake_fragment(self, output_path): 492 """ 493 write_cmake_fragment(output_path) -> None 494 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. 499 """ 500 501 dependencies = list(self.get_fragment_dependencies()) 502 503 # Write out the CMake fragment. 504 make_install_dir(os.path.dirname(output_path)) 505 f = open(output_path, 'w') 506 507 # Write the header. 508 header_fmt = '\ 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) 513 print >>f, """\ 514%s 515# 516# The LLVM Compiler Infrastructure 517# 518# This file is distributed under the University of Illinois Open Source 519# License. See LICENSE.TXT for details. 520# 521#===------------------------------------------------------------------------===# 522# 523# This file contains the LLVMBuild project information in a format easily 524# consumed by the CMake based build system. 525# 526# This file is autogenerated by llvm-build, do not edit! 527# 528#===------------------------------------------------------------------------===# 529""" % header_string 530 531 # Write the dependency information in the best way we can. 532 print >>f, """ 533# LLVMBuild CMake fragment dependencies. 534# 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 539# CMake. 540# 541# FIXME: File a CMake RFE to get a properly supported version of this 542# feature.""" 543 for dep in dependencies: 544 print >>f, """\ 545configure_file(\"%s\" 546 ${CMAKE_CURRENT_BINARY_DIR}/DummyConfigureOutput)""" % ( 547 cmake_quote_path(dep),) 548 549 # Write the properties we use to encode the required library dependency 550 # information in a form CMake can easily use directly. 551 print >>f, """ 552# Explicit library dependency information. 553# 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': 559 continue 560 561 print >>f, """\ 562set_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)))) 566 567 f.close() 568 569 def write_make_fragment(self, output_path): 570 """ 571 write_make_fragment(output_path) -> None 572 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. 577 """ 578 579 dependencies = list(self.get_fragment_dependencies()) 580 581 # Write out the Makefile fragment. 582 make_install_dir(os.path.dirname(output_path)) 583 f = open(output_path, 'w') 584 585 # Write the header. 586 header_fmt = '\ 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) 591 print >>f, """\ 592%s 593# 594# The LLVM Compiler Infrastructure 595# 596# This file is distributed under the University of Illinois Open Source 597# License. See LICENSE.TXT for details. 598# 599#===------------------------------------------------------------------------===# 600# 601# This file contains the LLVMBuild project information in a format easily 602# consumed by the Makefile based build system. 603# 604# This file is autogenerated by llvm-build, do not edit! 605# 606#===------------------------------------------------------------------------===# 607""" % header_string 608 609 # Write the dependencies for the fragment. 610 # 611 # FIXME: Technically, we need to properly quote for Make here. 612 print >>f, """\ 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,) 621 print >>f 622 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. 625 print >>f, """\ 626# The dummy targets to allow proper regeneration even when files are moved or 627# removed.""" 628 for dep in dependencies: 629 print >>f, "%s:" % (mk_quote_string_for_target(dep),) 630 print >>f, 'endif' 631 632 f.close() 633 634def add_magic_target_components(parser, project, opts): 635 """add_magic_target_components(project, opts) -> None 636 637 Add the "magic" target based components to the project, which can only be 638 determined based on the target configuration options. 639 640 This currently is responsible for populating the required_libraries list of 641 the "all-targets", "Native", "NativeCodeGen", and "Engine" components. 642 """ 643 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') 648 649 # Find the configured native target. 650 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', 654 'x86_64' : 'X86', 655 'Unknown' : None }.get(opts.native_target, 656 opts.native_target) 657 if native_target_name is None: 658 native_target = None 659 else: 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,)) 667 668 # Find the list of targets to enable. 669 if opts.enable_targets is None: 670 enable_targets = available_targets.values() 671 else: 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() 675 else: 676 enable_target_names = opts.enable_targets.split(';') 677 678 enable_targets = [] 679 for name in enable_target_names: 680 target = available_targets.get(name) 681 if target is None: 682 parser.error("invalid target to enable: %r (not in project)" % ( 683 name,)) 684 if target.type_name != 'TargetGroup': 685 parser.error("invalid target to enable: %r (not a target)" % ( 686 name,)) 687 enable_targets.append(target) 688 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) 695 if info is None: 696 fatal("expected project to contain special %r component" % ( 697 name,)) 698 699 if info.type_name != 'LibraryGroup': 700 fatal("special component %r should be a LibraryGroup" % ( 701 name,)) 702 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')) 709 710 info._is_special_group = True 711 return info 712 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') 718 719 # Set the enabled bit in all the target groups, and append to the 720 # all-targets list. 721 for ci in enable_targets: 722 all_targets.required_libraries.append(ci.name) 723 ci.enabled = True 724 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) 731 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) 737 else: 738 engine_group.required_libraries.append('Interpreter') 739 740def main(): 741 from optparse import OptionParser, OptionGroup 742 parser = OptionParser("usage: %prog [options]") 743 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", 750 help=( 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) 757 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 780the inferred or given source root, and with a '.in' suffix) by replacing certain 781substitution variables with lists of targets that support certain features (for 782example, targets with AsmPrinters) and write the result to the build root (as 783given by --build-root) at the same SUBPATH""", 784 metavar="SUBPATH", action="append", default=None) 785 parser.add_option_group(group) 786 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 " 791 "given [%default]"), 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) 804 805 (opts, args) = parser.parse_args() 806 807 # Determine the LLVM source path, if not given. 808 source_root = opts.source_root 809 if source_root: 810 if not os.path.exists(os.path.join(source_root, 'lib', 'VMCore', 811 'Function.cpp')): 812 parser.error('invalid LLVM source root: %r' % source_root) 813 else: 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', 819 'Function.cpp')): 820 parser.error('unable to infer LLVM source root, please specify') 821 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) 826 827 # Add the magic target based components. 828 add_magic_target_components(parser, project_info, opts) 829 830 # Validate the project component info. 831 project_info.validate_components() 832 833 # Print the component tree, if requested. 834 if opts.print_tree: 835 project_info.print_tree() 836 837 # Write out the components, if requested. This is useful for auto-upgrading 838 # the schema. 839 if opts.write_llvmbuild: 840 project_info.write_components(opts.write_llvmbuild) 841 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) 846 847 # Write out the make fragment, if requested. 848 if opts.write_make_fragment: 849 project_info.write_make_fragment(opts.write_make_fragment) 850 851 # Write out the cmake fragment, if requested. 852 if opts.write_cmake_fragment: 853 project_info.write_cmake_fragment(opts.write_cmake_fragment) 854 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") 861 862 # Create the substitution list. 863 available_targets = [ci for ci in project_info.component_infos 864 if ci.type_name == 'TargetGroup'] 865 substitutions = [ 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))] 881 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) 887 if not result: 888 note("configured file %r hasn't changed" % outpath) 889 890if __name__=='__main__': 891 main() 892