merge main into amd-staging (llvm#1694)

Author: ronlieb

.ci/compute_projects.py

@@ -52,6 +52,9 @@
     "clang": {"clang-tools-extra", "compiler-rt", "cross-project-tests"},
     "clang-tools-extra": {"libc"},
     "mlir": {"flang"},
+    # Test everything if ci scripts are changed.
+    # FIXME: Figure out what is missing and add here.
+    ".ci": {"llvm", "clang", "lld", "lldb"},
 }
 
 DEPENDENT_RUNTIMES_TO_TEST = {"clang": {"libcxx", "libcxxabi", "libunwind"}}
@@ -130,12 +133,11 @@ def _add_dependencies(projects: Set[str]) -> Set[str]:
 def _compute_projects_to_test(modified_projects: Set[str], platform: str) -> Set[str]:
     projects_to_test = set()
     for modified_project in modified_projects:
-        # Skip all projects where we cannot run tests.
-        if modified_project not in PROJECT_CHECK_TARGETS:
-            continue
         if modified_project in RUNTIMES:
             continue
-        projects_to_test.add(modified_project)
+        # Skip all projects where we cannot run tests.
+        if modified_project in PROJECT_CHECK_TARGETS:
+            projects_to_test.add(modified_project)
         if modified_project not in DEPENDENTS_TO_TEST:
             continue
         for dependent_project in DEPENDENTS_TO_TEST[modified_project]:

.ci/compute_projects_test.py

@@ -188,6 +188,19 @@ def test_exclude_gn(self):
         self.assertEqual(env_variables["runtimes_to_build"], "")
         self.assertEqual(env_variables["runtimes_check_targets"], "")
 
+     def test_ci(self):
+        env_variables = compute_projects.get_env_variables(
+            [".ci/compute_projects.py"], "Linux"
+        )
+        self.assertEqual(env_variables["projects_to_build"],
+                         "clang;lld;llvm;lldb")
+        self.assertEqual(env_variables["project_check_targets"], "check-clang
+                         check-lld check-llvm check-lldb")
+        self.assertEqual(env_variables["runtimes_to_build"],
+                         "libcxx;libcxxabi;libunwind")
+        self.assertEqual(env_variables["runtimes_check_targets"], "check-cxx
+                         check-cxxabi check-unwind")
+
 
 if __name__ == "__main__":
     unittest.main()

.ci/monolithic-linux.sh

@@ -18,7 +18,6 @@ set -o pipefail
 
 MONOREPO_ROOT="${MONOREPO_ROOT:="$(git rev-parse --show-toplevel)"}"
 BUILD_DIR="${BUILD_DIR:=${MONOREPO_ROOT}/build}"
-INSTALL_DIR="${BUILD_DIR}/install"
 rm -rf "${BUILD_DIR}"
 
 ccache --zero-stats
@@ -28,10 +27,14 @@ if [[ -n "${CLEAR_CACHE:-}" ]]; then
   ccache --clear
 fi
 
+mkdir -p artifacts/reproducers
+
+# Make sure any clang reproducers will end up as artifacts.
+export CLANG_CRASH_DIAGNOSTICS_DIR=`realpath artifacts/reproducers`
+
 function at-exit {
   retcode=$?
 
-  mkdir -p artifacts
   ccache --print-stats > artifacts/ccache_stats.txt
   cp "${BUILD_DIR}"/.ninja_log artifacts/.ninja_log
 
@@ -50,17 +53,28 @@ trap at-exit EXIT
 
 projects="${1}"
 targets="${2}"
+runtimes="${3}"
 
 lit_args="-v --xunit-xml-output ${BUILD_DIR}/test-results.xml --use-unique-output-file-name --timeout=1200 --time-tests"
 
 echo "--- cmake"
+
 export PIP_BREAK_SYSTEM_PACKAGES=1
 pip install -q -r "${MONOREPO_ROOT}"/mlir/python/requirements.txt
 pip install -q -r "${MONOREPO_ROOT}"/lldb/test/requirements.txt
 pip install -q -r "${MONOREPO_ROOT}"/.ci/requirements.txt
+
+# Set the system llvm-symbolizer as preferred.
+export LLVM_SYMBOLIZER_PATH=`which llvm-symbolizer`
+[[ ! -f "${LLVM_SYMBOLIZER_PATH}" ]] && echo "llvm-symbolizer not found!"
+
+# Set up all runtimes either way. libcxx is a dependency of LLDB.
+# If it ends up being unused, not much harm.
 cmake -S "${MONOREPO_ROOT}"/llvm -B "${BUILD_DIR}" \
       -D LLVM_ENABLE_PROJECTS="${projects}" \
+      -D LLVM_ENABLE_RUNTIMES="libcxx;libcxxabi;libunwind" \
       -G Ninja \
+      -D CMAKE_PREFIX_PATH="${HOME}/.local" \
       -D CMAKE_BUILD_TYPE=Release \
       -D LLVM_ENABLE_ASSERTIONS=ON \
       -D LLVM_BUILD_EXAMPLES=ON \
@@ -69,69 +83,47 @@ cmake -S "${MONOREPO_ROOT}"/llvm -B "${BUILD_DIR}" \
       -D LLVM_ENABLE_LLD=ON \
       -D CMAKE_CXX_FLAGS=-gmlt \
       -D LLVM_CCACHE_BUILD=ON \
+      -D LIBCXX_CXX_ABI=libcxxabi \
       -D MLIR_ENABLE_BINDINGS_PYTHON=ON \
-      -D CMAKE_INSTALL_PREFIX="${INSTALL_DIR}"
+      -D LLDB_ENABLE_PYTHON=ON \
+      -D LLDB_ENFORCE_STRICT_TEST_REQUIREMENTS=ON
 
 echo "--- ninja"
+
 # Targets are not escaped as they are passed as separate arguments.
 ninja -C "${BUILD_DIR}" -k 0 ${targets}
 
-runtimes="${3}"
 runtime_targets="${4}"
 
-# Compiling runtimes with just-built Clang and running their tests
-# as an additional testing for Clang.
+# Run runtimes tests.
+# We don't need to do a clean separate build of runtimes, because runtimes
+# will be built against just built clang, and because LIBCXX_TEST_PARAMS
+# and LIBCXXABI_TEST_PARAMS only affect lit configuration, which successfully
+# propagates without a clean build. Other that those two variables, builds
+# are supposed to be the same.
 if [[ "${runtimes}" != "" ]]; then
   if [[ "${runtime_targets}" == "" ]]; then
     echo "Runtimes to build are specified, but targets are not."
     exit 1
   fi
 
-  echo "--- ninja install-clang"
-
-  ninja -C ${BUILD_DIR} install-clang install-clang-resource-headers
-
-  RUNTIMES_BUILD_DIR="${MONOREPO_ROOT}/build-runtimes"
-  INSTALL_DIR="${BUILD_DIR}/install"
-  mkdir -p ${RUNTIMES_BUILD_DIR}
-
   echo "--- cmake runtimes C++26"
 
-  rm -rf "${RUNTIMES_BUILD_DIR}"
-  cmake -S "${MONOREPO_ROOT}/runtimes" -B "${RUNTIMES_BUILD_DIR}" -GNinja \
-      -D CMAKE_C_COMPILER="${INSTALL_DIR}/bin/clang" \
-      -D CMAKE_CXX_COMPILER="${INSTALL_DIR}/bin/clang++" \
-      -D LLVM_ENABLE_RUNTIMES="${runtimes}" \
-      -D LIBCXX_CXX_ABI=libcxxabi \
-      -D CMAKE_BUILD_TYPE=RelWithDebInfo \
-      -D CMAKE_INSTALL_PREFIX="${INSTALL_DIR}" \
+  cmake -S "${MONOREPO_ROOT}"/llvm -B "${BUILD_DIR}" \
       -D LIBCXX_TEST_PARAMS="std=c++26" \
-      -D LIBCXXABI_TEST_PARAMS="std=c++26" \
-      -D LLVM_LIT_ARGS="${lit_args}"
+      -D LIBCXXABI_TEST_PARAMS="std=c++26"
 
   echo "--- ninja runtimes C++26"
 
-  ninja -vC "${RUNTIMES_BUILD_DIR}" ${runtime_targets}
+  ninja -vC "${BUILD_DIR}" ${runtime_targets}
 
   echo "--- cmake runtimes clang modules"
 
-  # We don't need to do a clean build of runtimes, because LIBCXX_TEST_PARAMS
-  # and LIBCXXABI_TEST_PARAMS only affect lit configuration, which successfully
-  # propagates without a clean build. Other that those two variables, builds
-  # are supposed to be the same.
-
-  cmake -S "${MONOREPO_ROOT}/runtimes" -B "${RUNTIMES_BUILD_DIR}" -GNinja \
-      -D CMAKE_C_COMPILER="${INSTALL_DIR}/bin/clang" \
-      -D CMAKE_CXX_COMPILER="${INSTALL_DIR}/bin/clang++" \
-      -D LLVM_ENABLE_RUNTIMES="${runtimes}" \
-      -D LIBCXX_CXX_ABI=libcxxabi \
-      -D CMAKE_BUILD_TYPE=RelWithDebInfo \
-      -D CMAKE_INSTALL_PREFIX="${INSTALL_DIR}" \
+  cmake -S "${MONOREPO_ROOT}"/llvm -B "${BUILD_DIR}" \
       -D LIBCXX_TEST_PARAMS="enable_modules=clang" \
-      -D LIBCXXABI_TEST_PARAMS="enable_modules=clang" \
-      -D LLVM_LIT_ARGS="${lit_args}"
+      -D LIBCXXABI_TEST_PARAMS="enable_modules=clang"
 
   echo "--- ninja runtimes clang modules"
 
-  ninja -vC "${RUNTIMES_BUILD_DIR}" ${runtime_targets}
+  ninja -vC "${BUILD_DIR}" ${runtime_targets}
 fi

bolt/CMakeLists.txt

@@ -136,7 +136,7 @@ if (LLVM_INCLUDE_TESTS)
 endif()
 
 if (BOLT_ENABLE_RUNTIME)
-  message(STATUS "Building BOLT runtime libraries for X86")
+  message(STATUS "Building BOLT runtime libraries for ${CMAKE_SYSTEM_PROCESSOR}")
   set(extra_args "")
   if(CMAKE_SYSROOT)
     list(APPEND extra_args -DCMAKE_SYSROOT=${CMAKE_SYSROOT})

bolt/lib/Rewrite/RewriteInstance.cpp

@@ -597,8 +597,9 @@ Error RewriteInstance::discoverStorage() {
 
   // Hugify: Additional huge page from left side due to
   // weird ASLR mapping addresses (4KB aligned)
-  if (opts::Hugify && !BC->HasFixedLoadAddress)
+  if (opts::Hugify && !BC->HasFixedLoadAddress) {
     NextAvailableAddress += BC->PageAlign;
+  }
 
   if (!opts::UseGnuStack && !BC->IsLinuxKernel) {
     // This is where the black magic happens. Creating PHDR table in a segment
@@ -5885,17 +5886,28 @@ void RewriteInstance::rewriteFile() {
 
   // Write all allocatable sections - reloc-mode text is written here as well
   for (BinarySection &Section : BC->allocatableSections()) {
-    if (!Section.isFinalized() || !Section.getOutputData())
+    if (!Section.isFinalized() || !Section.getOutputData()) {
+      LLVM_DEBUG(if (opts::Verbosity > 1) {
+        dbgs() << "BOLT-INFO: new section is finalized or !getOutputData, skip "
+               << Section.getName() << '\n';
+      });
       continue;
-    if (Section.isLinkOnly())
+    }
+    if (Section.isLinkOnly()) {
+      LLVM_DEBUG(if (opts::Verbosity > 1) {
+        dbgs() << "BOLT-INFO: new section is link only, skip "
+               << Section.getName() << '\n';
+      });
       continue;
+    }
 
     if (opts::Verbosity >= 1)
       BC->outs() << "BOLT: writing new section " << Section.getName()
                  << "\n data at 0x"
                  << Twine::utohexstr(Section.getAllocAddress()) << "\n of size "
                  << Section.getOutputSize() << "\n at offset "
-                 << Section.getOutputFileOffset() << '\n';
+                 << Section.getOutputFileOffset() << " with content size "
+                 << Section.getOutputContents().size() << '\n';
     OS.seek(Section.getOutputFileOffset());
     Section.write(OS);
   }

bolt/runtime/common.h

@@ -151,10 +151,12 @@ struct timespec {
   uint64_t tv_nsec; /* nanoseconds */
 };
 
-#if defined(__aarch64__)
+#if defined(__aarch64__) || defined(__arm64__)
 #include "sys_aarch64.h"
-#else
+#elif defined(__x86_64__)
 #include "sys_x86_64.h"
+#else
+#error "For AArch64/ARM64 and X86_64 only."
 #endif
 
 constexpr uint32_t BufSize = 10240;

bolt/runtime/hugify.cpp

@@ -6,7 +6,8 @@
 //
 //===---------------------------------------------------------------------===//
 
-#if defined (__x86_64__) && !defined(__APPLE__)
+#if defined(__x86_64__) ||                                                     \
+    (defined(__aarch64__) || defined(__arm64__)) && !defined(__APPLE__)
 
 #include "common.h"
 
@@ -73,8 +74,10 @@ static bool hasPagecacheTHPSupport() {
   if (Res < 0)
     return false;
 
-  if (!strStr(Buf, "[always]") && !strStr(Buf, "[madvise]"))
+  if (!strStr(Buf, "[always]") && !strStr(Buf, "[madvise]")) {
+    DEBUG(report("[hugify] THP support is not enabled.\n");)
     return false;
+  }
 
   struct KernelVersionTy {
     uint32_t major;
@@ -167,12 +170,20 @@ extern "C" void __bolt_hugify_self_impl() {
 
 /// This is hooking ELF's entry, it needs to save all machine state.
 extern "C" __attribute((naked)) void __bolt_hugify_self() {
+  // clang-format off
 #if defined(__x86_64__)
   __asm__ __volatile__(SAVE_ALL "call __bolt_hugify_self_impl\n" RESTORE_ALL
-                                "jmp __bolt_hugify_start_program\n" ::
-                                    :);
+                                "jmp __bolt_hugify_start_program\n"
+                                :::);
+#elif defined(__aarch64__) || defined(__arm64__)
+  __asm__ __volatile__(SAVE_ALL "bl __bolt_hugify_self_impl\n" RESTORE_ALL
+                                "adrp x16, __bolt_hugify_start_program\n"
+                                "add x16, x16, #:lo12:__bolt_hugify_start_program\n"
+                                "br x16\n"
+                                :::);
 #else
-  exit(1);
+  __exit(1);
 #endif
+  // clang-format on
 }
 #endif

bolt/test/runtime/X86/Inputs/user_func_order.txt renamed to bolt/test/runtime/Inputs/user_func_order.txt

@@ -11,17 +11,28 @@ int main(int argc, char **argv) {
 REQUIRES: system-linux,bolt-runtime
 
 RUN: %clang %cflags -no-pie %s -o %t.nopie.exe -Wl,-q
-RUN: %clang %cflags -fpic -pie %s -o %t.pie.exe -Wl,-q
+RUN: %clang %cflags -fpic %s -o %t.pie.exe -Wl,-q
 
 RUN: llvm-bolt %t.nopie.exe --lite=0 -o %t.nopie --hugify
 RUN: llvm-bolt %t.pie.exe --lite=0 -o %t.pie --hugify
 
+RUN: llvm-nm --numeric-sort --print-armap %t.nopie | \
+RUN:   FileCheck %s -check-prefix=CHECK-NM
 RUN: %t.nopie | FileCheck %s -check-prefix=CHECK-NOPIE
 
-CHECK-NOPIE: Hello world
-
+RUN: llvm-nm --numeric-sort --print-armap %t.pie | \
+RUN:   FileCheck %s -check-prefix=CHECK-NM
 RUN: %t.pie | FileCheck %s -check-prefix=CHECK-PIE
 
+CHECK-NM:       W  __hot_start
+CHECK-NM-NEXT:  T _start
+CHECK-NM:       T main
+CHECK-NM:       W __hot_end
+CHECK-NM:       t __bolt_hugify_start_program
+CHECK-NM-NEXT:  W __bolt_runtime_start
+
+CHECK-NOPIE: Hello world
+
 CHECK-PIE: Hello world
 
 */

bolt/test/runtime/X86/hugify.c renamed to bolt/test/runtime/hugify.c

@@ -5,19 +5,15 @@
  */
 #include <stdio.h>
 
-int foo(int x) {
-  return x + 1;
-}
+int foo(int x) { return x + 1; }
 
 int fib(int x) {
   if (x < 2)
     return x;
   return fib(x - 1) + fib(x - 2);
 }
 
-int bar(int x) {
-  return x - 1;
-}
+int bar(int x) { return x - 1; }
 
 int main(int argc, char **argv) {
   printf("fib(%d) = %d\n", argc, fib(argc));
@@ -31,14 +27,28 @@ RUN: %clang %cflags -no-pie %s -o %t.exe -Wl,-q
 
 RUN: llvm-bolt %t.exe --relocs=1 --lite --reorder-functions=user \
 RUN:   --hugify --function-order=%p/Inputs/user_func_order.txt -o %t
+RUN: llvm-bolt %t.exe --relocs=1 --lite --reorder-functions=user \
+RUN:   --function-order=%p/Inputs/user_func_order.txt -o %t.nohugify
 RUN: llvm-nm --numeric-sort --print-armap %t | \
 RUN:   FileCheck %s -check-prefix=CHECK-NM
 RUN: %t 1 2 3 | FileCheck %s -check-prefix=CHECK-OUTPUT
+RUN: llvm-nm --numeric-sort --print-armap %t.nohugify | \
+RUN:   FileCheck %s -check-prefix=CHECK-NM-NOHUGIFY
+RUN: %t.nohugify 1 2 3 | FileCheck %s -check-prefix=CHECK-OUTPUT-NOHUGIFY
+
 
 CHECK-NM:      W  __hot_start
 CHECK-NM:      T main
 CHECK-NM-NEXT: T fib
 CHECK-NM-NEXT: W __hot_end
+CHECK-NM: t __bolt_hugify_start_program
+CHECK-NM-NEXT: W __bolt_runtime_start
+
+CHECK-NM-NOHUGIFY:      W  __hot_start
+CHECK-NM-NOHUGIFY:      T main
+CHECK-NM-NOHUGIFY-NEXT: T fib
+CHECK-NM-NOHUGIFY-NEXT: W __hot_end
 
 CHECK-OUTPUT: fib(4) = 3
+CHECK-OUTPUT-NOHUGIFY: fib(4) = 3
 */