1 //===-- sanitizer_linux.cc ------------------------------------------------===//
3 // This file is distributed under the University of Illinois Open Source
4 // License. See LICENSE.TXT for details.
6 //===----------------------------------------------------------------------===//
8 // This file is shared between AddressSanitizer and ThreadSanitizer
9 // run-time libraries and implements linux-specific functions from
11 //===----------------------------------------------------------------------===//
13 #include "sanitizer_platform.h"
15 #if SANITIZER_FREEBSD || SANITIZER_LINUX
17 #include "sanitizer_common.h"
18 #include "sanitizer_flags.h"
19 #include "sanitizer_internal_defs.h"
20 #include "sanitizer_libc.h"
21 #include "sanitizer_linux.h"
22 #include "sanitizer_mutex.h"
23 #include "sanitizer_placement_new.h"
24 #include "sanitizer_procmaps.h"
25 #include "sanitizer_stacktrace.h"
26 #include "sanitizer_symbolizer.h"
28 #if !SANITIZER_FREEBSD
29 #include <asm/param.h>
32 // For mips64, syscall(__NR_stat) fills the buffer in the 'struct kernel_stat'
33 // format. Struct kernel_stat is defined as 'struct stat' in asm/stat.h. To
34 // access stat from asm/stat.h, without conflicting with definition in
35 // sys/stat.h, we use this trick.
37 #include <asm/unistd.h>
38 #include <sys/types.h>
39 #define stat kernel_stat
51 #include <sys/ptrace.h>
52 #include <sys/resource.h>
54 #include <sys/syscall.h>
56 #include <sys/types.h>
62 #include <sys/sysctl.h>
63 #include <vm/vm_param.h>
65 #include <machine/atomic.h>
67 // <sys/umtx.h> must be included after <errno.h> and <sys/types.h> on
68 // FreeBSD 9.2 and 10.0.
71 extern char **environ
; // provided by crt1
72 #endif // SANITIZER_FREEBSD
74 #if !SANITIZER_ANDROID
75 #include <sys/signal.h>
80 struct kernel_timeval
{
85 // <linux/futex.h> is broken on some linux distributions.
86 const int FUTEX_WAIT
= 0;
87 const int FUTEX_WAKE
= 1;
88 #endif // SANITIZER_LINUX
90 // Are we using 32-bit or 64-bit Linux syscalls?
91 // x32 (which defines __x86_64__) has SANITIZER_WORDSIZE == 32
92 // but it still needs to use 64-bit syscalls.
93 #if SANITIZER_LINUX && (defined(__x86_64__) || defined(__powerpc64__) || \
94 SANITIZER_WORDSIZE == 64)
95 # define SANITIZER_LINUX_USES_64BIT_SYSCALLS 1
97 # define SANITIZER_LINUX_USES_64BIT_SYSCALLS 0
100 #if defined(__x86_64__) || SANITIZER_MIPS64
102 extern void internal_sigreturn();
106 namespace __sanitizer
{
108 #if SANITIZER_LINUX && defined(__x86_64__)
109 #include "sanitizer_syscall_linux_x86_64.inc"
110 #elif SANITIZER_LINUX && defined(__aarch64__)
111 #include "sanitizer_syscall_linux_aarch64.inc"
113 #include "sanitizer_syscall_generic.inc"
116 // --------------- sanitizer_libc.h
118 uptr
internal_mmap(void *addr
, uptr length
, int prot
, int flags
, int fd
,
120 #if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS
121 return internal_syscall(SYSCALL(mmap
), (uptr
)addr
, length
, prot
, flags
, fd
,
124 // mmap2 specifies file offset in 4096-byte units.
125 CHECK(IsAligned(offset
, 4096));
126 return internal_syscall(SYSCALL(mmap2
), addr
, length
, prot
, flags
, fd
,
130 #endif // !SANITIZER_S390
132 uptr
internal_munmap(void *addr
, uptr length
) {
133 return internal_syscall(SYSCALL(munmap
), (uptr
)addr
, length
);
136 int internal_mprotect(void *addr
, uptr length
, int prot
) {
137 return internal_syscall(SYSCALL(mprotect
), (uptr
)addr
, length
, prot
);
140 uptr
internal_close(fd_t fd
) {
141 return internal_syscall(SYSCALL(close
), fd
);
144 uptr
internal_open(const char *filename
, int flags
) {
145 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
146 return internal_syscall(SYSCALL(openat
), AT_FDCWD
, (uptr
)filename
, flags
);
148 return internal_syscall(SYSCALL(open
), (uptr
)filename
, flags
);
152 uptr
internal_open(const char *filename
, int flags
, u32 mode
) {
153 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
154 return internal_syscall(SYSCALL(openat
), AT_FDCWD
, (uptr
)filename
, flags
,
157 return internal_syscall(SYSCALL(open
), (uptr
)filename
, flags
, mode
);
161 uptr
internal_read(fd_t fd
, void *buf
, uptr count
) {
163 HANDLE_EINTR(res
, (sptr
)internal_syscall(SYSCALL(read
), fd
, (uptr
)buf
,
168 uptr
internal_write(fd_t fd
, const void *buf
, uptr count
) {
170 HANDLE_EINTR(res
, (sptr
)internal_syscall(SYSCALL(write
), fd
, (uptr
)buf
,
175 uptr
internal_ftruncate(fd_t fd
, uptr size
) {
177 HANDLE_EINTR(res
, (sptr
)internal_syscall(SYSCALL(ftruncate
), fd
,
182 #if !SANITIZER_LINUX_USES_64BIT_SYSCALLS && !SANITIZER_FREEBSD
183 static void stat64_to_stat(struct stat64
*in
, struct stat
*out
) {
184 internal_memset(out
, 0, sizeof(*out
));
185 out
->st_dev
= in
->st_dev
;
186 out
->st_ino
= in
->st_ino
;
187 out
->st_mode
= in
->st_mode
;
188 out
->st_nlink
= in
->st_nlink
;
189 out
->st_uid
= in
->st_uid
;
190 out
->st_gid
= in
->st_gid
;
191 out
->st_rdev
= in
->st_rdev
;
192 out
->st_size
= in
->st_size
;
193 out
->st_blksize
= in
->st_blksize
;
194 out
->st_blocks
= in
->st_blocks
;
195 out
->st_atime
= in
->st_atime
;
196 out
->st_mtime
= in
->st_mtime
;
197 out
->st_ctime
= in
->st_ctime
;
198 out
->st_ino
= in
->st_ino
;
202 #if defined(__mips64)
203 static void kernel_stat_to_stat(struct kernel_stat
*in
, struct stat
*out
) {
204 internal_memset(out
, 0, sizeof(*out
));
205 out
->st_dev
= in
->st_dev
;
206 out
->st_ino
= in
->st_ino
;
207 out
->st_mode
= in
->st_mode
;
208 out
->st_nlink
= in
->st_nlink
;
209 out
->st_uid
= in
->st_uid
;
210 out
->st_gid
= in
->st_gid
;
211 out
->st_rdev
= in
->st_rdev
;
212 out
->st_size
= in
->st_size
;
213 out
->st_blksize
= in
->st_blksize
;
214 out
->st_blocks
= in
->st_blocks
;
215 out
->st_atime
= in
->st_atime_nsec
;
216 out
->st_mtime
= in
->st_mtime_nsec
;
217 out
->st_ctime
= in
->st_ctime_nsec
;
218 out
->st_ino
= in
->st_ino
;
222 uptr
internal_stat(const char *path
, void *buf
) {
223 #if SANITIZER_FREEBSD
224 return internal_syscall(SYSCALL(stat
), path
, buf
);
225 #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
226 return internal_syscall(SYSCALL(newfstatat
), AT_FDCWD
, (uptr
)path
,
228 #elif SANITIZER_LINUX_USES_64BIT_SYSCALLS
229 # if defined(__mips64)
230 // For mips64, stat syscall fills buffer in the format of kernel_stat
231 struct kernel_stat kbuf
;
232 int res
= internal_syscall(SYSCALL(stat
), path
, &kbuf
);
233 kernel_stat_to_stat(&kbuf
, (struct stat
*)buf
);
236 return internal_syscall(SYSCALL(stat
), (uptr
)path
, (uptr
)buf
);
240 int res
= internal_syscall(SYSCALL(stat64
), path
, &buf64
);
241 stat64_to_stat(&buf64
, (struct stat
*)buf
);
246 uptr
internal_lstat(const char *path
, void *buf
) {
247 #if SANITIZER_FREEBSD
248 return internal_syscall(SYSCALL(lstat
), path
, buf
);
249 #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
250 return internal_syscall(SYSCALL(newfstatat
), AT_FDCWD
, (uptr
)path
,
251 (uptr
)buf
, AT_SYMLINK_NOFOLLOW
);
252 #elif SANITIZER_LINUX_USES_64BIT_SYSCALLS
253 # if SANITIZER_MIPS64
254 // For mips64, lstat syscall fills buffer in the format of kernel_stat
255 struct kernel_stat kbuf
;
256 int res
= internal_syscall(SYSCALL(lstat
), path
, &kbuf
);
257 kernel_stat_to_stat(&kbuf
, (struct stat
*)buf
);
260 return internal_syscall(SYSCALL(lstat
), (uptr
)path
, (uptr
)buf
);
264 int res
= internal_syscall(SYSCALL(lstat64
), path
, &buf64
);
265 stat64_to_stat(&buf64
, (struct stat
*)buf
);
270 uptr
internal_fstat(fd_t fd
, void *buf
) {
271 #if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS
272 # if SANITIZER_MIPS64
273 // For mips64, fstat syscall fills buffer in the format of kernel_stat
274 struct kernel_stat kbuf
;
275 int res
= internal_syscall(SYSCALL(fstat
), fd
, &kbuf
);
276 kernel_stat_to_stat(&kbuf
, (struct stat
*)buf
);
279 return internal_syscall(SYSCALL(fstat
), fd
, (uptr
)buf
);
283 int res
= internal_syscall(SYSCALL(fstat64
), fd
, &buf64
);
284 stat64_to_stat(&buf64
, (struct stat
*)buf
);
289 uptr
internal_filesize(fd_t fd
) {
291 if (internal_fstat(fd
, &st
))
293 return (uptr
)st
.st_size
;
296 uptr
internal_dup2(int oldfd
, int newfd
) {
297 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
298 return internal_syscall(SYSCALL(dup3
), oldfd
, newfd
, 0);
300 return internal_syscall(SYSCALL(dup2
), oldfd
, newfd
);
304 uptr
internal_readlink(const char *path
, char *buf
, uptr bufsize
) {
305 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
306 return internal_syscall(SYSCALL(readlinkat
), AT_FDCWD
,
307 (uptr
)path
, (uptr
)buf
, bufsize
);
309 return internal_syscall(SYSCALL(readlink
), (uptr
)path
, (uptr
)buf
, bufsize
);
313 uptr
internal_unlink(const char *path
) {
314 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
315 return internal_syscall(SYSCALL(unlinkat
), AT_FDCWD
, (uptr
)path
, 0);
317 return internal_syscall(SYSCALL(unlink
), (uptr
)path
);
321 uptr
internal_rename(const char *oldpath
, const char *newpath
) {
322 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
323 return internal_syscall(SYSCALL(renameat
), AT_FDCWD
, (uptr
)oldpath
, AT_FDCWD
,
326 return internal_syscall(SYSCALL(rename
), (uptr
)oldpath
, (uptr
)newpath
);
330 uptr
internal_sched_yield() {
331 return internal_syscall(SYSCALL(sched_yield
));
334 void internal__exit(int exitcode
) {
335 #if SANITIZER_FREEBSD
336 internal_syscall(SYSCALL(exit
), exitcode
);
338 internal_syscall(SYSCALL(exit_group
), exitcode
);
340 Die(); // Unreachable.
343 unsigned int internal_sleep(unsigned int seconds
) {
347 int res
= internal_syscall(SYSCALL(nanosleep
), &ts
, &ts
);
348 if (res
) return ts
.tv_sec
;
352 uptr
internal_execve(const char *filename
, char *const argv
[],
353 char *const envp
[]) {
354 return internal_syscall(SYSCALL(execve
), (uptr
)filename
, (uptr
)argv
,
358 // ----------------- sanitizer_common.h
359 bool FileExists(const char *filename
) {
361 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
362 if (internal_syscall(SYSCALL(newfstatat
), AT_FDCWD
, filename
, &st
, 0))
364 if (internal_stat(filename
, &st
))
367 // Sanity check: filename is a regular file.
368 return S_ISREG(st
.st_mode
);
372 #if SANITIZER_FREEBSD
373 return (uptr
)pthread_self();
375 return internal_syscall(SYSCALL(gettid
));
380 #if SANITIZER_FREEBSD
385 internal_memset(&tv
, 0, sizeof(tv
));
386 internal_syscall(SYSCALL(gettimeofday
), (uptr
)&tv
, 0);
387 return (u64
)tv
.tv_sec
* 1000*1000*1000 + tv
.tv_usec
* 1000;
390 // Like getenv, but reads env directly from /proc (on Linux) or parses the
391 // 'environ' array (on FreeBSD) and does not use libc. This function should be
392 // called first inside __asan_init.
393 const char *GetEnv(const char *name
) {
394 #if SANITIZER_FREEBSD
395 if (::environ
!= 0) {
396 uptr NameLen
= internal_strlen(name
);
397 for (char **Env
= ::environ
; *Env
!= 0; Env
++) {
398 if (internal_strncmp(*Env
, name
, NameLen
) == 0 && (*Env
)[NameLen
] == '=')
399 return (*Env
) + NameLen
+ 1;
402 return 0; // Not found.
403 #elif SANITIZER_LINUX
404 static char *environ
;
410 if (!ReadFileToBuffer("/proc/self/environ", &environ
, &environ_size
, &len
))
413 if (!environ
|| len
== 0) return nullptr;
414 uptr namelen
= internal_strlen(name
);
415 const char *p
= environ
;
416 while (*p
!= '\0') { // will happen at the \0\0 that terminates the buffer
417 // proc file has the format NAME=value\0NAME=value\0NAME=value\0...
419 (char*)internal_memchr(p
, '\0', len
- (p
- environ
));
420 if (!endp
) // this entry isn't NUL terminated
422 else if (!internal_memcmp(p
, name
, namelen
) && p
[namelen
] == '=') // Match.
423 return p
+ namelen
+ 1; // point after =
426 return nullptr; // Not found.
428 #error "Unsupported platform"
432 #if !SANITIZER_FREEBSD
434 SANITIZER_WEAK_ATTRIBUTE
extern void *__libc_stack_end
;
438 #if !SANITIZER_GO && !SANITIZER_FREEBSD
439 static void ReadNullSepFileToArray(const char *path
, char ***arr
,
444 *arr
= (char **)MmapOrDie(arr_size
* sizeof(char *), "NullSepFileArray");
445 if (!ReadFileToBuffer(path
, &buff
, &buff_size
, &buff_len
, 1024 * 1024)) {
451 for (count
= 1, i
= 1; ; i
++) {
453 if (buff
[i
+1] == 0) break;
454 (*arr
)[count
] = &buff
[i
+1];
455 CHECK_LE(count
, arr_size
- 1); // FIXME: make this more flexible.
459 (*arr
)[count
] = nullptr;
463 static void GetArgsAndEnv(char ***argv
, char ***envp
) {
464 #if !SANITIZER_FREEBSD
466 if (&__libc_stack_end
) {
468 uptr
* stack_end
= (uptr
*)__libc_stack_end
;
469 int argc
= *stack_end
;
470 *argv
= (char**)(stack_end
+ 1);
471 *envp
= (char**)(stack_end
+ argc
+ 2);
474 static const int kMaxArgv
= 2000, kMaxEnvp
= 2000;
475 ReadNullSepFileToArray("/proc/self/cmdline", argv
, kMaxArgv
);
476 ReadNullSepFileToArray("/proc/self/environ", envp
, kMaxEnvp
);
480 // On FreeBSD, retrieving the argument and environment arrays is done via the
481 // kern.ps_strings sysctl, which returns a pointer to a structure containing
482 // this information. See also <sys/exec.h>.
484 size_t sz
= sizeof(pss
);
485 if (sysctlbyname("kern.ps_strings", &pss
, &sz
, NULL
, 0) == -1) {
486 Printf("sysctl kern.ps_strings failed\n");
489 *argv
= pss
->ps_argvstr
;
490 *envp
= pss
->ps_envstr
;
496 GetArgsAndEnv(&argv
, &envp
);
502 GetArgsAndEnv(&argv
, &envp
);
503 uptr rv
= internal_execve("/proc/self/exe", argv
, envp
);
505 CHECK_EQ(internal_iserror(rv
, &rverrno
), true);
506 Printf("execve failed, errno %d\n", rverrno
);
516 BlockingMutex::BlockingMutex() {
517 internal_memset(this, 0, sizeof(*this));
520 void BlockingMutex::Lock() {
522 atomic_uint32_t
*m
= reinterpret_cast<atomic_uint32_t
*>(&opaque_storage_
);
523 if (atomic_exchange(m
, MtxLocked
, memory_order_acquire
) == MtxUnlocked
)
525 while (atomic_exchange(m
, MtxSleeping
, memory_order_acquire
) != MtxUnlocked
) {
526 #if SANITIZER_FREEBSD
527 _umtx_op(m
, UMTX_OP_WAIT_UINT
, MtxSleeping
, 0, 0);
529 internal_syscall(SYSCALL(futex
), (uptr
)m
, FUTEX_WAIT
, MtxSleeping
, 0, 0, 0);
534 void BlockingMutex::Unlock() {
535 atomic_uint32_t
*m
= reinterpret_cast<atomic_uint32_t
*>(&opaque_storage_
);
536 u32 v
= atomic_exchange(m
, MtxUnlocked
, memory_order_relaxed
);
537 CHECK_NE(v
, MtxUnlocked
);
538 if (v
== MtxSleeping
) {
539 #if SANITIZER_FREEBSD
540 _umtx_op(m
, UMTX_OP_WAKE
, 1, 0, 0);
542 internal_syscall(SYSCALL(futex
), (uptr
)m
, FUTEX_WAKE
, 1, 0, 0, 0);
547 void BlockingMutex::CheckLocked() {
548 atomic_uint32_t
*m
= reinterpret_cast<atomic_uint32_t
*>(&opaque_storage_
);
549 CHECK_NE(MtxUnlocked
, atomic_load(m
, memory_order_relaxed
));
552 // ----------------- sanitizer_linux.h
553 // The actual size of this structure is specified by d_reclen.
554 // Note that getdents64 uses a different structure format. We only provide the
555 // 32-bit syscall here.
556 struct linux_dirent
{
557 #if SANITIZER_X32 || defined(__aarch64__)
564 unsigned short d_reclen
;
566 unsigned char d_type
;
572 uptr
internal_ptrace(int request
, int pid
, void *addr
, void *data
) {
573 return internal_syscall(SYSCALL(ptrace
), request
, pid
, (uptr
)addr
,
577 uptr
internal_waitpid(int pid
, int *status
, int options
) {
578 return internal_syscall(SYSCALL(wait4
), pid
, (uptr
)status
, options
,
582 uptr
internal_getpid() {
583 return internal_syscall(SYSCALL(getpid
));
586 uptr
internal_getppid() {
587 return internal_syscall(SYSCALL(getppid
));
590 uptr
internal_getdents(fd_t fd
, struct linux_dirent
*dirp
, unsigned int count
) {
591 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
592 return internal_syscall(SYSCALL(getdents64
), fd
, (uptr
)dirp
, count
);
594 return internal_syscall(SYSCALL(getdents
), fd
, (uptr
)dirp
, count
);
598 uptr
internal_lseek(fd_t fd
, OFF_T offset
, int whence
) {
599 return internal_syscall(SYSCALL(lseek
), fd
, offset
, whence
);
603 uptr
internal_prctl(int option
, uptr arg2
, uptr arg3
, uptr arg4
, uptr arg5
) {
604 return internal_syscall(SYSCALL(prctl
), option
, arg2
, arg3
, arg4
, arg5
);
608 uptr
internal_sigaltstack(const struct sigaltstack
*ss
,
609 struct sigaltstack
*oss
) {
610 return internal_syscall(SYSCALL(sigaltstack
), (uptr
)ss
, (uptr
)oss
);
613 int internal_fork() {
614 #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
615 return internal_syscall(SYSCALL(clone
), SIGCHLD
, 0);
617 return internal_syscall(SYSCALL(fork
));
622 #define SA_RESTORER 0x04000000
623 // Doesn't set sa_restorer if the caller did not set it, so use with caution
625 int internal_sigaction_norestorer(int signum
, const void *act
, void *oldact
) {
626 __sanitizer_kernel_sigaction_t k_act
, k_oldact
;
627 internal_memset(&k_act
, 0, sizeof(__sanitizer_kernel_sigaction_t
));
628 internal_memset(&k_oldact
, 0, sizeof(__sanitizer_kernel_sigaction_t
));
629 const __sanitizer_sigaction
*u_act
= (const __sanitizer_sigaction
*)act
;
630 __sanitizer_sigaction
*u_oldact
= (__sanitizer_sigaction
*)oldact
;
632 k_act
.handler
= u_act
->handler
;
633 k_act
.sigaction
= u_act
->sigaction
;
634 internal_memcpy(&k_act
.sa_mask
, &u_act
->sa_mask
,
635 sizeof(__sanitizer_kernel_sigset_t
));
636 // Without SA_RESTORER kernel ignores the calls (probably returns EINVAL).
637 k_act
.sa_flags
= u_act
->sa_flags
| SA_RESTORER
;
638 // FIXME: most often sa_restorer is unset, however the kernel requires it
639 // to point to a valid signal restorer that calls the rt_sigreturn syscall.
640 // If sa_restorer passed to the kernel is NULL, the program may crash upon
641 // signal delivery or fail to unwind the stack in the signal handler.
642 // libc implementation of sigaction() passes its own restorer to
643 // rt_sigaction, so we need to do the same (we'll need to reimplement the
644 // restorers; for x86_64 the restorer address can be obtained from
645 // oldact->sa_restorer upon a call to sigaction(xxx, NULL, oldact).
646 #if !SANITIZER_ANDROID || !SANITIZER_MIPS32
647 k_act
.sa_restorer
= u_act
->sa_restorer
;
651 uptr result
= internal_syscall(SYSCALL(rt_sigaction
), (uptr
)signum
,
652 (uptr
)(u_act
? &k_act
: nullptr),
653 (uptr
)(u_oldact
? &k_oldact
: nullptr),
654 (uptr
)sizeof(__sanitizer_kernel_sigset_t
));
656 if ((result
== 0) && u_oldact
) {
657 u_oldact
->handler
= k_oldact
.handler
;
658 u_oldact
->sigaction
= k_oldact
.sigaction
;
659 internal_memcpy(&u_oldact
->sa_mask
, &k_oldact
.sa_mask
,
660 sizeof(__sanitizer_kernel_sigset_t
));
661 u_oldact
->sa_flags
= k_oldact
.sa_flags
;
662 #if !SANITIZER_ANDROID || !SANITIZER_MIPS32
663 u_oldact
->sa_restorer
= k_oldact
.sa_restorer
;
669 // Invokes sigaction via a raw syscall with a restorer, but does not support
670 // all platforms yet.
671 // We disable for Go simply because we have not yet added to buildgo.sh.
672 #if (defined(__x86_64__) || SANITIZER_MIPS64) && !SANITIZER_GO
673 int internal_sigaction_syscall(int signum
, const void *act
, void *oldact
) {
675 return internal_sigaction_norestorer(signum
, act
, oldact
);
676 __sanitizer_sigaction u_adjust
;
677 internal_memcpy(&u_adjust
, act
, sizeof(u_adjust
));
678 #if !SANITIZER_ANDROID || !SANITIZER_MIPS32
679 if (u_adjust
.sa_restorer
== nullptr) {
680 u_adjust
.sa_restorer
= internal_sigreturn
;
683 return internal_sigaction_norestorer(signum
, (const void *)&u_adjust
,
686 #endif // defined(__x86_64__) && !SANITIZER_GO
687 #endif // SANITIZER_LINUX
689 uptr
internal_sigprocmask(int how
, __sanitizer_sigset_t
*set
,
690 __sanitizer_sigset_t
*oldset
) {
691 #if SANITIZER_FREEBSD
692 return internal_syscall(SYSCALL(sigprocmask
), how
, set
, oldset
);
694 __sanitizer_kernel_sigset_t
*k_set
= (__sanitizer_kernel_sigset_t
*)set
;
695 __sanitizer_kernel_sigset_t
*k_oldset
= (__sanitizer_kernel_sigset_t
*)oldset
;
696 return internal_syscall(SYSCALL(rt_sigprocmask
), (uptr
)how
,
697 (uptr
)&k_set
->sig
[0], (uptr
)&k_oldset
->sig
[0],
698 sizeof(__sanitizer_kernel_sigset_t
));
702 void internal_sigfillset(__sanitizer_sigset_t
*set
) {
703 internal_memset(set
, 0xff, sizeof(*set
));
706 void internal_sigemptyset(__sanitizer_sigset_t
*set
) {
707 internal_memset(set
, 0, sizeof(*set
));
711 void internal_sigdelset(__sanitizer_sigset_t
*set
, int signum
) {
714 CHECK_LT(signum
, sizeof(*set
) * 8);
715 __sanitizer_kernel_sigset_t
*k_set
= (__sanitizer_kernel_sigset_t
*)set
;
716 const uptr idx
= signum
/ (sizeof(k_set
->sig
[0]) * 8);
717 const uptr bit
= signum
% (sizeof(k_set
->sig
[0]) * 8);
718 k_set
->sig
[idx
] &= ~(1 << bit
);
721 bool internal_sigismember(__sanitizer_sigset_t
*set
, int signum
) {
724 CHECK_LT(signum
, sizeof(*set
) * 8);
725 __sanitizer_kernel_sigset_t
*k_set
= (__sanitizer_kernel_sigset_t
*)set
;
726 const uptr idx
= signum
/ (sizeof(k_set
->sig
[0]) * 8);
727 const uptr bit
= signum
% (sizeof(k_set
->sig
[0]) * 8);
728 return k_set
->sig
[idx
] & (1 << bit
);
730 #endif // SANITIZER_LINUX
732 // ThreadLister implementation.
733 ThreadLister::ThreadLister(int pid
)
738 entry_((struct linux_dirent
*)buffer_
.data()),
740 char task_directory_path
[80];
741 internal_snprintf(task_directory_path
, sizeof(task_directory_path
),
742 "/proc/%d/task/", pid
);
743 uptr openrv
= internal_open(task_directory_path
, O_RDONLY
| O_DIRECTORY
);
744 if (internal_iserror(openrv
)) {
746 Report("Can't open /proc/%d/task for reading.\n", pid
);
749 descriptor_
= openrv
;
753 int ThreadLister::GetNextTID() {
758 if ((char *)entry_
>= &buffer_
[bytes_read_
] && !GetDirectoryEntries())
760 if (entry_
->d_ino
!= 0 && entry_
->d_name
[0] >= '0' &&
761 entry_
->d_name
[0] <= '9') {
762 // Found a valid tid.
763 tid
= (int)internal_atoll(entry_
->d_name
);
765 entry_
= (struct linux_dirent
*)(((char *)entry_
) + entry_
->d_reclen
);
770 void ThreadLister::Reset() {
771 if (error_
|| descriptor_
< 0)
773 internal_lseek(descriptor_
, 0, SEEK_SET
);
776 ThreadLister::~ThreadLister() {
777 if (descriptor_
>= 0)
778 internal_close(descriptor_
);
781 bool ThreadLister::error() { return error_
; }
783 bool ThreadLister::GetDirectoryEntries() {
784 CHECK_GE(descriptor_
, 0);
785 CHECK_NE(error_
, true);
786 bytes_read_
= internal_getdents(descriptor_
,
787 (struct linux_dirent
*)buffer_
.data(),
789 if (internal_iserror(bytes_read_
)) {
790 Report("Can't read directory entries from /proc/%d/task.\n", pid_
);
793 } else if (bytes_read_
== 0) {
796 entry_
= (struct linux_dirent
*)buffer_
.data();
801 // Android post-M sysconf(_SC_PAGESIZE) crashes if called from .preinit_array.
802 #if SANITIZER_ANDROID
804 #elif SANITIZER_LINUX && (defined(__x86_64__) || defined(__i386__))
805 return EXEC_PAGESIZE
;
807 return sysconf(_SC_PAGESIZE
); // EXEC_PAGESIZE may not be trustworthy.
811 uptr
ReadBinaryName(/*out*/char *buf
, uptr buf_len
) {
812 #if SANITIZER_FREEBSD
813 const int Mib
[] = { CTL_KERN
, KERN_PROC
, KERN_PROC_PATHNAME
, -1 };
814 const char *default_module_name
= "kern.proc.pathname";
815 size_t Size
= buf_len
;
816 bool IsErr
= (sysctl(Mib
, ARRAY_SIZE(Mib
), buf
, &Size
, NULL
, 0) != 0);
817 int readlink_error
= IsErr
? errno
: 0;
818 uptr module_name_len
= Size
;
820 const char *default_module_name
= "/proc/self/exe";
821 uptr module_name_len
= internal_readlink(
822 default_module_name
, buf
, buf_len
);
824 bool IsErr
= internal_iserror(module_name_len
, &readlink_error
);
827 // We can't read binary name for some reason, assume it's unknown.
828 Report("WARNING: reading executable name failed with errno %d, "
829 "some stack frames may not be symbolized\n", readlink_error
);
830 module_name_len
= internal_snprintf(buf
, buf_len
, "%s",
831 default_module_name
);
832 CHECK_LT(module_name_len
, buf_len
);
834 return module_name_len
;
837 uptr
ReadLongProcessName(/*out*/ char *buf
, uptr buf_len
) {
842 if (ReadFileToBuffer("/proc/self/cmdline", &tmpbuf
, &tmpsize
, &tmplen
,
844 internal_strncpy(buf
, tmpbuf
, buf_len
);
845 UnmapOrDie(tmpbuf
, tmpsize
);
846 return internal_strlen(buf
);
849 return ReadBinaryName(buf
, buf_len
);
852 // Match full names of the form /path/to/base_name{-,.}*
853 bool LibraryNameIs(const char *full_name
, const char *base_name
) {
854 const char *name
= full_name
;
856 while (*name
!= '\0') name
++;
857 while (name
> full_name
&& *name
!= '/') name
--;
858 if (*name
== '/') name
++;
859 uptr base_name_length
= internal_strlen(base_name
);
860 if (internal_strncmp(name
, base_name
, base_name_length
)) return false;
861 return (name
[base_name_length
] == '-' || name
[base_name_length
] == '.');
864 #if !SANITIZER_ANDROID
865 // Call cb for each region mapped by map.
866 void ForEachMappedRegion(link_map
*map
, void (*cb
)(const void *, uptr
)) {
867 CHECK_NE(map
, nullptr);
868 #if !SANITIZER_FREEBSD
869 typedef ElfW(Phdr
) Elf_Phdr
;
870 typedef ElfW(Ehdr
) Elf_Ehdr
;
871 #endif // !SANITIZER_FREEBSD
872 char *base
= (char *)map
->l_addr
;
873 Elf_Ehdr
*ehdr
= (Elf_Ehdr
*)base
;
874 char *phdrs
= base
+ ehdr
->e_phoff
;
875 char *phdrs_end
= phdrs
+ ehdr
->e_phnum
* ehdr
->e_phentsize
;
877 // Find the segment with the minimum base so we can "relocate" the p_vaddr
878 // fields. Typically ET_DYN objects (DSOs) have base of zero and ET_EXEC
879 // objects have a non-zero base.
880 uptr preferred_base
= (uptr
)-1;
881 for (char *iter
= phdrs
; iter
!= phdrs_end
; iter
+= ehdr
->e_phentsize
) {
882 Elf_Phdr
*phdr
= (Elf_Phdr
*)iter
;
883 if (phdr
->p_type
== PT_LOAD
&& preferred_base
> (uptr
)phdr
->p_vaddr
)
884 preferred_base
= (uptr
)phdr
->p_vaddr
;
887 // Compute the delta from the real base to get a relocation delta.
888 sptr delta
= (uptr
)base
- preferred_base
;
889 // Now we can figure out what the loader really mapped.
890 for (char *iter
= phdrs
; iter
!= phdrs_end
; iter
+= ehdr
->e_phentsize
) {
891 Elf_Phdr
*phdr
= (Elf_Phdr
*)iter
;
892 if (phdr
->p_type
== PT_LOAD
) {
893 uptr seg_start
= phdr
->p_vaddr
+ delta
;
894 uptr seg_end
= seg_start
+ phdr
->p_memsz
;
895 // None of these values are aligned. We consider the ragged edges of the
896 // load command as defined, since they are mapped from the file.
897 seg_start
= RoundDownTo(seg_start
, GetPageSizeCached());
898 seg_end
= RoundUpTo(seg_end
, GetPageSizeCached());
899 cb((void *)seg_start
, seg_end
- seg_start
);
905 #if defined(__x86_64__) && SANITIZER_LINUX
906 // We cannot use glibc's clone wrapper, because it messes with the child
907 // task's TLS. It writes the PID and TID of the child task to its thread
908 // descriptor, but in our case the child task shares the thread descriptor with
909 // the parent (because we don't know how to allocate a new thread
910 // descriptor to keep glibc happy). So the stock version of clone(), when
911 // used with CLONE_VM, would end up corrupting the parent's thread descriptor.
912 uptr
internal_clone(int (*fn
)(void *), void *child_stack
, int flags
, void *arg
,
913 int *parent_tidptr
, void *newtls
, int *child_tidptr
) {
915 if (!fn
|| !child_stack
)
917 CHECK_EQ(0, (uptr
)child_stack
% 16);
918 child_stack
= (char *)child_stack
- 2 * sizeof(unsigned long long);
919 ((unsigned long long *)child_stack
)[0] = (uptr
)fn
;
920 ((unsigned long long *)child_stack
)[1] = (uptr
)arg
;
921 register void *r8
__asm__("r8") = newtls
;
922 register int *r10
__asm__("r10") = child_tidptr
;
923 __asm__
__volatile__(
924 /* %rax = syscall(%rax = SYSCALL(clone),
926 * %rsi = child_stack,
927 * %rdx = parent_tidptr,
929 * %r10 = child_tidptr)
936 "testq %%rax,%%rax\n"
939 /* In the child. Terminate unwind chain. */
940 // XXX: We should also terminate the CFI unwind chain
941 // here. Unfortunately clang 3.2 doesn't support the
942 // necessary CFI directives, so we skip that part.
945 /* Call "fn(arg)". */
950 /* Call _exit(%rax). */
955 /* Return to parent. */
958 : "a"(SYSCALL(clone
)), "i"(SYSCALL(exit
)),
964 : "rsp", "memory", "r11", "rcx");
967 #elif defined(__mips__)
968 uptr
internal_clone(int (*fn
)(void *), void *child_stack
, int flags
, void *arg
,
969 int *parent_tidptr
, void *newtls
, int *child_tidptr
) {
971 if (!fn
|| !child_stack
)
973 CHECK_EQ(0, (uptr
)child_stack
% 16);
974 child_stack
= (char *)child_stack
- 2 * sizeof(unsigned long long);
975 ((unsigned long long *)child_stack
)[0] = (uptr
)fn
;
976 ((unsigned long long *)child_stack
)[1] = (uptr
)arg
;
977 register void *a3
__asm__("$7") = newtls
;
978 register int *a4
__asm__("$8") = child_tidptr
;
979 // We don't have proper CFI directives here because it requires alot of code
980 // for very marginal benefits.
981 __asm__
__volatile__(
982 /* $v0 = syscall($v0 = __NR_clone,
985 * $a2 = parent_tidptr,
987 * $a4 = child_tidptr)
994 /* Store the fifth argument on stack
995 * if we are using 32-bit abi.
997 #if SANITIZER_WORDSIZE == 32
1010 /* Call "fn(arg)". */
1011 #if SANITIZER_WORDSIZE == 32
1012 #ifdef __BIG_ENDIAN__
1025 /* Call _exit($v0). */
1030 /* Return to parent. */
1040 : "memory", "$29" );
1043 #elif defined(__aarch64__)
1044 uptr
internal_clone(int (*fn
)(void *), void *child_stack
, int flags
, void *arg
,
1045 int *parent_tidptr
, void *newtls
, int *child_tidptr
) {
1047 if (!fn
|| !child_stack
)
1049 CHECK_EQ(0, (uptr
)child_stack
% 16);
1050 child_stack
= (char *)child_stack
- 2 * sizeof(unsigned long long);
1051 ((unsigned long long *)child_stack
)[0] = (uptr
)fn
;
1052 ((unsigned long long *)child_stack
)[1] = (uptr
)arg
;
1054 register int (*__fn
)(void *) __asm__("x0") = fn
;
1055 register void *__stack
__asm__("x1") = child_stack
;
1056 register int __flags
__asm__("x2") = flags
;
1057 register void *__arg
__asm__("x3") = arg
;
1058 register int *__ptid
__asm__("x4") = parent_tidptr
;
1059 register void *__tls
__asm__("x5") = newtls
;
1060 register int *__ctid
__asm__("x6") = child_tidptr
;
1062 __asm__
__volatile__(
1063 "mov x0,x2\n" /* flags */
1064 "mov x2,x4\n" /* ptid */
1065 "mov x3,x5\n" /* tls */
1066 "mov x4,x6\n" /* ctid */
1067 "mov x8,%9\n" /* clone */
1077 /* In the child, now. Call "fn(arg)". */
1078 "ldp x1, x0, [sp], #16\n"
1081 /* Call _exit(%r0). */
1088 "r"(__fn
), "r"(__stack
), "r"(__flags
), "r"(__arg
),
1089 "r"(__ptid
), "r"(__tls
), "r"(__ctid
),
1090 "i"(__NR_clone
), "i"(__NR_exit
)
1094 #elif defined(__powerpc64__)
1095 uptr
internal_clone(int (*fn
)(void *), void *child_stack
, int flags
, void *arg
,
1096 int *parent_tidptr
, void *newtls
, int *child_tidptr
) {
1098 /* Stack frame offsets. */
1100 #define FRAME_MIN_SIZE 112
1101 #define FRAME_TOC_SAVE 40
1103 #define FRAME_MIN_SIZE 32
1104 #define FRAME_TOC_SAVE 24
1106 if (!fn
|| !child_stack
)
1108 CHECK_EQ(0, (uptr
)child_stack
% 16);
1109 child_stack
= (char *)child_stack
- 2 * sizeof(unsigned long long);
1110 ((unsigned long long *)child_stack
)[0] = (uptr
)fn
;
1111 ((unsigned long long *)child_stack
)[1] = (uptr
)arg
;
1113 register int (*__fn
)(void *) __asm__("r3") = fn
;
1114 register void *__cstack
__asm__("r4") = child_stack
;
1115 register int __flags
__asm__("r5") = flags
;
1116 register void * __arg
__asm__("r6") = arg
;
1117 register int * __ptidptr
__asm__("r7") = parent_tidptr
;
1118 register void * __newtls
__asm__("r8") = newtls
;
1119 register int * __ctidptr
__asm__("r9") = child_tidptr
;
1121 __asm__
__volatile__(
1122 /* fn, arg, child_stack are saved acrVoss the syscall */
1132 r7 == child_tidptr */
1140 /* Test if syscall was successful */
1141 "cmpdi cr1, 3, 0\n\t"
1142 "crandc cr1*4+eq, cr1*4+eq, cr0*4+so\n\t"
1145 /* Do the function call */
1159 /* Call _exit(r3) */
1163 /* Return to parent */
1167 : "0" (-1), "i" (EINVAL
),
1168 "i" (__NR_clone
), "i" (__NR_exit
),
1169 "r" (__fn
), "r" (__cstack
), "r" (__flags
),
1170 "r" (__arg
), "r" (__ptidptr
), "r" (__newtls
),
1171 "r" (__ctidptr
), "i" (FRAME_MIN_SIZE
), "i" (FRAME_TOC_SAVE
)
1172 : "cr0", "cr1", "memory", "ctr",
1173 "r0", "r29", "r27", "r28");
1176 #endif // defined(__x86_64__) && SANITIZER_LINUX
1178 #if SANITIZER_ANDROID
1179 #if __ANDROID_API__ < 21
1180 extern "C" __attribute__((weak
)) int dl_iterate_phdr(
1181 int (*)(struct dl_phdr_info
*, size_t, void *), void *);
1184 static int dl_iterate_phdr_test_cb(struct dl_phdr_info
*info
, size_t size
,
1186 // Any name starting with "lib" indicates a bug in L where library base names
1187 // are returned instead of paths.
1188 if (info
->dlpi_name
&& info
->dlpi_name
[0] == 'l' &&
1189 info
->dlpi_name
[1] == 'i' && info
->dlpi_name
[2] == 'b') {
1190 *(bool *)data
= true;
1196 static atomic_uint32_t android_api_level
;
1198 static AndroidApiLevel
AndroidDetectApiLevel() {
1199 if (!&dl_iterate_phdr
)
1200 return ANDROID_KITKAT
; // K or lower
1201 bool base_name_seen
= false;
1202 dl_iterate_phdr(dl_iterate_phdr_test_cb
, &base_name_seen
);
1204 return ANDROID_LOLLIPOP_MR1
; // L MR1
1205 return ANDROID_POST_LOLLIPOP
; // post-L
1206 // Plain L (API level 21) is completely broken wrt ASan and not very
1207 // interesting to detect.
1210 AndroidApiLevel
AndroidGetApiLevel() {
1211 AndroidApiLevel level
=
1212 (AndroidApiLevel
)atomic_load(&android_api_level
, memory_order_relaxed
);
1213 if (level
) return level
;
1214 level
= AndroidDetectApiLevel();
1215 atomic_store(&android_api_level
, level
, memory_order_relaxed
);
1221 bool IsHandledDeadlySignal(int signum
) {
1222 if (common_flags()->handle_abort
&& signum
== SIGABRT
)
1224 if (common_flags()->handle_sigill
&& signum
== SIGILL
)
1226 if (common_flags()->handle_sigfpe
&& signum
== SIGFPE
)
1228 return (signum
== SIGSEGV
|| signum
== SIGBUS
) && common_flags()->handle_segv
;
1232 void *internal_start_thread(void(*func
)(void *arg
), void *arg
) {
1233 // Start the thread with signals blocked, otherwise it can steal user signals.
1234 __sanitizer_sigset_t set
, old
;
1235 internal_sigfillset(&set
);
1236 #if SANITIZER_LINUX && !SANITIZER_ANDROID
1237 // Glibc uses SIGSETXID signal during setuid call. If this signal is blocked
1238 // on any thread, setuid call hangs (see test/tsan/setuid.c).
1239 internal_sigdelset(&set
, 33);
1241 internal_sigprocmask(SIG_SETMASK
, &set
, &old
);
1243 real_pthread_create(&th
, nullptr, (void*(*)(void *arg
))func
, arg
);
1244 internal_sigprocmask(SIG_SETMASK
, &old
, nullptr);
1248 void internal_join_thread(void *th
) {
1249 real_pthread_join(th
, nullptr);
1252 void *internal_start_thread(void (*func
)(void *), void *arg
) { return 0; }
1254 void internal_join_thread(void *th
) {}
1257 #if defined(__aarch64__)
1258 // Android headers in the older NDK releases miss this definition.
1259 struct __sanitizer_esr_context
{
1260 struct _aarch64_ctx head
;
1264 static bool Aarch64GetESR(ucontext_t
*ucontext
, u64
*esr
) {
1265 static const u32 kEsrMagic
= 0x45535201;
1266 u8
*aux
= ucontext
->uc_mcontext
.__reserved
;
1268 _aarch64_ctx
*ctx
= (_aarch64_ctx
*)aux
;
1269 if (ctx
->size
== 0) break;
1270 if (ctx
->magic
== kEsrMagic
) {
1271 *esr
= ((__sanitizer_esr_context
*)ctx
)->esr
;
1280 SignalContext::WriteFlag
SignalContext::GetWriteFlag(void *context
) {
1281 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1282 #if defined(__x86_64__) || defined(__i386__)
1283 static const uptr PF_WRITE
= 1U << 1;
1284 #if SANITIZER_FREEBSD
1285 uptr err
= ucontext
->uc_mcontext
.mc_err
;
1287 uptr err
= ucontext
->uc_mcontext
.gregs
[REG_ERR
];
1289 return err
& PF_WRITE
? WRITE
: READ
;
1290 #elif defined(__arm__)
1291 static const uptr FSR_WRITE
= 1U << 11;
1292 uptr fsr
= ucontext
->uc_mcontext
.error_code
;
1293 return fsr
& FSR_WRITE
? WRITE
: READ
;
1294 #elif defined(__aarch64__)
1295 static const u64 ESR_ELx_WNR
= 1U << 6;
1297 if (!Aarch64GetESR(ucontext
, &esr
)) return UNKNOWN
;
1298 return esr
& ESR_ELx_WNR
? WRITE
: READ
;
1301 return UNKNOWN
; // FIXME: Implement.
1305 void GetPcSpBp(void *context
, uptr
*pc
, uptr
*sp
, uptr
*bp
) {
1306 #if defined(__arm__)
1307 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1308 *pc
= ucontext
->uc_mcontext
.arm_pc
;
1309 *bp
= ucontext
->uc_mcontext
.arm_fp
;
1310 *sp
= ucontext
->uc_mcontext
.arm_sp
;
1311 #elif defined(__aarch64__)
1312 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1313 *pc
= ucontext
->uc_mcontext
.pc
;
1314 *bp
= ucontext
->uc_mcontext
.regs
[29];
1315 *sp
= ucontext
->uc_mcontext
.sp
;
1316 #elif defined(__hppa__)
1317 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1318 *pc
= ucontext
->uc_mcontext
.sc_iaoq
[0];
1319 /* GCC uses %r3 whenever a frame pointer is needed. */
1320 *bp
= ucontext
->uc_mcontext
.sc_gr
[3];
1321 *sp
= ucontext
->uc_mcontext
.sc_gr
[30];
1322 #elif defined(__x86_64__)
1323 # if SANITIZER_FREEBSD
1324 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1325 *pc
= ucontext
->uc_mcontext
.mc_rip
;
1326 *bp
= ucontext
->uc_mcontext
.mc_rbp
;
1327 *sp
= ucontext
->uc_mcontext
.mc_rsp
;
1329 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1330 *pc
= ucontext
->uc_mcontext
.gregs
[REG_RIP
];
1331 *bp
= ucontext
->uc_mcontext
.gregs
[REG_RBP
];
1332 *sp
= ucontext
->uc_mcontext
.gregs
[REG_RSP
];
1334 #elif defined(__i386__)
1335 # if SANITIZER_FREEBSD
1336 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1337 *pc
= ucontext
->uc_mcontext
.mc_eip
;
1338 *bp
= ucontext
->uc_mcontext
.mc_ebp
;
1339 *sp
= ucontext
->uc_mcontext
.mc_esp
;
1341 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1342 *pc
= ucontext
->uc_mcontext
.gregs
[REG_EIP
];
1343 *bp
= ucontext
->uc_mcontext
.gregs
[REG_EBP
];
1344 *sp
= ucontext
->uc_mcontext
.gregs
[REG_ESP
];
1346 #elif defined(__powerpc__) || defined(__powerpc64__)
1347 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1348 *pc
= ucontext
->uc_mcontext
.regs
->nip
;
1349 *sp
= ucontext
->uc_mcontext
.regs
->gpr
[PT_R1
];
1350 // The powerpc{,64}-linux ABIs do not specify r31 as the frame
1351 // pointer, but GCC always uses r31 when we need a frame pointer.
1352 *bp
= ucontext
->uc_mcontext
.regs
->gpr
[PT_R31
];
1353 #elif defined(__sparc__)
1354 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1356 # if defined (__arch64__)
1357 *pc
= ucontext
->uc_mcontext
.mc_gregs
[MC_PC
];
1358 *sp
= ucontext
->uc_mcontext
.mc_gregs
[MC_O6
];
1359 stk_ptr
= (uptr
*) (*sp
+ 2047);
1362 *pc
= ucontext
->uc_mcontext
.gregs
[REG_PC
];
1363 *sp
= ucontext
->uc_mcontext
.gregs
[REG_O6
];
1364 stk_ptr
= (uptr
*) *sp
;
1367 #elif defined(__mips__)
1368 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1369 *pc
= ucontext
->uc_mcontext
.pc
;
1370 *bp
= ucontext
->uc_mcontext
.gregs
[30];
1371 *sp
= ucontext
->uc_mcontext
.gregs
[29];
1372 #elif defined(__s390__)
1373 ucontext_t
*ucontext
= (ucontext_t
*)context
;
1374 # if defined(__s390x__)
1375 *pc
= ucontext
->uc_mcontext
.psw
.addr
;
1377 *pc
= ucontext
->uc_mcontext
.psw
.addr
& 0x7fffffff;
1379 *bp
= ucontext
->uc_mcontext
.gregs
[11];
1380 *sp
= ucontext
->uc_mcontext
.gregs
[15];
1382 # error "Unsupported arch"
1386 void MaybeReexec() {
1387 // No need to re-exec on Linux.
1390 uptr
FindAvailableMemoryRange(uptr size
, uptr alignment
, uptr left_padding
) {
1391 UNREACHABLE("FindAvailableMemoryRange is not available");
1395 } // namespace __sanitizer
1397 #endif // SANITIZER_FREEBSD || SANITIZER_LINUX