"${LLVM_BINARY_DIR}/tools/llvm-config/LibraryDependencies.inc")
set(LLVMBUILDCMAKEFRAG
"${LLVM_BINARY_DIR}/LLVMBuild.cmake")
+
+# Create the list of optional components that are enabled
+if (LLVM_USE_INTEL_JITEVENTS)
+ set(LLVMOPTIONALCOMPONENTS IntelJITEvents)
+endif (LLVM_USE_INTEL_JITEVENTS)
+if (LLVM_USE_OPROFILE)
+ set(LLVMOPTIONALCOMPONENTS ${LLVMOPTIONALCOMPONENTS} OProfileJIT)
+endif (LLVM_USE_OPROFILE)
+
message(STATUS "Constructing LLVMBuild project information")
execute_process(
COMMAND ${PYTHON_EXECUTABLE} ${LLVMBUILDTOOL}
--native-target "${LLVM_NATIVE_ARCH}"
--enable-targets "${LLVM_TARGETS_TO_BUILD}"
+ --enable-optional-components "${LLVMOPTIONALCOMPONENTS}"
--write-library-table ${LLVMCONFIGLIBRARYDEPENDENCIESINC}
--write-cmake-fragment ${LLVMBUILDCMAKEFRAG}
ERROR_VARIABLE LLVMBUILDOUTPUT
# Flags to control building support for OProfile JIT API
USE_OPROFILE := @USE_OPROFILE@
+
+ifeq ($(USE_INTEL_JITEVENTS), 1)
+ OPTIONAL_COMPONENTS += IntelJITEvents
+endif
+ifeq ($(USE_OPROFILE), 1)
+ OPTIONAL_COMPONENTS += OProfileJIT
+endif
$(Verb) $(LLVMBuildTool) \
--native-target "$(TARGET_NATIVE_ARCH)" \
--enable-targets "$(TARGETS_TO_BUILD)" \
+ --enable-optional-components "$(OPTIONAL_COMPONENTS)" \
--write-library-table $(LLVMConfigLibraryDependenciesInc) \
--write-make-fragment $(LLVMBuildMakeFrag)
components. For example, the <i>X86</i> target might define a library
group for all of the <i>X86</i> components. That library group might
then be included in the <i>all-targets</i> library group.</p></li>
+
+ <li><i>installed</i> <b>[optional]</b> <b>[boolean]</b>
+ <p>Whether this library is installed. Libraries that are not installed
+ are only reported by <tt>llvm-config</tt> when it is run as part of a
+ development directory.</p></li>
</ul>
</li>
[common]
[component_0]
-type = Library
+type = OptionalLibrary
name = IntelJITEvents
parent = ExecutionEngine
[common]
[component_0]
-type = Library
+type = OptionalLibrary
name = OProfileJIT
parent = ExecutionEngine
static void VisitComponent(StringRef Name,
const StringMap<AvailableComponent*> &ComponentMap,
std::set<AvailableComponent*> &VisitedComponents,
- std::vector<StringRef> &RequiredLibs) {
+ std::vector<StringRef> &RequiredLibs,
+ bool IncludeNonInstalled) {
// Lookup the component.
AvailableComponent *AC = ComponentMap.lookup(Name);
assert(AC && "Invalid component name!");
return;
}
+ // Only include non-installed components if requested.
+ if (!AC->IsInstalled && !IncludeNonInstalled)
+ return;
+
// Otherwise, visit all the dependencies.
for (unsigned i = 0; AC->RequiredLibraries[i]; ++i) {
VisitComponent(AC->RequiredLibraries[i], ComponentMap, VisitedComponents,
- RequiredLibs);
+ RequiredLibs, IncludeNonInstalled);
}
// Add to the required library list.
/// \param Components - The names of the components to find libraries for.
/// \param RequiredLibs [out] - On return, the ordered list of libraries that
/// are required to link the given components.
+/// \param IncludeNonInstalled - Whether non-installed components should be
+/// reported.
void ComputeLibsForComponents(const std::vector<StringRef> &Components,
- std::vector<StringRef> &RequiredLibs) {
+ std::vector<StringRef> &RequiredLibs,
+ bool IncludeNonInstalled) {
std::set<AvailableComponent*> VisitedComponents;
// Build a map of component names to information.
}
VisitComponent(ComponentLower, ComponentMap, VisitedComponents,
- RequiredLibs);
+ RequiredLibs, IncludeNonInstalled);
}
// The list is now ordered with leafs first, we want the libraries to printed
PrintLibFiles = true;
} else if (Arg == "--components") {
for (unsigned j = 0; j != array_lengthof(AvailableComponents); ++j) {
+ // Only include non-installed components when in a development tree.
+ if (!AvailableComponents[j].IsInstalled && !IsInDevelopmentTree)
+ continue;
+
OS << ' ';
OS << AvailableComponents[j].Name;
}
// Construct the list of all the required libraries.
std::vector<StringRef> RequiredLibs;
- ComputeLibsForComponents(Components, RequiredLibs);
+ ComputeLibsForComponents(Components, RequiredLibs,
+ /*IncludeNonInstalled=*/IsInDevelopmentTree);
for (unsigned i = 0, e = RequiredLibs.size(); i != e; ++i) {
StringRef Lib = RequiredLibs[i];
def get_llvmbuild_fragment(self):
abstract
+ def get_parent_target_group(self):
+ """get_parent_target_group() -> ComponentInfo or None
+
+ Return the nearest parent target group (if any), or None if the
+ component is not part of any target group.
+ """
+
+ # If this is a target group, return it.
+ if self.type_name == 'TargetGroup':
+ return self
+
+ # Otherwise recurse on the parent, if any.
+ if self.parent_instance:
+ return self.parent_instance.get_parent_target_group()
+
class GroupComponentInfo(ComponentInfo):
"""
Group components have no semantics as far as the build system are concerned,
type_name = 'Library'
@staticmethod
- def parse(subpath, items):
+ def parse_items(items):
kwargs = ComponentInfo.parse_items(items)
kwargs['library_name'] = items.get_optional_string('library_name')
kwargs['required_libraries'] = items.get_list('required_libraries')
kwargs['add_to_library_groups'] = items.get_list(
'add_to_library_groups')
+ kwargs['installed'] = items.get_optional_bool('installed', True)
+ return kwargs
+
+ @staticmethod
+ def parse(subpath, items):
+ kwargs = LibraryComponentInfo.parse_items(items)
return LibraryComponentInfo(subpath, **kwargs)
def __init__(self, subpath, name, dependencies, parent, library_name,
- required_libraries, add_to_library_groups):
+ required_libraries, add_to_library_groups, installed):
ComponentInfo.__init__(self, subpath, name, dependencies, parent)
# If given, the name to use for the library instead of deriving it from
# considered part of.
self.add_to_library_groups = list(add_to_library_groups)
+ # Whether or not this library is installed.
+ self.installed = installed
+
def get_component_references(self):
for r in ComponentInfo.get_component_references(self):
yield r
if self.add_to_library_groups:
print >>result, 'add_to_library_groups = %s' % ' '.join(
self.add_to_library_groups)
+ if not self.installed:
+ print >>result, 'installed = 0'
return result.getvalue()
def get_library_name(self):
def get_llvmconfig_component_name(self):
return self.get_library_name().lower()
+class OptionalLibraryComponentInfo(LibraryComponentInfo):
+ type_name = "OptionalLibrary"
+
+ @staticmethod
+ def parse(subpath, items):
+ kwargs = LibraryComponentInfo.parse_items(items)
+ return OptionalLibraryComponentInfo(subpath, **kwargs)
+
+ def __init__(self, subpath, name, dependencies, parent, library_name,
+ required_libraries, add_to_library_groups, installed):
+ LibraryComponentInfo.__init__(self, subpath, name, dependencies, parent,
+ library_name, required_libraries,
+ add_to_library_groups, installed)
+
class LibraryGroupComponentInfo(ComponentInfo):
type_name = 'LibraryGroup'
for t in (GroupComponentInfo,
LibraryComponentInfo, LibraryGroupComponentInfo,
ToolComponentInfo, BuildToolComponentInfo,
- TargetGroupComponentInfo))
+ TargetGroupComponentInfo, OptionalLibraryComponentInfo))
def load_from_path(path, subpath):
# Load the LLVMBuild.txt file as an .ini format file.
parser = ConfigParser.RawConfigParser()
f.close()
- def write_library_table(self, output_path):
+ def write_library_table(self, output_path, enabled_optional_components):
# Write out the mapping from component names to required libraries.
#
# We do this in topological order so that we know we can append the
# dependencies for added library groups.
entries = {}
for c in self.ordered_component_infos:
+ # Skip optional components which are not enabled.
+ if c.type_name == 'OptionalLibrary' \
+ and c.name not in enabled_optional_components:
+ continue
+
+ # Skip target groups which are not enabled.
+ tg = c.get_parent_target_group()
+ if tg and not tg.enabled:
+ continue
+
# Only certain components are in the table.
- if c.type_name not in ('Library', 'LibraryGroup', 'TargetGroup'):
+ if c.type_name not in ('Library', 'OptionalLibrary', \
+ 'LibraryGroup', 'TargetGroup'):
continue
# Compute the llvm-config "component name". For historical reasons,
llvmconfig_component_name = c.get_llvmconfig_component_name()
# Get the library name, or None for LibraryGroups.
- if c.type_name == 'Library':
+ if c.type_name == 'Library' or c.type_name == 'OptionalLibrary':
library_name = c.get_prefixed_library_name()
+ is_installed = c.installed
else:
library_name = None
+ is_installed = True
# Get the component names of all the required libraries.
required_llvmconfig_component_names = [
# Add the entry.
entries[c.name] = (llvmconfig_component_name, library_name,
- required_llvmconfig_component_names)
+ required_llvmconfig_component_names,
+ is_installed)
# Convert to a list of entries and sort by name.
entries = entries.values()
# Create an 'all' pseudo component. We keep the dependency list small by
# only listing entries that have no other dependents.
root_entries = set(e[0] for e in entries)
- for _,_,deps in entries:
+ for _,_,deps,_ in entries:
root_entries -= set(deps)
- entries.append(('all', None, root_entries))
+ entries.append(('all', None, root_entries, True))
entries.sort()
# Compute the maximum number of required libraries, plus one so there is
# always a sentinel.
max_required_libraries = max(len(deps)
- for _,_,deps in entries) + 1
+ for _,_,deps,_ in entries) + 1
# Write out the library table.
make_install_dir(os.path.dirname(output_path))
print >>f, ' /// The name of the library for this component (or NULL).'
print >>f, ' const char *Library;'
print >>f, ''
+ print >>f, ' /// Whether the component is installed.'
+ print >>f, ' bool IsInstalled;'
+ print >>f, ''
print >>f, '\
/// The list of libraries required when linking this component.'
print >>f, ' const char *RequiredLibraries[%d];' % (
max_required_libraries)
print >>f, '} AvailableComponents[%d] = {' % len(entries)
- for name,library_name,required_names in entries:
+ for name,library_name,required_names,is_installed in entries:
if library_name is None:
library_name_as_cstr = '0'
else:
library_name_as_cstr = '"lib%s.a"' % library_name
- print >>f, ' { "%s", %s, { %s } },' % (
- name, library_name_as_cstr,
+ print >>f, ' { "%s", %s, %d, { %s } },' % (
+ name, library_name_as_cstr, is_installed,
', '.join('"%s"' % dep
for dep in required_names))
print >>f, '};'
help=("Enable the given space or semi-colon separated "
"list of targets, or all targets if not present"),
action="store", default=None)
+ group.add_option("", "--enable-optional-components",
+ dest="optional_components", metavar="NAMES",
+ help=("Enable the given space or semi-colon separated "
+ "list of optional components"),
+ action="store", default=None)
parser.add_option_group(group)
(opts, args) = parser.parse_args()
# Write out the required library table, if requested.
if opts.write_library_table:
- project_info.write_library_table(opts.write_library_table)
+ project_info.write_library_table(opts.write_library_table,
+ opts.optional_components)
# Write out the make fragment, if requested.
if opts.write_make_fragment:
name = gtest
parent = Libraries
required_libraries = Support
+installed = 0
[component_1]
type = Library
name = gtest_main
parent = Libraries
required_libraries = gtest
+installed = 0
projects / llvm / commitdiff