Fix build with CMake if LLVM_USE_INTEL_JITEVENTS option is enabled.

[bader]

Summary

• Added LLVM libraries required for IntelJITEvents to LLVMBuild.txt.
• Removed 'jit' library from llvm-jitlistener.
• Added support for OptionalLibraries to llvm-build cmake files generator.

[bader]

ping

[bader]

ping #2

[• ddunbar]

The llvm-build part LGTM.

• Daniel

[bader]

In D5646#7, @ddunbar wrote:

The llvm-build part LGTM.

• Daniel

Hi Daniel,

Thanks a lot for reviewing the patch!
In addition to llvm-build part there are only two one-line fixes:

1. Removed linking llvm-jitlistener with old JIT library (which was removed - rev. 216982). This part was already reviewed by Rafael, but never landed.
2. Added LLVM libraries to the list of required dependencies for IntelJITEvents. I'm not sure that the list is exhaustive, but it's enough to pass build in our environment with LLVM_USE_INTEL_JITEVENTS option.

If you are OK with the rest of the changes, could you commit this patch for me, please?

Thanks in advance,
Alexey

[• ddunbar]

I'm not actively working on LLVM currently, please work with someone else
who is active in this area if you need the patch committed for you.

• Daniel

Closed by commit rL220848 (authored by mkuper).

lib/ExecutionEngine/IntelJITEvents/LLVMBuild.txt

 ;===------------------------------------------------------------------------===;
 
 [common]
 
 [component_0]
 type = OptionalLibrary
 name = IntelJITEvents
 parent = ExecutionEngine
+required_libraries = Core DebugInfo Support
 No newline at end of file

tools/llvm-jitlistener/CMakeLists.txt

 # This tool is excluded from the CMake build if Intel JIT events are disabled.
 
 link_directories( ${LLVM_INTEL_JITEVENTS_LIBDIR} )
 include_directories( ${LLVM_INTEL_JITEVENTS_INCDIR} )
 
 set(LLVM_LINK_COMPONENTS
   asmparser
   bitreader
   debuginfo
   inteljitevents
   interpreter
   irreader
-  jit
   mcjit
   nativecodegen
   object
   selectiondag
   )
 
 add_llvm_tool(llvm-jitlistener
   llvm-jitlistener.cpp
   )

utils/llvm-build/llvmbuild/main.py

def cmake_quote_path(value):
     value = value.replace("\\", "/")
 
     return value
 
 def mk_quote_string_for_target(value):
     """
     mk_quote_string_for_target(target_name) -> str
 
-    Return a quoted form of the given target_name suitable for including in a 
+    Return a quoted form of the given target_name suitable for including in a
     Makefile as a target name.
     """
 
     # The only quoting we currently perform is for ':', to support msys users.
     return value.replace(":", "\\:")
 
 def make_install_dir(path):
     """
def write_library_table(self, output_path, enabled_optional_components):
             # Only certain components are in the table.
             if c.type_name not in ('Library', 'OptionalLibrary', \
                                    'LibraryGroup', 'TargetGroup'):
                 continue
 
             # Compute the llvm-config "component name". For historical reasons,
             # this is lowercased based on the library name.
             llvmconfig_component_name = c.get_llvmconfig_component_name()
-            
             # Get the library name, or None for LibraryGroups.
             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
 
def get_required_libraries_for_component(self, ci, traverse_groups = False):
         get_required_libraries_for_component(component_info) -> iter
 
         Given a Library component info descriptor, return an iterator over all
         of the directly required libraries for linking with this component. If
         traverse_groups is True, then library and target groups will be
         traversed to include their required libraries.
         """
 
-        assert ci.type_name in ('Library', 'LibraryGroup', 'TargetGroup')
+        assert ci.type_name in ('Library', 'OptionalLibrary', 'LibraryGroup', 'TargetGroup')
 
         for name in ci.required_libraries:
             # Get the dependency info.
             dep = self.component_info_map[name]
 
             # If it is a library, yield it.
-            if dep.type_name == 'Library':
+            if dep.type_name == 'Library' or dep.type_name == 'OptionalLibrary':
                 yield dep
                 continue
 
             # Otherwise if it is a group, yield or traverse depending on what
             # was requested.
             if dep.type_name in ('LibraryGroup', 'TargetGroup'):
                 if not traverse_groups:
                     yield dep
def get_fragment_dependencies(self):
             if os.path.splitext(path)[1] in ['.pyc', '.pyo', '.pyd']:
                 path = path[:-1]
 
             # If the path exists and is in the source tree, consider it a
             # dependency.
             if (path.startswith(self.source_root) and os.path.exists(path)):
                 yield path
 
-    def write_cmake_fragment(self, output_path):
+    def write_cmake_fragment(self, output_path, enabled_optional_components):
         """
         write_cmake_fragment(output_path) -> None
 
         Generate a CMake fragment which includes all of the collated LLVMBuild
         information in a format that is easily digestible by a CMake. The exact
         contents of this are closely tied to how the CMake configuration
         integrates LLVMBuild, see CMakeLists.txt in the top-level.
         """
configure_file(\"%s\"
         # information in a form CMake can easily use directly.
         f.write("""
 # Explicit library dependency information.
 #
 # The following property assignments effectively create a map from component
 # names to required libraries, in a way that is easily accessed from CMake.
 """)
         for ci in self.ordered_component_infos:
-            # We only write the information for libraries currently.
-            if ci.type_name != 'Library':
+            # Skip optional components which are not enabled.
+            if ci.type_name == 'OptionalLibrary' \
+                and ci.name not in enabled_optional_components:
+                continue
+
+            # We only write the information for certain components currently.
+            if ci.type_name not in ('Library', 'OptionalLibrary'):
                 continue
 
             f.write("""\
 set_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_%s %s)\n""" % (
                 ci.get_prefixed_library_name(), " ".join(sorted(
                      dep.get_prefixed_library_name()
                      for dep in self.get_required_libraries_for_component(ci)))))
 
         f.close()
 
-    def write_cmake_exports_fragment(self, output_path):
+    def write_cmake_exports_fragment(self, output_path, enabled_optional_components):
         """
         write_cmake_exports_fragment(output_path) -> None
 
         Generate a CMake fragment which includes LLVMBuild library
         dependencies expressed similarly to how CMake would write
         them via install(EXPORT).
         """
 
         dependencies = list(self.get_fragment_dependencies())
 
         # Write out the CMake exports fragment.
         make_install_dir(os.path.dirname(output_path))
         f = open(output_path, 'w')
 
         f.write("""\
 # Explicit library dependency information.
 #
 # The following property assignments tell CMake about link
 # dependencies of libraries imported from LLVM.
 """)
         for ci in self.ordered_component_infos:
+            # Skip optional components which are not enabled.
+            if ci.type_name == 'OptionalLibrary' \
+                and ci.name not in enabled_optional_components:
+                continue
+
             # We only write the information for libraries currently.
-            if ci.type_name != 'Library':
+            if ci.type_name not in ('Library', 'OptionalLibrary'):
                 continue
 
             # Skip disabled targets.
             tg = ci.get_parent_target_group()
             if tg and not tg.enabled:
                 continue
 
             f.write("""\
if opts.write_library_table:
                                          opts.optional_components)
 
     # Write out the make fragment, if requested.
     if opts.write_make_fragment:
         project_info.write_make_fragment(opts.write_make_fragment)
 
     # Write out the cmake fragment, if requested.
     if opts.write_cmake_fragment:
-        project_info.write_cmake_fragment(opts.write_cmake_fragment)
+        project_info.write_cmake_fragment(opts.write_cmake_fragment,
+                                          opts.optional_components)
     if opts.write_cmake_exports_fragment:
-        project_info.write_cmake_exports_fragment(opts.write_cmake_exports_fragment)
+        project_info.write_cmake_exports_fragment(opts.write_cmake_exports_fragment,
+                                                  opts.optional_components)
 
     # Configure target definition files, if requested.
     if opts.configure_target_def_files:
         # Verify we were given a build root.
         if not opts.build_root:
             parser.error("must specify --build-root when using "
                          "--configure-target-def-file")