1 import StringIO 2 import os 3 import sys 4 5 import componentinfo 6 import configutil 7 8 from util import * 9 10 ### 11 12 def 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 25 def 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 40 def 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 51 def 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 64 class 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 = sorted( 186 set(self.component_infos), 187 key = lambda c: c.name) 188 while components_to_visit: 189 visit_component_info(iter(components_to_visit).next(), [], set()) 190 191 # Canonicalize children lists. 192 for c in self.ordered_component_infos: 193 c.children.sort(key = lambda c: c.name) 194 195 def print_tree(self): 196 def visit(node, depth = 0): 197 print '%s%-40s (%s)' % (' '*depth, node.name, node.type_name) 198 for c in node.children: 199 visit(c, depth + 1) 200 visit(self.component_info_map['$ROOT']) 201 202 def write_components(self, output_path): 203 # Organize all the components by the directory their LLVMBuild file 204 # should go in. 205 info_basedir = {} 206 for ci in self.component_infos: 207 # Ignore the $ROOT component. 208 if ci.parent is None: 209 continue 210 211 info_basedir[ci.subpath] = info_basedir.get(ci.subpath, []) + [ci] 212 213 # Compute the list of subdirectories to scan. 214 subpath_subdirs = {} 215 for ci in self.component_infos: 216 # Ignore root components. 217 if ci.subpath == '/': 218 continue 219 220 # Otherwise, append this subpath to the parent list. 221 parent_path = os.path.dirname(ci.subpath) 222 subpath_subdirs[parent_path] = parent_list = subpath_subdirs.get( 223 parent_path, set()) 224 parent_list.add(os.path.basename(ci.subpath)) 225 226 # Generate the build files. 227 for subpath, infos in info_basedir.items(): 228 # Order the components by name to have a canonical ordering. 229 infos.sort(key = lambda ci: ci.name) 230 231 # Format the components into llvmbuild fragments. 232 fragments = [] 233 234 # Add the common fragments. 235 subdirectories = subpath_subdirs.get(subpath) 236 if subdirectories: 237 fragment = """\ 238 subdirectories = %s 239 """ % (" ".join(sorted(subdirectories)),) 240 fragments.append(("common", fragment)) 241 242 # Add the component fragments. 243 num_common_fragments = len(fragments) 244 for ci in infos: 245 fragment = ci.get_llvmbuild_fragment() 246 if fragment is None: 247 continue 248 249 name = "component_%d" % (len(fragments) - num_common_fragments) 250 fragments.append((name, fragment)) 251 252 if not fragments: 253 continue 254 255 assert subpath.startswith('/') 256 directory_path = os.path.join(output_path, subpath[1:]) 257 258 # Create the directory if it does not already exist. 259 if not os.path.exists(directory_path): 260 os.makedirs(directory_path) 261 262 # In an effort to preserve comments (which aren't parsed), read in 263 # the original file and extract the comments. We only know how to 264 # associate comments that prefix a section name. 265 f = open(infos[0]._source_path) 266 comments_map = {} 267 comment_block = "" 268 for ln in f: 269 if ln.startswith(';'): 270 comment_block += ln 271 elif ln.startswith('[') and ln.endswith(']\n'): 272 comments_map[ln[1:-2]] = comment_block 273 else: 274 comment_block = "" 275 f.close() 276 277 # Create the LLVMBuild fil[e. 278 file_path = os.path.join(directory_path, 'LLVMBuild.txt') 279 f = open(file_path, "w") 280 281 # Write the header. 282 header_fmt = ';===- %s %s-*- Conf -*--===;' 283 header_name = '.' + os.path.join(subpath, 'LLVMBuild.txt') 284 header_pad = '-' * (80 - len(header_fmt % (header_name, ''))) 285 header_string = header_fmt % (header_name, header_pad) 286 print >>f, """\ 287 %s 288 ; 289 ; The LLVM Compiler Infrastructure 290 ; 291 ; This file is distributed under the University of Illinois Open Source 292 ; License. See LICENSE.TXT for details. 293 ; 294 ;===------------------------------------------------------------------------===; 295 ; 296 ; This is an LLVMBuild description file for the components in this subdirectory. 297 ; 298 ; For more information on the LLVMBuild system, please see: 299 ; 300 ; http://llvm.org/docs/LLVMBuild.html 301 ; 302 ;===------------------------------------------------------------------------===; 303 """ % header_string 304 305 # Write out each fragment.each component fragment. 306 for name,fragment in fragments: 307 comment = comments_map.get(name) 308 if comment is not None: 309 f.write(comment) 310 print >>f, "[%s]" % name 311 f.write(fragment) 312 if fragment is not fragments[-1][1]: 313 print >>f 314 315 f.close() 316 317 def write_library_table(self, output_path, enabled_optional_components): 318 # Write out the mapping from component names to required libraries. 319 # 320 # We do this in topological order so that we know we can append the 321 # dependencies for added library groups. 322 entries = {} 323 for c in self.ordered_component_infos: 324 # Skip optional components which are not enabled. 325 if c.type_name == 'OptionalLibrary' \ 326 and c.name not in enabled_optional_components: 327 continue 328 329 # Skip target groups which are not enabled. 330 tg = c.get_parent_target_group() 331 if tg and not tg.enabled: 332 continue 333 334 # Only certain components are in the table. 335 if c.type_name not in ('Library', 'OptionalLibrary', \ 336 'LibraryGroup', 'TargetGroup'): 337 continue 338 339 # Compute the llvm-config "component name". For historical reasons, 340 # this is lowercased based on the library name. 341 llvmconfig_component_name = c.get_llvmconfig_component_name() 342 343 # Get the library name, or None for LibraryGroups. 344 if c.type_name == 'Library' or c.type_name == 'OptionalLibrary': 345 library_name = c.get_prefixed_library_name() 346 is_installed = c.installed 347 else: 348 library_name = None 349 is_installed = True 350 351 # Get the component names of all the required libraries. 352 required_llvmconfig_component_names = [ 353 self.component_info_map[dep].get_llvmconfig_component_name() 354 for dep in c.required_libraries] 355 356 # Insert the entries for library groups we should add to. 357 for dep in c.add_to_library_groups: 358 entries[dep][2].append(llvmconfig_component_name) 359 360 # Add the entry. 361 entries[c.name] = (llvmconfig_component_name, library_name, 362 required_llvmconfig_component_names, 363 is_installed) 364 365 # Convert to a list of entries and sort by name. 366 entries = entries.values() 367 368 # Create an 'all' pseudo component. We keep the dependency list small by 369 # only listing entries that have no other dependents. 370 root_entries = set(e[0] for e in entries) 371 for _,_,deps,_ in entries: 372 root_entries -= set(deps) 373 entries.append(('all', None, root_entries, True)) 374 375 entries.sort() 376 377 # Compute the maximum number of required libraries, plus one so there is 378 # always a sentinel. 379 max_required_libraries = max(len(deps) 380 for _,_,deps,_ in entries) + 1 381 382 # Write out the library table. 383 make_install_dir(os.path.dirname(output_path)) 384 f = open(output_path, 'w') 385 print >>f, """\ 386 //===- llvm-build generated file --------------------------------*- C++ -*-===// 387 // 388 // Component Library Depenedency Table 389 // 390 // Automatically generated file, do not edit! 391 // 392 //===----------------------------------------------------------------------===// 393 """ 394 print >>f, 'struct AvailableComponent {' 395 print >>f, ' /// The name of the component.' 396 print >>f, ' const char *Name;' 397 print >>f, '' 398 print >>f, ' /// The name of the library for this component (or NULL).' 399 print >>f, ' const char *Library;' 400 print >>f, '' 401 print >>f, ' /// Whether the component is installed.' 402 print >>f, ' bool IsInstalled;' 403 print >>f, '' 404 print >>f, '\ 405 /// The list of libraries required when linking this component.' 406 print >>f, ' const char *RequiredLibraries[%d];' % ( 407 max_required_libraries) 408 print >>f, '} AvailableComponents[%d] = {' % len(entries) 409 for name,library_name,required_names,is_installed in entries: 410 if library_name is None: 411 library_name_as_cstr = '0' 412 else: 413 library_name_as_cstr = '"lib%s.a"' % library_name 414 print >>f, ' { "%s", %s, %d, { %s } },' % ( 415 name, library_name_as_cstr, is_installed, 416 ', '.join('"%s"' % dep 417 for dep in required_names)) 418 print >>f, '};' 419 f.close() 420 421 def get_required_libraries_for_component(self, ci, traverse_groups = False): 422 """ 423 get_required_libraries_for_component(component_info) -> iter 424 425 Given a Library component info descriptor, return an iterator over all 426 of the directly required libraries for linking with this component. If 427 traverse_groups is True, then library and target groups will be 428 traversed to include their required libraries. 429 """ 430 431 assert ci.type_name in ('Library', 'LibraryGroup', 'TargetGroup') 432 433 for name in ci.required_libraries: 434 # Get the dependency info. 435 dep = self.component_info_map[name] 436 437 # If it is a library, yield it. 438 if dep.type_name == 'Library': 439 yield dep 440 continue 441 442 # Otherwise if it is a group, yield or traverse depending on what 443 # was requested. 444 if dep.type_name in ('LibraryGroup', 'TargetGroup'): 445 if not traverse_groups: 446 yield dep 447 continue 448 449 for res in self.get_required_libraries_for_component(dep, True): 450 yield res 451 452 def get_fragment_dependencies(self): 453 """ 454 get_fragment_dependencies() -> iter 455 456 Compute the list of files (as absolute paths) on which the output 457 fragments depend (i.e., files for which a modification should trigger a 458 rebuild of the fragment). 459 """ 460 461 # Construct a list of all the dependencies of the Makefile fragment 462 # itself. These include all the LLVMBuild files themselves, as well as 463 # all of our own sources. 464 # 465 # Many components may come from the same file, so we make sure to unique 466 # these. 467 build_paths = set() 468 for ci in self.component_infos: 469 p = os.path.join(self.source_root, ci.subpath[1:], 'LLVMBuild.txt') 470 if p not in build_paths: 471 yield p 472 build_paths.add(p) 473 474 # Gather the list of necessary sources by just finding all loaded 475 # modules that are inside the LLVM source tree. 476 for module in sys.modules.values(): 477 # Find the module path. 478 if not hasattr(module, '__file__'): 479 continue 480 path = getattr(module, '__file__') 481 if not path: 482 continue 483 484 # Strip off any compiled suffix. 485 if os.path.splitext(path)[1] in ['.pyc', '.pyo', '.pyd']: 486 path = path[:-1] 487 488 # If the path exists and is in the source tree, consider it a 489 # dependency. 490 if (path.startswith(self.source_root) and os.path.exists(path)): 491 yield path 492 493 def write_cmake_fragment(self, output_path): 494 """ 495 write_cmake_fragment(output_path) -> None 496 497 Generate a CMake fragment which includes all of the collated LLVMBuild 498 information in a format that is easily digestible by a CMake. The exact 499 contents of this are closely tied to how the CMake configuration 500 integrates LLVMBuild, see CMakeLists.txt in the top-level. 501 """ 502 503 dependencies = list(self.get_fragment_dependencies()) 504 505 # Write out the CMake fragment. 506 make_install_dir(os.path.dirname(output_path)) 507 f = open(output_path, 'w') 508 509 # Write the header. 510 header_fmt = '\ 511 #===-- %s - LLVMBuild Configuration for LLVM %s-*- CMake -*--===#' 512 header_name = os.path.basename(output_path) 513 header_pad = '-' * (80 - len(header_fmt % (header_name, ''))) 514 header_string = header_fmt % (header_name, header_pad) 515 print >>f, """\ 516 %s 517 # 518 # The LLVM Compiler Infrastructure 519 # 520 # This file is distributed under the University of Illinois Open Source 521 # License. See LICENSE.TXT for details. 522 # 523 #===------------------------------------------------------------------------===# 524 # 525 # This file contains the LLVMBuild project information in a format easily 526 # consumed by the CMake based build system. 527 # 528 # This file is autogenerated by llvm-build, do not edit! 529 # 530 #===------------------------------------------------------------------------===# 531 """ % header_string 532 533 # Write the dependency information in the best way we can. 534 print >>f, """ 535 # LLVMBuild CMake fragment dependencies. 536 # 537 # CMake has no builtin way to declare that the configuration depends on 538 # a particular file. However, a side effect of configure_file is to add 539 # said input file to CMake's internal dependency list. So, we use that 540 # and a dummy output file to communicate the dependency information to 541 # CMake. 542 # 543 # FIXME: File a CMake RFE to get a properly supported version of this 544 # feature.""" 545 for dep in dependencies: 546 print >>f, """\ 547 configure_file(\"%s\" 548 ${CMAKE_CURRENT_BINARY_DIR}/DummyConfigureOutput)""" % ( 549 cmake_quote_path(dep),) 550 551 # Write the properties we use to encode the required library dependency 552 # information in a form CMake can easily use directly. 553 print >>f, """ 554 # Explicit library dependency information. 555 # 556 # The following property assignments effectively create a map from component 557 # names to required libraries, in a way that is easily accessed from CMake.""" 558 for ci in self.ordered_component_infos: 559 # We only write the information for libraries currently. 560 if ci.type_name != 'Library': 561 continue 562 563 print >>f, """\ 564 set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_%s %s)""" % ( 565 ci.get_prefixed_library_name(), " ".join(sorted( 566 dep.get_prefixed_library_name() 567 for dep in self.get_required_libraries_for_component(ci)))) 568 569 f.close() 570 571 def write_make_fragment(self, output_path): 572 """ 573 write_make_fragment(output_path) -> None 574 575 Generate a Makefile fragment which includes all of the collated 576 LLVMBuild information in a format that is easily digestible by a 577 Makefile. The exact contents of this are closely tied to how the LLVM 578 Makefiles integrate LLVMBuild, see Makefile.rules in the top-level. 579 """ 580 581 dependencies = list(self.get_fragment_dependencies()) 582 583 # Write out the Makefile fragment. 584 make_install_dir(os.path.dirname(output_path)) 585 f = open(output_path, 'w') 586 587 # Write the header. 588 header_fmt = '\ 589 #===-- %s - LLVMBuild Configuration for LLVM %s-*- Makefile -*--===#' 590 header_name = os.path.basename(output_path) 591 header_pad = '-' * (80 - len(header_fmt % (header_name, ''))) 592 header_string = header_fmt % (header_name, header_pad) 593 print >>f, """\ 594 %s 595 # 596 # The LLVM Compiler Infrastructure 597 # 598 # This file is distributed under the University of Illinois Open Source 599 # License. See LICENSE.TXT for details. 600 # 601 #===------------------------------------------------------------------------===# 602 # 603 # This file contains the LLVMBuild project information in a format easily 604 # consumed by the Makefile based build system. 605 # 606 # This file is autogenerated by llvm-build, do not edit! 607 # 608 #===------------------------------------------------------------------------===# 609 """ % header_string 610 611 # Write the dependencies for the fragment. 612 # 613 # FIXME: Technically, we need to properly quote for Make here. 614 print >>f, """\ 615 # Clients must explicitly enable LLVMBUILD_INCLUDE_DEPENDENCIES to get 616 # these dependencies. This is a compromise to help improve the 617 # performance of recursive Make systems.""" 618 print >>f, 'ifeq ($(LLVMBUILD_INCLUDE_DEPENDENCIES),1)' 619 print >>f, "# The dependencies for this Makefile fragment itself." 620 print >>f, "%s: \\" % (mk_quote_string_for_target(output_path),) 621 for dep in dependencies: 622 print >>f, "\t%s \\" % (dep,) 623 print >>f 624 625 # Generate dummy rules for each of the dependencies, so that things 626 # continue to work correctly if any of those files are moved or removed. 627 print >>f, """\ 628 # The dummy targets to allow proper regeneration even when files are moved or 629 # removed.""" 630 for dep in dependencies: 631 print >>f, "%s:" % (mk_quote_string_for_target(dep),) 632 print >>f, 'endif' 633 634 f.close() 635 636 def add_magic_target_components(parser, project, opts): 637 """add_magic_target_components(project, opts) -> None 638 639 Add the "magic" target based components to the project, which can only be 640 determined based on the target configuration options. 641 642 This currently is responsible for populating the required_libraries list of 643 the "all-targets", "Native", "NativeCodeGen", and "Engine" components. 644 """ 645 646 # Determine the available targets. 647 available_targets = dict((ci.name,ci) 648 for ci in project.component_infos 649 if ci.type_name == 'TargetGroup') 650 651 # Find the configured native target. 652 653 # We handle a few special cases of target names here for historical 654 # reasons, as these are the names configure currently comes up with. 655 native_target_name = { 'x86' : 'X86', 656 'x86_64' : 'X86', 657 'Unknown' : None }.get(opts.native_target, 658 opts.native_target) 659 if native_target_name is None: 660 native_target = None 661 else: 662 native_target = available_targets.get(native_target_name) 663 if native_target is None: 664 parser.error("invalid native target: %r (not in project)" % ( 665 opts.native_target,)) 666 if native_target.type_name != 'TargetGroup': 667 parser.error("invalid native target: %r (not a target)" % ( 668 opts.native_target,)) 669 670 # Find the list of targets to enable. 671 if opts.enable_targets is None: 672 enable_targets = available_targets.values() 673 else: 674 # We support both space separated and semi-colon separated lists. 675 if ' ' in opts.enable_targets: 676 enable_target_names = opts.enable_targets.split() 677 else: 678 enable_target_names = opts.enable_targets.split(';') 679 680 enable_targets = [] 681 for name in enable_target_names: 682 target = available_targets.get(name) 683 if target is None: 684 parser.error("invalid target to enable: %r (not in project)" % ( 685 name,)) 686 if target.type_name != 'TargetGroup': 687 parser.error("invalid target to enable: %r (not a target)" % ( 688 name,)) 689 enable_targets.append(target) 690 691 # Find the special library groups we are going to populate. We enforce that 692 # these appear in the project (instead of just adding them) so that they at 693 # least have an explicit representation in the project LLVMBuild files (and 694 # comments explaining how they are populated). 695 def find_special_group(name): 696 info = info_map.get(name) 697 if info is None: 698 fatal("expected project to contain special %r component" % ( 699 name,)) 700 701 if info.type_name != 'LibraryGroup': 702 fatal("special component %r should be a LibraryGroup" % ( 703 name,)) 704 705 if info.required_libraries: 706 fatal("special component %r must have empty %r list" % ( 707 name, 'required_libraries')) 708 if info.add_to_library_groups: 709 fatal("special component %r must have empty %r list" % ( 710 name, 'add_to_library_groups')) 711 712 info._is_special_group = True 713 return info 714 715 info_map = dict((ci.name, ci) for ci in project.component_infos) 716 all_targets = find_special_group('all-targets') 717 native_group = find_special_group('Native') 718 native_codegen_group = find_special_group('NativeCodeGen') 719 engine_group = find_special_group('Engine') 720 721 # Set the enabled bit in all the target groups, and append to the 722 # all-targets list. 723 for ci in enable_targets: 724 all_targets.required_libraries.append(ci.name) 725 ci.enabled = True 726 727 # If we have a native target, then that defines the native and 728 # native_codegen libraries. 729 if native_target and native_target.enabled: 730 native_group.required_libraries.append(native_target.name) 731 native_codegen_group.required_libraries.append( 732 '%sCodeGen' % native_target.name) 733 734 # If we have a native target with a JIT, use that for the engine. Otherwise, 735 # use the interpreter. 736 if native_target and native_target.enabled and native_target.has_jit: 737 engine_group.required_libraries.append('JIT') 738 engine_group.required_libraries.append(native_group.name) 739 else: 740 engine_group.required_libraries.append('Interpreter') 741 742 def main(): 743 from optparse import OptionParser, OptionGroup 744 parser = OptionParser("usage: %prog [options]") 745 746 group = OptionGroup(parser, "Input Options") 747 group.add_option("", "--source-root", dest="source_root", metavar="PATH", 748 help="Path to the LLVM source (inferred if not given)", 749 action="store", default=None) 750 group.add_option("", "--llvmbuild-source-root", 751 dest="llvmbuild_source_root", 752 help=( 753 "If given, an alternate path to search for LLVMBuild.txt files"), 754 action="store", default=None, metavar="PATH") 755 group.add_option("", "--build-root", dest="build_root", metavar="PATH", 756 help="Path to the build directory (if needed) [%default]", 757 action="store", default=None) 758 parser.add_option_group(group) 759 760 group = OptionGroup(parser, "Output Options") 761 group.add_option("", "--print-tree", dest="print_tree", 762 help="Print out the project component tree [%default]", 763 action="store_true", default=False) 764 group.add_option("", "--write-llvmbuild", dest="write_llvmbuild", 765 help="Write out the LLVMBuild.txt files to PATH", 766 action="store", default=None, metavar="PATH") 767 group.add_option("", "--write-library-table", 768 dest="write_library_table", metavar="PATH", 769 help="Write the C++ library dependency table to PATH", 770 action="store", default=None) 771 group.add_option("", "--write-cmake-fragment", 772 dest="write_cmake_fragment", metavar="PATH", 773 help="Write the CMake project information to PATH", 774 action="store", default=None) 775 group.add_option("", "--write-make-fragment", 776 dest="write_make_fragment", metavar="PATH", 777 help="Write the Makefile project information to PATH", 778 action="store", default=None) 779 group.add_option("", "--configure-target-def-file", 780 dest="configure_target_def_files", 781 help="""Configure the given file at SUBPATH (relative to 782 the inferred or given source root, and with a '.in' suffix) by replacing certain 783 substitution variables with lists of targets that support certain features (for 784 example, targets with AsmPrinters) and write the result to the build root (as 785 given by --build-root) at the same SUBPATH""", 786 metavar="SUBPATH", action="append", default=None) 787 parser.add_option_group(group) 788 789 group = OptionGroup(parser, "Configuration Options") 790 group.add_option("", "--native-target", 791 dest="native_target", metavar="NAME", 792 help=("Treat the named target as the 'native' one, if " 793 "given [%default]"), 794 action="store", default=None) 795 group.add_option("", "--enable-targets", 796 dest="enable_targets", metavar="NAMES", 797 help=("Enable the given space or semi-colon separated " 798 "list of targets, or all targets if not present"), 799 action="store", default=None) 800 group.add_option("", "--enable-optional-components", 801 dest="optional_components", metavar="NAMES", 802 help=("Enable the given space or semi-colon separated " 803 "list of optional components"), 804 action="store", default=None) 805 parser.add_option_group(group) 806 807 (opts, args) = parser.parse_args() 808 809 # Determine the LLVM source path, if not given. 810 source_root = opts.source_root 811 if source_root: 812 if not os.path.exists(os.path.join(source_root, 'lib', 'IR', 813 'Function.cpp')): 814 parser.error('invalid LLVM source root: %r' % source_root) 815 else: 816 llvmbuild_path = os.path.dirname(__file__) 817 llvm_build_path = os.path.dirname(llvmbuild_path) 818 utils_path = os.path.dirname(llvm_build_path) 819 source_root = os.path.dirname(utils_path) 820 if not os.path.exists(os.path.join(source_root, 'lib', 'IR', 821 'Function.cpp')): 822 parser.error('unable to infer LLVM source root, please specify') 823 824 # Construct the LLVM project information. 825 llvmbuild_source_root = opts.llvmbuild_source_root or source_root 826 project_info = LLVMProjectInfo.load_from_path( 827 source_root, llvmbuild_source_root) 828 829 # Add the magic target based components. 830 add_magic_target_components(parser, project_info, opts) 831 832 # Validate the project component info. 833 project_info.validate_components() 834 835 # Print the component tree, if requested. 836 if opts.print_tree: 837 project_info.print_tree() 838 839 # Write out the components, if requested. This is useful for auto-upgrading 840 # the schema. 841 if opts.write_llvmbuild: 842 project_info.write_components(opts.write_llvmbuild) 843 844 # Write out the required library table, if requested. 845 if opts.write_library_table: 846 project_info.write_library_table(opts.write_library_table, 847 opts.optional_components) 848 849 # Write out the make fragment, if requested. 850 if opts.write_make_fragment: 851 project_info.write_make_fragment(opts.write_make_fragment) 852 853 # Write out the cmake fragment, if requested. 854 if opts.write_cmake_fragment: 855 project_info.write_cmake_fragment(opts.write_cmake_fragment) 856 857 # Configure target definition files, if requested. 858 if opts.configure_target_def_files: 859 # Verify we were given a build root. 860 if not opts.build_root: 861 parser.error("must specify --build-root when using " 862 "--configure-target-def-file") 863 864 # Create the substitution list. 865 available_targets = [ci for ci in project_info.component_infos 866 if ci.type_name == 'TargetGroup'] 867 substitutions = [ 868 ("@LLVM_ENUM_TARGETS@", 869 ' '.join('LLVM_TARGET(%s)' % ci.name 870 for ci in available_targets)), 871 ("@LLVM_ENUM_ASM_PRINTERS@", 872 ' '.join('LLVM_ASM_PRINTER(%s)' % ci.name 873 for ci in available_targets 874 if ci.has_asmprinter)), 875 ("@LLVM_ENUM_ASM_PARSERS@", 876 ' '.join('LLVM_ASM_PARSER(%s)' % ci.name 877 for ci in available_targets 878 if ci.has_asmparser)), 879 ("@LLVM_ENUM_DISASSEMBLERS@", 880 ' '.join('LLVM_DISASSEMBLER(%s)' % ci.name 881 for ci in available_targets 882 if ci.has_disassembler))] 883 884 # Configure the given files. 885 for subpath in opts.configure_target_def_files: 886 inpath = os.path.join(source_root, subpath + '.in') 887 outpath = os.path.join(opts.build_root, subpath) 888 result = configutil.configure_file(inpath, outpath, substitutions) 889 if not result: 890 note("configured file %r hasn't changed" % outpath) 891 892 if __name__=='__main__': 893 main() 894
