This is an archive of the discontinued LLVM Phabricator instance.

Differential D93862

Use SANITIZER_GNU in compiler-rt when detecting features
AbandonedPublic

Authored by MaskRay on Dec 28 2020, 8:33 AM.

Details

Reviewers
kcc
• ddunbar
eugenis
ronchaine
Summary

Previously compiler-rt used SANITIZER_LINUX && !SANITIZER_ANDROID,
which caused non-glibc linux systems to fail the build because
SANITIZER_LINUX assumed GNU extensions were present (and the headers
were arranged as on GNU systems, instead as on POSIX systems)

Use SANITIZER_GNU with asan.

Allows linux/musl to compile asan. We need to define _DYNAMIC there as
well, since it is not standard

Diff Detail

Event Timeline

ronchaine created this revision.Dec 28 2020, 8:33 AM
Herald added subscribers: fedor.sergeev, krytarowski, dberris. · View Herald TranscriptDec 28 2020, 8:33 AM
ronchaine requested review of this revision.Dec 28 2020, 8:33 AM
Herald added a subscriber: Restricted Project. · View Herald TranscriptDec 28 2020, 8:33 AM
ronchaine added a comment.Dec 28 2020, 8:39 AM

Standalone patch as per request in D63785 from new rebase to master (2020-12-28).

I added the reviewers straight from that issue, plus MaskRay as the request for this patch came from them.
I cannot test this patch on Android myself for the lack of build environment.

Harbormaster completed remote builds in B83584: Diff 313858.Dec 28 2020, 9:09 AM
MaskRay added a comment.Dec 28 2020, 9:59 AM

Hi @ronchaine, I posted D93848 after I posted that comment...

MaskRay commandeered this revision.Dec 31 2020, 11:43 AM
MaskRay edited reviewers, added: ronchaine; removed: MaskRay.

Superseded by D93848

MaskRay abandoned this revision.Dec 31 2020, 11:43 AM

Revision Contents

PathSize
compiler-rt/
lib/
asan/
6 lines
interception/
6 lines
sanitizer_common/
6 lines
90 lines

Diff 313858

compiler-rt/lib/asan/asan_linux.cpp

Show All 39 Lines
#if SANITIZER_FREEBSD #if SANITIZER_FREEBSD
#include <sys/link_elf.h> #include <sys/link_elf.h>
#endif #endif
#if SANITIZER_SOLARIS #if SANITIZER_SOLARIS
#include <link.h> #include <link.h>
#endif #endif
#if SANITIZER_ANDROID || SANITIZER_FREEBSD || SANITIZER_SOLARIS #if SANITIZER_LINUX && !SANITIZER_GNU
#include <link.h>
#endif
#if !SANITIZER_GNU && !SANITIZER_NETBSD
#include <ucontext.h> #include <ucontext.h>
extern "C" void* _DYNAMIC; extern "C" void* _DYNAMIC;
#elif SANITIZER_NETBSD #elif SANITIZER_NETBSD
#include <link_elf.h> #include <link_elf.h>
#include <ucontext.h> #include <ucontext.h>
extern Elf_Dyn _DYNAMIC; extern Elf_Dyn _DYNAMIC;
#else #else
#include <sys/ucontext.h> #include <sys/ucontext.h>
▲ Show 20 Lines • Show All 187 Lines • Show Last 20 Lines

compiler-rt/lib/interception/interception_linux.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
bool InterceptFunction(const char *name, uptr *ptr_to_real, uptr func, bool InterceptFunction(const char *name, uptr *ptr_to_real, uptr func,
uptr wrapper) { uptr wrapper) {
void *addr = GetFuncAddr(name, wrapper); void *addr = GetFuncAddr(name, wrapper);
*ptr_to_real = (uptr)addr; *ptr_to_real = (uptr)addr;
return addr && (func == wrapper); return addr && (func == wrapper);
} }
// Android and Solaris do not have dlvsym // dlvsym is GNU extension, FreeBSD has support for it
#if !SANITIZER_ANDROID && !SANITIZER_SOLARIS #if SANITIZER_GNU || SANITIZER_FREEBSD
static void *GetFuncAddr(const char *name, const char *ver) { static void *GetFuncAddr(const char *name, const char *ver) {
return dlvsym(RTLD_NEXT, name, ver); return dlvsym(RTLD_NEXT, name, ver);
} }
bool InterceptFunction(const char *name, const char *ver, uptr *ptr_to_real, bool InterceptFunction(const char *name, const char *ver, uptr *ptr_to_real,
uptr func, uptr wrapper) { uptr func, uptr wrapper) {
void *addr = GetFuncAddr(name, ver); void *addr = GetFuncAddr(name, ver);
*ptr_to_real = (uptr)addr; *ptr_to_real = (uptr)addr;
return addr && (func == wrapper); return addr && (func == wrapper);
} }
#endif // !SANITIZER_ANDROID #endif // SANITIZER_GNU || SANITIZER_FREEBSD
} // namespace __interception } // namespace __interception
#endif // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || #endif // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD ||
// SANITIZER_SOLARIS // SANITIZER_SOLARIS

compiler-rt/lib/sanitizer_common/sanitizer_platform.h

Show All 19 Lines
#endif #endif
#if defined(__linux__) #if defined(__linux__)
# define SANITIZER_LINUX 1 # define SANITIZER_LINUX 1
#else #else
# define SANITIZER_LINUX 0 # define SANITIZER_LINUX 0
#endif #endif
#if defined(__GLIBC__)
#define SANITIZER_GNU 1
#else
#define SANITIZER_GNU 0
#endif
#if defined(__FreeBSD__) #if defined(__FreeBSD__)
# define SANITIZER_FREEBSD 1 # define SANITIZER_FREEBSD 1
#else #else
# define SANITIZER_FREEBSD 0 # define SANITIZER_FREEBSD 0
#endif #endif
#if defined(__NetBSD__) #if defined(__NetBSD__)
# define SANITIZER_NETBSD 1 # define SANITIZER_NETBSD 1
▲ Show 20 Lines • Show All 335 Lines • Show Last 20 Lines

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
#if !SANITIZER_MAC #if !SANITIZER_MAC
#include <utmp.h> #include <utmp.h>
#endif #endif
#if !SANITIZER_IOS #if !SANITIZER_IOS
#include <net/route.h> #include <net/route.h>
#endif #endif
#if !SANITIZER_ANDROID #if SANITIZER_GNU
#include <fstab.h> #include <fstab.h>
#endif
#if !SANITIZER_ANDROID
#include <sys/mount.h> #include <sys/mount.h>
#include <sys/timeb.h> #include <sys/timeb.h>
#include <utmpx.h> #include <utmpx.h>
#endif #endif
#if SANITIZER_LINUX #if SANITIZER_LINUX
#include <malloc.h> #include <malloc.h>
#include <mntent.h> #include <mntent.h>
Show All 35 Lines
#endif #endif
#if !SANITIZER_ANDROID #if !SANITIZER_ANDROID
#include <ifaddrs.h> #include <ifaddrs.h>
#include <sys/ucontext.h> #include <sys/ucontext.h>
#include <wordexp.h> #include <wordexp.h>
#endif #endif
#if SANITIZER_LINUX && !SANITIZER_ANDROID #if SANITIZER_GNU
#include <glob.h> #include <glob.h>
#include <obstack.h> #include <obstack.h>
#include <mqueue.h> #include <mqueue.h>
#include <net/if_ppp.h> #include <net/if_ppp.h>
#include <netax25/ax25.h> #include <netax25/ax25.h>
#include <netipx/ipx.h> #include <netipx/ipx.h>
#include <netrom/netrom.h> #include <netrom/netrom.h>
#if HAVE_RPC_XDR_H #if HAVE_RPC_XDR_H
Show All 14 Lines
#include <linux/if_plip.h> #include <linux/if_plip.h>
#include <linux/lp.h> #include <linux/lp.h>
#include <linux/mroute.h> #include <linux/mroute.h>
#include <linux/mroute6.h> #include <linux/mroute6.h>
#include <linux/scc.h> #include <linux/scc.h>
#include <linux/serial.h> #include <linux/serial.h>
#include <sys/msg.h> #include <sys/msg.h>
#include <sys/ipc.h> #include <sys/ipc.h>
#include <crypt.h> #endif // SANITIZER_GNU
#endif // SANITIZER_LINUX && !SANITIZER_ANDROID
#if SANITIZER_ANDROID #if SANITIZER_LINUX && !SANITIZER_GNU
#include <linux/kd.h> #include <linux/kd.h>
#include <linux/mtio.h> #include <linux/mtio.h>
#include <linux/ppp_defs.h> #include <linux/ppp_defs.h>
#include <linux/if_ppp.h> #include <linux/if_ppp.h>
#if !SANITIZER_ANDROID
#include <linux/ax25.h>
#include <linux/cyclades.h>
#include <linux/ipx.h>
// #include <linux/mtio.h> doesn't have the required mtconfiginfo
// #include <linux/netrom.h> doesn't have the required nr_parms_struct
#include <linux/if_eql.h>
#include <linux/if_plip.h>
#include <linux/ipc.h>
#include <linux/lp.h>
#include <linux/mroute.h>
#include <linux/netrom.h>
#include <linux/scc.h>
#include <linux/shm.h>
#endif #endif
#endif // SANITIZER_LINUX && !SANITIZER_GNU
#if SANITIZER_LINUX #if SANITIZER_LINUX
#include <crypt.h>
#include <link.h> #include <link.h>
#include <sys/vfs.h>
#include <sys/epoll.h>
#include <linux/capability.h> #include <linux/capability.h>
#include <sys/epoll.h>
#include <sys/vfs.h>
#endif // SANITIZER_LINUX #endif // SANITIZER_LINUX
#if SANITIZER_MAC #if SANITIZER_MAC
#include <net/ethernet.h> #include <net/ethernet.h>
#include <sys/filio.h> #include <sys/filio.h>
#include <sys/sockio.h> #include <sys/sockio.h>
#endif #endif
Show All 30 Lines#endif // !SANITIZER_IOS && !(SANITIZER_MAC && TARGET_CPU_ARM64)
unsigned struct_sched_param_sz = sizeof(struct sched_param); unsigned struct_sched_param_sz = sizeof(struct sched_param);
unsigned struct_regex_sz = sizeof(regex_t); unsigned struct_regex_sz = sizeof(regex_t);
unsigned struct_regmatch_sz = sizeof(regmatch_t); unsigned struct_regmatch_sz = sizeof(regmatch_t);
#if (SANITIZER_MAC && !TARGET_CPU_ARM64) && !SANITIZER_IOS #if (SANITIZER_MAC && !TARGET_CPU_ARM64) && !SANITIZER_IOS
unsigned struct_statfs64_sz = sizeof(struct statfs64); unsigned struct_statfs64_sz = sizeof(struct statfs64);
#endif // (SANITIZER_MAC && !TARGET_CPU_ARM64) && !SANITIZER_IOS #endif // (SANITIZER_MAC && !TARGET_CPU_ARM64) && !SANITIZER_IOS
#if !SANITIZER_ANDROID #if SANITIZER_GNU
unsigned struct_fstab_sz = sizeof(struct fstab); unsigned struct_fstab_sz = sizeof(struct fstab);
unsigned struct_statfs_sz = sizeof(struct statfs); unsigned struct_statfs_sz = sizeof(struct statfs);
unsigned struct_sockaddr_sz = sizeof(struct sockaddr); unsigned struct_sockaddr_sz = sizeof(struct sockaddr);
unsigned ucontext_t_sz = sizeof(ucontext_t); unsigned ucontext_t_sz = sizeof(ucontext_t);
#endif // !SANITIZER_ANDROID #endif // SANITIZER_GNU
#if SANITIZER_LINUX #if SANITIZER_LINUX
unsigned struct_epoll_event_sz = sizeof(struct epoll_event); unsigned struct_epoll_event_sz = sizeof(struct epoll_event);
unsigned struct_sysinfo_sz = sizeof(struct sysinfo); unsigned struct_sysinfo_sz = sizeof(struct sysinfo);
unsigned __user_cap_header_struct_sz = unsigned __user_cap_header_struct_sz =
sizeof(struct __user_cap_header_struct); sizeof(struct __user_cap_header_struct);
unsigned __user_cap_data_struct_sz = sizeof(struct __user_cap_data_struct); unsigned __user_cap_data_struct_sz = sizeof(struct __user_cap_data_struct);
unsigned struct_new_utsname_sz = sizeof(struct new_utsname); unsigned struct_new_utsname_sz = sizeof(struct new_utsname);
Show All 18 Lines
#elif defined(__arm__) || defined(__i386__) || defined(__mips__) \ #elif defined(__arm__) || defined(__i386__) || defined(__mips__) \
|| defined(__powerpc__) || defined(__s390__) || defined(__sparc__) || defined(__powerpc__) || defined(__s390__) || defined(__sparc__)
#define SIZEOF_STRUCT_USTAT 20 #define SIZEOF_STRUCT_USTAT 20
#else #else
#error Unknown size of struct ustat #error Unknown size of struct ustat
#endif #endif
unsigned struct_ustat_sz = SIZEOF_STRUCT_USTAT; unsigned struct_ustat_sz = SIZEOF_STRUCT_USTAT;
unsigned struct_rlimit64_sz = sizeof(struct rlimit64); unsigned struct_rlimit64_sz = sizeof(struct rlimit64);
unsigned struct_statvfs64_sz = sizeof(struct statvfs64); unsigned struct_statvfs64_sz = sizeof(struct statvfs64);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: invalid application of 'sizeof' to an incomplete type 'struct statvfs64' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: invalid application of 'sizeof' to an incomplete type 'struct statvfs64'…
unsigned struct_crypt_data_sz = sizeof(struct crypt_data); unsigned struct_crypt_data_sz = sizeof(struct crypt_data);
#endif // SANITIZER_LINUX && !SANITIZER_ANDROID #endif // SANITIZER_LINUX && !SANITIZER_ANDROID
#if SANITIZER_LINUX && !SANITIZER_ANDROID #if SANITIZER_GNU
unsigned struct_timex_sz = sizeof(struct timex); unsigned struct_timex_sz = sizeof(struct timex);
unsigned struct_msqid_ds_sz = sizeof(struct msqid_ds); unsigned struct_msqid_ds_sz = sizeof(struct msqid_ds);
unsigned struct_mq_attr_sz = sizeof(struct mq_attr); unsigned struct_mq_attr_sz = sizeof(struct mq_attr);
unsigned struct_statvfs_sz = sizeof(struct statvfs); unsigned struct_statvfs_sz = sizeof(struct statvfs);
#endif // SANITIZER_LINUX && !SANITIZER_ANDROID #endif // SANITIZER_GNU
const uptr sig_ign = (uptr)SIG_IGN; const uptr sig_ign = (uptr)SIG_IGN;
const uptr sig_dfl = (uptr)SIG_DFL; const uptr sig_dfl = (uptr)SIG_DFL;
const uptr sig_err = (uptr)SIG_ERR; const uptr sig_err = (uptr)SIG_ERR;
const uptr sa_siginfo = (uptr)SA_SIGINFO; const uptr sa_siginfo = (uptr)SA_SIGINFO;
#if SANITIZER_LINUX #if SANITIZER_LINUX
int e_tabsz = (int)E_TABSZ; int e_tabsz = (int)E_TABSZ;
#endif #endif
#if SANITIZER_GNU
#if SANITIZER_LINUX && !SANITIZER_ANDROID
unsigned struct_shminfo_sz = sizeof(struct shminfo); unsigned struct_shminfo_sz = sizeof(struct shminfo);
unsigned struct_shm_info_sz = sizeof(struct shm_info); unsigned struct_shm_info_sz = sizeof(struct shm_info);
int shmctl_ipc_stat = (int)IPC_STAT; int shmctl_ipc_stat = (int)IPC_STAT;
int shmctl_ipc_info = (int)IPC_INFO; int shmctl_ipc_info = (int)IPC_INFO;
int shmctl_shm_info = (int)SHM_INFO; int shmctl_shm_info = (int)SHM_INFO;
int shmctl_shm_stat = (int)SHM_STAT; int shmctl_shm_stat = (int)SHM_STAT;
#endif #endif
Show All 19 Lines#endif
} }
#if SANITIZER_LINUX #if SANITIZER_LINUX
unsigned struct_ElfW_Phdr_sz = sizeof(ElfW(Phdr)); unsigned struct_ElfW_Phdr_sz = sizeof(ElfW(Phdr));
#elif SANITIZER_FREEBSD #elif SANITIZER_FREEBSD
unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr); unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr);
#endif #endif
#if SANITIZER_LINUX && !SANITIZER_ANDROID #if SANITIZER_GNU
int glob_nomatch = GLOB_NOMATCH; int glob_nomatch = GLOB_NOMATCH;
int glob_altdirfunc = GLOB_ALTDIRFUNC; int glob_altdirfunc = GLOB_ALTDIRFUNC;
#endif #endif
#if SANITIZER_LINUX && !SANITIZER_ANDROID && \ #if SANITIZER_GNU && \
(defined(__i386) || defined(__x86_64) || defined(__mips64) || \ (defined(__i386) || defined(__x86_64) || defined(__mips64) || \
defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__) || \ defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__) || \
defined(__s390__) || SANITIZER_RISCV64) defined(__s390__) || SANITIZER_RISCV64)
#if defined(__mips64) || defined(__powerpc64__) || defined(__arm__) #if defined(__mips64) || defined(__powerpc64__) || defined(__arm__)
unsigned struct_user_regs_struct_sz = sizeof(struct pt_regs); unsigned struct_user_regs_struct_sz = sizeof(struct pt_regs);
unsigned struct_user_fpregs_struct_sz = sizeof(elf_fpregset_t); unsigned struct_user_fpregs_struct_sz = sizeof(elf_fpregset_t);
#elif SANITIZER_RISCV64 #elif SANITIZER_RISCV64
unsigned struct_user_regs_struct_sz = sizeof(struct user_regs_struct); unsigned struct_user_regs_struct_sz = sizeof(struct user_regs_struct);
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines#if SANITIZER_LINUX
unsigned struct_floppy_write_errors_sz = sizeof(struct floppy_write_errors); unsigned struct_floppy_write_errors_sz = sizeof(struct floppy_write_errors);
unsigned struct_format_descr_sz = sizeof(struct format_descr); unsigned struct_format_descr_sz = sizeof(struct format_descr);
unsigned struct_hd_driveid_sz = sizeof(struct hd_driveid); unsigned struct_hd_driveid_sz = sizeof(struct hd_driveid);
unsigned struct_hd_geometry_sz = sizeof(struct hd_geometry); unsigned struct_hd_geometry_sz = sizeof(struct hd_geometry);
unsigned struct_input_absinfo_sz = sizeof(struct input_absinfo); unsigned struct_input_absinfo_sz = sizeof(struct input_absinfo);
unsigned struct_input_id_sz = sizeof(struct input_id); unsigned struct_input_id_sz = sizeof(struct input_id);
unsigned struct_mtpos_sz = sizeof(struct mtpos); unsigned struct_mtpos_sz = sizeof(struct mtpos);
unsigned struct_rtentry_sz = sizeof(struct rtentry); unsigned struct_rtentry_sz = sizeof(struct rtentry);
#if SANITIZER_GNU
unsigned struct_termio_sz = sizeof(struct termio); unsigned struct_termio_sz = sizeof(struct termio);
#endif
unsigned struct_vt_consize_sz = sizeof(struct vt_consize); unsigned struct_vt_consize_sz = sizeof(struct vt_consize);
unsigned struct_vt_sizes_sz = sizeof(struct vt_sizes); unsigned struct_vt_sizes_sz = sizeof(struct vt_sizes);
unsigned struct_vt_stat_sz = sizeof(struct vt_stat); unsigned struct_vt_stat_sz = sizeof(struct vt_stat);
#endif // SANITIZER_LINUX #endif // SANITIZER_LINUX
#if SANITIZER_LINUX #if SANITIZER_LINUX
#if SOUND_VERSION >= 0x040000 #if SOUND_VERSION >= 0x040000
unsigned struct_copr_buffer_sz = 0; unsigned struct_copr_buffer_sz = 0;
Show All 9 Lines#endif
unsigned struct_mtop_sz = sizeof(struct mtop); unsigned struct_mtop_sz = sizeof(struct mtop);
unsigned struct_sbi_instrument_sz = sizeof(struct sbi_instrument); unsigned struct_sbi_instrument_sz = sizeof(struct sbi_instrument);
unsigned struct_seq_event_rec_sz = sizeof(struct seq_event_rec); unsigned struct_seq_event_rec_sz = sizeof(struct seq_event_rec);
unsigned struct_synth_info_sz = sizeof(struct synth_info); unsigned struct_synth_info_sz = sizeof(struct synth_info);
unsigned struct_vt_mode_sz = sizeof(struct vt_mode); unsigned struct_vt_mode_sz = sizeof(struct vt_mode);
#endif // SANITIZER_LINUX #endif // SANITIZER_LINUX
#if SANITIZER_LINUX && !SANITIZER_ANDROID #if SANITIZER_LINUX && !SANITIZER_ANDROID
#if SANITIZER_GNU
unsigned struct_ax25_parms_struct_sz = sizeof(struct ax25_parms_struct); unsigned struct_ax25_parms_struct_sz = sizeof(struct ax25_parms_struct);
#endif
unsigned struct_cyclades_monitor_sz = sizeof(struct cyclades_monitor); unsigned struct_cyclades_monitor_sz = sizeof(struct cyclades_monitor);
#if EV_VERSION > (0x010000) #if EV_VERSION > (0x010000)
unsigned struct_input_keymap_entry_sz = sizeof(struct input_keymap_entry); unsigned struct_input_keymap_entry_sz = sizeof(struct input_keymap_entry);
#else #else
unsigned struct_input_keymap_entry_sz = 0; unsigned struct_input_keymap_entry_sz = 0;
#endif #endif
unsigned struct_ipx_config_data_sz = sizeof(struct ipx_config_data); unsigned struct_ipx_config_data_sz = sizeof(struct ipx_config_data);
unsigned struct_kbdiacrs_sz = sizeof(struct kbdiacrs); unsigned struct_kbdiacrs_sz = sizeof(struct kbdiacrs);
unsigned struct_kbentry_sz = sizeof(struct kbentry); unsigned struct_kbentry_sz = sizeof(struct kbentry);
unsigned struct_kbkeycode_sz = sizeof(struct kbkeycode); unsigned struct_kbkeycode_sz = sizeof(struct kbkeycode);
unsigned struct_kbsentry_sz = sizeof(struct kbsentry); unsigned struct_kbsentry_sz = sizeof(struct kbsentry);
#if SANITIZER_GNU
unsigned struct_mtconfiginfo_sz = sizeof(struct mtconfiginfo); unsigned struct_mtconfiginfo_sz = sizeof(struct mtconfiginfo);
unsigned struct_nr_parms_struct_sz = sizeof(struct nr_parms_struct); unsigned struct_nr_parms_struct_sz = sizeof(struct nr_parms_struct);
#endif
unsigned struct_scc_modem_sz = sizeof(struct scc_modem); unsigned struct_scc_modem_sz = sizeof(struct scc_modem);
unsigned struct_scc_stat_sz = sizeof(struct scc_stat); unsigned struct_scc_stat_sz = sizeof(struct scc_stat);
#if SANITIZER_GNU
unsigned struct_serial_multiport_struct_sz unsigned struct_serial_multiport_struct_sz
= sizeof(struct serial_multiport_struct); = sizeof(struct serial_multiport_struct);
unsigned struct_serial_struct_sz = sizeof(struct serial_struct); unsigned struct_serial_struct_sz = sizeof(struct serial_struct);
#endif
unsigned struct_sockaddr_ax25_sz = sizeof(struct sockaddr_ax25); unsigned struct_sockaddr_ax25_sz = sizeof(struct sockaddr_ax25);
unsigned struct_unimapdesc_sz = sizeof(struct unimapdesc); unsigned struct_unimapdesc_sz = sizeof(struct unimapdesc);
unsigned struct_unimapinit_sz = sizeof(struct unimapinit); unsigned struct_unimapinit_sz = sizeof(struct unimapinit);
#endif // SANITIZER_LINUX && !SANITIZER_ANDROID #endif // SANITIZER_LINUX && !SANITIZER_ANDROID
#if SANITIZER_LINUX && !SANITIZER_ANDROID #if SANITIZER_LINUX && !SANITIZER_ANDROID
unsigned struct_audio_buf_info_sz = sizeof(struct audio_buf_info); unsigned struct_audio_buf_info_sz = sizeof(struct audio_buf_info);
unsigned struct_ppp_stats_sz = sizeof(struct ppp_stats); unsigned struct_ppp_stats_sz = sizeof(struct ppp_stats);
#endif // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID #endif // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
#if !SANITIZER_ANDROID && !SANITIZER_MAC #if !SANITIZER_ANDROID && !SANITIZER_MAC
unsigned struct_sioc_sg_req_sz = sizeof(struct sioc_sg_req); unsigned struct_sioc_sg_req_sz = sizeof(struct sioc_sg_req);
unsigned struct_sioc_vif_req_sz = sizeof(struct sioc_vif_req); unsigned struct_sioc_vif_req_sz = sizeof(struct sioc_vif_req);
#endif #endif
#if defined(BUFSIZ)
const unsigned long __sanitizer_bufsiz = BUFSIZ; const unsigned long __sanitizer_bufsiz = BUFSIZ;
#else
const unsigned long __sanitizer_bufsiz = 4096;
#endif
const unsigned IOCTL_NOT_PRESENT = 0; const unsigned IOCTL_NOT_PRESENT = 0;
unsigned IOCTL_FIOASYNC = FIOASYNC; unsigned IOCTL_FIOASYNC = FIOASYNC;
unsigned IOCTL_FIOCLEX = FIOCLEX; unsigned IOCTL_FIOCLEX = FIOCLEX;
unsigned IOCTL_FIOGETOWN = FIOGETOWN; unsigned IOCTL_FIOGETOWN = FIOGETOWN;
unsigned IOCTL_FIONBIO = FIONBIO; unsigned IOCTL_FIONBIO = FIONBIO;
unsigned IOCTL_FIONCLEX = FIONCLEX; unsigned IOCTL_FIONCLEX = FIONCLEX;
▲ Show 20 Lines • Show All 375 Lines • ▼ Show 20 Lines#endif
unsigned IOCTL_LPCAREFUL = LPCAREFUL; unsigned IOCTL_LPCAREFUL = LPCAREFUL;
unsigned IOCTL_LPCHAR = LPCHAR; unsigned IOCTL_LPCHAR = LPCHAR;
unsigned IOCTL_LPGETIRQ = LPGETIRQ; unsigned IOCTL_LPGETIRQ = LPGETIRQ;
unsigned IOCTL_LPGETSTATUS = LPGETSTATUS; unsigned IOCTL_LPGETSTATUS = LPGETSTATUS;
unsigned IOCTL_LPRESET = LPRESET; unsigned IOCTL_LPRESET = LPRESET;
unsigned IOCTL_LPSETIRQ = LPSETIRQ; unsigned IOCTL_LPSETIRQ = LPSETIRQ;
unsigned IOCTL_LPTIME = LPTIME; unsigned IOCTL_LPTIME = LPTIME;
unsigned IOCTL_LPWAIT = LPWAIT; unsigned IOCTL_LPWAIT = LPWAIT;
#if SANITIZER_GNU
unsigned IOCTL_MTIOCGETCONFIG = MTIOCGETCONFIG; unsigned IOCTL_MTIOCGETCONFIG = MTIOCGETCONFIG;
unsigned IOCTL_MTIOCSETCONFIG = MTIOCSETCONFIG; unsigned IOCTL_MTIOCSETCONFIG = MTIOCSETCONFIG;
#endif
unsigned IOCTL_PIO_CMAP = PIO_CMAP; unsigned IOCTL_PIO_CMAP = PIO_CMAP;
unsigned IOCTL_PIO_FONT = PIO_FONT; unsigned IOCTL_PIO_FONT = PIO_FONT;
unsigned IOCTL_PIO_UNIMAP = PIO_UNIMAP; unsigned IOCTL_PIO_UNIMAP = PIO_UNIMAP;
unsigned IOCTL_PIO_UNIMAPCLR = PIO_UNIMAPCLR; unsigned IOCTL_PIO_UNIMAPCLR = PIO_UNIMAPCLR;
unsigned IOCTL_PIO_UNISCRNMAP = PIO_UNISCRNMAP; unsigned IOCTL_PIO_UNISCRNMAP = PIO_UNISCRNMAP;
#if SANITIZER_GNU
unsigned IOCTL_SCSI_IOCTL_GET_IDLUN = SCSI_IOCTL_GET_IDLUN; unsigned IOCTL_SCSI_IOCTL_GET_IDLUN = SCSI_IOCTL_GET_IDLUN;
unsigned IOCTL_SCSI_IOCTL_PROBE_HOST = SCSI_IOCTL_PROBE_HOST; unsigned IOCTL_SCSI_IOCTL_PROBE_HOST = SCSI_IOCTL_PROBE_HOST;
unsigned IOCTL_SCSI_IOCTL_TAGGED_DISABLE = SCSI_IOCTL_TAGGED_DISABLE; unsigned IOCTL_SCSI_IOCTL_TAGGED_DISABLE = SCSI_IOCTL_TAGGED_DISABLE;
unsigned IOCTL_SCSI_IOCTL_TAGGED_ENABLE = SCSI_IOCTL_TAGGED_ENABLE; unsigned IOCTL_SCSI_IOCTL_TAGGED_ENABLE = SCSI_IOCTL_TAGGED_ENABLE;
#endif
unsigned IOCTL_SIOCAIPXITFCRT = SIOCAIPXITFCRT; unsigned IOCTL_SIOCAIPXITFCRT = SIOCAIPXITFCRT;
unsigned IOCTL_SIOCAIPXPRISLT = SIOCAIPXPRISLT; unsigned IOCTL_SIOCAIPXPRISLT = SIOCAIPXPRISLT;
unsigned IOCTL_SIOCAX25ADDUID = SIOCAX25ADDUID; unsigned IOCTL_SIOCAX25ADDUID = SIOCAX25ADDUID;
unsigned IOCTL_SIOCAX25DELUID = SIOCAX25DELUID; unsigned IOCTL_SIOCAX25DELUID = SIOCAX25DELUID;
#if SANITIZER_GNU
unsigned IOCTL_SIOCAX25GETPARMS = SIOCAX25GETPARMS; unsigned IOCTL_SIOCAX25GETPARMS = SIOCAX25GETPARMS;
#endif
unsigned IOCTL_SIOCAX25GETUID = SIOCAX25GETUID; unsigned IOCTL_SIOCAX25GETUID = SIOCAX25GETUID;
unsigned IOCTL_SIOCAX25NOUID = SIOCAX25NOUID; unsigned IOCTL_SIOCAX25NOUID = SIOCAX25NOUID;
#if SANITIZER_GNU
unsigned IOCTL_SIOCAX25SETPARMS = SIOCAX25SETPARMS; unsigned IOCTL_SIOCAX25SETPARMS = SIOCAX25SETPARMS;
#endif
unsigned IOCTL_SIOCDEVPLIP = SIOCDEVPLIP; unsigned IOCTL_SIOCDEVPLIP = SIOCDEVPLIP;
unsigned IOCTL_SIOCIPXCFGDATA = SIOCIPXCFGDATA; unsigned IOCTL_SIOCIPXCFGDATA = SIOCIPXCFGDATA;
unsigned IOCTL_SIOCNRDECOBS = SIOCNRDECOBS; unsigned IOCTL_SIOCNRDECOBS = SIOCNRDECOBS;
#if SANITIZER_GNU
unsigned IOCTL_SIOCNRGETPARMS = SIOCNRGETPARMS; unsigned IOCTL_SIOCNRGETPARMS = SIOCNRGETPARMS;
unsigned IOCTL_SIOCNRRTCTL = SIOCNRRTCTL; unsigned IOCTL_SIOCNRRTCTL = SIOCNRRTCTL;
unsigned IOCTL_SIOCNRSETPARMS = SIOCNRSETPARMS; unsigned IOCTL_SIOCNRSETPARMS = SIOCNRSETPARMS;
#endif
unsigned IOCTL_TIOCGSERIAL = TIOCGSERIAL; unsigned IOCTL_TIOCGSERIAL = TIOCGSERIAL;
unsigned IOCTL_TIOCSERGETMULTI = TIOCSERGETMULTI; unsigned IOCTL_TIOCSERGETMULTI = TIOCSERGETMULTI;
unsigned IOCTL_TIOCSERSETMULTI = TIOCSERSETMULTI; unsigned IOCTL_TIOCSERSETMULTI = TIOCSERSETMULTI;
unsigned IOCTL_TIOCSSERIAL = TIOCSSERIAL; unsigned IOCTL_TIOCSSERIAL = TIOCSSERIAL;
#endif // SANITIZER_LINUX && !SANITIZER_ANDROID #endif // SANITIZER_LINUX && !SANITIZER_ANDROID
#if SANITIZER_LINUX && !SANITIZER_ANDROID #if SANITIZER_LINUX && !SANITIZER_ANDROID
unsigned IOCTL_GIO_SCRNMAP = GIO_SCRNMAP; unsigned IOCTL_GIO_SCRNMAP = GIO_SCRNMAP;
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
// in. // in.
COMPILER_CHECK(sizeof(__sanitizer_dl_phdr_info) <= sizeof(dl_phdr_info)); COMPILER_CHECK(sizeof(__sanitizer_dl_phdr_info) <= sizeof(dl_phdr_info));
CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_addr); CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_addr);
CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_name); CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_name);
CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_phdr); CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_phdr);
CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_phnum); CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_phnum);
#endif // SANITIZER_LINUX || SANITIZER_FREEBSD #endif // SANITIZER_LINUX || SANITIZER_FREEBSD
#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID #if (SANITIZER_GNU || SANITIZER_FREEBSD)
CHECK_TYPE_SIZE(glob_t); CHECK_TYPE_SIZE(glob_t);
CHECK_SIZE_AND_OFFSET(glob_t, gl_pathc); CHECK_SIZE_AND_OFFSET(glob_t, gl_pathc);
CHECK_SIZE_AND_OFFSET(glob_t, gl_pathv); CHECK_SIZE_AND_OFFSET(glob_t, gl_pathv);
CHECK_SIZE_AND_OFFSET(glob_t, gl_offs); CHECK_SIZE_AND_OFFSET(glob_t, gl_offs);
CHECK_SIZE_AND_OFFSET(glob_t, gl_flags); CHECK_SIZE_AND_OFFSET(glob_t, gl_flags);
CHECK_SIZE_AND_OFFSET(glob_t, gl_closedir); CHECK_SIZE_AND_OFFSET(glob_t, gl_closedir);
CHECK_SIZE_AND_OFFSET(glob_t, gl_readdir); CHECK_SIZE_AND_OFFSET(glob_t, gl_readdir);
CHECK_SIZE_AND_OFFSET(glob_t, gl_opendir); CHECK_SIZE_AND_OFFSET(glob_t, gl_opendir);
Show All 17 Lines
CHECK_SIZE_AND_OFFSET(hostent, h_addrtype); CHECK_SIZE_AND_OFFSET(hostent, h_addrtype);
CHECK_SIZE_AND_OFFSET(hostent, h_length); CHECK_SIZE_AND_OFFSET(hostent, h_length);
CHECK_SIZE_AND_OFFSET(hostent, h_addr_list); CHECK_SIZE_AND_OFFSET(hostent, h_addr_list);
CHECK_TYPE_SIZE(iovec); CHECK_TYPE_SIZE(iovec);
CHECK_SIZE_AND_OFFSET(iovec, iov_base); CHECK_SIZE_AND_OFFSET(iovec, iov_base);
CHECK_SIZE_AND_OFFSET(iovec, iov_len); CHECK_SIZE_AND_OFFSET(iovec, iov_len);
#if SANITIZER_GNU || SANITIZER_ANDROID
CHECK_TYPE_SIZE(msghdr); CHECK_TYPE_SIZE(msghdr);
CHECK_SIZE_AND_OFFSET(msghdr, msg_name); CHECK_SIZE_AND_OFFSET(msghdr, msg_name);
CHECK_SIZE_AND_OFFSET(msghdr, msg_namelen); CHECK_SIZE_AND_OFFSET(msghdr, msg_namelen);
CHECK_SIZE_AND_OFFSET(msghdr, msg_iov); CHECK_SIZE_AND_OFFSET(msghdr, msg_iov);
CHECK_SIZE_AND_OFFSET(msghdr, msg_iovlen); CHECK_SIZE_AND_OFFSET(msghdr, msg_iovlen);
CHECK_SIZE_AND_OFFSET(msghdr, msg_control); CHECK_SIZE_AND_OFFSET(msghdr, msg_control);
CHECK_SIZE_AND_OFFSET(msghdr, msg_controllen); CHECK_SIZE_AND_OFFSET(msghdr, msg_controllen);
CHECK_SIZE_AND_OFFSET(msghdr, msg_flags); CHECK_SIZE_AND_OFFSET(msghdr, msg_flags);
CHECK_TYPE_SIZE(cmsghdr); CHECK_TYPE_SIZE(cmsghdr);
CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_len); CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_len);
CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_level); CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_level);
CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_type); CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_type);
#endif
#ifndef __GLIBC_PREREQ
#define __GLIBC_PREREQ(x, y) 0
#endif
#if SANITIZER_LINUX && (__ANDROID_API__ >= 21 || __GLIBC_PREREQ (2, 14)) #if SANITIZER_LINUX && (__ANDROID_API__ >= 21 || __GLIBC_PREREQ (2, 14))
CHECK_TYPE_SIZE(mmsghdr); CHECK_TYPE_SIZE(mmsghdr);
CHECK_SIZE_AND_OFFSET(mmsghdr, msg_hdr); CHECK_SIZE_AND_OFFSET(mmsghdr, msg_hdr);
CHECK_SIZE_AND_OFFSET(mmsghdr, msg_len); CHECK_SIZE_AND_OFFSET(mmsghdr, msg_len);
#endif #endif
COMPILER_CHECK(sizeof(__sanitizer_dirent) <= sizeof(dirent)); COMPILER_CHECK(sizeof(__sanitizer_dirent) <= sizeof(dirent));
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Lines
CHECK_SIZE_AND_OFFSET(mntent, mnt_type); CHECK_SIZE_AND_OFFSET(mntent, mnt_type);
CHECK_SIZE_AND_OFFSET(mntent, mnt_opts); CHECK_SIZE_AND_OFFSET(mntent, mnt_opts);
CHECK_SIZE_AND_OFFSET(mntent, mnt_freq); CHECK_SIZE_AND_OFFSET(mntent, mnt_freq);
CHECK_SIZE_AND_OFFSET(mntent, mnt_passno); CHECK_SIZE_AND_OFFSET(mntent, mnt_passno);
#endif #endif
CHECK_TYPE_SIZE(ether_addr); CHECK_TYPE_SIZE(ether_addr);
#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID #if SANITIZER_GNU || SANITIZER_FREEBSD
CHECK_TYPE_SIZE(ipc_perm); CHECK_TYPE_SIZE(ipc_perm);
# if SANITIZER_FREEBSD # if SANITIZER_FREEBSD
CHECK_SIZE_AND_OFFSET(ipc_perm, key); CHECK_SIZE_AND_OFFSET(ipc_perm, key);
CHECK_SIZE_AND_OFFSET(ipc_perm, seq); CHECK_SIZE_AND_OFFSET(ipc_perm, seq);
# else # else
CHECK_SIZE_AND_OFFSET(ipc_perm, __key); CHECK_SIZE_AND_OFFSET(ipc_perm, __key);
CHECK_SIZE_AND_OFFSET(ipc_perm, __seq); CHECK_SIZE_AND_OFFSET(ipc_perm, __seq);
# endif # endif
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 LinesCOMPILER_CHECK(offsetof(__sanitizer_ifaddrs, ifa_dstaddr) ==
offsetof(ifaddrs, ifa_ifu)); offsetof(ifaddrs, ifa_ifu));
# endif // SANITIZER_FREEBSD # endif // SANITIZER_FREEBSD
#else #else
CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_dstaddr); CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_dstaddr);
#endif // SANITIZER_LINUX #endif // SANITIZER_LINUX
CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_data); CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_data);
#endif #endif
#if SANITIZER_LINUX // mallinfo is annoying, cause it's SVID instead of POSIX or C standard...
#if SANITIZER_GNU
COMPILER_CHECK(sizeof(__sanitizer_struct_mallinfo) == sizeof(struct mallinfo)); COMPILER_CHECK(sizeof(__sanitizer_struct_mallinfo) == sizeof(struct mallinfo));
#endif #endif
#if !SANITIZER_ANDROID #if !SANITIZER_ANDROID
CHECK_TYPE_SIZE(timeb); CHECK_TYPE_SIZE(timeb);
CHECK_SIZE_AND_OFFSET(timeb, time); CHECK_SIZE_AND_OFFSET(timeb, time);
CHECK_SIZE_AND_OFFSET(timeb, millitm); CHECK_SIZE_AND_OFFSET(timeb, millitm);
CHECK_SIZE_AND_OFFSET(timeb, timezone); CHECK_SIZE_AND_OFFSET(timeb, timezone);
Show All 21 Lines
CHECK_TYPE_SIZE(group); CHECK_TYPE_SIZE(group);
CHECK_SIZE_AND_OFFSET(group, gr_name); CHECK_SIZE_AND_OFFSET(group, gr_name);
CHECK_SIZE_AND_OFFSET(group, gr_passwd); CHECK_SIZE_AND_OFFSET(group, gr_passwd);
CHECK_SIZE_AND_OFFSET(group, gr_gid); CHECK_SIZE_AND_OFFSET(group, gr_gid);
CHECK_SIZE_AND_OFFSET(group, gr_mem); CHECK_SIZE_AND_OFFSET(group, gr_mem);
#if HAVE_RPC_XDR_H #if HAVE_RPC_XDR_H
CHECK_TYPE_SIZE(XDR); CHECK_TYPE_SIZE(XDR);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: use of undeclared identifier 'XDR' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: use of undeclared identifier 'XDR' [clang-diagnostic-error] [[https://github.
CHECK_SIZE_AND_OFFSET(XDR, x_op); CHECK_SIZE_AND_OFFSET(XDR, x_op);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: expected expression [clang-diagnostic-error]
not useful
clang-tidy: error: unknown type name 'XDR' [clang-diagnostic-error]
not useful
clang-tidy: error: use of undeclared identifier 'XDR' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: expected expression [clang-diagnostic-error] [[https://github.
CHECK_SIZE_AND_OFFSET(XDR, x_ops); CHECK_SIZE_AND_OFFSET(XDR, x_ops);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: expected expression [clang-diagnostic-error]
not useful
clang-tidy: error: unknown type name 'XDR' [clang-diagnostic-error]
not useful
clang-tidy: error: use of undeclared identifier 'XDR' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: expected expression [clang-diagnostic-error] [[https://github.
CHECK_SIZE_AND_OFFSET(XDR, x_public); CHECK_SIZE_AND_OFFSET(XDR, x_public);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: expected expression [clang-diagnostic-error]
not useful
clang-tidy: error: unknown type name 'XDR' [clang-diagnostic-error]
not useful
clang-tidy: error: use of undeclared identifier 'XDR' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: expected expression [clang-diagnostic-error] [[https://github.
CHECK_SIZE_AND_OFFSET(XDR, x_private); CHECK_SIZE_AND_OFFSET(XDR, x_private);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: expected expression [clang-diagnostic-error]
not useful
clang-tidy: error: unknown type name 'XDR' [clang-diagnostic-error]
not useful
clang-tidy: error: use of undeclared identifier 'XDR' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: expected expression [clang-diagnostic-error] [[https://github.
CHECK_SIZE_AND_OFFSET(XDR, x_base); CHECK_SIZE_AND_OFFSET(XDR, x_base);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: expected expression [clang-diagnostic-error]
not useful
clang-tidy: error: unknown type name 'XDR' [clang-diagnostic-error]
not useful
clang-tidy: error: use of undeclared identifier 'XDR' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: expected expression [clang-diagnostic-error] [[https://github.
CHECK_SIZE_AND_OFFSET(XDR, x_handy); CHECK_SIZE_AND_OFFSET(XDR, x_handy);
Lint: Pre-merge checks
Inline Actions

clang-tidy: error: expected expression [clang-diagnostic-error]
not useful
clang-tidy: error: use of undeclared identifier 'XDR' [clang-diagnostic-error]
not useful

Lint: Pre-merge checks: clang-tidy: error: expected expression [clang-diagnostic-error] [[https://github.
COMPILER_CHECK(__sanitizer_XDR_ENCODE == XDR_ENCODE); COMPILER_CHECK(__sanitizer_XDR_ENCODE == XDR_ENCODE);
COMPILER_CHECK(__sanitizer_XDR_DECODE == XDR_DECODE); COMPILER_CHECK(__sanitizer_XDR_DECODE == XDR_DECODE);
COMPILER_CHECK(__sanitizer_XDR_FREE == XDR_FREE); COMPILER_CHECK(__sanitizer_XDR_FREE == XDR_FREE);
#endif #endif
#if SANITIZER_LINUX && !SANITIZER_ANDROID // #if SANITIZER_LINUX && !SANITIZER_ANDROID
#if SANITIZER_GNU
COMPILER_CHECK(sizeof(__sanitizer_FILE) <= sizeof(FILE)); COMPILER_CHECK(sizeof(__sanitizer_FILE) <= sizeof(FILE));
CHECK_SIZE_AND_OFFSET(FILE, _flags); CHECK_SIZE_AND_OFFSET(FILE, _flags);
CHECK_SIZE_AND_OFFSET(FILE, _IO_read_ptr); CHECK_SIZE_AND_OFFSET(FILE, _IO_read_ptr);
CHECK_SIZE_AND_OFFSET(FILE, _IO_read_end); CHECK_SIZE_AND_OFFSET(FILE, _IO_read_end);
CHECK_SIZE_AND_OFFSET(FILE, _IO_read_base); CHECK_SIZE_AND_OFFSET(FILE, _IO_read_base);
CHECK_SIZE_AND_OFFSET(FILE, _IO_write_ptr); CHECK_SIZE_AND_OFFSET(FILE, _IO_write_ptr);
CHECK_SIZE_AND_OFFSET(FILE, _IO_write_end); CHECK_SIZE_AND_OFFSET(FILE, _IO_write_end);
CHECK_SIZE_AND_OFFSET(FILE, _IO_write_base); CHECK_SIZE_AND_OFFSET(FILE, _IO_write_base);
CHECK_SIZE_AND_OFFSET(FILE, _IO_buf_base); CHECK_SIZE_AND_OFFSET(FILE, _IO_buf_base);
CHECK_SIZE_AND_OFFSET(FILE, _IO_buf_end); CHECK_SIZE_AND_OFFSET(FILE, _IO_buf_end);
CHECK_SIZE_AND_OFFSET(FILE, _IO_save_base); CHECK_SIZE_AND_OFFSET(FILE, _IO_save_base);
CHECK_SIZE_AND_OFFSET(FILE, _IO_backup_base); CHECK_SIZE_AND_OFFSET(FILE, _IO_backup_base);
CHECK_SIZE_AND_OFFSET(FILE, _IO_save_end); CHECK_SIZE_AND_OFFSET(FILE, _IO_save_end);
CHECK_SIZE_AND_OFFSET(FILE, _markers); CHECK_SIZE_AND_OFFSET(FILE, _markers);
CHECK_SIZE_AND_OFFSET(FILE, _chain); CHECK_SIZE_AND_OFFSET(FILE, _chain);
CHECK_SIZE_AND_OFFSET(FILE, _fileno); CHECK_SIZE_AND_OFFSET(FILE, _fileno);
#endif #endif
#if SANITIZER_LINUX && !SANITIZER_ANDROID #if SANITIZER_GNU
COMPILER_CHECK(sizeof(__sanitizer__obstack_chunk) <= sizeof(_obstack_chunk)); COMPILER_CHECK(sizeof(__sanitizer__obstack_chunk) <= sizeof(_obstack_chunk));
CHECK_SIZE_AND_OFFSET(_obstack_chunk, limit); CHECK_SIZE_AND_OFFSET(_obstack_chunk, limit);
CHECK_SIZE_AND_OFFSET(_obstack_chunk, prev); CHECK_SIZE_AND_OFFSET(_obstack_chunk, prev);
CHECK_TYPE_SIZE(obstack); CHECK_TYPE_SIZE(obstack);
CHECK_SIZE_AND_OFFSET(obstack, chunk_size); CHECK_SIZE_AND_OFFSET(obstack, chunk_size);
CHECK_SIZE_AND_OFFSET(obstack, chunk); CHECK_SIZE_AND_OFFSET(obstack, chunk);
CHECK_SIZE_AND_OFFSET(obstack, object_base); CHECK_SIZE_AND_OFFSET(obstack, object_base);
CHECK_SIZE_AND_OFFSET(obstack, next_free); CHECK_SIZE_AND_OFFSET(obstack, next_free);
Show All 17 Lines