Implement the CI in GitHub Actions

.github/workflows/built_test.yml

@@ -0,0 +1,156 @@
+# Documentation: https://wiki.unvanquished.net/wiki/Continuous_integration
+
+name: Build
+
+on:
+  push:
+    branches:
+      - master
+      - 'for-*.*.*/sync' # Next-release branch
+  pull_request:
+    branches:
+      - '**'
+    paths:
+      - '.github/workflows/build_test.yml'
+      - '.gitmodules'
+      # 'android/**'
+      - 'autotools/**'
+      - 'compat/**'
+      - configure.ac
+      - DEPS
+      - fetch-externals
+      - 'm4/**'
+      - Makefile.am
+      - 'src/**'
+      - 'test/**'
+      - 'wine/**'
+
+jobs:
+  build:
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.vm_image }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Linux amd64 GCC
+            vm_image: ubuntu-22.04
+            apt_packages: g++-12 libcurl4-openssl-dev
+            env_commands: export CC=gcc-12 CXX=g++-12
+          - name: Linux i686 GCC
+            # This platform reliably caught in CI the random thread-related
+			# bug src/client/linux/linux_client_unittest, making it possible
+			# to track down and debug it. It also catches more pointer type
+			# mismatches, thanks to the different sizes. In the end it helps
+			# improving robustness.
+            vm_image: ubuntu-22.04
+            apt_architecture: i386
+            apt_packages: g++-i686-linux-gnu libcurl4-openssl-dev:i386 zlib1g-dev:i386
+            env_commands: export CC=i686-linux-gnu-gcc CXX=i686-linux-gnu-g++
+          - name: Linux arm64 GCC
+            vm_image: ubuntu-22.04-arm
+            apt_packages: g++-12 libcurl4-openssl-dev binutils-x86-64-linux-gnu
+            env_commands: export CC=gcc-12 CXX=g++-12
+          - name: Linux amd64 Clang
+            vm_image: ubuntu-22.04
+            apt_packages: clang libcurl4-openssl-dev
+            env_commands: export CC=clang CXX=clang++
+          - name: Windows amd64 MinGW
+            vm_image: ubuntu-26.04
+            apt_packages: g++-mingw-w64-x86-64 mingw-w64-x86-64-dev gcc-mingw-w64-x86-64-posix-runtime wine libcurl4-openssl-dev libz-mingw-w64-dev
+            setup_commands: sudo update-alternatives --set x86_64-w64-mingw32-g++ /usr/bin/x86_64-w64-mingw32-g++-posix
+            env_commands: export TESTDRIVER_SHARED_TEMP_WINEPREFIX=true
+            configure_options: --host=x86_64-w64-mingw32 --enable-static-mingw
+          - name: Windows arm64 MinGW
+            vm_image: windows-11-arm
+            shell: msys2 {0}
+            msystem: CLANGARM64
+            pacman_packages: base-devel mingw-w64-clang-aarch64-clang mingw-w64-clang-aarch64-gcc-compat autoconf automake libtool
+            env_commands: export CC=aarch64-w64-mingw32-gcc CXX=aarch64-w64-mingw32-g++
+            configure_options: --host=aarch64-w64-mingw32 --enable-static-mingw
+          - name: macOS amd64 AppleClang
+            vm_image: macos-15-intel
+            brew_packages: autoconf automake libtool
+            nproc_command: sysctl -n hw.logicalcpu
+          - name: macOS arm64 AppleClang
+            vm_image: macos-15
+            brew_packages: autoconf automake libtool
+            nproc_command: sysctl -n hw.logicalcpu
+
+    env:
+      APT_ARCHITECTURE: ${{ matrix.apt_architecture }}
+      APT_PACKAGES: ${{ matrix.apt_packages }}
+      BREW_PACKAGES: ${{ matrix.brew_packages }}
+      SETUP_COMMANDS: ${{ matrix.setup_commands }}
+      ENV_COMMANDS: ${{ matrix.env_commands }}
+      NPROC_COMMAND: ${{ matrix.nproc_command }}
+      CONFIGURE_OPTIONS: ${{ matrix.configure_options }}
+
+    defaults:
+      run:
+        shell: ${{ matrix.shell || 'bash' }}
+
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Checkout dependencies
+        # This doesn't require the MSYS2 shell, so we can run this before the MSYS2 setup,
+        # and we don't have to install fetch-externals' dependencies in MSYS2 environment
+        # like python and git which are already provided in the default Git bash environment.
+        shell: bash
+        run: |
+          # To fetch googletest.
+          ./fetch-externals
+
+      - name: Setup MSYS2 packages
+        if: ${{ matrix.pacman_packages != '' }}
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: ${{ matrix.msystem }}
+          install: ${{ matrix.pacman_packages }}
+          update: true
+
+      - name: Setup Apt architecture
+        if: ${{ matrix.apt_architecture != '' }}
+        run: |
+          set -xue
+          sudo dpkg --add-architecture "${APT_ARCHITECTURE}"
+
+      - name: Setup Apt packages
+        if: ${{ matrix.apt_packages != '' }}
+        run: |
+          set -xue
+          sudo apt-get update && sudo apt-get -y -q --no-install-recommends install ${APT_PACKAGES}
+
+      - name: Setup Brew packages
+        if: ${{ matrix.brew_packages != '' }}
+        run: |
+          set -xue
+          brew update && brew install ${BREW_PACKAGES}
+
+      - name: Setup commands
+        if: ${{ matrix.setup_commands != '' }}
+        run: |
+          set -xue
+          ${SETUP_COMMANDS}
+
+      - name: Build
+        run: |
+          set -xue
+          ${ENV_COMMANDS}
+          parallelism="$(${NPROC_COMMAND:-nproc})"
+          echo "Build parallelism: ${parallelism}"
+          autoreconf -fvi
+          ./configure ${CONFIGURE_OPTIONS}
+          make "-j${parallelism}"
+
+      - name: Test
+        run: |
+          set -xue
+          ${ENV_COMMANDS}
+          parallelism="$(${NPROC_COMMAND:-nproc})"
+          if ! make "-j${parallelism}" check; then
+            [ ! -f test-suite.log ] || cat test-suite.log
+            false
+          fi

DEPS

@@ -45,7 +45,7 @@ deps = {
       "@6910c9d9165801d8827d628cb72eb7ea9dd538c5",
 
   # Linux syscall support.
-  "src/src/third_party/lss":
-    "https://chromium.googlesource.com/linux-syscall-support/" +
-      "@29164a80da4d41134950d76d55199ea33fbb9613",
+  #"src/src/third_party/lss":
+  #  "https://chromium.googlesource.com/linux-syscall-support/" +
+  #    "@29164a80da4d41134950d76d55199ea33fbb9613",
 }

Makefile.am

@@ -258,6 +258,21 @@ check_SCRIPTS = \
 	src/processor/minidump_stackwalk_test \
 	src/processor/minidump_stackwalk_machine_readable_test
 
+## dump_syms tests
+check_DEPS = \
+	src/tools/linux/dump_syms/dump_syms \
+	src/tools/windows/dump_syms_dwarf/dump_syms_dwarf
+
+check_SCRIPTS = \
+	src/tools/linux/dump_syms/dump_syms_test \
+	src/tools/windows/dump_syms_dwarf/dump_syms_dwarf_test
+
+check_DEPS += \
+	src/tools/mac/dump_syms/dump_syms_mac
+
+check_SCRIPTS += \
+	src/tools/mac/dump_syms/dump_syms_mac_test
+
 endif !DISABLE_PROCESSOR
 
 
@@ -305,16 +320,19 @@ check_PROGRAMS += \
 #	src/tools/linux/symupload/minidump_upload \
 #	src/tools/linux/symupload/sym_upload
 
+bin_PROGRAMS += \
+	src/tools/mac/dump_syms/dump_syms_mac
+
+check_PROGRAMS += \
+	src/common/mac/macho_reader_unittest
+
 if LINUX_HOST
 
 bin_PROGRAMS += \
 	src/tools/linux/core2md/core2md \
 	src/tools/linux/pid2md/pid2md \
 	src/tools/linux/md2core/minidump-2-core
 
-bin_PROGRAMS += \
-	src/tools/mac/dump_syms/dump_syms_mac
-
 if HAVE_MEMFD_CREATE
 libexec_PROGRAMS += \
 	src/tools/linux/core_handler/core_handler
@@ -323,9 +341,6 @@ endif
 check_PROGRAMS += \
 	src/tools/linux/md2core/minidump_2_core_unittest
 
-check_PROGRAMS += \
-	src/common/mac/macho_reader_unittest
-
 endif LINUX_HOST
 
 endif !DISABLE_TOOLS
@@ -781,8 +796,12 @@ src_tools_mac_dump_syms_dump_syms_mac_SOURCES = \
 	src/common/mac/macho_walker.cc \
 	src/common/mac/macho_walker.h \
 	src/tools/mac/dump_syms/dump_syms_tool.cc
-src_tools_mac_dump_syms_dump_syms_mac_CXXFLAGS= \
-	-I$(top_srcdir)/src/third_party/mac_headers \
+src_tools_mac_dump_syms_dump_syms_mac_CXXFLAGS =
+if !MACOS_BUILD
+src_tools_mac_dump_syms_dump_syms_mac_CXXFLAGS += \
+	-I$(top_srcdir)/src/third_party/mac_headers
+endif
+src_tools_mac_dump_syms_dump_syms_mac_CXXFLAGS += \
 	$(RUSTC_DEMANGLE_CFLAGS) \
 	-DHAVE_MACH_O_NLIST_H
 src_tools_mac_dump_syms_dump_syms_mac_LDADD= \
@@ -905,8 +924,12 @@ src_common_mac_macho_reader_unittest_SOURCES = \
 	src/common/mac/macho_walker.cc \
 	src/common/tests/file_utils.cc
 src_common_mac_macho_reader_unittest_CPPFLAGS = \
-	$(AM_CPPFLAGS) $(TEST_CFLAGS) \
-	-I$(top_srcdir)/src/third_party/mac_headers \
+	$(AM_CPPFLAGS) $(TEST_CFLAGS)
+if !MACOS_BUILD
+src_common_mac_macho_reader_unittest_CPPFLAGS += \
+	-I$(top_srcdir)/src/third_party/mac_headers
+endif
+src_common_mac_macho_reader_unittest_CPPFLAGS += \
 	-DHAVE_MACH_O_NLIST_H \
 	$(PTHREAD_CFLAGS)
 src_common_mac_macho_reader_unittest_LDADD = \

configure.ac

@@ -142,20 +142,17 @@ esac
 AM_CONDITIONAL(ANDROID_HOST, test x$ANDROID_HOST = xtrue)
 
 case $build_os in
+  darwin*)
+    MACOS_BUILD=true
+    ;;
   mingw* | msys* | cygwin*)
     WINDOWS_BUILD=true
     ;;
 esac
 
-AM_CONDITIONAL(WINE_HOST, test x$WINDOWS_HOST = xtrue -a x$WINDOWS_BUILD != xtrue)
+AM_CONDITIONAL(MACOS_BUILD, test x$MACOS_BUILD = xtrue)
 
-# Some tools (like mac ones) only support x86 currently.
-case $host_cpu in
-  i?86|x86_64)
-    X86_HOST=true
-    ;;
-esac
-AM_CONDITIONAL(X86_HOST, test x$X86_HOST = xtrue)
+AM_CONDITIONAL(WINE_HOST, test x$WINDOWS_HOST = xtrue -a x$WINDOWS_BUILD != xtrue)
 
 AC_ARG_ENABLE(processor,
               AS_HELP_STRING([--disable-processor],

src/client/linux/minidump_writer/minidump_writer_unittest.cc

@@ -270,12 +270,44 @@ TEST(MinidumpWriterTest, MinidumpStacksSkippedIfRequested) {
     // current executable). This thread should not be captured in the minidump.
     pthread_t thread;
     pthread_attr_t thread_attributes;
-    pthread_attr_init(&thread_attributes);
-    pthread_attr_setdetachstate(&thread_attributes, PTHREAD_CREATE_DETACHED);
+    if (pthread_attr_init(&thread_attributes) != 0) {
+      syscall(__NR_exit_group, 1);
+    }
+    if (pthread_attr_setdetachstate(
+            &thread_attributes, PTHREAD_CREATE_DETACHED) != 0) {
+      pthread_attr_destroy(&thread_attributes);
+      syscall(__NR_exit_group, 1);
+    }
+
+    const size_t stack_size = 1024 * 1024;
+    void* thread_stack = mmap(nullptr, stack_size,
+                              PROT_READ | PROT_WRITE,
+                              MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK,
+                              -1, 0);
+    if (thread_stack == MAP_FAILED) {
+      pthread_attr_destroy(&thread_attributes);
+      syscall(__NR_exit_group, 1);
+    }
+    memset(thread_stack, 0, stack_size);
+
+    if (pthread_attr_setstack(
+            &thread_attributes, thread_stack, stack_size) != 0) {
+      munmap(thread_stack, stack_size);
+      pthread_attr_destroy(&thread_attributes);
+      syscall(__NR_exit_group, 1);
+    }
+
     sigset_t sigset;
     sigemptyset(&sigset);
-    pthread_create(&thread, &thread_attributes,
-                   reinterpret_cast<void* (*)(void*)>(&sigsuspend), &sigset);
+    const int create_result =
+        pthread_create(&thread, &thread_attributes,
+                       reinterpret_cast<void* (*)(void*)>(&sigsuspend),
+                       &sigset);
+    pthread_attr_destroy(&thread_attributes);
+    if (create_result != 0) {
+      munmap(thread_stack, stack_size);
+      syscall(__NR_exit_group, 1);
+    }
 
     char b;
     IGNORE_RET(HANDLE_EINTR(read(fds[0], &b, sizeof(b))));

src/common/mac/byteswap.h

@@ -35,6 +35,8 @@
 #ifndef COMMON_MAC_BYTESWAP_H_
 #define COMMON_MAC_BYTESWAP_H_
 
+#include "compat/linux.h"
+
 #ifdef __APPLE__
 #include <libkern/OSByteOrder.h>
 
@@ -45,12 +47,19 @@ static inline int16_t  ByteSwap(int16_t  v) { return OSSwapInt16(v); }
 static inline int32_t  ByteSwap(int32_t  v) { return OSSwapInt32(v); }
 static inline int64_t  ByteSwap(int64_t  v) { return OSSwapInt64(v); }
 
-#elif defined(__linux__)
+#else
 // For NXByteOrder
 #include <architecture/byte_order.h>
 #include <stdint.h>
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#include <stdlib.h>
+#define bswap_16(x) __builtin_bswap16(x)
+#define bswap_32(x) __builtin_bswap32(x)
+#define bswap_64(x) __builtin_bswap64(x)
+#else
 #include <endian.h>
 #include_next <byteswap.h>
+#endif
 
 static inline uint16_t ByteSwap(uint16_t v) { return bswap_16(v); }
 static inline uint32_t ByteSwap(uint32_t v) { return bswap_32(v); }

src/common/memory_allocator.h

@@ -76,7 +76,8 @@ class PageAllocator {
   template <typename T>
   static T AlignUp(T offset, size_t alignment) {
     assert(alignment > 0 && ((alignment - 1) & alignment) == 0);
-    return (offset + (alignment - 1)) & ~(alignment - 1);
+    const T mask = static_cast<T>(alignment - 1);
+    return (offset + mask) & ~mask;
   }
 
   // Allocates an array with requested amount of `bytes` and at a location with

src/common/stabs_to_module.cc

@@ -44,12 +44,16 @@
 #include <utility>
 
 #include "common/stabs_to_module.h"
+#include "common/language.h"
 
 namespace google_breakpad {
 
 // Demangle using abi call.
 // Older GCC may not support it.
 static std::string Demangle(const std::string& mangled) {
+  if (!Language::IsMangledName(mangled))
+    return mangled;
+
   int status = 0;
   char *demangled = abi::__cxa_demangle(
       mangled.c_str(), nullptr, nullptr, &status);