[fix](be) Fix ARM64 correctness, alignment UB, and build compatibility

[u70b3]

What problem does this PR solve?

Problem Summary:

Systematic analysis of the BE codebase for aarch64 (ARM64) hazards — x86-only code paths, misaligned-access UB, and weak-memory-model races — done on a 128-core ARM server (aarch64, Ubuntu 22.04). Several real bugs were found and reproduced, plus a class of latent UB that is fragile on ARM. This PR fixes the real bugs, hardens the latent ones with zero-cost changes, and adds regression tests. A final commit fixes what prevents master from compiling at all on a current aarch64 toolchain.

Real bugs (reproduced on aarch64):

1. common/signal_handler.h — the crash-handler election CAS is non-atomic on aarch64. The fallback chain requires HAVE___SYNC_VAL_COMPARE_AND_SWAP (never defined by this CMake build) or x86 inline asm, so aarch64 lands in a naive read-check-write that "has a race condition" (per its own comment). FailureSignalHandler() uses it to elect the single thread that dumps crash state. Reproduced with a 128-thread gtest: 2–13 threads won the election per run (should be exactly 1), which means concurrent crashers corrupt each other's dumps or crash again inside the handler. Fixed with __atomic_compare_exchange_n (available on every supported arch).
2. service/doris_main.cpp — AArch32 asm in the startup NEON check. vadd.i32 q8,q8,q8 does not assemble on AArch64 once __ARM_NEON__ is defined (Clang defines it on some ARM targets); reproduced: unknown mnemonic 'vadd.i32'. Now picks add v8.4s,... on __aarch64__ and keeps the AArch32 spelling on __arm__.
3. util/bfd_parser.cpp — hardcoded bfd_set_default_target("elf64-x86-64") fails on aarch64 (verified: the x86 backend is not bundled in aarch64 libbfd), logging a spurious error at every BE start. Selects the target per architecture.
4. core/column/columns_common.cpp — the SIMD path of count_bytes_in_filter was silently compiled out on aarch64. The guard #if defined(__SSE2__) || defined(__aarch64__) && defined(__POPCNT__) already parses as __SSE2__ || (__aarch64__ && __POPCNT__) (&& binds tighter), and ARM toolchains never define __POPCNT__ (sse2neon does not define __SSE2__ either), so aarch64 always took the scalar loop. Dropped the __POPCNT__ gate so the block is enabled unconditionally on __aarch64__ (same SSE2 intrinsics via sse2neon; results verified bit-identical by ColumnsCommonTest).
5. thirdparty/build-thirdparty.sh — [[ "${USE_AVX2}" -eq 0 ]] is true for USE_AVX2=ON (bash arithmetic evaluates "ON" to 0), silently disabling croaring AVX2 for users following the script's own help text. Now normalized case-insensitively: 0/OFF/FALSE/NO disable, 1/ON/TRUE/YES or empty/unset keep enabled (consistent with the CMake boolean semantics BE sees via -DUSE_AVX2=...), unknown values warn and keep the default.

Misaligned-access UB hardening (aarch64 scalar loads tolerate misalignment so nothing crashes today, but these are C++ UB, trip UBSan, and can miscompile under aggressive optimization; unaligned_load/memcpy compile to the same single load instruction — zero cost):
util/bit_packing.inline.h (parquet/RLE decode hot path), util/bitmap_intersect.h (serialize/deserialize), storage/types.h (get_cpp_type_value on packed rows), util/hash_util.hpp (crc_hash/crc_hash64/murmur_hash2_64), ngram_bloom_filter.cpp (init — also fixes a rounded-up tail over-read: it copied words * sizeof(uint64_t) bytes from a size-byte buffer, i.e. up to 7 bytes past the end for bf sizes not divisible by 8 such as 65535; it now copies exactly size bytes and keeps the last word's tail zeroed so contains() still matches query-side filters).

Weak-memory-model hardening (aarch64 is weakly ordered):

• io/cache/block_file_cache_profile: the statistics counters are now a plain AtomicStatistics value member with the metrics hook registered in the constructor. The previous atomic_shared_ptr load on the hot read path was not lock-free (libstdc++ implements std::atomic<shared_ptr> with an internal lock pool; the project's libc++ fallback uses the legacy lock-table free functions), and the lazy-init publication race it guarded was unreachable — the singleton is fully constructed before instance() publishes it.
• storage/olap_common.h VersionWithTime: update_ts is atomic and is stored before the release CAS that publishes a new version. A reader that acquire-loads version and then update_ts is therefore guaranteed a timestamp at least as new as the one stored for that version's publication; "new version + stale timestamp" cannot happen (the previous store-after-CAS order left that interleaving window open on every architecture, x86 included). The residual "old version + newer ts" combination only biases compaction toward the conservative max retention count. Covered by a deterministic multi-threaded regression test.
• bucketed_aggregation_source_operator: relaxed load of the merge-target index (whose value is then dereferenced cross-thread) → acquire, matching the sibling use in the same file.
• util/histogram.cpp: CAS retry loops get _mm_pause (maps to isb via sse2neon on aarch64) to avoid LL/SC contention storms on many-core ARM.

Build fixes (separate commit — master does not compile on aarch64 Ubuntu 22.04 with a current distro toolchain; needed to build/test any of the above):
clang-19 compat: -Wshadow kept non-fatal (newer clang flags namespace shadowing by protobuf-generated enums), std::powf→std::pow, std::format→fmt::format, [[maybe_unused]] for a function only used on the x86_64 unwind path, UT -Wno-deprecated-declarations (libstdc++ ≥ 12), a __res_nsearch→res_nsearch forwarder in glibc-compatibility (glibc ≥ 2.34 exports it only as a non-default compat version, which breaks linking the prebuilt krb5 archive), and #define SNII_CRC32C_X86 0 on non-x86 in snii/encoding/crc32c.cpp (the BE_TEST-only TU used the macro in #if without defining it off-x86, so -Wundef -Werror broke the aarch64 doris_be_test link).

How verified (TDD on a 128-core aarch64 server)

• The CAS race test fails before the fix (2–13 winners/128 threads) and passes after; same for the asm compile check and the bfd/bash behavior checks.
• New unaligned-buffer tests pass with the hardening and serve as regression guards (also runnable under -fsanitize=alignment); the ngram exact-size test (bf sizes 65/67/100/511/65535, zero-slack buffers) is the ASan guard for the tail over-read.
• VersionWithTimeTest (4 readers × 20k version publications) deterministically passes with the fixed publication order and has a real failure window under the old order.
• SignalHandlerTest, NGramBloomFilterTest, BitPackingUnalignedTest, BitmapIntersectTest (incl. VecDateTimeValue keys), ColumnsCommonTest, HashUtilUnalignedTest (murmur + crc + crc64), VersionWithTimeTest: 16/16 pass on aarch64 (clang 19.1.7, -march=armv8-a+crc), full doris_be_test link included.
• 251 existing unit tests across the touched areas (bit packing, bitmap, bloom filter, crc, hash util, histogram, columns): all pass.
• Full FE+BE build with these changes succeeds (-Werror), single-node cluster smoke test (create/insert/filter/aggregate/md5) verified.

Known follow-ups (out of scope for this PR)

• Narrow the global -Wno-error=shadow exemption: existing warnings (mostly protobuf-generated enum collisions) are numerous and deserve a scoped cleanup PR.
• Run the new ngram exact-size test under an ASAN_UT build so the over-read guard actively trips on regression (functional semantics already verified in the normal build).
• The bucketed_aggregation acquire load and histogram _mm_pause have no dedicated tests — memory-ordering and spin-hint behavior are not practically unit-testable; the comments there are the guard.
• This PR spans several independent fault domains (ARM64 correctness / alignment UB / concurrency / build / croaring config); happy to split it into per-theme PRs if reviewers prefer that for review and backport.

Release note

Fix several aarch64 (ARM64) correctness and build issues in BE, including a non-atomic CAS in the crash signal handler, and harden hot paths against misaligned-access UB and weak-memory-ordering hazards.

Check List (For Author)

• Test

  • Unit Test
  • Manual test (add detailed scripts or steps below)
    • Built FE+BE on aarch64 Ubuntu 22.04 (clang 19.1.7, -march=armv8-a+crc), started a single-node cluster, ran create/insert/select smoke SQL successfully. Unit tests: run-be-ut.sh --run --filter='SignalHandlerTest.*:NGramBloomFilterTest.*:BitPackingUnalignedTest.*:BitmapIntersectTest.*:ColumnsCommonTest.*:HashUtilUnalignedTest.*:VersionWithTimeTest.*' (16/16 pass).

• Behavior changed:

  • Yes. No on-disk format, protocol, or hash-output change (the hardening only changes how the same bytes are loaded, and bloom-filter bits are byte-identical). Runtime behavior changes: the crash-handler election is now atomic on aarch64 (exactly one dumper), the aarch64 SIMD popcount path in count_bytes_in_filter is enabled (same results, faster), the bfd default target is selected per architecture (spurious BE-start error log on aarch64 is gone), and croaring now honors the documented USE_AVX2 switch consistently with BE's CMake.

• Does this need documentation?

  • No.

[hello-stephen]

Thank you for your contribution to Apache Doris.
Don't know what should be done next? See How to process your PR.

Please clearly describe your PR:

1. What problem was fixed (it's best to include specific error reporting information). How it was fixed.
2. Which behaviors were modified. What was the previous behavior, what is it now, why was it modified, and what possible impacts might there be.
3. What features were added. Why was this function added?
4. Which code was refactored and why was this part of the code refactored?
5. Which functions were optimized and what is the difference before and after the optimization?