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