clang-analyzer plugins require LLVM_ENABLE_PLUGINS also

[vtjnash]

Summary

The clang-analyzer plugins are not linked to a particular tool, so they
can only be compiled if plugins are broadly supported. We could opt
instead to decide whether to link them to specifically against clang or
with undefined symbols, depending on the value of LLVM_ENABLE_PLUGINS,
but we do not currently expect there to be a use case for that rather
niche configuration.

@simon_tatham Thanks for the clear issue text. I believe this will fix both of the configuration issues you uncovered in D119199.

[simon_tatham]

I gave this patch a test against our downstream code, and found that it doesn't stop me needing the change I suggested in D119199: in clang/tools/driver/CMakeLists.txt, I had to change

if(CLANG_PLUGIN_SUPPORT)
  export_executable_symbols_for_plugins(clang)
endif()

so that the if statement reads

if(CLANG_PLUGIN_SUPPORT OR LLVM_EXPORT_SYMBOLS_FOR_PLUGINS)

because otherwise, the clang/examples builds will still try to link against the clang executable target, which needs its symbols to have been exported.

[vtjnash]

cleanup

[vtjnash]

We are not going to start exporting plugin support if the user explicitly disabled it with CLANG_PLUGIN_SUPPORT=OFF, but why is it trying to read that directory at all, when it should be disallowed by this PR unless CLANG_PLUGIN_SUPPORT=ON

[vtjnash]

fixup

[simon_tatham]

I ran another test of this patch, by trying the cross product of the following cmake configuration choices (on a build targeting Windows, with LLVM_ENABLE_PROJECTS=clang):

• LLVM_EXPORT_SYMBOLS_FOR_PLUGINS set to each of ON and OFF
• CLANG_BUILD_EXAMPLES set to each of ON and OFF
• CLANG_PLUGIN_SUPPORT set to each of ON and OFF

3 of those 8 cases failed.

• export-symbols OFF, build-examples ON, plugin-support OFF
• export-symbols OFF, build-examples ON, plugin-support ON
• export-symbols ON, build-examples ON, plugin-support OFF (which is the configuration we're currently using downstream)

In all three cases, I saw errors such as this (suggesting that a plugin is being added to the list of things to test even though it wasn't built):

CMake Error at cmake/modules/AddLLVM.cmake:1821 (add_dependencies):
  The dependency target "AnnotateFunctions" of target "check-all" does not
  exist.
Call Stack (most recent call first):
  CMakeLists.txt:1134 (add_lit_target)

Perhaps not all of the 8 configurations in this cross product are actually sensible? But if one of them is not sensible, it would be better to get a clear error message saying why, than to have to debug things like the above.

[vtjnash]

add one more missing case to check

[vtjnash]

Okay, this should work now for those cases! Sorry, I kept thinking it was clang/examples that was broken, and missed that it was clang/test that was failing, so I failed to see what I needed to fix there too, so that we were not trying to build the tests in configurations where the functionality is disabled.

[simon_tatham]

LGTM this time. Thanks very much for the rework!

clang/CMakeLists.txt

if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
   endif()
 endif()
 
 add_definitions( -D_GNU_SOURCE )
 
 option(CLANG_BUILD_TOOLS
   "Build the Clang tools. If OFF, just generate build targets." ON)
 
+if(LLVM_ENABLE_PLUGINS OR LLVM_EXPORT_SYMBOLS_FOR_PLUGINS)
+  set(HAVE_CLANG_PLUGIN_SUPPORT ON)
+else()
+  set(HAVE_CLANG_PLUGIN_SUPPORT OFF)
+endif()
 CMAKE_DEPENDENT_OPTION(CLANG_PLUGIN_SUPPORT
   "Build clang with plugin support" ON
-  "LLVM_ENABLE_PLUGINS OR LLVM_EXPORT_SYMBOLS_FOR_PLUGINS" OFF)
+  "HAVE_CLANG_PLUGIN_SUPPORT" OFF)
 
 option(CLANG_ENABLE_ARCMT "Build ARCMT." ON)
 option(CLANG_ENABLE_STATIC_ANALYZER
   "Include static analyzer in clang binary." ON)
 
 option(CLANG_ENABLE_PROTO_FUZZER "Build Clang protobuf fuzzer." OFF)
 
 if(NOT CLANG_ENABLE_STATIC_ANALYZER AND CLANG_ENABLE_ARCMT)

clang/examples/AnnotateFunctions/CMakeLists.txt

 add_llvm_library(AnnotateFunctions MODULE AnnotateFunctions.cpp PLUGIN_TOOL clang)
 
-if(CLANG_PLUGIN_SUPPORT AND (WIN32 OR CYGWIN))
+if(WIN32 OR CYGWIN)
   set(LLVM_LINK_COMPONENTS
     Support
   )
   clang_target_link_libraries(AnnotateFunctions PRIVATE
     clangAST
     clangBasic
     clangFrontend
     clangLex
     )
 endif()

clang/examples/Attribute/CMakeLists.txt

 add_llvm_library(Attribute MODULE Attribute.cpp PLUGIN_TOOL clang)
 
-if(CLANG_PLUGIN_SUPPORT AND (WIN32 OR CYGWIN))
+if(WIN32 OR CYGWIN)
   target_link_libraries(Attribute PRIVATE
     clangAST
     clangBasic
     clangFrontend
     clangLex
     LLVMSupport
     )
 endif()

clang/examples/CMakeLists.txt

 if(NOT CLANG_BUILD_EXAMPLES)
   set_property(DIRECTORY PROPERTY EXCLUDE_FROM_ALL ON)
   set(EXCLUDE_FROM_ALL ON)
 endif()
 
+if(CLANG_PLUGIN_SUPPORT)
   add_subdirectory(PrintFunctionNames)
   add_subdirectory(AnnotateFunctions)
   add_subdirectory(Attribute)
   add_subdirectory(CallSuperAttribute)
   add_subdirectory(PluginsOrder)
+endif()

clang/examples/CallSuperAttribute/CMakeLists.txt

 add_llvm_library(CallSuperAttr MODULE CallSuperAttrInfo.cpp PLUGIN_TOOL clang)
 
-if(CLANG_PLUGIN_SUPPORT AND (WIN32 OR CYGWIN))
+if(WIN32 OR CYGWIN)
   set(LLVM_LINK_COMPONENTS
     Support
   )
   clang_target_link_libraries(CallSuperAttr PRIVATE
     clangAST
     clangBasic
     clangFrontend
     clangLex
     )
 endif()

clang/examples/PluginsOrder/CMakeLists.txt

 add_llvm_library(PluginsOrder MODULE PluginsOrder.cpp PLUGIN_TOOL clang)
 
-if(CLANG_PLUGIN_SUPPORT AND (WIN32 OR CYGWIN))
+if(WIN32 OR CYGWIN)
   set(LLVM_LINK_COMPONENTS
     Support
   )
   clang_target_link_libraries(PluginsOrder PRIVATE
     clangAST
     clangFrontend
     )
 endif()

clang/examples/PrintFunctionNames/CMakeLists.txt

 # If we don't need RTTI or EH, there's no reason to export anything
 # from the plugin.
 if( NOT MSVC ) # MSVC mangles symbols differently, and
                # PrintFunctionNames.export contains C++ symbols.
   if( NOT LLVM_REQUIRES_RTTI )
     if( NOT LLVM_REQUIRES_EH )
       set(LLVM_EXPORTED_SYMBOL_FILE ${CMAKE_CURRENT_SOURCE_DIR}/PrintFunctionNames.exports)
     endif()
   endif()
 endif()
 
 add_llvm_library(PrintFunctionNames MODULE PrintFunctionNames.cpp PLUGIN_TOOL clang)
 
-if(CLANG_PLUGIN_SUPPORT AND (WIN32 OR CYGWIN))
+if(WIN32 OR CYGWIN)
   set(LLVM_LINK_COMPONENTS
     Support
   )
   clang_target_link_libraries(PrintFunctionNames PRIVATE
     clangAST
     clangBasic
     clangFrontend
     )
 endif()

clang/lib/Analysis/plugins/CMakeLists.txt

-if(CLANG_ENABLE_STATIC_ANALYZER AND CLANG_PLUGIN_SUPPORT)
+# Since these do not specify a specific PLUGIN_TOOL (which could be clang or
+# clang-tidy), we cannot compile this unless the platform supports plugins with
+# undefined symbols, and cannot use it unless the user has opted for clang plugins).
+if(CLANG_ENABLE_STATIC_ANALYZER AND CLANG_PLUGIN_SUPPORT AND LLVM_ENABLE_PLUGINS)
   add_subdirectory(SampleAnalyzer)
   add_subdirectory(CheckerDependencyHandling)
   add_subdirectory(CheckerOptionHandling)
 endif()

clang/test/CMakeLists.txt

 
 if (CLANG_ENABLE_ARCMT)
   list(APPEND CLANG_TEST_DEPS
     arcmt-test
     c-arcmt-test
   )
 endif ()
 
-if (CLANG_BUILD_EXAMPLES)
+if(CLANG_BUILD_EXAMPLES AND CLANG_PLUGIN_SUPPORT)
   list(APPEND CLANG_TEST_DEPS
     Attribute
     AnnotateFunctions
     CallSuperAttr
     PluginsOrder
     PrintFunctionNames
     )
 endif ()
list(APPEND CLANG_TEST_DEPS
     yaml2obj
     )
 
   if(TARGET llvm-lto)
     list(APPEND CLANG_TEST_DEPS llvm-lto)
   endif()
 endif()
 
-if (CLANG_ENABLE_STATIC_ANALYZER)
-  if (CLANG_PLUGIN_SUPPORT)
+if(CLANG_ENABLE_STATIC_ANALYZER)
+  if(CLANG_PLUGIN_SUPPORT AND LLVM_ENABLE_PLUGINS) # Determine if we built them
     list(APPEND CLANG_TEST_DEPS
       SampleAnalyzerPlugin
       CheckerDependencyHandlingAnalyzerPlugin
       CheckerOptionHandlingAnalyzerPlugin
       )
   endif()
 endif()