[compiler-rt] [sanitizer_common] Implement address sanitizer on AIX: add platform specific functionality (4/n) (PR #131868)
Jake Egan via llvm-commits
llvm-commits at lists.llvm.org
Mon Mar 24 22:58:21 PDT 2025
https://github.com/jakeegan updated https://github.com/llvm/llvm-project/pull/131868
>From 21bc2f63a81df55c8ad20676ece4930691a4473e Mon Sep 17 00:00:00 2001
From: Jake Egan <jake.egan at ibm.com>
Date: Tue, 18 Mar 2025 01:08:17 -0400
Subject: [PATCH 1/6] [sanitizer_common] Add AIX specific functionality
---
.../lib/sanitizer_common/CMakeLists.txt | 4 +
.../lib/sanitizer_common/sanitizer_aix.cpp | 499 ++++++++++++++++++
.../lib/sanitizer_common/sanitizer_aix.h | 47 ++
.../lib/sanitizer_common/sanitizer_common.cpp | 6 +
.../lib/sanitizer_common/sanitizer_common.h | 7 +-
.../lib/sanitizer_common/sanitizer_file.cpp | 4 +-
.../lib/sanitizer_common/sanitizer_file.h | 3 +-
.../lib/sanitizer_common/sanitizer_posix.h | 5 +
.../sanitizer_posix_libcdep.cpp | 29 +-
.../lib/sanitizer_common/sanitizer_procmaps.h | 3 +-
.../sanitizer_procmaps_aix.cpp | 212 ++++++++
.../sanitizer_procmaps_common.cpp | 7 +-
.../sanitizer_common/sanitizer_stacktrace.cpp | 7 +-
.../sanitizer_common/sanitizer_symbolizer.cpp | 5 +-
.../sanitizer_symbolizer_libcdep.cpp | 10 +-
.../sanitizer_symbolizer_posix_libcdep.cpp | 32 +-
.../sanitizer_symbolizer_win.cpp | 2 +-
.../sanitizer_common/sanitizer_unwind_aix.cpp | 66 +++
.../sanitizer_default_arch/llvm-symbolizer | 7 +
.../symbolizer_default_arch_ppc64.cpp | 18 +
20 files changed, 955 insertions(+), 18 deletions(-)
create mode 100644 compiler-rt/lib/sanitizer_common/sanitizer_aix.cpp
create mode 100644 compiler-rt/lib/sanitizer_common/sanitizer_aix.h
create mode 100644 compiler-rt/lib/sanitizer_common/sanitizer_procmaps_aix.cpp
create mode 100644 compiler-rt/lib/sanitizer_common/sanitizer_unwind_aix.cpp
create mode 100644 compiler-rt/test/sanitizer_common/TestCases/Inputs/sanitizer_default_arch/llvm-symbolizer
create mode 100644 compiler-rt/test/sanitizer_common/TestCases/symbolizer_default_arch_ppc64.cpp
diff --git a/compiler-rt/lib/sanitizer_common/CMakeLists.txt b/compiler-rt/lib/sanitizer_common/CMakeLists.txt
index 09391e4f5f370..8789e02780050 100644
--- a/compiler-rt/lib/sanitizer_common/CMakeLists.txt
+++ b/compiler-rt/lib/sanitizer_common/CMakeLists.txt
@@ -2,6 +2,7 @@
# These components are shared between AddressSanitizer and ThreadSanitizer.
set(SANITIZER_SOURCES_NOTERMINATION
+ sanitizer_aix.cpp
sanitizer_allocator.cpp
sanitizer_common.cpp
sanitizer_deadlock_detector1.cpp
@@ -25,6 +26,7 @@ set(SANITIZER_SOURCES_NOTERMINATION
sanitizer_platform_limits_solaris.cpp
sanitizer_posix.cpp
sanitizer_printf.cpp
+ sanitizer_procmaps_aix.cpp
sanitizer_procmaps_common.cpp
sanitizer_procmaps_bsd.cpp
sanitizer_procmaps_fuchsia.cpp
@@ -95,6 +97,7 @@ set(SANITIZER_SYMBOLIZER_SOURCES
sanitizer_symbolizer_report_fuchsia.cpp
sanitizer_symbolizer_win.cpp
sanitizer_thread_history.cpp
+ sanitizer_unwind_aix.cpp
sanitizer_unwind_linux_libcdep.cpp
sanitizer_unwind_fuchsia.cpp
sanitizer_unwind_win.cpp
@@ -107,6 +110,7 @@ set(SANITIZER_IMPL_HEADERS
sancov_flags.h
sancov_flags.inc
sanitizer_addrhashmap.h
+ sanitizer_aix.h
sanitizer_allocator.h
sanitizer_allocator_checks.h
sanitizer_allocator_combined.h
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_aix.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_aix.cpp
new file mode 100644
index 0000000000000..fac3d7b10829f
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_aix.cpp
@@ -0,0 +1,499 @@
+//===-- sanitizer_aix.cpp -------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between various sanitizers' runtime libraries and
+// implements AIX-specific functions.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+
+#if SANITIZER_AIX
+# include <dlfcn.h>
+# include <errno.h>
+# include <fcntl.h>
+# include <pthread.h>
+# include <sched.h>
+# include <signal.h>
+# include <stdio.h>
+# include <stdlib.h>
+# include <string.h>
+# include <sys/errno.h>
+# include <sys/mman.h>
+# include <sys/procfs.h>
+# include <sys/stat.h>
+# include <sys/thread.h>
+# include <sys/time.h>
+# include <sys/types.h>
+# include <sys/ucontext.h>
+# include <unistd.h>
+
+# include "interception/interception.h"
+# include "sanitizer_aix.h"
+# include "sanitizer_common.h"
+# include "sanitizer_file.h"
+# include "sanitizer_libc.h"
+# include "sanitizer_procmaps.h"
+
+extern char **p_xargv;
+
+namespace __sanitizer {
+
+# include "sanitizer_syscall_generic.inc"
+
+static void *GetFuncAddr(const char *name) {
+ // FIXME: if we are going to ship dynamic asan library, we may need to search
+ // all the loaded modules with RTLD_DEFAULT if RTLD_NEXT failed.
+ void *addr = dlsym(RTLD_NEXT, name);
+ return addr;
+}
+
+// Internal implementation for the libc functions are also calling to the same
+// name function in libc. However because the same name function to libc may be
+// intercepted, and in the interceptor function, it may call REAL(func). But the
+// REAL(func) may be not assigned at this time, because internal_func may be
+// called before interceptor init functions are called. So we need to call to
+// libc function via function pointer.
+
+# define _REAL(func, ...) real##_##func(__VA_ARGS__)
+
+# define DEFINE__REAL(ret_type, func, ...) \
+ static ret_type (*real_##func)(__VA_ARGS__) = NULL; \
+ if (!real_##func) { \
+ real_##func = (ret_type(*)(__VA_ARGS__))GetFuncAddr(#func); \
+ } \
+ CHECK(real_##func);
+
+uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd,
+ u64 offset) {
+ DEFINE__REAL(uptr, mmap, void *addr, uptr length, int prot, int flags, int fd,
+ u64 offset);
+ return _REAL(mmap, addr, length, prot, flags, fd, offset);
+}
+
+uptr internal_munmap(void *addr, uptr length) {
+ DEFINE__REAL(uptr, munmap, void *addr, uptr length);
+ return _REAL(munmap, addr, length);
+}
+
+int internal_mprotect(void *addr, uptr length, int prot) {
+ DEFINE__REAL(int, mprotect, void *addr, uptr length, int prot);
+ return _REAL(mprotect, addr, length, prot);
+}
+
+int internal_madvise(uptr addr, uptr length, int advice) {
+ char *raddr = reinterpret_cast<char *>(addr);
+ DEFINE__REAL(int, madvise, char *raddr, uptr length, int advice)
+ return _REAL(madvise, raddr, length, advice);
+}
+
+uptr internal_close(fd_t fd) {
+ DEFINE__REAL(uptr, close, fd_t fd);
+ return _REAL(close, fd);
+}
+
+uptr internal_open(const char *filename, int flags) {
+ DEFINE__REAL(uptr, open, const char *filename, int flags);
+ return _REAL(open, filename, flags);
+}
+
+uptr internal_open(const char *filename, int flags, u32 mode) {
+ DEFINE__REAL(uptr, open, const char *filename, int flags, u32 mode);
+ return _REAL(open, filename, flags, mode);
+}
+
+__sanitizer_FILE *internal_popen(const char *command, const char *type) {
+ DEFINE__REAL(__sanitizer_FILE *, popen, const char *command,
+ const char *type);
+ return _REAL(popen, command, type);
+}
+
+int internal_pclose(__sanitizer_FILE *file) {
+ FILE *rfile = reinterpret_cast<FILE *>(file);
+ DEFINE__REAL(int, pclose, FILE *file);
+ return _REAL(pclose, rfile);
+}
+
+uptr internal_read(fd_t fd, void *buf, uptr count) {
+ DEFINE__REAL(uptr, read, fd_t fd, void *buf, uptr count);
+ return _REAL(read, fd, buf, count);
+}
+
+uptr internal_write(fd_t fd, const void *buf, uptr count) {
+ DEFINE__REAL(uptr, write, fd_t fd, const void *buf, uptr count);
+ return _REAL(write, fd, buf, count);
+}
+
+uptr internal_stat(const char *path, void *buf) {
+ DEFINE__REAL(uptr, stat, const char *path, void *buf);
+ return _REAL(stat, path, buf);
+}
+
+uptr internal_lstat(const char *path, void *buf) {
+ DEFINE__REAL(uptr, lstat, const char *path, void *buf);
+ return _REAL(lstat, path, buf);
+}
+
+uptr internal_fstat(fd_t fd, void *buf) {
+ DEFINE__REAL(uptr, fstat, fd_t fd, void *buf);
+ return _REAL(fstat, fd, buf);
+}
+
+uptr internal_filesize(fd_t fd) {
+ struct stat st;
+ if (internal_fstat(fd, &st))
+ return -1;
+ return (uptr)st.st_size;
+}
+
+uptr internal_dup(int oldfd) {
+ DEFINE__REAL(uptr, dup, int oldfd);
+ return _REAL(dup, oldfd);
+}
+
+uptr internal_dup2(int oldfd, int newfd) {
+ DEFINE__REAL(uptr, dup2, int oldfd, int newfd);
+ return _REAL(dup2, oldfd, newfd);
+}
+
+uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
+ DEFINE__REAL(uptr, readlink, const char *path, char *buf, uptr bufsize);
+ return _REAL(readlink, path, buf, bufsize);
+}
+
+uptr internal_unlink(const char *path) {
+ DEFINE__REAL(uptr, unlink, const char *path);
+ return _REAL(unlink, path);
+}
+
+uptr internal_sched_yield() {
+ DEFINE__REAL(uptr, sched_yield);
+ return _REAL(sched_yield);
+}
+
+void FutexWait(atomic_uint32_t *p, u32 cmp) { internal_sched_yield(); }
+
+void FutexWake(atomic_uint32_t *p, u32 count) {}
+
+void internal__exit(int exitcode) {
+ DEFINE__REAL(void, _exit, int exitcode);
+ _REAL(_exit, exitcode);
+ Die(); // Unreachable.
+}
+
+void internal_usleep(u64 useconds) {
+ DEFINE__REAL(void, usleep, u64 useconds);
+ _REAL(usleep, useconds);
+}
+
+uptr internal_getpid() {
+ DEFINE__REAL(uptr, getpid);
+ return _REAL(getpid);
+}
+
+int internal_dlinfo(void *handle, int request, void *p) { return 0; }
+
+int internal_sigaction(int signum, const void *act, void *oldact) {
+ DEFINE__REAL(int, sigaction, int signum, const void *act, void *oldact);
+ return _REAL(sigaction, signum, act, oldact);
+}
+
+void internal_sigfillset(__sanitizer_sigset_t *set) {
+ sigset_t *rset = reinterpret_cast<sigset_t *>(set);
+ DEFINE__REAL(void, sigfillset, sigset_t *rset);
+ _REAL(sigfillset, rset);
+}
+
+uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
+ __sanitizer_sigset_t *oldset) {
+ sigset_t *rset = reinterpret_cast<sigset_t *>(set);
+ sigset_t *roldset = reinterpret_cast<sigset_t *>(oldset);
+ DEFINE__REAL(uptr, sigprocmask, int how, sigset_t *rset, sigset_t *roldset);
+ return _REAL(sigprocmask, how, rset, roldset);
+}
+
+char *internal_getcwd(char *buf, uptr size) {
+ DEFINE__REAL(char *, getcwd, char *buf, uptr size);
+ return _REAL(getcwd, buf, size);
+}
+
+int internal_fork() {
+ DEFINE__REAL(int, fork);
+ return _REAL(fork);
+}
+
+uptr internal_execve(const char *filename, char *const argv[],
+ char *const envp[]) {
+ DEFINE__REAL(uptr, execve, const char *filename, char *const argv[],
+ char *const envp[]);
+ return _REAL(execve, filename, argv, envp);
+}
+
+uptr internal_waitpid(int pid, int *status, int options) {
+ DEFINE__REAL(uptr, waitpid, int pid, int *status, int options);
+ return _REAL(waitpid, pid, status, options);
+}
+
+int internal_pthread_join(pthread_t thread, void **status) {
+ DEFINE__REAL(int, pthread_join, pthread_t thread, void **status);
+ return _REAL(pthread_join, thread, status);
+}
+
+int internal_pthread_create(pthread_t *thread, const pthread_attr_t *attr,
+ void *(*start_routine)(void *), void *arg) {
+ DEFINE__REAL(int, pthread_create, pthread_t *thread,
+ const pthread_attr_t *attr, void *(*start_routine)(void *),
+ void *arg);
+ return _REAL(pthread_create, thread, attr, start_routine, arg);
+}
+
+void *internal_start_thread(void *(*func)(void *arg), void *arg) {
+ // Start the thread with signals blocked, otherwise it can steal user signals.
+ __sanitizer_sigset_t set, old;
+ internal_sigfillset(&set);
+ internal_sigprocmask(SIG_SETMASK, &set, &old);
+ pthread_t th;
+ internal_pthread_create(&th, 0, func, arg);
+ internal_sigprocmask(SIG_SETMASK, &old, 0);
+ // pthread_t is unsinged int on AIX
+ return reinterpret_cast<void *>(th);
+}
+
+void internal_join_thread(void *th) {
+ internal_pthread_join((pthread_t)(reinterpret_cast<uptr>(th)), nullptr);
+}
+
+uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) {
+ clock_t rclk_id = reinterpret_cast<clock_t>(clk_id);
+ struct timespec *rtp = reinterpret_cast<struct timespec *>(tp);
+ DEFINE__REAL(uptr, clock_gettime, clock_t rclk_id, struct timespec * rtp);
+ return _REAL(clock_gettime, rclk_id, rtp);
+}
+
+void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
+ uptr *stack_bottom) {
+ CHECK(stack_top);
+ CHECK(stack_bottom);
+ if (at_initialization) {
+ // This is the main thread. Libpthread may not be initialized yet.
+ struct rlimit rl;
+ CHECK_EQ(getrlimit(RLIMIT_STACK, &rl), 0);
+
+ // Find the mapping that contains a stack variable.
+ MemoryMappingLayout proc_maps(/*cache_enabled*/ true);
+ if (proc_maps.Error()) {
+ *stack_top = *stack_bottom = 0;
+ return;
+ }
+ MemoryMappedSegment segment;
+ uptr prev_end = 0;
+ while (proc_maps.Next(&segment)) {
+ if ((uptr)&rl < segment.end)
+ break;
+ prev_end = segment.end;
+ }
+
+ CHECK((uptr)&rl >= segment.start && (uptr)&rl < segment.end);
+
+ // Get stacksize from rlimit, but clip it so that it does not overlap
+ // with other mappings.
+ uptr stacksize = rl.rlim_cur;
+ if (stacksize > segment.end - prev_end)
+ stacksize = segment.end - prev_end;
+ // When running with unlimited stack size, we still want to set some limit.
+ // The unlimited stack size is caused by 'ulimit -s unlimited'.
+ // Also, for some reason, GNU make spawns subprocesses with unlimited stack.
+ if (stacksize > kMaxThreadStackSize)
+ stacksize = kMaxThreadStackSize;
+ *stack_top = segment.end;
+ *stack_bottom = segment.end - stacksize;
+ return;
+ }
+ uptr stacksize = 0;
+ void *stackaddr = nullptr;
+ pthread_attr_t attr;
+ pthread_attr_init(&attr);
+ CHECK_EQ(pthread_getattr_np(pthread_self(), &attr), 0);
+ internal_pthread_attr_getstack(&attr, &stackaddr, &stacksize);
+ pthread_attr_destroy(&attr);
+
+ *stack_top = (uptr)stackaddr;
+ *stack_bottom = (uptr)stackaddr - stacksize;
+}
+
+void GetThreadStackAndTls(bool main, uptr *stk_begin, uptr *stk_end,
+ uptr *tls_begin, uptr *tls_end) {
+ // FIXME: handle TLS related flag
+ *tls_begin = 0;
+ *tls_end = 0;
+
+ uptr stack_top, stack_bottom;
+ GetThreadStackTopAndBottom(main, &stack_top, &stack_bottom);
+ *stk_begin = stack_bottom;
+ *stk_end = stack_top;
+}
+
+const char *GetEnv(const char *name) { return getenv(name); }
+
+tid_t GetTid() { return thread_self(); }
+
+uptr ReadBinaryName(char *buf, uptr buf_len) {
+ struct stat statData;
+ struct psinfo psinfoData;
+
+ char FilePsinfo[100] = {};
+ internal_snprintf(FilePsinfo, 100, "/proc/%d/psinfo", internal_getpid());
+ CHECK_EQ(internal_stat(FilePsinfo, &statData), 0);
+
+ const int fd = internal_open(FilePsinfo, O_RDONLY);
+ ssize_t readNum = internal_read(fd, &psinfoData, sizeof(psinfoData));
+ CHECK_GE(readNum, 0);
+
+ internal_close(fd);
+ char *binary_name = (reinterpret_cast<char ***>(psinfoData.pr_argv))[0][0];
+
+ // This is an absulate path.
+ if (binary_name[0] == '/')
+ return internal_snprintf(buf, buf_len, "%s", binary_name);
+
+ // This is a relative path to the binary, starts with ./ or ../
+ if (binary_name[0] == '.') {
+ char *path = nullptr;
+ if ((path = internal_getcwd(buf, buf_len)) != nullptr)
+ return internal_snprintf(buf + internal_strlen(path),
+ buf_len - internal_strlen(path), "/%s",
+ binary_name) +
+ internal_strlen(path);
+ }
+
+ // This is running a raw binary in the dir where it is from.
+ char *path = nullptr;
+ if ((path = internal_getcwd(buf, buf_len)) != nullptr) {
+ char fullName[kMaxPathLength] = {};
+ internal_snprintf(fullName, kMaxPathLength, "%s/%s", path, binary_name);
+ if (FileExists(fullName))
+ return internal_snprintf(buf + internal_strlen(path),
+ buf_len - internal_strlen(path), "/%s",
+ binary_name) +
+ internal_strlen(path);
+ }
+
+ // Find the binary in the env PATH.
+ if ((path = FindPathToBinaryOrLibrary(binary_name)) != nullptr)
+ return internal_snprintf(buf, buf_len, "%s", path);
+
+ return 0;
+}
+
+// https://www.ibm.com/docs/en/aix/7.3?topic=concepts-system-memory-allocation-using-malloc-subsystem
+uptr GetMaxVirtualAddress() {
+# if SANITIZER_WORDSIZE == 64
+ return (1ULL << 60) - 1;
+# else
+ return 0xffffffff;
+# endif
+}
+
+uptr GetMaxUserVirtualAddress() { return GetMaxVirtualAddress(); }
+
+uptr ReadLongProcessName(/*out*/ char *buf, uptr buf_len) {
+ return ReadBinaryName(buf, buf_len);
+}
+
+void InitializePlatformCommonFlags(CommonFlags *cf) {}
+
+void InitializePlatformEarly() {
+ // Do nothing.
+}
+
+uptr GetPageSize() { return getpagesize(); }
+
+void CheckASLR() {
+ // Do nothing
+}
+
+HandleSignalMode GetHandleSignalMode(int signum) {
+ switch (signum) {
+ case SIGABRT:
+ return common_flags()->handle_abort;
+ case SIGILL:
+ return common_flags()->handle_sigill;
+ case SIGTRAP:
+ return common_flags()->handle_sigtrap;
+ case SIGFPE:
+ return common_flags()->handle_sigfpe;
+ case SIGSEGV:
+ return common_flags()->handle_segv;
+ case SIGBUS:
+ return common_flags()->handle_sigbus;
+ }
+ return kHandleSignalNo;
+}
+
+void InitTlsSize() {}
+
+bool FileExists(const char *filename) {
+ struct stat st;
+ if (internal_stat(filename, &st))
+ return false;
+ // Sanity check: filename is a regular file.
+ return S_ISREG(st.st_mode);
+}
+
+bool DirExists(const char *path) {
+ struct stat st;
+ if (internal_stat(path, &st))
+ return false;
+ return S_ISDIR(st.st_mode);
+}
+
+uptr GetTlsSize() {
+ // FIXME: implement this interface.
+ return 0;
+}
+
+SignalContext::WriteFlag SignalContext::GetWriteFlag() const {
+ return SignalContext::Unknown;
+}
+
+bool SignalContext::IsTrueFaultingAddress() const { return true; }
+
+void SignalContext::InitPcSpBp() {
+ ucontext_t *ucontext = (ucontext_t *)context;
+ pc = ucontext->uc_mcontext.jmp_context.iar;
+ sp = ucontext->uc_mcontext.jmp_context.gpr[1];
+ // The powerpc{,64} ABIs do not specify r31 as the frame pointer, but compiler
+ // always uses r31 when we need a frame pointer.
+ bp = ucontext->uc_mcontext.jmp_context.gpr[31];
+}
+
+void SignalContext::DumpAllRegisters(void *context) {}
+
+char **GetEnviron() { return nullptr; }
+
+char **GetArgv() { return p_xargv; }
+
+void ListOfModules::init() {
+ clearOrInit();
+ MemoryMappingLayout memory_mapping(false);
+ memory_mapping.DumpListOfModules(&modules_);
+}
+
+void ListOfModules::fallbackInit() { clear(); }
+
+u64 MonotonicNanoTime() {
+ timespec ts;
+ internal_clock_gettime(CLOCK_MONOTONIC, &ts);
+ return (u64)ts.tv_sec * (1000ULL * 1000 * 1000) + ts.tv_nsec;
+}
+
+// FIXME implement on this platform.
+void GetMemoryProfile(fill_profile_f cb, uptr *stats) {}
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_AIX
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_aix.h b/compiler-rt/lib/sanitizer_common/sanitizer_aix.h
new file mode 100644
index 0000000000000..5883d1f2e16de
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_aix.h
@@ -0,0 +1,47 @@
+//===-- sanitizer_aix.h -----------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between various sanitizers' runtime libraries and
+// provides definitions for AIX-specific functions.
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_AIX_H
+#define SANITIZER_AIX_H
+
+#include "sanitizer_platform.h"
+
+#if SANITIZER_AIX
+#include "sanitizer_common.h"
+# include "sanitizer_posix.h"
+
+namespace __sanitizer {
+
+#if SANITIZER_WORDSIZE == 32
+static const uptr InstructionStart = 0x10000000;
+#else
+static const uptr InstructionStart = 0x100000000;
+#endif
+
+struct ProcSelfMapsBuff {
+ char *data;
+ uptr mmaped_size;
+ uptr len;
+};
+
+struct MemoryMappingLayoutData {
+ ProcSelfMapsBuff proc_self_maps;
+ const char *current;
+};
+
+void ReadProcMaps(ProcSelfMapsBuff *proc_maps);
+
+char *internal_getcwd(char *buf, uptr size);
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_AIX
+#endif // SANITIZER_AIX_H
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_common.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_common.cpp
index 6cd69a53093e7..3b5286bcf9be9 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_common.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_common.cpp
@@ -275,6 +275,12 @@ const char *GetProcessName() {
return process_name_cache_str;
}
+const char *GetBinaryName() {
+ if (binary_name_cache_str[0] == '\0')
+ ReadBinaryName(binary_name_cache_str, sizeof(binary_name_cache_str));
+ return binary_name_cache_str;
+}
+
static uptr ReadProcessName(/*out*/ char *buf, uptr buf_len) {
ReadLongProcessName(buf, buf_len);
char *s = const_cast<char *>(StripModuleName(buf));
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_common.h b/compiler-rt/lib/sanitizer_common/sanitizer_common.h
index d9e7ded593feb..466790d335ac0 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_common.h
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_common.h
@@ -290,6 +290,7 @@ uptr ReadBinaryNameCached(/*out*/char *buf, uptr buf_len);
uptr ReadBinaryDir(/*out*/ char *buf, uptr buf_len);
uptr ReadLongProcessName(/*out*/ char *buf, uptr buf_len);
const char *GetProcessName();
+const char *GetBinaryName();
void UpdateProcessName();
void CacheBinaryName();
void DisableCoreDumperIfNecessary();
@@ -835,7 +836,8 @@ class LoadedModule {
max_address_(0),
arch_(kModuleArchUnknown),
uuid_size_(0),
- instrumented_(false) {
+ instrumented_(false),
+ instr_start_(0) {
internal_memset(uuid_, 0, kModuleUUIDSize);
ranges_.clear();
}
@@ -855,6 +857,8 @@ class LoadedModule {
const u8 *uuid() const { return uuid_; }
uptr uuid_size() const { return uuid_size_; }
bool instrumented() const { return instrumented_; }
+ uptr get_instr_start() const { return instr_start_; }
+ void set_instr_start(uptr start) { instr_start_ = start; }
struct AddressRange {
AddressRange *next;
@@ -885,6 +889,7 @@ class LoadedModule {
uptr uuid_size_;
u8 uuid_[kModuleUUIDSize];
bool instrumented_;
+ uptr instr_start_;
IntrusiveList<AddressRange> ranges_;
};
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_file.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_file.cpp
index 96af270f9d8b5..6684e54c1d510 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_file.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_file.cpp
@@ -203,12 +203,12 @@ bool ReadFileToVector(const char *file_name,
static const char kPathSeparator = SANITIZER_WINDOWS ? ';' : ':';
-char *FindPathToBinary(const char *name) {
+char *FindPathToBinaryOrLibrary(const char *name, const char *env_string) {
if (FileExists(name)) {
return internal_strdup(name);
}
- const char *path = GetEnv("PATH");
+ const char *path = GetEnv(env_string);
if (!path)
return nullptr;
uptr name_len = internal_strlen(name);
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_file.h b/compiler-rt/lib/sanitizer_common/sanitizer_file.h
index bef2c842d9f24..000f437d126e5 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_file.h
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_file.h
@@ -79,7 +79,8 @@ bool SupportsColoredOutput(fd_t fd);
const char *GetPwd();
bool FileExists(const char *filename);
bool DirExists(const char *path);
-char *FindPathToBinary(const char *name);
+char *FindPathToBinaryOrLibrary(const char *name,
+ const char *env_string = "PATH");
bool IsPathSeparator(const char c);
bool IsAbsolutePath(const char *path);
// Returns true on success, false on failure.
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_posix.h b/compiler-rt/lib/sanitizer_common/sanitizer_posix.h
index b5491c540dc08..da9cd92357145 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_posix.h
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_posix.h
@@ -33,6 +33,11 @@ uptr internal_close_range(fd_t lowfd, fd_t highfd, int flags);
# endif
uptr internal_close(fd_t fd);
+#if SANITIZER_AIX
+__sanitizer_FILE* internal_popen(const char *command, const char *type);
+int internal_pclose(__sanitizer_FILE* file);
+#endif
+
uptr internal_read(fd_t fd, void *buf, uptr count);
uptr internal_write(fd_t fd, const void *buf, uptr count);
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp
index b1eb2009cf157..307d8c969a338 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp
@@ -36,7 +36,7 @@
#include <sys/wait.h>
#include <unistd.h>
-#if SANITIZER_FREEBSD
+#if SANITIZER_FREEBSD || SANITIZER_AIX
// The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before
// that, it was never implemented. So just define it to zero.
#undef MAP_NORESERVE
@@ -416,8 +416,19 @@ bool MmapFixedSuperNoReserve(uptr fixed_addr, uptr size, const char *name) {
}
uptr ReservedAddressRange::Init(uptr size, const char *name, uptr fixed_addr) {
+ // AIX can not mmap on a mmaped memory, so init it as read/write so we won't
+ // mmap on this memory again.
+# if SANITIZER_AIX
+ if (fixed_addr) {
+ MmapFixed(fixed_addr, size, MAP_PRIVATE | MAP_FIXED | MAP_ANON, name);
+ base_ = (void *)fixed_addr;
+ } else
+ base_ = (void *)internal_mmap(nullptr, size, PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANON, -1, 0);
+# else
base_ = fixed_addr ? MmapFixedNoAccess(fixed_addr, size, name)
: MmapNoAccess(size);
+# endif
size_ = size;
name_ = name;
(void)os_handle_; // unsupported
@@ -427,13 +438,21 @@ uptr ReservedAddressRange::Init(uptr size, const char *name, uptr fixed_addr) {
// Uses fixed_addr for now.
// Will use offset instead once we've implemented this function for real.
uptr ReservedAddressRange::Map(uptr fixed_addr, uptr size, const char *name) {
+#if SANITIZER_AIX
+ return fixed_addr;
+#else
return reinterpret_cast<uptr>(
MmapFixedOrDieOnFatalError(fixed_addr, size, name));
+#endif
}
uptr ReservedAddressRange::MapOrDie(uptr fixed_addr, uptr size,
const char *name) {
+#if SANITIZER_AIX
+ return fixed_addr;
+#else
return reinterpret_cast<uptr>(MmapFixedOrDie(fixed_addr, size, name));
+#endif
}
void ReservedAddressRange::Unmap(uptr addr, uptr size) {
@@ -465,11 +484,15 @@ real_pthread_attr_getstack(void *attr, void **addr, size_t *size);
} // extern "C"
int internal_pthread_attr_getstack(void *attr, void **addr, uptr *size) {
-#if !SANITIZER_GO && !SANITIZER_APPLE
+// AIX requires definition for weak symbols. real_pthread_attr_getstack defined
+// in asan library which is not linked while compile with -fsanitize=undefined.
+// So don't use use real_pthread_attr_getstack on AIX either in this sanitizer
+// common file.
+# if !SANITIZER_GO && !SANITIZER_APPLE && !SANITIZER_AIX
if (&real_pthread_attr_getstack)
return real_pthread_attr_getstack((pthread_attr_t *)attr, addr,
(size_t *)size);
-#endif
+# endif
return pthread_attr_getstack((pthread_attr_t *)attr, addr, (size_t *)size);
}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps.h b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps.h
index bf3c2c28e32e3..8e5162f40a55b 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps.h
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps.h
@@ -17,7 +17,7 @@
#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || \
SANITIZER_APPLE || SANITIZER_SOLARIS || \
- SANITIZER_FUCHSIA
+ SANITIZER_FUCHSIA || SANITIZER_AIX
#include "sanitizer_common.h"
#include "sanitizer_internal_defs.h"
@@ -25,6 +25,7 @@
#include "sanitizer_linux.h"
#include "sanitizer_mac.h"
#include "sanitizer_mutex.h"
+#include "sanitizer_aix.h"
namespace __sanitizer {
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_aix.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_aix.cpp
new file mode 100644
index 0000000000000..852aba2f169b8
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_aix.cpp
@@ -0,0 +1,212 @@
+//===-- sanitizer_procmaps_aix.cpp ----------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Information about the process mappings (AIX-specific parts).
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+
+#if SANITIZER_AIX
+# include <stdio.h>
+
+# include "sanitizer_common.h"
+# include "sanitizer_procmaps.h"
+# include "sanitizer_file.h"
+
+namespace __sanitizer {
+
+static bool IsOneOf(char c, char c1, char c2) { return c == c1 || c == c2; }
+
+void ReadProcMaps(ProcSelfMapsBuff *proc_maps) {
+ uptr pid = internal_getpid();
+
+ // The mapping in /proc/id/map is not ordered by address, this will hit some
+ // issue when checking stack base and size. Howevern AIX procmap can generate
+ // sorted ranges.
+ char Command[100] = {};
+
+ internal_snprintf(Command, 100, "procmap -qX %d", pid);
+ // Open pipe to file
+ __sanitizer_FILE *pipe = internal_popen(Command, "r");
+
+ if (!pipe) {
+ proc_maps->data = nullptr;
+ proc_maps->mmaped_size = 0;
+ proc_maps->len = 0;
+ return;
+ }
+
+ char buffer[512] = {};
+
+ InternalScopedString Data;
+ while (fgets(buffer, 512, reinterpret_cast<FILE *>(pipe)) != nullptr)
+ Data.Append(buffer);
+
+ size_t MmapedSize = Data.length() * 4 / 3;
+ void *VmMap = MmapOrDie(MmapedSize, "ReadProcMaps()");
+ internal_memcpy(VmMap, Data.data(), Data.length());
+
+ proc_maps->data = (char *)VmMap;
+ proc_maps->mmaped_size = MmapedSize;
+ proc_maps->len = Data.length();
+
+ internal_pclose(pipe);
+}
+
+bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) {
+ if (Error())
+ return false; // simulate empty maps
+ char *last = data_.proc_self_maps.data + data_.proc_self_maps.len;
+ if (data_.current >= last)
+ return false;
+ char *next_line =
+ (char *)internal_memchr(data_.current, '\n', last - data_.current);
+
+ // Skip the first header line and the second kernel line
+ // pid : binary name
+ if (data_.current == data_.proc_self_maps.data) {
+ data_.current = next_line + 1;
+ next_line =
+ (char *)internal_memchr(next_line + 1, '\n', last - data_.current);
+
+ data_.current = next_line + 1;
+ next_line =
+ (char *)internal_memchr(next_line + 1, '\n', last - data_.current);
+ }
+
+ if (next_line == 0)
+ next_line = last;
+
+ // Skip the last line:
+ // Total 533562K
+ if (!IsHex(*data_.current))
+ return false;
+
+ // Example: 10000000 10161fd9 1415K r-x s MAINTEXT 151ed82 a.out
+ segment->start = ParseHex(&data_.current);
+ while (data_.current < next_line && *data_.current == ' ') data_.current++;
+
+ segment->end = ParseHex(&data_.current);
+ while (data_.current < next_line && *data_.current == ' ') data_.current++;
+
+ // Ignore the size, we can get accurate size from end and start
+ while (IsDecimal(*data_.current)) data_.current++;
+ CHECK_EQ(*data_.current++, 'K');
+
+ while (data_.current < next_line && *data_.current == ' ') data_.current++;
+ segment->protection = 0;
+
+ if (*data_.current++ == 'r')
+ segment->protection |= kProtectionRead;
+ CHECK(IsOneOf(*data_.current, '-', 'w'));
+ if (*data_.current++ == 'w')
+ segment->protection |= kProtectionWrite;
+ CHECK(IsOneOf(*data_.current, '-', 'x'));
+ if (*data_.current++ == 'x')
+ segment->protection |= kProtectionExecute;
+
+ // Ignore the PSIZE(s/m/L/H)
+ while (data_.current < next_line && *data_.current == ' ') data_.current++;
+ data_.current += 4;
+
+ // Get the region TYPE
+ while (data_.current < next_line && *data_.current == ' ') data_.current++;
+ char Type[16] = {};
+ uptr len = 0;
+ while (*data_.current != ' ') Type[len++] = *data_.current++;
+ Type[len] = 0;
+
+ if (!internal_strcmp(Type, "SLIBTEXT") || !internal_strcmp(Type, "PLIBDATA"))
+ segment->protection |= kProtectionShared;
+
+ // Ignore the VSID
+ while (data_.current < next_line && *data_.current == ' ') data_.current++;
+ ParseHex(&data_.current);
+
+ while (data_.current < next_line && *data_.current == ' ') data_.current++;
+
+ if (segment->filename && data_.current != next_line) {
+ if (!internal_strcmp(Type, "MAINDATA") ||
+ !internal_strcmp(Type, "MAINTEXT")) {
+ // AIX procmap does not print full name for the binary, however when using
+ // llvm-symbolizer, it requires the binary must be with full name.
+ const char *BinaryName = GetBinaryName();
+ uptr len =
+ Min((uptr)(internal_strlen(BinaryName)), segment->filename_size - 1);
+ internal_strncpy(segment->filename, BinaryName, len);
+ segment->filename[len] = 0;
+ } else {
+ // AIX library may exist as xxx.a[yyy.o], to find the path to xxx.a,
+ // the [yyy.o] part needs to be removed.
+ char *NameEnd = (char *)internal_memchr(data_.current, '[',
+ next_line - data_.current);
+ if (!NameEnd)
+ NameEnd = next_line - 1;
+
+ uptr len = Min((uptr)(NameEnd - data_.current),
+ segment->filename_size - 1);
+ internal_strncpy(segment->filename, data_.current, len);
+ segment->filename[len] = 0;
+
+ // AIX procmap does not print full name for user's library , however when
+ // use llvm-symbolizer, it requires the library must be with full name.
+ if ((!internal_strcmp(Type, "SLIBTEXT") ||
+ !internal_strcmp(Type, "PLIBDATA")) &&
+ segment->filename[0] != '/') {
+ // First check if the library is in the directory where the binary is
+ // executed. On AIX, there is no need to put library in same dir with
+ // the binary to path search envs.
+ char *path = nullptr;
+ char buf[kMaxPathLength];
+ unsigned buf_len = kMaxPathLength;
+ bool found = false;
+ if ((path = internal_getcwd(buf, buf_len)) != nullptr) {
+ // if the path is too long, don't do other search either.
+ if (internal_strlen(path) > segment->filename_size - 1)
+ found = true;
+ else {
+ internal_snprintf(
+ buf + internal_strlen(path),
+ segment->filename_size - 1 - internal_strlen(path), "/%s",
+ segment->filename);
+ if (FileExists(buf)) {
+ uptr len =
+ Min((uptr)(internal_strlen(buf)), segment->filename_size - 1);
+ internal_strncpy(segment->filename, buf, len);
+ segment->filename[len] = 0;
+ found = true;
+ }
+ }
+ }
+ if (!found) {
+ const char *LibName =
+ FindPathToBinaryOrLibrary(segment->filename, "LIBPATH");
+ CHECK(LibName);
+ uptr len =
+ Min((uptr)(internal_strlen(LibName)), segment->filename_size - 1);
+ internal_strncpy(segment->filename, LibName, len);
+ segment->filename[len] = 0;
+ found = true;
+ }
+ CHECK(found);
+ }
+ }
+ } else if (segment->filename) {
+ segment->filename[0] = 0;
+ }
+
+ segment->offset = 0;
+
+ data_.current = next_line + 1;
+
+ return true;
+}
+
+} // namespace __sanitizer
+
+#endif // SANITIZER_AIX
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_common.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_common.cpp
index 7214a2b9ea468..4089420c8f63e 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_common.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_common.cpp
@@ -12,7 +12,7 @@
#include "sanitizer_platform.h"
#if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
- SANITIZER_SOLARIS
+ SANITIZER_SOLARIS || SANITIZER_AIX
#include "sanitizer_common.h"
#include "sanitizer_placement_new.h"
@@ -140,6 +140,11 @@ void MemoryMappingLayout::DumpListOfModules(
uptr base_address = (i ? segment.start : 0) - segment.offset;
LoadedModule cur_module;
cur_module.set(cur_name, base_address);
+#if SANITIZER_AIX
+ // Instructions in AIX shared libraries don't start 0x0.
+ if (segment.IsShared() && segment.IsExecutable())
+ cur_module.set_instr_start(InstructionStart);
+#endif
segment.AddAddressRanges(&cur_module);
modules->push_back(cur_module);
}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.cpp
index d24fae98213aa..824fa3ead5b81 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.cpp
@@ -111,13 +111,14 @@ void BufferedStackTrace::UnwindFast(uptr pc, uptr bp, uptr stack_top,
IsAligned((uptr)frame, sizeof(*frame)) &&
size < max_depth) {
#ifdef __powerpc__
- // PowerPC ABIs specify that the return address is saved at offset
- // 16 of the *caller's* stack frame. Thus we must dereference the
- // back chain to find the caller frame before extracting it.
uhwptr *caller_frame = (uhwptr*)frame[0];
if (!IsValidFrame((uptr)caller_frame, stack_top, bottom) ||
!IsAligned((uptr)caller_frame, sizeof(uhwptr)))
break;
+ // PowerPC ABIs(64-bit LE, 64-bit AIX, 32-bit AIX) specify that the return
+ // address is saved at offsettwo ptr size(16 for 64-bit, 8 for 32-bit) of
+ // the *caller's* stack frame. Thus we must dereference the back chain to
+ // find the caller frame before extracting it.
uhwptr pc1 = caller_frame[2];
#elif defined(__s390__)
uhwptr pc1 = frame[14];
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.cpp
index 519f768f89694..3370feb7f17c6 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer.cpp
@@ -46,7 +46,10 @@ void AddressInfo::FillModuleInfo(const char *mod_name, uptr mod_offset,
void AddressInfo::FillModuleInfo(const LoadedModule &mod) {
module = internal_strdup(mod.full_name());
- module_offset = address - mod.base_address();
+ // On some platforms, like on AIX, the first instructions does not start from
+ // 0x0, we need to addd the start back to get correct instruction offset in
+ // the objects.
+ module_offset = address - mod.base_address() + mod.get_instr_start();
module_arch = mod.arch();
if (mod.uuid_size())
internal_memcpy(uuid, mod.uuid(), mod.uuid_size());
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp
index 74458028ae8f5..daa76a692726a 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp
@@ -179,7 +179,13 @@ bool Symbolizer::FindModuleNameAndOffsetForAddress(uptr address,
if (!module)
return false;
*module_name = module->full_name();
+ // On AIX, the address for the data in the object is the same with the runtime one.
+ // So, we don't need to sub the base address.
+#if SANITIZER_AIX
+ *module_offset = address;
+#else
*module_offset = address - module->base_address();
+#endif
*module_arch = module->arch();
return true;
}
@@ -278,6 +284,9 @@ class LLVMSymbolizerProcess final : public SymbolizerProcess {
const char* const kSymbolizerArch = "--default-arch=powerpc64";
#elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
const char* const kSymbolizerArch = "--default-arch=powerpc64le";
+#elif defined(__powerpc__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+ // Must check __powerpc__ after __powerpc64__ because both can be set.
+ const char* const kSymbolizerArch = "--default-arch=powerpc";
#elif defined(__s390x__)
const char* const kSymbolizerArch = "--default-arch=s390x";
#elif defined(__s390__)
@@ -468,7 +477,6 @@ const char *LLVMSymbolizer::FormatAndSendCommand(const char *command_prefix,
Report("WARNING: Command buffer too small");
return nullptr;
}
-
return symbolizer_process_->SendCommand(buffer_);
}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp
index 0ddc24802d216..f5858860c5aa5 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp
@@ -38,9 +38,35 @@
// because we do not require a C++ ABI library to be linked to a program
// using sanitizers; if it's not present, we'll just use the mangled name.
namespace __cxxabiv1 {
+// `weak` attribute without definition on AIX will cause linking time undefined
+// symbol error, we use dlopen/dlsym here to find related symbol.
+# if SANITIZER_AIX
+typedef char *__cxa_demangle_t(const char *mangled, char *buffer,
+ size_t *length, int *status);
+
+char *__cxa_demangle(const char *mangled, char *buffer, size_t *length,
+ int *status) {
+ // Use NULL as the module name, so if the libc++abi module is linked into the
+ // main executable, we are able to find the __cxa_demangle symbol and this
+ // impelemtation will not force libc++abi to be loaded to the executable.
+ void *Handler = dlopen(0, RTLD_NOW);
+ if (!Handler) {
+ return nullptr;
+ }
+
+ auto FooPtr =
+ reinterpret_cast<__cxa_demangle_t *>(dlsym(Handler, "__cxa_demangle"));
+ if (!FooPtr) {
+ return nullptr;
+ }
+
+ return FooPtr(mangled, buffer, length, status);
+}
+# else
extern "C" SANITIZER_WEAK_ATTRIBUTE
char *__cxa_demangle(const char *mangled, char *buffer,
size_t *length, int *status);
+# endif
}
namespace __sanitizer {
@@ -445,17 +471,17 @@ static SymbolizerTool *ChooseExternalSymbolizer(LowLevelAllocator *allocator) {
// Otherwise symbolizer program is unknown, let's search $PATH
CHECK(path == nullptr);
#if SANITIZER_APPLE
- if (const char *found_path = FindPathToBinary("atos")) {
+ if (const char *found_path = FindPathToBinaryOrLibrary("atos")) {
VReport(2, "Using atos found at: %s\n", found_path);
return new(*allocator) AtosSymbolizer(found_path, allocator);
}
#endif // SANITIZER_APPLE
- if (const char *found_path = FindPathToBinary("llvm-symbolizer")) {
+ if (const char *found_path = FindPathToBinaryOrLibrary("llvm-symbolizer")) {
VReport(2, "Using llvm-symbolizer found at: %s\n", found_path);
return new(*allocator) LLVMSymbolizer(found_path, allocator);
}
if (common_flags()->allow_addr2line) {
- if (const char *found_path = FindPathToBinary("addr2line")) {
+ if (const char *found_path = FindPathToBinaryOrLibrary("addr2line")) {
VReport(2, "Using addr2line found at: %s\n", found_path);
return new(*allocator) Addr2LinePool(found_path, allocator);
}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_win.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_win.cpp
index 1ff8b8f1bab48..531632c65fa6b 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_win.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_win.cpp
@@ -289,7 +289,7 @@ static void ChooseSymbolizerTools(IntrusiveList<SymbolizerTool> *list,
}
const char *path =
- user_path ? user_path : FindPathToBinary("llvm-symbolizer.exe");
+ user_path ? user_path : FindPathToBinaryOrLibrary("llvm-symbolizer.exe");
if (path) {
if (user_path && user_path[0] == '\0') {
VReport(2, "External symbolizer is explicitly disabled.\n");
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_unwind_aix.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_unwind_aix.cpp
new file mode 100644
index 0000000000000..45b4b1f3d5c9d
--- /dev/null
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_unwind_aix.cpp
@@ -0,0 +1,66 @@
+//===-- sanitizer_unwind_aix.cpp ------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the unwind.h-based (aka "slow") stack unwinding routines
+// available to the tools on AIX.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+
+#if SANITIZER_AIX
+# include <unwind.h>
+
+# include "sanitizer_common.h"
+# include "sanitizer_stacktrace.h"
+
+namespace __sanitizer {
+
+struct UnwindTraceArg {
+ BufferedStackTrace *stack;
+ u32 max_depth;
+};
+
+_Unwind_Reason_Code Unwind_Trace(struct _Unwind_Context *ctx, void *param) {
+ UnwindTraceArg *arg = (UnwindTraceArg *)param;
+ CHECK_LT(arg->stack->size, arg->max_depth);
+ uptr pc = _Unwind_GetIP(ctx);
+ // On AIX 32-bit and 64-bit, address smaller than 0x0fffffff is for kernel.
+ if (pc <= 0x0fffffff)
+ return _URC_NORMAL_STOP;
+ arg->stack->trace_buffer[arg->stack->size++] = pc;
+ if (arg->stack->size == arg->max_depth)
+ return _URC_NORMAL_STOP;
+ return _URC_NO_REASON;
+}
+
+void BufferedStackTrace::UnwindSlow(uptr pc, u32 max_depth) {
+ CHECK_GE(max_depth, 2);
+ size = 0;
+ UnwindTraceArg arg = {this, Min(max_depth + 1, kStackTraceMax)};
+ _Unwind_Backtrace(Unwind_Trace, &arg);
+ // We need to pop a few frames so that pc is on top.
+ uptr to_pop = LocatePcInTrace(pc);
+ // trace_buffer[0] belongs to the current function so we always pop it,
+ // unless there is only 1 frame in the stack trace (1 frame is always better
+ // than 0!).
+ // 1-frame stacks don't normally happen, but this depends on the actual
+ // unwinder implementation (libgcc, libunwind, etc) which is outside of our
+ // control.
+ if (to_pop == 0 && size > 1)
+ to_pop = 1;
+
+ PopStackFrames(to_pop);
+ trace_buffer[0] = pc;
+}
+
+void BufferedStackTrace::UnwindSlow(uptr pc, void *context, u32 max_depth) {
+ UnwindSlow(pc, max_depth);
+}
+} // namespace __sanitizer
+
+#endif // SANITIZER_AIX
diff --git a/compiler-rt/test/sanitizer_common/TestCases/Inputs/sanitizer_default_arch/llvm-symbolizer b/compiler-rt/test/sanitizer_common/TestCases/Inputs/sanitizer_default_arch/llvm-symbolizer
new file mode 100644
index 0000000000000..4a3d68a43ad7d
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/Inputs/sanitizer_default_arch/llvm-symbolizer
@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+
+# Assisted by watsonx Code Assistant
+import json
+import sys
+print(json.dumps(sys.argv[1:]), file=sys.stderr)
+print("main\n??:0:0\n")
diff --git a/compiler-rt/test/sanitizer_common/TestCases/symbolizer_default_arch_ppc64.cpp b/compiler-rt/test/sanitizer_common/TestCases/symbolizer_default_arch_ppc64.cpp
new file mode 100644
index 0000000000000..714bcd5332821
--- /dev/null
+++ b/compiler-rt/test/sanitizer_common/TestCases/symbolizer_default_arch_ppc64.cpp
@@ -0,0 +1,18 @@
+// REQUIRES: powerpc64-target-arch
+
+// RUN: %clangxx -O0 %s -o %t
+// RUN: %env_tool_opts=external_symbolizer_path=%p/Inputs/sanitizer_default_arch/llvm-symbolizer \
+// RUN: %run %t 2>&1 | FileCheck %s
+
+#include <sanitizer/common_interface_defs.h>
+
+static void Symbolize() {
+ char buffer[100];
+ __sanitizer_symbolize_pc(__builtin_return_address(0), "%p %F %L", buffer,
+ sizeof(buffer));
+}
+
+int main() {
+ // CHECK: "--default-arch=powerpc64"
+ Symbolize();
+}
>From 8506adb7459d02c638d9494a9a95d3a190fe4a2a Mon Sep 17 00:00:00 2001
From: Jake Egan <jake.egan at ibm.com>
Date: Fri, 21 Mar 2025 11:51:16 -0400
Subject: [PATCH 2/6] Fix formatting
---
.../lib/sanitizer_common/sanitizer_aix.cpp | 2 +-
.../lib/sanitizer_common/sanitizer_aix.h | 8 ++++----
.../lib/sanitizer_common/sanitizer_posix.h | 8 ++++----
.../sanitizer_posix_libcdep.cpp | 14 +++++++-------
.../lib/sanitizer_common/sanitizer_procmaps.h | 19 +++++++++----------
.../sanitizer_procmaps_aix.cpp | 8 ++++----
.../sanitizer_procmaps_common.cpp | 12 ++++++------
.../sanitizer_common/sanitizer_stacktrace.cpp | 2 +-
.../sanitizer_symbolizer_libcdep.cpp | 6 ------
.../sanitizer_symbolizer_posix_libcdep.cpp | 7 ++++---
10 files changed, 40 insertions(+), 46 deletions(-)
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_aix.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_aix.cpp
index fac3d7b10829f..edbbabe65dcb6 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_aix.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_aix.cpp
@@ -270,7 +270,7 @@ void internal_join_thread(void *th) {
uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) {
clock_t rclk_id = reinterpret_cast<clock_t>(clk_id);
struct timespec *rtp = reinterpret_cast<struct timespec *>(tp);
- DEFINE__REAL(uptr, clock_gettime, clock_t rclk_id, struct timespec * rtp);
+ DEFINE__REAL(uptr, clock_gettime, clock_t rclk_id, struct timespec *rtp);
return _REAL(clock_gettime, rclk_id, rtp);
}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_aix.h b/compiler-rt/lib/sanitizer_common/sanitizer_aix.h
index 5883d1f2e16de..8854db9d3b259 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_aix.h
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_aix.h
@@ -15,16 +15,16 @@
#include "sanitizer_platform.h"
#if SANITIZER_AIX
-#include "sanitizer_common.h"
+# include "sanitizer_common.h"
# include "sanitizer_posix.h"
namespace __sanitizer {
-#if SANITIZER_WORDSIZE == 32
+# if SANITIZER_WORDSIZE == 32
static const uptr InstructionStart = 0x10000000;
-#else
+# else
static const uptr InstructionStart = 0x100000000;
-#endif
+# endif
struct ProcSelfMapsBuff {
char *data;
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_posix.h b/compiler-rt/lib/sanitizer_common/sanitizer_posix.h
index da9cd92357145..942cbf4e736ab 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_posix.h
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_posix.h
@@ -33,10 +33,10 @@ uptr internal_close_range(fd_t lowfd, fd_t highfd, int flags);
# endif
uptr internal_close(fd_t fd);
-#if SANITIZER_AIX
-__sanitizer_FILE* internal_popen(const char *command, const char *type);
-int internal_pclose(__sanitizer_FILE* file);
-#endif
+# if SANITIZER_AIX
+__sanitizer_FILE *internal_popen(const char *command, const char *type);
+int internal_pclose(__sanitizer_FILE *file);
+# endif
uptr internal_read(fd_t fd, void *buf, uptr count);
uptr internal_write(fd_t fd, const void *buf, uptr count);
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp
index 307d8c969a338..5411e074c797e 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp
@@ -36,7 +36,7 @@
#include <sys/wait.h>
#include <unistd.h>
-#if SANITIZER_FREEBSD || SANITIZER_AIX
+# if SANITIZER_FREEBSD || SANITIZER_AIX
// The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before
// that, it was never implemented. So just define it to zero.
#undef MAP_NORESERVE
@@ -438,21 +438,21 @@ uptr ReservedAddressRange::Init(uptr size, const char *name, uptr fixed_addr) {
// Uses fixed_addr for now.
// Will use offset instead once we've implemented this function for real.
uptr ReservedAddressRange::Map(uptr fixed_addr, uptr size, const char *name) {
-#if SANITIZER_AIX
+# if SANITIZER_AIX
return fixed_addr;
-#else
+# else
return reinterpret_cast<uptr>(
MmapFixedOrDieOnFatalError(fixed_addr, size, name));
-#endif
+# endif
}
uptr ReservedAddressRange::MapOrDie(uptr fixed_addr, uptr size,
const char *name) {
-#if SANITIZER_AIX
+# if SANITIZER_AIX
return fixed_addr;
-#else
+# else
return reinterpret_cast<uptr>(MmapFixedOrDie(fixed_addr, size, name));
-#endif
+# endif
}
void ReservedAddressRange::Unmap(uptr addr, uptr size) {
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps.h b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps.h
index 8e5162f40a55b..2708fa4b129dd 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps.h
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps.h
@@ -16,16 +16,15 @@
#include "sanitizer_platform.h"
#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || \
- SANITIZER_APPLE || SANITIZER_SOLARIS || \
- SANITIZER_FUCHSIA || SANITIZER_AIX
-
-#include "sanitizer_common.h"
-#include "sanitizer_internal_defs.h"
-#include "sanitizer_fuchsia.h"
-#include "sanitizer_linux.h"
-#include "sanitizer_mac.h"
-#include "sanitizer_mutex.h"
-#include "sanitizer_aix.h"
+ SANITIZER_APPLE || SANITIZER_SOLARIS || SANITIZER_FUCHSIA || SANITIZER_AIX
+
+# include "sanitizer_aix.h"
+# include "sanitizer_common.h"
+# include "sanitizer_fuchsia.h"
+# include "sanitizer_internal_defs.h"
+# include "sanitizer_linux.h"
+# include "sanitizer_mac.h"
+# include "sanitizer_mutex.h"
namespace __sanitizer {
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_aix.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_aix.cpp
index 852aba2f169b8..6394b0878ff6c 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_aix.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_aix.cpp
@@ -15,8 +15,8 @@
# include <stdio.h>
# include "sanitizer_common.h"
-# include "sanitizer_procmaps.h"
# include "sanitizer_file.h"
+# include "sanitizer_procmaps.h"
namespace __sanitizer {
@@ -148,8 +148,8 @@ bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) {
if (!NameEnd)
NameEnd = next_line - 1;
- uptr len = Min((uptr)(NameEnd - data_.current),
- segment->filename_size - 1);
+ uptr len =
+ Min((uptr)(NameEnd - data_.current), segment->filename_size - 1);
internal_strncpy(segment->filename, data_.current, len);
segment->filename[len] = 0;
@@ -191,7 +191,7 @@ bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) {
Min((uptr)(internal_strlen(LibName)), segment->filename_size - 1);
internal_strncpy(segment->filename, LibName, len);
segment->filename[len] = 0;
- found = true;
+ found = true;
}
CHECK(found);
}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_common.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_common.cpp
index 4089420c8f63e..21b7c7e153c8d 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_common.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_common.cpp
@@ -11,12 +11,12 @@
#include "sanitizer_platform.h"
-#if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
+#if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
SANITIZER_SOLARIS || SANITIZER_AIX
-#include "sanitizer_common.h"
-#include "sanitizer_placement_new.h"
-#include "sanitizer_procmaps.h"
+# include "sanitizer_common.h"
+# include "sanitizer_placement_new.h"
+# include "sanitizer_procmaps.h"
namespace __sanitizer {
@@ -140,11 +140,11 @@ void MemoryMappingLayout::DumpListOfModules(
uptr base_address = (i ? segment.start : 0) - segment.offset;
LoadedModule cur_module;
cur_module.set(cur_name, base_address);
-#if SANITIZER_AIX
+# if SANITIZER_AIX
// Instructions in AIX shared libraries don't start 0x0.
if (segment.IsShared() && segment.IsExecutable())
cur_module.set_instr_start(InstructionStart);
-#endif
+# endif
segment.AddAddressRanges(&cur_module);
modules->push_back(cur_module);
}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.cpp
index 824fa3ead5b81..e715f949a899f 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.cpp
@@ -110,7 +110,7 @@ void BufferedStackTrace::UnwindFast(uptr pc, uptr bp, uptr stack_top,
while (IsValidFrame((uptr)frame, stack_top, bottom) &&
IsAligned((uptr)frame, sizeof(*frame)) &&
size < max_depth) {
-#ifdef __powerpc__
+# ifdef __powerpc__
uhwptr *caller_frame = (uhwptr*)frame[0];
if (!IsValidFrame((uptr)caller_frame, stack_top, bottom) ||
!IsAligned((uptr)caller_frame, sizeof(uhwptr)))
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp
index daa76a692726a..3cfbba5e3c7f0 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp
@@ -179,13 +179,7 @@ bool Symbolizer::FindModuleNameAndOffsetForAddress(uptr address,
if (!module)
return false;
*module_name = module->full_name();
- // On AIX, the address for the data in the object is the same with the runtime one.
- // So, we don't need to sub the base address.
-#if SANITIZER_AIX
- *module_offset = address;
-#else
*module_offset = address - module->base_address();
-#endif
*module_arch = module->arch();
return true;
}
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp
index f5858860c5aa5..f25bfe4b79496 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp
@@ -63,9 +63,10 @@ char *__cxa_demangle(const char *mangled, char *buffer, size_t *length,
return FooPtr(mangled, buffer, length, status);
}
# else
- extern "C" SANITIZER_WEAK_ATTRIBUTE
- char *__cxa_demangle(const char *mangled, char *buffer,
- size_t *length, int *status);
+extern "C" SANITIZER_WEAK_ATTRIBUTE char *__cxa_demangle(const char *mangled,
+ char *buffer,
+ size_t *length,
+ int *status);
# endif
}
>From 796e86658402891c32e471746c08e11e388d1450 Mon Sep 17 00:00:00 2001
From: Jake Egan <jake.egan at ibm.com>
Date: Fri, 21 Mar 2025 11:54:33 -0400
Subject: [PATCH 3/6] Revert deleted whitespace
---
.../lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp | 1 +
1 file changed, 1 insertion(+)
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp
index 3cfbba5e3c7f0..b4dbddcb68a0d 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp
@@ -471,6 +471,7 @@ const char *LLVMSymbolizer::FormatAndSendCommand(const char *command_prefix,
Report("WARNING: Command buffer too small");
return nullptr;
}
+
return symbolizer_process_->SendCommand(buffer_);
}
>From 5328967121822ad7ed13388b80419f21604fcd65 Mon Sep 17 00:00:00 2001
From: Jake Egan <jake.egan at ibm.com>
Date: Mon, 24 Mar 2025 04:02:56 -0400
Subject: [PATCH 4/6] Fix build failure on Linux
---
.../sanitizer_common/tests/sanitizer_common_test.cpp | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/compiler-rt/lib/sanitizer_common/tests/sanitizer_common_test.cpp b/compiler-rt/lib/sanitizer_common/tests/sanitizer_common_test.cpp
index 111e55ef36bfb..598f9232149dd 100644
--- a/compiler-rt/lib/sanitizer_common/tests/sanitizer_common_test.cpp
+++ b/compiler-rt/lib/sanitizer_common/tests/sanitizer_common_test.cpp
@@ -325,20 +325,20 @@ INSTANTIATE_TEST_SUITE_P(SortAndDedupTest, SortAndDedupTest,
::testing::ValuesIn(kSortAndDedupTests));
#if SANITIZER_LINUX && !SANITIZER_ANDROID
-TEST(SanitizerCommon, FindPathToBinary) {
- char *true_path = FindPathToBinary("true");
+TEST(SanitizerCommon, FindPathToBinaryOrLibrary) {
+ char *true_path = FindPathToBinaryOrLibrary("true");
EXPECT_NE((char*)0, internal_strstr(true_path, "/bin/true"));
InternalFree(true_path);
- EXPECT_EQ(0, FindPathToBinary("unexisting_binary.ergjeorj"));
+ EXPECT_EQ(0, FindPathToBinaryOrLibrary("unexisting_binary.ergjeorj"));
}
#elif SANITIZER_WINDOWS
-TEST(SanitizerCommon, FindPathToBinary) {
+TEST(SanitizerCommon, FindPathToBinaryOrLibrary) {
// ntdll.dll should be on PATH in all supported test environments on all
// supported Windows versions.
- char *ntdll_path = FindPathToBinary("ntdll.dll");
+ char *ntdll_path = FindPathToBinaryOrLibrary("ntdll.dll");
EXPECT_NE((char*)0, internal_strstr(ntdll_path, "ntdll.dll"));
InternalFree(ntdll_path);
- EXPECT_EQ(0, FindPathToBinary("unexisting_binary.ergjeorj"));
+ EXPECT_EQ(0, FindPathToBinaryOrLibrary("unexisting_binary.ergjeorj"));
}
#endif
>From 44e2d8eedc9c21b11f21f19a6dd36f30f7387a9b Mon Sep 17 00:00:00 2001
From: Jake Egan <jake.egan at ibm.com>
Date: Mon, 24 Mar 2025 07:55:15 -0400
Subject: [PATCH 5/6] getenviron
---
compiler-rt/lib/sanitizer_common/sanitizer_aix.cpp | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_aix.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_aix.cpp
index edbbabe65dcb6..b45ce619d7098 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_aix.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_aix.cpp
@@ -39,6 +39,7 @@
# include "sanitizer_libc.h"
# include "sanitizer_procmaps.h"
+extern char **environ;
extern char **p_xargv;
namespace __sanitizer {
@@ -473,7 +474,7 @@ void SignalContext::InitPcSpBp() {
void SignalContext::DumpAllRegisters(void *context) {}
-char **GetEnviron() { return nullptr; }
+char **GetEnviron() { return environ; }
char **GetArgv() { return p_xargv; }
>From ab9cd921c0089996750535b144e328bc81507e13 Mon Sep 17 00:00:00 2001
From: Jake Egan <jake.egan at ibm.com>
Date: Tue, 25 Mar 2025 01:58:03 -0400
Subject: [PATCH 6/6] Don't use procmap utility
---
.../lib/sanitizer_common/sanitizer_aix.h | 4 +
.../sanitizer_procmaps_aix.cpp | 162 +++++++-----------
2 files changed, 69 insertions(+), 97 deletions(-)
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_aix.h b/compiler-rt/lib/sanitizer_common/sanitizer_aix.h
index 8854db9d3b259..6c48cec22772d 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_aix.h
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_aix.h
@@ -18,6 +18,9 @@
# include "sanitizer_common.h"
# include "sanitizer_posix.h"
+struct prmap;
+ typedef struct prmap prmap_t;
+
namespace __sanitizer {
# if SANITIZER_WORDSIZE == 32
@@ -30,6 +33,7 @@ struct ProcSelfMapsBuff {
char *data;
uptr mmaped_size;
uptr len;
+ prmap_t *mapEnd;
};
struct MemoryMappingLayoutData {
diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_aix.cpp b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_aix.cpp
index 6394b0878ff6c..54088b9947a20 100644
--- a/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_aix.cpp
+++ b/compiler-rt/lib/sanitizer_common/sanitizer_procmaps_aix.cpp
@@ -12,127 +12,97 @@
#include "sanitizer_platform.h"
#if SANITIZER_AIX
+# include <assert.h>
+# include <stdlib.h>
# include <stdio.h>
+# include <sys/procfs.h>
# include "sanitizer_common.h"
-# include "sanitizer_file.h"
# include "sanitizer_procmaps.h"
+# include "sanitizer_file.h"
namespace __sanitizer {
-static bool IsOneOf(char c, char c1, char c2) { return c == c1 || c == c2; }
+static int qsort_comp(const void *va, const void * vb) {
+ const prmap_t *a = (const prmap_t *)va;
+ const prmap_t *b = (const prmap_t *)vb;
-void ReadProcMaps(ProcSelfMapsBuff *proc_maps) {
- uptr pid = internal_getpid();
+ if (a->pr_vaddr < b->pr_vaddr)
+ return -1;
+
+ if (a->pr_vaddr > b->pr_vaddr)
+ return 1;
+
+ return 0;
+}
- // The mapping in /proc/id/map is not ordered by address, this will hit some
- // issue when checking stack base and size. Howevern AIX procmap can generate
- // sorted ranges.
- char Command[100] = {};
+static prmap_t *SortProcMapEntries(char *buffer) {
+ prmap_t *begin = (prmap_t*)buffer;
+ prmap_t *mapIter = begin;
+ // The AIX procmap utility detects the end of the array of `prmap`s by finding
+ // an entry where pr_size and pr_vaddr are both zero.
+ while (mapIter->pr_size != 0 || mapIter->pr_vaddr != 0)
+ ++mapIter;
+ prmap_t *end = mapIter;
- internal_snprintf(Command, 100, "procmap -qX %d", pid);
- // Open pipe to file
- __sanitizer_FILE *pipe = internal_popen(Command, "r");
+ size_t count = end - begin;
+ size_t elemSize = sizeof(prmap_t);
+ qsort(begin, count, elemSize, qsort_comp);
- if (!pipe) {
+ return end;
+}
+
+void ReadProcMaps(ProcSelfMapsBuff *proc_maps) {
+ uptr pid = internal_getpid();
+ constexpr unsigned BUFFER_SIZE = 128;
+ char filenameBuf[BUFFER_SIZE] = {};
+ internal_snprintf(filenameBuf, BUFFER_SIZE, "/proc/%d/map", pid);
+ if (!ReadFileToBuffer(filenameBuf, &proc_maps->data, &proc_maps->mmaped_size, &proc_maps->len)) {
proc_maps->data = nullptr;
proc_maps->mmaped_size = 0;
proc_maps->len = 0;
+ proc_maps->mapEnd = nullptr;
return;
}
- char buffer[512] = {};
-
- InternalScopedString Data;
- while (fgets(buffer, 512, reinterpret_cast<FILE *>(pipe)) != nullptr)
- Data.Append(buffer);
-
- size_t MmapedSize = Data.length() * 4 / 3;
- void *VmMap = MmapOrDie(MmapedSize, "ReadProcMaps()");
- internal_memcpy(VmMap, Data.data(), Data.length());
-
- proc_maps->data = (char *)VmMap;
- proc_maps->mmaped_size = MmapedSize;
- proc_maps->len = Data.length();
-
- internal_pclose(pipe);
+ proc_maps->mapEnd = SortProcMapEntries(proc_maps->data);
}
bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) {
if (Error())
return false; // simulate empty maps
- char *last = data_.proc_self_maps.data + data_.proc_self_maps.len;
- if (data_.current >= last)
- return false;
- char *next_line =
- (char *)internal_memchr(data_.current, '\n', last - data_.current);
-
- // Skip the first header line and the second kernel line
- // pid : binary name
- if (data_.current == data_.proc_self_maps.data) {
- data_.current = next_line + 1;
- next_line =
- (char *)internal_memchr(next_line + 1, '\n', last - data_.current);
-
- data_.current = next_line + 1;
- next_line =
- (char *)internal_memchr(next_line + 1, '\n', last - data_.current);
- }
- if (next_line == 0)
- next_line = last;
+ const prmap_t *mapIter = (const prmap_t *)data_.current;
- // Skip the last line:
- // Total 533562K
- if (!IsHex(*data_.current))
+ if (mapIter >= data_.proc_self_maps.mapEnd)
return false;
- // Example: 10000000 10161fd9 1415K r-x s MAINTEXT 151ed82 a.out
- segment->start = ParseHex(&data_.current);
- while (data_.current < next_line && *data_.current == ' ') data_.current++;
+ // Skip the kernel segment.
+ if ((mapIter->pr_mflags & MA_TYPE_MASK) == MA_KERNTEXT)
+ ++mapIter;
- segment->end = ParseHex(&data_.current);
- while (data_.current < next_line && *data_.current == ' ') data_.current++;
+ if (mapIter >= data_.proc_self_maps.mapEnd)
+ return false;
- // Ignore the size, we can get accurate size from end and start
- while (IsDecimal(*data_.current)) data_.current++;
- CHECK_EQ(*data_.current++, 'K');
+ segment->start = (uptr)mapIter->pr_vaddr;
+ segment->end = segment->start + mapIter->pr_size;
- while (data_.current < next_line && *data_.current == ' ') data_.current++;
segment->protection = 0;
-
- if (*data_.current++ == 'r')
+ uint32_t flags = mapIter->pr_mflags;
+ if (flags & MA_READ)
segment->protection |= kProtectionRead;
- CHECK(IsOneOf(*data_.current, '-', 'w'));
- if (*data_.current++ == 'w')
+ if (flags & MA_WRITE)
segment->protection |= kProtectionWrite;
- CHECK(IsOneOf(*data_.current, '-', 'x'));
- if (*data_.current++ == 'x')
+ if (flags & MA_EXEC)
segment->protection |= kProtectionExecute;
- // Ignore the PSIZE(s/m/L/H)
- while (data_.current < next_line && *data_.current == ' ') data_.current++;
- data_.current += 4;
-
- // Get the region TYPE
- while (data_.current < next_line && *data_.current == ' ') data_.current++;
- char Type[16] = {};
- uptr len = 0;
- while (*data_.current != ' ') Type[len++] = *data_.current++;
- Type[len] = 0;
-
- if (!internal_strcmp(Type, "SLIBTEXT") || !internal_strcmp(Type, "PLIBDATA"))
+ // TODO FIXME why not PLIBTEXT?
+ uint32_t type = mapIter->pr_mflags & MA_TYPE_MASK;
+ if (type == MA_SLIBTEXT || type == MA_PLIBDATA)
segment->protection |= kProtectionShared;
- // Ignore the VSID
- while (data_.current < next_line && *data_.current == ' ') data_.current++;
- ParseHex(&data_.current);
-
- while (data_.current < next_line && *data_.current == ' ') data_.current++;
-
- if (segment->filename && data_.current != next_line) {
- if (!internal_strcmp(Type, "MAINDATA") ||
- !internal_strcmp(Type, "MAINTEXT")) {
+ if (segment->filename && mapIter->pr_pathoff) {
+ if (type == MA_MAINDATA || type == MA_MAINEXEC) {
// AIX procmap does not print full name for the binary, however when using
// llvm-symbolizer, it requires the binary must be with full name.
const char *BinaryName = GetBinaryName();
@@ -143,20 +113,16 @@ bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) {
} else {
// AIX library may exist as xxx.a[yyy.o], to find the path to xxx.a,
// the [yyy.o] part needs to be removed.
- char *NameEnd = (char *)internal_memchr(data_.current, '[',
- next_line - data_.current);
- if (!NameEnd)
- NameEnd = next_line - 1;
- uptr len =
- Min((uptr)(NameEnd - data_.current), segment->filename_size - 1);
- internal_strncpy(segment->filename, data_.current, len);
+ // TODO FIXME
+ const char *pathPtr = data_.proc_self_maps.data + mapIter->pr_pathoff;
+ uptr len = Min((uptr)internal_strlen(pathPtr),
+ segment->filename_size - 1);
+ internal_strncpy(segment->filename, pathPtr, len);
segment->filename[len] = 0;
-
// AIX procmap does not print full name for user's library , however when
// use llvm-symbolizer, it requires the library must be with full name.
- if ((!internal_strcmp(Type, "SLIBTEXT") ||
- !internal_strcmp(Type, "PLIBDATA")) &&
+ if ((type == MA_SLIBTEXT || type == MA_PLIBDATA) &&
segment->filename[0] != '/') {
// First check if the library is in the directory where the binary is
// executed. On AIX, there is no need to put library in same dir with
@@ -191,7 +157,7 @@ bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) {
Min((uptr)(internal_strlen(LibName)), segment->filename_size - 1);
internal_strncpy(segment->filename, LibName, len);
segment->filename[len] = 0;
- found = true;
+ found = true;
}
CHECK(found);
}
@@ -200,9 +166,11 @@ bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) {
segment->filename[0] = 0;
}
+ assert(mapIter->pr_off == 0 && "expect a zero offset into module.");
segment->offset = 0;
- data_.current = next_line + 1;
+ ++mapIter;
+ data_.current = (const char*)mapIter;
return true;
}
More information about the llvm-commits
mailing list