[build] Rename clang-headers to clang-resource-headers

[smeenai]

Summary

The current install-clang-headers target installs clang's resource
directory headers. This is different from the install-llvm-headers
target, which installs LLVM's API headers. We want to introduce the
corresponding target to clang, and the natural name for that new target
would be install-clang-headers. Rename the existing target to
install-clang-resource-headers to free up the install-clang-headers name
for the new target, following the discussion on cfe-dev [1].

I didn't find any bots on zorg referencing install-clang-headers. I'll
send out another PSA to cfe-dev to accompany this rename.

[1] http://lists.llvm.org/pipermail/cfe-dev/2019-February/061365.html

[phosek]

LGTM

[tstellar]

This looks good, but could you also add an entry in the ReleaseNotes for this.

[smeenai]

In D58791#1415496, @tstellar wrote:

This looks good, but could you also add an entry in the ReleaseNotes for this.

Will do – thanks for the reminder :)

[smeenai]

Release notes

[smeenai]

I added an entry to the release notes. The release notes change only covers the changes in this diff. My plan is to land this, wait for a few days (so that users of the target get broken in an obvious way), and then add the new install-clang-headers target (for installing the API headers); I'll update the release notes again as part of that change.

[smeenai]

Rebase

cfe/trunk/cmake/caches/Apple-stage2.cmake

set(LLVM_TOOLCHAIN_TOOLS
   llvm-nm
   llvm-size
   CACHE STRING "")
 
 set(LLVM_DISTRIBUTION_COMPONENTS
   clang
   LTO
   clang-format
-  clang-headers
+  clang-resource-headers
   cxx-headers
   ${LLVM_TOOLCHAIN_TOOLS}
   CACHE STRING "")
 
 # test args
 
 set(LLVM_LIT_ARGS "--xunit-xml-output=testresults.xunit.xml -v" CACHE STRING "")

cfe/trunk/cmake/caches/BaremetalARM.cmake

set(LLVM_TOOLCHAIN_TOOLS
   llvm-size
   llvm-symbolizer
   opt
   CACHE STRING "")
 
 set(LLVM_DISTRIBUTION_COMPONENTS
   clang
   lld
-  clang-headers
+  clang-resource-headers
   builtins-armv6m-none-eabi
   builtins-armv7m-none-eabi
   builtins-armv7em-none-eabi
   runtimes
   ${LLVM_TOOLCHAIN_TOOLS}
   CACHE STRING "")

cfe/trunk/cmake/caches/DistributionExample-stage2.cmake

set(LLVM_TOOLCHAIN_TOOLS
   llvm-nm
   llvm-size
   CACHE STRING "")
 
 set(LLVM_DISTRIBUTION_COMPONENTS
   clang
   LTO
   clang-format
-  clang-headers
+  clang-resource-headers
   builtins
   runtimes
   ${LLVM_TOOLCHAIN_TOOLS}
   CACHE STRING "")

cfe/trunk/cmake/caches/Fuchsia-stage2.cmake

set(LLVM_TOOLCHAIN_TOOLS
   CACHE STRING "")
 
 set(LLVM_DISTRIBUTION_COMPONENTS
   clang
   lld
   LTO
   clang-apply-replacements
   clang-format
-  clang-headers
+  clang-resource-headers
   clang-include-fixer
   clang-refactor
   clang-tidy
   clangd
   builtins
   runtimes
   ${LLVM_TOOLCHAIN_TOOLS}
   CACHE STRING "")

cfe/trunk/cmake/modules/AddClang.cmake

 endmacro(add_clang_executable)
 
 macro(add_clang_tool name)
   if (NOT CLANG_BUILD_TOOLS)
     set(EXCLUDE_FROM_ALL ON)
   endif()
 
   add_clang_executable(${name} ${ARGN})
-  add_dependencies(${name} clang-headers)
+  add_dependencies(${name} clang-resource-headers)
 
   if (CLANG_BUILD_TOOLS)
     if(${name} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
         NOT LLVM_DISTRIBUTION_COMPONENTS)
       set(export_to_clangtargets EXPORT ClangTargets)
       set_property(GLOBAL PROPERTY CLANG_HAS_EXPORTS True)
     endif()
 

cfe/trunk/docs/LibTooling.rst

 
 Builtin includes
 ^^^^^^^^^^^^^^^^
 
 Clang tools need their builtin headers and search for them the same way Clang
 does.  Thus, the default location to look for builtin headers is in a path
 ``$(dirname /path/to/tool)/../lib/clang/3.3/include`` relative to the tool
 binary.  This works out-of-the-box for tools running from llvm's toplevel
-binary directory after building clang-headers, or if the tool is running from
-the binary directory of a clang install next to the clang binary.
+binary directory after building clang-resource-headers, or if the tool is
+running from the binary directory of a clang install next to the clang binary.
 
 Tips: if your tool fails to find ``stddef.h`` or similar headers, call the tool
 with ``-v`` and look at the search paths it looks through.
 
 Linking
 ^^^^^^^
 
 For a list of libraries to link, look at one of the tools' CMake files (for
 example `clang-check/CMakeList.txt
 <https://github.com/llvm/llvm-project/blob/master/clang/tools/clang-check/CMakeLists.txt>`_).

cfe/trunk/docs/ReleaseNotes.rst

 ...
 
 ABI Changes in Clang
 --------------------
 
 - ...
 
 OpenMP Support in Clang
-----------------------------------
+-----------------------
 
 - Added emission of the debug information for NVPTX target devices.
 
 CUDA Support in Clang
 ---------------------
 
 - Added emission of the debug information for the device code.
 
 Internal API Changes
 --------------------
 
 These are major API changes that have happened since the 8.0.0 release of
 Clang. If upgrading an external codebase that uses Clang as a library,
 this section should help get you past the largest hurdles of upgrading.
 
+Build System Changes
+--------------------
+
+These are major changes to the build system that have happened since the 8.0.0
+release of Clang. Users of the build system should adjust accordingly.
+
+- In 8.0.0 and below, the install-clang-headers target would install clang's
+  resource directory headers. This installation is now performed by the
+  install-clang-resource-headers target. Users of the old install-clang-headers
+  target should switch to the new install-clang-resource-headers target.
+
 -  ...
 
 AST Matchers
 ------------
 
 - ...
 
 clang-format

cfe/trunk/examples/clang-interpreter/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   native
   )
 
 add_clang_executable(clang-interpreter
   main.cpp
   )
 
 add_dependencies(clang-interpreter
-  clang-headers
+  clang-resource-headers
   )
 
 target_link_libraries(clang-interpreter
   PRIVATE
   clangBasic
   clangCodeGen
   clangDriver
   clangFrontend

cfe/trunk/lib/Headers/CMakeLists.txt

 endforeach( f )
 
 # Generate header files and copy them to the build directory
 # Generate arm_neon.h
 clang_generate_header(-gen-arm-neon arm_neon.td arm_neon.h)
 # Generate arm_fp16.h
 clang_generate_header(-gen-arm-fp16 arm_fp16.td arm_fp16.h)
 
-add_custom_target(clang-headers ALL DEPENDS ${out_files})
-set_target_properties(clang-headers PROPERTIES
+add_custom_target(clang-resource-headers ALL DEPENDS ${out_files})
+set_target_properties(clang-resource-headers PROPERTIES
   FOLDER "Misc"
   RUNTIME_OUTPUT_DIRECTORY "${output_dir}")
 
 set(header_install_dir lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION})
 
 install(
   DIRECTORY ${output_dir}
   DESTINATION ${header_install_dir}
-  COMPONENT clang-headers)
+  COMPONENT clang-resource-headers)
 
 if (NOT LLVM_ENABLE_IDE)
-  add_llvm_install_targets(install-clang-headers
-                           DEPENDS clang-headers
-                           COMPONENT clang-headers)
+  add_llvm_install_targets(install-clang-resource-headers
+                           DEPENDS clang-resource-headers
+                           COMPONENT clang-resource-headers)
 endif()

cfe/trunk/test/CMakeLists.txt

configure_lit_site_cfg(
   )
 
 option(CLANG_TEST_USE_VG "Run Clang tests under Valgrind" OFF)
 if(CLANG_TEST_USE_VG)
   set(CLANG_TEST_EXTRA_ARGS ${CLANG_TEST_EXTRA_ARGS} "--vg")
 endif ()
 
 list(APPEND CLANG_TEST_DEPS
-  clang clang-headers
+  clang clang-resource-headers
   clang-format
   c-index-test diagtool
   clang-tblgen
   clang-offload-bundler
   clang-import-test
   clang-rename
   clang-refactor
   clang-diff

cfe/trunk/tools/driver/CMakeLists.txt

else()
   set_target_properties(clang PROPERTIES VERSION ${CLANG_EXECUTABLE_VERSION})
 endif()
 
 # Support plugins.
 if(CLANG_PLUGIN_SUPPORT)
   export_executable_symbols(clang)
 endif()
 
-add_dependencies(clang clang-headers)
+add_dependencies(clang clang-resource-headers)
 
 if(NOT CLANG_LINKS_TO_CREATE)
   set(CLANG_LINKS_TO_CREATE clang++ clang-cl clang-cpp)
 endif()
 
 foreach(link ${CLANG_LINKS_TO_CREATE})
   add_clang_symlink(${link} clang)
 endforeach()

cfe/trunk/tools/libclang/CMakeLists.txt

if(WIN32)
   set(output_name "libclang")
 else()
   set(output_name "clang")
 endif()
 
 add_clang_library(libclang ${ENABLE_SHARED} ${ENABLE_STATIC}
   OUTPUT_NAME ${output_name}
   ${SOURCES}
-  DEPENDS clang-headers
+  DEPENDS clang-resource-headers
 
   LINK_LIBS
   ${LIBS}
 
   LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   Core
   Support

clang-tools-extra/trunk/clang-tidy/tool/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmParsers
   AllTargetsDescs
   AllTargetsInfos
   support
   )
 
 add_clang_tool(clang-tidy
   ClangTidyMain.cpp
   )
 add_dependencies(clang-tidy
-  clang-headers
+  clang-resource-headers
   )
 target_link_libraries(clang-tidy
   PRIVATE
   clangAST
   clangASTMatchers
   clangBasic
   clangTidy
   clangTidyAndroidModule

clang-tools-extra/trunk/test/CMakeLists.txt

set(CLANG_TOOLS_TEST_DEPS
   pp-trace
 
   # Unit tests
   ExtraToolsUnitTests
 
   # For the clang-tidy libclang integration test.
   c-index-test
   # clang-tidy tests require it.
-  clang-headers
+  clang-resource-headers
 
   clang-tidy
 )
 
 if(CLANGD_BUILD_XPC_SUPPORT)
   list(APPEND CLANG_TOOLS_TEST_DEPS clangd-xpc-test-client)
 endif()
 

compiler-rt/trunk/test/CMakeLists.txt

 endif()
 
 # When ANDROID, we build tests with the host compiler (i.e. CMAKE_C_COMPILER),
 # and run tests with tools from the host toolchain.
 if(NOT ANDROID)
   if(NOT COMPILER_RT_STANDALONE_BUILD AND NOT RUNTIMES_BUILD)
     # Use LLVM utils and Clang from the same build tree.
     list(APPEND SANITIZER_COMMON_LIT_TEST_DEPS
-      clang clang-headers FileCheck count not llvm-config llvm-nm llvm-objdump
+      clang clang-resource-headers FileCheck count not llvm-config llvm-nm llvm-objdump
       llvm-readobj llvm-symbolizer compiler-rt-headers sancov)
     if (WIN32)
       list(APPEND SANITIZER_COMMON_LIT_TEST_DEPS KillTheDoctor)
     endif()
   endif()
   if(CMAKE_HOST_UNIX)
     list(APPEND SANITIZER_COMMON_LIT_TEST_DEPS SanitizerLintCheck)
   endif()

lldb/trunk/cmake/modules/LLDBFramework.cmake

 add_custom_command(TARGET lldb-framework-headers POST_BUILD
   COMMAND ${CMAKE_COMMAND} -E copy_directory ${lldb_header_staging} $<TARGET_FILE_DIR:liblldb>/Headers
   COMMAND ${LLDB_SOURCE_DIR}/scripts/framework-header-fix.sh $<TARGET_FILE_DIR:liblldb>/Headers ${LLDB_VERSION}
   COMMENT "LLDB.framework: copy framework headers"
 )
 
 # Copy vendor-specific headers from clang (without staging).
 if(NOT IOS AND NOT LLDB_BUILT_STANDALONE)
-  add_dependencies(lldb-framework clang-headers)
+  add_dependencies(lldb-framework clang-resource-headers)
   add_custom_command(TARGET lldb-framework POST_BUILD
     COMMAND ${CMAKE_COMMAND} -E copy_directory
-            $<TARGET_PROPERTY:clang-headers,RUNTIME_OUTPUT_DIRECTORY>
+            $<TARGET_PROPERTY:clang-resource-headers,RUNTIME_OUTPUT_DIRECTORY>
             $<TARGET_FILE_DIR:liblldb>/Resources/Clang/include
     COMMENT "LLDB.framework: copy clang vendor-specific headers"
   )
 endif()

lldb/trunk/lldb.xcodeproj/project.pbxproj

4959511A1A1ACE9500F6F8FC /* Install Clang compiler headers */ = {
       inputPaths = (
         "$(BUILT_PRODUCTS_DIR)/LLDB.framework/Resources/Clang",
       );
       name = "Install Clang compiler headers";
       outputPaths = (
       );
       runOnlyForDeploymentPostprocessing = 0;
       shellPath = /bin/sh;
-      shellScript = "/usr/bin/python $SRCROOT/scripts/Xcode/package-clang-headers.py $TARGET_BUILD_DIR $LLVM_BUILD_DIR/x86_64\n";
+      shellScript = "/usr/bin/python $SRCROOT/scripts/Xcode/package-clang-resource-headers.py $TARGET_BUILD_DIR $LLVM_BUILD_DIR/x86_64\n";
     };
     4C3326CA18B2A2B800EB5DD7 /* ShellScript */ = {
       isa = PBXShellScriptBuildPhase;
       buildActionMask = 2147483647;
       files = (
       );
       inputPaths = (
       );

lldb/trunk/scripts/Xcode/package-clang-headers.py

-#! /usr/bin/env python
-
-# package-clang-headers.py
-#
-# The Clang module loader depends on built-in headers for the Clang compiler.
-# We grab these from the Clang build and move them into the LLDB module.
-
-# TARGET_DIR is where the lldb framework/shared library gets put.
-# LLVM_BUILD_DIR is where LLVM and Clang got built
-# LLVM_BUILD_DIR/lib/clang should exist and contain headers
-
-import os
-import re
-import shutil
-import sys
-
-import lldbbuild
-
-if len(sys.argv) != 3:
-    print "usage: " + sys.argv[0] + " TARGET_DIR LLVM_BUILD_DIR"
-    sys.exit(1)
-
-target_dir = sys.argv[1]
-llvm_build_dir = lldbbuild.expected_package_build_path_for("llvm")
-
-if not os.path.isdir(target_dir):
-    print target_dir + " doesn't exist"
-    sys.exit(1)
-
-if not os.path.isdir(llvm_build_dir):
-    llvm_build_dir = re.sub("-macosx-", "-iphoneos-", llvm_build_dir)
-
-if not os.path.isdir(llvm_build_dir):
-    llvm_build_dir = re.sub("-iphoneos-", "-appletvos-", llvm_build_dir)
-
-if not os.path.isdir(llvm_build_dir):
-    llvm_build_dir = re.sub("-appletvos-", "-watchos-", llvm_build_dir)
-
-if not os.path.isdir(llvm_build_dir):
-    llvm_build_dir = re.sub("-watchos-", "-bridgeos-", llvm_build_dir)
-
-if not os.path.isdir(llvm_build_dir):
-    print llvm_build_dir + " doesn't exist"
-    sys.exit(1)
-
-resources = os.path.join(target_dir, "LLDB.framework", "Resources")
-
-if not os.path.isdir(resources):
-    print resources + " must exist"
-    sys.exit(1)
-
-clang_dir = os.path.join(llvm_build_dir, "lib", "clang")
-
-if not os.path.isdir(clang_dir):
-    print clang_dir + " must exist"
-    sys.exit(1)
-
-version_dir = None
-
-for subdir in os.listdir(clang_dir):
-    if (re.match("^[0-9]+(\.[0-9]+)*$", subdir)):
-        version_dir = os.path.join(clang_dir, subdir)
-        break
-
-if version_dir is None:
-    print "Couldn't find a subdirectory of the form #(.#)... in " + clang_dir
-    sys.exit(1)
-
-if not os.path.isdir(version_dir):
-    print version_dir + " is not a directory"
-    sys.exit(1)
-
-# Just checking... we're actually going to copy all of version_dir
-include_dir = os.path.join(version_dir, "include")
-
-if not os.path.isdir(include_dir):
-    print version_dir + " is not a directory"
-    sys.exit(1)
-
-clang_resources = os.path.join(resources, "Clang")
-
-if os.path.isdir(clang_resources):
-    shutil.rmtree(clang_resources)
-
-shutil.copytree(version_dir, clang_resources)

lldb/trunk/scripts/Xcode/package-clang-resource-headers.py

+#! /usr/bin/env python
+
+# package-clang-resource-headers.py
+#
+# The Clang module loader depends on built-in headers for the Clang compiler.
+# We grab these from the Clang build and move them into the LLDB module.
+
+# TARGET_DIR is where the lldb framework/shared library gets put.
+# LLVM_BUILD_DIR is where LLVM and Clang got built
+# LLVM_BUILD_DIR/lib/clang should exist and contain headers
+
+import os
+import re
+import shutil
+import sys
+
+import lldbbuild
+
+if len(sys.argv) != 3:
+    print "usage: " + sys.argv[0] + " TARGET_DIR LLVM_BUILD_DIR"
+    sys.exit(1)
+
+target_dir = sys.argv[1]
+llvm_build_dir = lldbbuild.expected_package_build_path_for("llvm")
+
+if not os.path.isdir(target_dir):
+    print target_dir + " doesn't exist"
+    sys.exit(1)
+
+if not os.path.isdir(llvm_build_dir):
+    llvm_build_dir = re.sub("-macosx-", "-iphoneos-", llvm_build_dir)
+
+if not os.path.isdir(llvm_build_dir):
+    llvm_build_dir = re.sub("-iphoneos-", "-appletvos-", llvm_build_dir)
+
+if not os.path.isdir(llvm_build_dir):
+    llvm_build_dir = re.sub("-appletvos-", "-watchos-", llvm_build_dir)
+
+if not os.path.isdir(llvm_build_dir):
+    llvm_build_dir = re.sub("-watchos-", "-bridgeos-", llvm_build_dir)
+
+if not os.path.isdir(llvm_build_dir):
+    print llvm_build_dir + " doesn't exist"
+    sys.exit(1)
+
+resources = os.path.join(target_dir, "LLDB.framework", "Resources")
+
+if not os.path.isdir(resources):
+    print resources + " must exist"
+    sys.exit(1)
+
+clang_dir = os.path.join(llvm_build_dir, "lib", "clang")
+
+if not os.path.isdir(clang_dir):
+    print clang_dir + " must exist"
+    sys.exit(1)
+
+version_dir = None
+
+for subdir in os.listdir(clang_dir):
+    if (re.match("^[0-9]+(\.[0-9]+)*$", subdir)):
+        version_dir = os.path.join(clang_dir, subdir)
+        break
+
+if version_dir is None:
+    print "Couldn't find a subdirectory of the form #(.#)... in " + clang_dir
+    sys.exit(1)
+
+if not os.path.isdir(version_dir):
+    print version_dir + " is not a directory"
+    sys.exit(1)
+
+# Just checking... we're actually going to copy all of version_dir
+include_dir = os.path.join(version_dir, "include")
+
+if not os.path.isdir(include_dir):
+    print version_dir + " is not a directory"
+    sys.exit(1)
+
+clang_resources = os.path.join(resources, "Clang")
+
+if os.path.isdir(clang_resources):
+    shutil.rmtree(clang_resources)
+
+shutil.copytree(version_dir, clang_resources)

lldb/trunk/source/API/CMakeLists.txt

 else()
   set_target_properties(liblldb
     PROPERTIES
     OUTPUT_NAME lldb
   )
 endif()
 
 if (NOT LLDB_BUILT_STANDALONE)
-  add_dependencies(liblldb clang-headers)
+  add_dependencies(liblldb clang-resource-headers)
 endif()
 
 if(LLDB_BUILD_FRAMEWORK)
   include(LLDBFramework)
 endif()

llvm/trunk/docs/Docker.rst

 Here's a very simple example of getting a docker image with clang binary,
 compiled by the system compiler in the debian8 image:
 
 .. code-block:: bash
 
     ./llvm/utils/docker/build_docker_image.sh \
   --source debian8 \
   --docker-repository clang-debian8 --docker-tag "staging" \
-  -p clang -i install-clang -i install-clang-headers \
+  -p clang -i install-clang -i install-clang-resource-headers \
   -- \
   -DCMAKE_BUILD_TYPE=Release
 
 Note that a build like that doesn't use a 2-stage build process that
 you probably want for clang. Running a 2-stage build is a little more intricate,
 this command will do that:
 
 .. code-block:: bash
 
     # Run a 2-stage build.
     #   LLVM_TARGETS_TO_BUILD=Native is to reduce stage1 compile time.
     #   Options, starting with BOOTSTRAP_* are passed to stage2 cmake invocation.
     ./build_docker_image.sh \
   --source debian8 \
   --docker-repository clang-debian8 --docker-tag "staging" \
-  -p clang -i stage2-install-clang -i stage2-install-clang-headers \
+  -p clang -i stage2-install-clang -i stage2-install-clang-resource-headers \
   -- \
   -DLLVM_TARGETS_TO_BUILD=Native -DCMAKE_BUILD_TYPE=Release \
   -DBOOTSTRAP_CMAKE_BUILD_TYPE=Release \
-  -DCLANG_ENABLE_BOOTSTRAP=ON -DCLANG_BOOTSTRAP_TARGETS="install-clang;install-clang-headers"
+  -DCLANG_ENABLE_BOOTSTRAP=ON -DCLANG_BOOTSTRAP_TARGETS="install-clang;install-clang-resource-headers"
   
 This will produce a new image ``clang-debian8:staging`` from the latest
 upstream revision.
 After the image is built you can run bash inside a container based on your image
 like this:
 
 .. code-block:: bash
 

 ``branches/google/stable`` branch, i.e. the following command will produce a
 debian8-based image using the latest ``google/stable`` sources for you:
 
 .. code-block:: bash
 
     ./llvm/utils/docker/build_docker_image.sh \
   -s debian8 --d clang-debian8 -t "staging" \
   --branch branches/google/stable \
-  -p clang -i install-clang -i install-clang-headers \
+  -p clang -i install-clang -i install-clang-resource-headers \
   -- \
   -DCMAKE_BUILD_TYPE=Release
 
 
 Minimizing docker image size
 ============================
 Due to how Docker's filesystem works, all intermediate writes are persisted in
 the resulting image, even if they are removed in the following commands.

llvm/trunk/runtimes/CMakeLists.txt

else() # if this is included from LLVM's CMake
 
   # If compiler-rt is present we need to build the builtin libraries first. This
   # is required because the other runtimes need the builtin libraries present
   # before the just-built compiler can pass the configuration tests.
   get_compiler_rt_path(compiler_rt_path)
   if(compiler_rt_path)
     if(NOT LLVM_BUILTIN_TARGETS)
       builtin_default_target(${compiler_rt_path}
-        DEPENDS clang-headers)
+        DEPENDS clang-resource-headers)
     else()
       if("default" IN_LIST LLVM_BUILTIN_TARGETS)
         builtin_default_target(${compiler_rt_path}
-          DEPENDS clang-headers)
+          DEPENDS clang-resource-headers)
         list(REMOVE_ITEM LLVM_BUILTIN_TARGETS "default")
       else()
         add_custom_target(builtins)
         add_custom_target(install-builtins)
         add_custom_target(install-builtins-stripped)
       endif()
 
       foreach(target ${LLVM_BUILTIN_TARGETS})
         builtin_register_target(${compiler_rt_path} ${target}
-          DEPENDS clang-headers)
+          DEPENDS clang-resource-headers)
 
         add_dependencies(builtins builtins-${target})
         add_dependencies(install-builtins install-builtins-${target})
         add_dependencies(install-builtins-stripped install-builtins-${target}-stripped)
       endforeach()
     endif()
     set(deps builtins)
     # We don't need to depend on the builtins if we're building instrumented

llvm/trunk/utils/docker/build_docker_image.sh

 
 Required options: --source and --docker-repository, at least one
   --install-target.
 
 All options after '--' are passed to CMake invocation.
 
 For example, running:
 $ build_docker_image.sh -s debian8 -d mydocker/debian8-clang -t latest \ 
-  -p clang -i install-clang -i install-clang-headers
+  -p clang -i install-clang -i install-clang-resource-headers
 will produce two docker images:
     mydocker/debian8-clang-build:latest - an intermediate image used to compile
       clang.
     mydocker/clang-debian8:latest       - a small image with preinstalled clang.
 Please note that this example produces a not very useful installation, since it
 doesn't override CMake defaults, which produces a Debug and non-boostrapped
 version of clang.
 
 To get a 2-stage clang build, you could use this command:
 $ ./build_docker_image.sh -s debian8 -d mydocker/clang-debian8 -t "latest" \ 
-    -p clang -i stage2-install-clang -i stage2-install-clang-headers \ 
+    -p clang -i stage2-install-clang -i stage2-install-clang-resource-headers \ 
     -- \ 
     -DLLVM_TARGETS_TO_BUILD=Native -DCMAKE_BUILD_TYPE=Release \ 
     -DBOOTSTRAP_CMAKE_BUILD_TYPE=Release \ 
     -DCLANG_ENABLE_BOOTSTRAP=ON \ 
-    -DCLANG_BOOTSTRAP_TARGETS="install-clang;install-clang-headers"
+    -DCLANG_BOOTSTRAP_TARGETS="install-clang;install-clang-resource-headers"
 EOF
 }
 
 CHECKSUMS_FILE=""
 SEEN_INSTALL_TARGET=0
 SEEN_CMAKE_ARGS=0
 while [[ $# -gt 0 ]]; do
   case "$1" in

openmp/trunk/cmake/OpenMPTesting.cmake

add_custom_target(${target}
       COMMENT ${comment}
       DEPENDS ${ARG_DEPENDS}
       ${cmake_3_2_USES_TERMINAL}
     )
   else()
     add_lit_testsuite(${target}
       ${comment}
       ${ARG_UNPARSED_ARGUMENTS}
-      DEPENDS clang clang-headers FileCheck ${ARG_DEPENDS}
+      DEPENDS clang clang-resource-headers FileCheck ${ARG_DEPENDS}
       ARGS ${ARG_ARGS}
     )
   endif()
 endfunction()
 
 function(construct_check_openmp_target)
   get_property(OPENMP_LIT_TESTSUITES GLOBAL PROPERTY OPENMP_LIT_TESTSUITES)
   get_property(OPENMP_LIT_DEPENDS GLOBAL PROPERTY OPENMP_LIT_DEPENDS)
 
   # We already added the testsuites themselves, no need to do that again.
   set(EXCLUDE_FROM_ALL True)
   add_openmp_testsuite(check-openmp "Running OpenMP tests" ${OPENMP_LIT_TESTSUITES} DEPENDS ${OPENMP_LIT_DEPENDS})
 endfunction()