mirror of
https://sourceware.org/git/glibc.git
synced 2024-11-08 14:20:07 +00:00
Use glibc_likely instead __builtin_expect.
This commit is contained in:
Ondřej Bílka
parent
1448f32447
commit
a1ffb40e32
496
ChangeLog
496
ChangeLog
@ -1,3 +1,499 @@
|
||||
2014-02-10 Ondřej Bílka <neleai@seznam.cz>
|
||||
|
||||
* assert/assert.c (__assert_fail_base): Use glibc_likely instead __builtin_expect.
|
||||
* benchtests/bench-memmem.c (simple_memmem): Likewise.
|
||||
* catgets/open_catalog.c (__open_catalog): Likewise.
|
||||
* csu/libc-start.c (LIBC_START_MAIN): Likewise.
|
||||
* debug/confstr_chk.c: Likewise.
|
||||
* debug/fread_chk.c (__fread_chk): Likewise.
|
||||
* debug/fread_u_chk.c (__fread_unlocked_chk): Likewise.
|
||||
* debug/getgroups_chk.c: Likewise.
|
||||
* debug/mbsnrtowcs_chk.c: Likewise.
|
||||
* debug/mbsrtowcs_chk.c: Likewise.
|
||||
* debug/mbstowcs_chk.c: Likewise.
|
||||
* debug/memcpy_chk.c: Likewise.
|
||||
* debug/memmove_chk.c: Likewise.
|
||||
* debug/mempcpy_chk.c: Likewise.
|
||||
* debug/memset_chk.c: Likewise.
|
||||
* debug/stpcpy_chk.c (__stpcpy_chk): Likewise.
|
||||
* debug/strcat_chk.c (__strcat_chk): Likewise.
|
||||
* debug/strcpy_chk.c (__strcpy_chk): Likewise.
|
||||
* debug/strncat_chk.c (__strncat_chk): Likewise.
|
||||
* debug/vsnprintf_chk.c (___vsnprintf_chk): Likewise.
|
||||
* debug/vswprintf_chk.c (__vswprintf_chk): Likewise.
|
||||
* debug/wcpcpy_chk.c (__wcpcpy_chk): Likewise.
|
||||
* debug/wcpncpy_chk.c: Likewise.
|
||||
* debug/wcscat_chk.c (__wcscat_chk): Likewise.
|
||||
* debug/wcscpy_chk.c (__wcscpy_chk): Likewise.
|
||||
* debug/wcsncat_chk.c (__wcsncat_chk): Likewise.
|
||||
* debug/wcsncpy_chk.c: Likewise.
|
||||
* debug/wcsnrtombs_chk.c: Likewise.
|
||||
* debug/wcsrtombs_chk.c: Likewise.
|
||||
* debug/wcstombs_chk.c: Likewise.
|
||||
* debug/wmemcpy_chk.c: Likewise.
|
||||
* debug/wmemmove_chk.c: Likewise.
|
||||
* debug/wmempcpy_chk.c: Likewise.
|
||||
* debug/wmemset_chk.c: Likewise.
|
||||
* dirent/scandirat.c (SCANDIRAT): Likewise.
|
||||
* dlfcn/dladdr1.c (dladdr1): Likewise.
|
||||
* dlfcn/dladdr.c (dladdr): Likewise.
|
||||
* dlfcn/dlclose.c (dlclose_doit): Likewise.
|
||||
* dlfcn/dlerror.c (__dlerror): Likewise.
|
||||
* dlfcn/dlinfo.c (dlinfo_doit): Likewise.
|
||||
* dlfcn/dlmopen.c (dlmopen_doit): Likewise.
|
||||
* dlfcn/dlopen.c (dlopen_doit): Likewise.
|
||||
* dlfcn/dlopenold.c (__dlopen_nocheck): Likewise.
|
||||
* dlfcn/dlsym.c (dlsym_doit): Likewise.
|
||||
* dlfcn/dlvsym.c (dlvsym_doit): Likewise.
|
||||
* elf/dl-cache.c (_dl_load_cache_lookup): Likewise.
|
||||
* elf/dl-close.c (remove_slotinfo, _dl_close_worker, _dl_close):
|
||||
Likewise.
|
||||
* elf/dl-conflict.c: Likewise.
|
||||
* elf/dl-deps.c (_dl_build_local_scope, _dl_map_object_deps): Likewise.
|
||||
* elf/dl-dst.h: Likewise.
|
||||
* elf/dl-fini.c (_dl_sort_fini, _dl_fini): Likewise.
|
||||
* elf/dl-fptr.c (_dl_make_fptr): Likewise.
|
||||
* elf/dl-hwcaps.c (_dl_important_hwcaps): Likewise.
|
||||
* elf/dl-init.c (call_init, _dl_init): Likewise.
|
||||
* elf/dl-libc.c (__libc_dlopen_mode, __libc_dlsym): Likewise.
|
||||
* elf/dl-load.c (_dl_dst_substitute, fillin_rpath, _dl_init_paths,
|
||||
_dl_map_object_from_fd, open_verify, open_path,
|
||||
_dl_map_object): Likewise.
|
||||
* elf/dl-lookup.c (do_lookup_x, add_dependency, _dl_lookup_symbol_x):
|
||||
Likewise.
|
||||
* elf/dl-minimal.c (__libc_memalign): Likewise.
|
||||
* elf/dl-open.c (add_to_global, dl_open_worker, _dl_open): Likewise.
|
||||
* elf/dl-reloc.c (_dl_relocate_object): Likewise.
|
||||
* elf/dl-runtime.c (_dl_fixup, _dl_profile_fixup): Likewise.
|
||||
* elf/dl-sym.c (do_sym): Likewise.
|
||||
* elf/dl-tls.c (tls_get_addr_tail, update_get_addr, __tls_get_addr,
|
||||
_dl_tls_get_addr_soft): Likewise.
|
||||
* elf/dl-version.c (match_symbol, _dl_check_map_versions): Likewise.
|
||||
* elf/dl-writev.h (_dl_writev): Likewise.
|
||||
* elf/ldconfig.c (search_dir): Likewise.
|
||||
* elf/rtld.c (_dl_start_final, _dl_start, init_tls, do_preload,
|
||||
dl_main): Likewise.
|
||||
* elf/setup-vdso.h (setup_vdso): Likewise.
|
||||
* grp/compat-initgroups.c (compat_call): Likewise.
|
||||
* grp/fgetgrent.c (fgetgrent): Likewise.
|
||||
* grp/initgroups.c (getgrouplist, initgroups): Likewise.
|
||||
* grp/putgrent.c (putgrent): Likewise.
|
||||
* hesiod/nss_hesiod/hesiod-grp.c (_nss_hesiod_initgroups_dyn):
|
||||
Likewise.
|
||||
* hurd/hurdinit.c: Likewise.
|
||||
* iconvdata/8bit-gap.c (struct): Likewise.
|
||||
* iconvdata/ansi_x3.110.c : Likewise.
|
||||
* iconvdata/big5.c : Likewise.
|
||||
* iconvdata/big5hkscs.c : Likewise.
|
||||
* iconvdata/cp1255.c: Likewise.
|
||||
* iconvdata/cp1258.c : Likewise.
|
||||
* iconvdata/cp932.c : Likewise.
|
||||
* iconvdata/euc-cn.c: Likewise.
|
||||
* iconvdata/euc-jisx0213.c : Likewise.
|
||||
* iconvdata/euc-jp.c: Likewise.
|
||||
* iconvdata/euc-jp-ms.c : Likewise.
|
||||
* iconvdata/euc-kr.c (euckr_from_ucs4): Likewise.
|
||||
* iconvdata/gb18030.c : Likewise.
|
||||
* iconvdata/gbbig5.c (const): Likewise.
|
||||
* iconvdata/gbgbk.c: Likewise.
|
||||
* iconvdata/gbk.c : Likewise.
|
||||
* iconvdata/ibm1364.c : Likewise.
|
||||
* iconvdata/ibm930.c : Likewise.
|
||||
* iconvdata/ibm932.c: Likewise.
|
||||
* iconvdata/ibm933.c : Likewise.
|
||||
* iconvdata/ibm935.c : Likewise.
|
||||
* iconvdata/ibm937.c : Likewise.
|
||||
* iconvdata/ibm939.c : Likewise.
|
||||
* iconvdata/ibm943.c: Likewise.
|
||||
* iconvdata/iso_11548-1.c: Likewise.
|
||||
* iconvdata/iso-2022-cn.c : Likewise.
|
||||
* iconvdata/iso-2022-cn-ext.c : Likewise.
|
||||
* iconvdata/iso-2022-jp-3.c: Likewise.
|
||||
* iconvdata/iso-2022-jp.c (gconv_end): Likewise.
|
||||
* iconvdata/iso-2022-kr.c : Likewise.
|
||||
* iconvdata/iso646.c (gconv_end): Likewise.
|
||||
* iconvdata/iso_6937-2.c : Likewise.
|
||||
* iconvdata/iso_6937.c : Likewise.
|
||||
* iconvdata/iso8859-1.c: Likewise.
|
||||
* iconvdata/johab.c (johab_sym_hanja_to_ucs): Likewise.
|
||||
* iconvdata/shift_jisx0213.c : Likewise.
|
||||
* iconvdata/sjis.c : Likewise.
|
||||
* iconvdata/t.61.c : Likewise.
|
||||
* iconvdata/tcvn5712-1.c : Likewise.
|
||||
* iconvdata/tscii.c: Likewise.
|
||||
* iconvdata/uhc.c : Likewise.
|
||||
* iconvdata/unicode.c (gconv_end): Likewise.
|
||||
* iconvdata/utf-16.c (gconv_end): Likewise.
|
||||
* iconvdata/utf-32.c (gconv_end): Likewise.
|
||||
* iconvdata/utf-7.c (base64): Likewise.
|
||||
* iconv/gconv_cache.c (__gconv_load_cache): Likewise.
|
||||
* iconv/gconv_close.c (__gconv_close): Likewise.
|
||||
* iconv/gconv_open.c (__gconv_open): Likewise.
|
||||
* iconv/gconv_simple.c (internal_ucs4_loop_single, ucs4_internal_loop,
|
||||
ucs4_internal_loop_unaligned, ucs4_internal_loop_single,
|
||||
internal_ucs4le_loop_single, ucs4le_internal_loop,
|
||||
ucs4le_internal_loop_unaligned, ucs4le_internal_loop_single): Likewise.
|
||||
* iconv/iconv.c (iconv): Likewise.
|
||||
* iconv/iconv_close.c: Likewise.
|
||||
* iconv/loop.c (SINGLE): Likewise.
|
||||
* iconv/skeleton.c (FUNCTION_NAME): Likewise.
|
||||
* include/atomic.h: Likewise.
|
||||
* inet/inet6_option.c (option_alloc): Likewise.
|
||||
* intl/bindtextdom.c (set_binding_values): Likewise.
|
||||
* intl/dcigettext.c (DCIGETTEXT, _nl_find_msg): Likewise.
|
||||
* intl/loadmsgcat.c (_nl_load_domain): Likewise.
|
||||
* intl/localealias.c (read_alias_file): Likewise.
|
||||
* libio/filedoalloc.c (_IO_file_doallocate): Likewise.
|
||||
* libio/fileops.c (_IO_file_open, _IO_file_underflow_mmap,
|
||||
_IO_new_file_overflow, _IO_file_xsgetn_mmap): Likewise.
|
||||
* libio/fmemopen.c (fmemopen): Likewise.
|
||||
* libio/iofgets.c (_IO_fgets): Likewise.
|
||||
* libio/iofgets_u.c (fgets_unlocked): Likewise.
|
||||
* libio/iofgetws.c (fgetws): Likewise.
|
||||
* libio/iofgetws_u.c (fgetws_unlocked): Likewise.
|
||||
* libio/iogetdelim.c (_IO_getdelim): Likewise.
|
||||
* libio/wfileops.c (_IO_wfile_underflow, _IO_wfile_underflow_mmap,
|
||||
adjust_wide_data, _IO_wfile_seekoff): Likewise.
|
||||
* locale/findlocale.c (_nl_find_locale): Likewise.
|
||||
* locale/loadarchive.c (_nl_load_locale_from_archive): Likewise.
|
||||
* locale/loadlocale.c (_nl_intern_locale_data, _nl_load_locale):
|
||||
Likewise.
|
||||
* locale/setlocale.c (setlocale): Likewise.
|
||||
* login/programs/pt_chown.c (main): Likewise.
|
||||
* malloc/arena.c (ptmalloc_init, shrink_heap, arena_get2): Likewise.
|
||||
* malloc/malloc.c (_int_malloc, _int_free): Likewise.
|
||||
* malloc/memusage.c (update_data, malloc, realloc, calloc, free,
|
||||
mmap, mmap64, mremap, munmap): Likewise.
|
||||
* math/e_exp2l.c: Likewise.
|
||||
* math/e_scalb.c (invalid_fn, __ieee754_scalb): Likewise.
|
||||
* math/e_scalbf.c (invalid_fn, __ieee754_scalbf): Likewise.
|
||||
* math/e_scalbl.c (invalid_fn, __ieee754_scalbl): Likewise.
|
||||
* math/s_catan.c (__catan): Likewise.
|
||||
* math/s_catanf.c (__catanf): Likewise.
|
||||
* math/s_catanh.c (__catanh): Likewise.
|
||||
* math/s_catanhf.c (__catanhf): Likewise.
|
||||
* math/s_catanhl.c (__catanhl): Likewise.
|
||||
* math/s_catanl.c (__catanl): Likewise.
|
||||
* math/s_ccosh.c (__ccosh): Likewise.
|
||||
* math/s_ccoshf.c (__ccoshf): Likewise.
|
||||
* math/s_ccoshl.c (__ccoshl): Likewise.
|
||||
* math/s_cexp.c (__cexp): Likewise.
|
||||
* math/s_cexpf.c (__cexpf): Likewise.
|
||||
* math/s_cexpl.c (__cexpl): Likewise.
|
||||
* math/s_clog10.c (__clog10): Likewise.
|
||||
* math/s_clog10f.c (__clog10f): Likewise.
|
||||
* math/s_clog10l.c (__clog10l): Likewise.
|
||||
* math/s_clog.c (__clog): Likewise.
|
||||
* math/s_clogf.c (__clogf): Likewise.
|
||||
* math/s_clogl.c (__clogl): Likewise.
|
||||
* math/s_csin.c (__csin): Likewise.
|
||||
* math/s_csinf.c (__csinf): Likewise.
|
||||
* math/s_csinh.c (__csinh): Likewise.
|
||||
* math/s_csinhf.c (__csinhf): Likewise.
|
||||
* math/s_csinhl.c (__csinhl): Likewise.
|
||||
* math/s_csinl.c (__csinl): Likewise.
|
||||
* math/s_csqrt.c (__csqrt): Likewise.
|
||||
* math/s_csqrtf.c (__csqrtf): Likewise.
|
||||
* math/s_csqrtl.c (__csqrtl): Likewise.
|
||||
* math/s_ctan.c (__ctan): Likewise.
|
||||
* math/s_ctanf.c (__ctanf): Likewise.
|
||||
* math/s_ctanh.c (__ctanh): Likewise.
|
||||
* math/s_ctanhf.c (__ctanhf): Likewise.
|
||||
* math/s_ctanhl.c (__ctanhl): Likewise.
|
||||
* math/s_ctanl.c (__ctanl): Likewise.
|
||||
* math/w_pow.c: Likewise.
|
||||
* math/w_powf.c: Likewise.
|
||||
* math/w_powl.c: Likewise.
|
||||
* math/w_scalb.c (sysv_scalb): Likewise.
|
||||
* math/w_scalbf.c (sysv_scalbf): Likewise.
|
||||
* math/w_scalbl.c (sysv_scalbl): Likewise.
|
||||
* misc/error.c (error_tail): Likewise.
|
||||
* misc/pselect.c (__pselect): Likewise.
|
||||
* nis/nis_callback.c (__nis_create_callback): Likewise.
|
||||
* nis/nis_call.c (__nisfind_server): Likewise.
|
||||
* nis/nis_creategroup.c (nis_creategroup): Likewise.
|
||||
* nis/nis_domain_of_r.c (nis_domain_of_r): Likewise.
|
||||
* nis/nis_findserv.c (__nis_findfastest_with_timeout): Likewise.
|
||||
* nis/nis_getservlist.c (nis_getservlist): Likewise.
|
||||
* nis/nis_lookup.c (nis_lookup): Likewise.
|
||||
* nis/nis_subr.c (nis_leaf_of_r, nis_getnames): Likewise.
|
||||
* nis/nis_table.c (__create_ib_request, nis_list, nis_add_entry,
|
||||
nis_modify_entry, nis_first_entry, nis_next_entry): Likewise.
|
||||
* nis/nis_xdr.c (xdr_endpoint): Likewise.
|
||||
* nis/nss_compat/compat-grp.c (getgrent_next_file, internal_getgrnam_r,
|
||||
internal_getgrgid_r): Likewise.
|
||||
* nis/nss_compat/compat-initgroups.c (add_group, internal_getgrent_r):
|
||||
Likewise.
|
||||
* nis/nss_compat/compat-pwd.c (getpwent_next_file, internal_getpwnam_r,
|
||||
internal_getpwuid_r): Likewise.
|
||||
* nis/nss_compat/compat-spwd.c (getspent_next_file,
|
||||
internal_getspnam_r): Likewise.
|
||||
* nis/nss_nis/nis-alias.c (internal_nis_getaliasent_r,
|
||||
_nss_nis_getaliasbyname_r): Likewise.
|
||||
* nis/nss_nis/nis-ethers.c (_nss_nis_gethostton_r,
|
||||
_nss_nis_getntohost_r): Likewise.
|
||||
* nis/nss_nis/nis-grp.c (internal_nis_setgrent,
|
||||
internal_nis_getgrent_r, _nss_nis_getgrnam_r, _nss_nis_getgrgid_r):
|
||||
Likewise.
|
||||
* nis/nss_nis/nis-hosts.c (_nss_nis_sethostent,
|
||||
internal_nis_gethostent_r, internal_gethostbyname2_r,
|
||||
_nss_nis_gethostbyname_r, _nss_nis_gethostbyaddr_r,
|
||||
_nss_nis_gethostbyname4_r): Likewise.
|
||||
* nis/nss_nis/nis-initgroups.c (internal_getgrent_r,
|
||||
initgroups_netid): Likewise.
|
||||
* nis/nss_nis/nis-netgrp.c (_nss_nis_setnetgrent): Likewise.
|
||||
* nis/nss_nis/nis-network.c (internal_nis_getnetent_r,
|
||||
_nss_nis_getnetbyname_r, _nss_nis_getnetbyaddr_r): Likewise.
|
||||
* nis/nss_nis/nis-proto.c (_nss_nis_getprotobyname_r,
|
||||
_nss_nis_getprotobynumber_r): Likewise.
|
||||
* nis/nss_nis/nis-publickey.c (_nss_nis_getpublickey,
|
||||
_nss_nis_getsecretkey): Likewise.
|
||||
* nis/nss_nis/nis-pwd.c (_nis_saveit, internal_nis_setpwent,
|
||||
internal_nis_getpwent_r, _nss_nis_getpwnam_r, _nss_nis_getpwuid_r):
|
||||
Likewise.
|
||||
* nis/nss_nis/nis-rpc.c (internal_nis_getrpcent_r,
|
||||
_nss_nis_getrpcbyname_r, _nss_nis_getrpcbynumber_r): Likewise.
|
||||
* nis/nss_nis/nis-service.c (dosearch, internal_nis_getservent_r,
|
||||
_nss_nis_getservbyname_r, _nss_nis_getservbyport_r): Likewise.
|
||||
* nis/nss_nis/nis-spwd.c (_nss_nis_setspent, internal_nis_getspent_r,
|
||||
_nss_nis_getspnam_r): Likewise.
|
||||
* nis/nss_nisplus/nisplus-alias.c (_nss_nisplus_getaliasbyname_r):
|
||||
Likewise.
|
||||
* nis/nss_nisplus/nisplus-ethers.c (_nss_nisplus_gethostton_r,
|
||||
_nss_nisplus_getntohost_r): Likewise.
|
||||
* nis/nss_nisplus/nisplus-grp.c (internal_nisplus_getgrent_r,
|
||||
_nss_nisplus_getgrnam_r, _nss_nisplus_getgrgid_r): Likewise.
|
||||
* nis/nss_nisplus/nisplus-hosts.c (internal_gethostbyname2_r,
|
||||
_nss_nisplus_gethostbyaddr_r, _nss_nisplus_gethostbyname4_r): Likewise.
|
||||
* nis/nss_nisplus/nisplus-initgroups.c (_nss_nisplus_initgroups_dyn):
|
||||
Likewise.
|
||||
* nis/nss_nisplus/nisplus-network.c (_nss_nisplus_getnetbyname_r,
|
||||
_nss_nisplus_getnetbyaddr_r): Likewise.
|
||||
* nis/nss_nisplus/nisplus-proto.c (_nss_nisplus_getprotobyname_r,
|
||||
_nss_nisplus_getprotobynumber_r): Likewise.
|
||||
* nis/nss_nisplus/nisplus-pwd.c (internal_nisplus_getpwent_r,
|
||||
_nss_nisplus_getpwnam_r, _nss_nisplus_getpwuid_r): Likewise.
|
||||
* nis/nss_nisplus/nisplus-rpc.c (_nss_nisplus_getrpcbyname_r):
|
||||
Likewise.
|
||||
* nis/nss_nisplus/nisplus-service.c (internal_nisplus_getservent_r,
|
||||
_nss_nisplus_getservbyname_r, _nss_nisplus_getservbyport_r): Likewise.
|
||||
* nis/nss_nisplus/nisplus-spwd.c (internal_nisplus_getspent_r,
|
||||
_nss_nisplus_getspnam_r): Likewise.
|
||||
* nis/ypclnt.c (__yp_bind, yp_match, yp_all, yp_maplist): Likewise.
|
||||
* nscd/aicache.c (addhstaiX): Likewise.
|
||||
* nscd/cache.c (cache_search, prune_cache): Likewise.
|
||||
* nscd/connections.c (register_traced_file, send_ro_fd, handle_request,
|
||||
nscd_run_prune, nscd_run_worker, fd_ready, main_loop_epoll): Likewise.
|
||||
* nscd/grpcache.c (addgrbyX): Likewise.
|
||||
* nscd/hstcache.c (addhstbyX): Likewise.
|
||||
* nscd/initgrcache.c (addinitgroupsX): Likewise.
|
||||
* nscd/mem.c (gc, mempool_alloc): Likewise.
|
||||
* nscd/netgroupcache.c (do_notfound, addgetnetgrentX, addinnetgrX):
|
||||
Likewise.
|
||||
* nscd/nscd-client.h (__nscd_acquire_maplock, __nscd_drop_map_ref):
|
||||
Likewise.
|
||||
* nscd/nscd_getai.c (__nscd_getai): Likewise.
|
||||
* nscd/nscd_getgr_r.c (nscd_getgr_r): Likewise.
|
||||
* nscd/nscd_gethst_r.c (__nscd_get_nl_timestamp, nscd_gethst_r):
|
||||
Likewise.
|
||||
* nscd/nscd_getpw_r.c (nscd_getpw_r): Likewise.
|
||||
* nscd/nscd_getserv_r.c (nscd_getserv_r): Likewise.
|
||||
* nscd/nscd_helper.c (__readvall, open_socket,
|
||||
__nscd_get_mapping, __nscd_get_map_ref): Likewise.
|
||||
* nscd/nscd_initgroups.c (__nscd_getgrouplist): Likewise.
|
||||
* nscd/nscd_netgroup.c (__nscd_setnetgrent, __nscd_innetgr): Likewise.
|
||||
* nscd/pwdcache.c (addpwbyX): Likewise.
|
||||
* nscd/selinux.c (preserve_capabilities): Likewise.
|
||||
* nscd/servicescache.c (addservbyX): Likewise.
|
||||
* nss/nss_files/files-XXX.c (internal_getent): Likewise.
|
||||
* posix/fnmatch.c (fnmatch): Likewise.
|
||||
* posix/getopt.c (_getopt_internal_r): Likewise.
|
||||
* posix/glob.c (glob, glob_in_dir): Likewise.
|
||||
* posix/wordexp.c (exec_comm_child): Likewise.
|
||||
* resolv/nss_dns/dns-host.c (_nss_dns_gethostbyaddr2_r, getanswer_r,
|
||||
gaih_getanswer_slice): Likewise.
|
||||
* resolv/nss_dns/dns-network.c (getanswer_r): Likewise.
|
||||
* resolv/res_init.c: Likewise.
|
||||
* resolv/res_mkquery.c (res_nmkquery): Likewise.
|
||||
* resolv/res_query.c (__libc_res_nquery): Likewise.
|
||||
* resolv/res_send.c (__libc_res_nsend, send_vc, reopen, send_dg):
|
||||
Likewise.
|
||||
* stdio-common/_i18n_number.h (_i18n_number_rewrite): Likewise.
|
||||
* stdio-common/perror.c (perror): Likewise.
|
||||
* stdio-common/printf_fp.c (___printf_fp): Likewise.
|
||||
* stdio-common/tmpnam.c (tmpnam): Likewise.
|
||||
* stdio-common/vfscanf.c (_IO_vfscanf_internal): Likewise.
|
||||
* stdlib/cxa_finalize.c (__cxa_finalize): Likewise.
|
||||
* stdlib/cxa_thread_atexit_impl.c (__cxa_thread_atexit_impl): Likewise.
|
||||
* stdlib/drand48-iter.c (__drand48_iterate): Likewise.
|
||||
* stdlib/putenv.c (putenv): Likewise.
|
||||
* stdlib/setenv.c (__add_to_environ): Likewise.
|
||||
* stdlib/strtod_l.c (____STRTOF_INTERNAL): Likewise.
|
||||
* stdlib/strtol_l.c (INTERNAL): Likewise.
|
||||
* string/memmem.c (memmem): Likewise.
|
||||
* string/strerror.c (strerror): Likewise.
|
||||
* string/strnlen.c (__strnlen): Likewise.
|
||||
* string/test-memmem.c (simple_memmem): Likewise.
|
||||
* sunrpc/clnt_udp.c (__libc_clntudp_bufcreate): Likewise.
|
||||
* sunrpc/pm_getport.c (__get_socket): Likewise.
|
||||
* sysdeps/gnu/unwind-resume.c (init, _Unwind_Resume): Likewise.
|
||||
* sysdeps/i386/dl-irel.h (elf_irel): Likewise.
|
||||
* sysdeps/i386/dl-machine.h (elf_machine_runtime_setup,
|
||||
elf_machine_rel, elf_machine_lazy_rel, elf_machine_lazy_rela):
|
||||
Likewise.
|
||||
* sysdeps/ieee754/dbl-64/e_atanh.c (__ieee754_atanh): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/e_exp2.c (__ieee754_exp2): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/e_fmod.c (__ieee754_fmod): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/e_gamma_r.c (__ieee754_gamma_r): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/e_hypot.c (__ieee754_hypot): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/e_j1.c (__ieee754_j1, __ieee754_y1): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/e_jn.c (__ieee754_jn, __ieee754_yn): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/e_log10.c (__ieee754_log10): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/e_log2.c (__ieee754_log2): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/e_log.c (__ieee754_log): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/e_sinh.c (__ieee754_sinh): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/s_asinh.c (__asinh): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/s_fma.c (__fma): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/s_log1p.c (__log1p): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/s_logb.c (__logb): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/s_modf.c (__modf): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/s_scalbln.c (__scalbln): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/s_scalbn.c (__scalbn): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/wordsize-64/e_acosh.c (__ieee754_acosh):
|
||||
Likewise.
|
||||
* sysdeps/ieee754/dbl-64/wordsize-64/e_log10.c (__ieee754_log10):
|
||||
Likewise.
|
||||
* sysdeps/ieee754/dbl-64/wordsize-64/e_log2.c (__ieee754_log2):
|
||||
Likewise.
|
||||
* sysdeps/ieee754/dbl-64/wordsize-64/s_frexp.c (__frexp): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/wordsize-64/s_logb.c (__logb): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/wordsize-64/s_remquo.c (__remquo): Likewise.
|
||||
* sysdeps/ieee754/dbl-64/wordsize-64/s_round.c (__round): Likewise.
|
||||
* sysdeps/ieee754/flt-32/e_atanhf.c (__ieee754_atanhf): Likewise.
|
||||
* sysdeps/ieee754/flt-32/e_gammaf_r.c (__ieee754_gammaf_r): Likewise.
|
||||
* sysdeps/ieee754/flt-32/s_logbf.c (__logbf): Likewise.
|
||||
* sysdeps/ieee754/ldbl-128ibm/e_fmodl.c (__ieee754_fmodl): Likewise.
|
||||
* sysdeps/ieee754/ldbl-128ibm/math_ldbl.h (ldbl_nearbyint): Likewise.
|
||||
* sysdeps/ieee754/ldbl-128ibm/s_llrintl.c (__llrintl): Likewise.
|
||||
* sysdeps/ieee754/ldbl-128ibm/s_llroundl.c (__llroundl): Likewise.
|
||||
* sysdeps/ieee754/ldbl-128ibm/s_logbl.c (__logbl): Likewise.
|
||||
* sysdeps/ieee754/ldbl-128ibm/s_lrintl.c (__lrintl): Likewise.
|
||||
* sysdeps/ieee754/ldbl-128ibm/s_lroundl.c (__lroundl): Likewise.
|
||||
* sysdeps/ieee754/ldbl-128/s_fmal.c (__fmal): Likewise.
|
||||
* sysdeps/ieee754/ldbl-96/e_gammal_r.c (__ieee754_gammal_r): Likewise.
|
||||
* sysdeps/ieee754/ldbl-96/e_j0l.c (__ieee754_j0l, __ieee754_y0l):
|
||||
Likewise.
|
||||
* sysdeps/ieee754/ldbl-96/e_j1l.c (__ieee754_j1l, __ieee754_y1l):
|
||||
Likewise.
|
||||
* sysdeps/ieee754/ldbl-96/e_jnl.c (__ieee754_jnl, __ieee754_ynl):
|
||||
Likewise.
|
||||
* sysdeps/ieee754/ldbl-96/s_fma.c (__fma): Likewise.
|
||||
* sysdeps/ieee754/ldbl-96/s_fmal.c (__fmal): Likewise.
|
||||
* sysdeps/posix/clock_getres.c (hp_timing_getres, realtime_getres):
|
||||
Likewise.
|
||||
* sysdeps/posix/fdopendir.c (__fdopendir): Likewise.
|
||||
* sysdeps/posix/getaddrinfo.c (gaih_inet, getaddrinfo): Likewise.
|
||||
* sysdeps/posix/opendir.c (__opendirat): Likewise.
|
||||
* sysdeps/posix/sleep.c: Likewise.
|
||||
* sysdeps/posix/tempname.c: Likewise.
|
||||
* sysdeps/powerpc/powerpc32/dl-irel.h (elf_irela): Likewise.
|
||||
* sysdeps/powerpc/powerpc32/dl-machine.c (__process_machine_rela):
|
||||
Likewise.
|
||||
* sysdeps/powerpc/powerpc32/dl-machine.h (elf_machine_runtime_setup,
|
||||
elf_machine_rela): Likewise.
|
||||
* sysdeps/powerpc/powerpc64/dl-irel.h (elf_irela): Likewise.
|
||||
* sysdeps/powerpc/powerpc64/dl-machine.h (elf_machine_rela): Likewise.
|
||||
* sysdeps/pthread/aio_notify.c (__aio_notify_only): Likewise.
|
||||
* sysdeps/pthread/aio_suspend.c (do_aio_misc_wait, aio_suspend):
|
||||
Likewise.
|
||||
* sysdeps/s390/dl-irel.h (elf_irela): Likewise.
|
||||
* sysdeps/s390/s390-32/dl-machine.h (elf_machine_runtime_setup,
|
||||
elf_machine_rela, elf_machine_lazy_rel): Likewise.
|
||||
* sysdeps/s390/s390-64/dl-machine.h (elf_machine_runtime_setup,
|
||||
elf_machine_rela, elf_machine_lazy_rel): Likewise.
|
||||
* sysdeps/s390/s390-64/utf16-utf32-z9.c (gconv_end): Likewise.
|
||||
* sysdeps/s390/s390-64/utf8-utf16-z9.c (gconv_end): Likewise.
|
||||
* sysdeps/s390/s390-64/utf8-utf32-z9.c (gconv_end): Likewise.
|
||||
* sysdeps/sh/dl-machine.h (elf_machine_rela): Likewise.
|
||||
* sysdeps/sparc/sparc32/dl-irel.h (elf_irela): Likewise.
|
||||
* sysdeps/sparc/sparc32/dl-machine.h (elf_machine_rela,
|
||||
elf_machine_lazy_rel): Likewise.
|
||||
* sysdeps/sparc/sparc64/dl-irel.h (elf_irela): Likewise.
|
||||
* sysdeps/sparc/sparc64/dl-machine.h (elf_machine_rela,
|
||||
elf_machine_lazy_rel): Likewise.
|
||||
* sysdeps/sparc/sparc64/dl-plt.h (sparc64_fixup_plt): Likewise.
|
||||
* sysdeps/unix/clock_gettime.c (hp_timing_gettime): Likewise.
|
||||
* sysdeps/unix/clock_settime.c (hp_timing_settime): Likewise.
|
||||
* sysdeps/unix/grantpt.c (grantpt): Likewise.
|
||||
* sysdeps/unix/sysv/linux/accept4.c (accept4): Likewise.
|
||||
* sysdeps/unix/sysv/linux/adjtime.c (ADJTIME): Likewise.
|
||||
* sysdeps/unix/sysv/linux/check_pf.c (__check_pf): Likewise.
|
||||
* sysdeps/unix/sysv/linux/dl-osinfo.h (_dl_setup_stack_chk_guard):
|
||||
Likewise.
|
||||
* sysdeps/unix/sysv/linux/faccessat.c (faccessat): Likewise.
|
||||
* sysdeps/unix/sysv/linux/fchmodat.c (fchmodat): Likewise.
|
||||
* sysdeps/unix/sysv/linux/fchownat.c (fchownat): Likewise.
|
||||
* sysdeps/unix/sysv/linux/futimesat.c (futimesat): Likewise.
|
||||
* sysdeps/unix/sysv/linux/fxstatat64.c (__fxstatat64): Likewise.
|
||||
* sysdeps/unix/sysv/linux/fxstatat.c (__fxstatat): Likewise.
|
||||
* sysdeps/unix/sysv/linux/i386/fallocate64.c (fallocate64): Likewise.
|
||||
* sysdeps/unix/sysv/linux/i386/fallocate.c (fallocate): Likewise.
|
||||
* sysdeps/unix/sysv/linux/i386/fchownat.c (fchownat): Likewise.
|
||||
* sysdeps/unix/sysv/linux/i386/fxstatat.c (__fxstatat): Likewise.
|
||||
* sysdeps/unix/sysv/linux/i386/get_clockfreq.c (__get_clockfreq):
|
||||
Likewise.
|
||||
* sysdeps/unix/sysv/linux/i386/posix_fallocate64.c
|
||||
(__posix_fallocate64_l64): Likewise.
|
||||
* sysdeps/unix/sysv/linux/i386/posix_fallocate.c
|
||||
(posix_fallocate): Likewise.
|
||||
* sysdeps/unix/sysv/linux/i386/scandir64.c (__old_scandir64): Likewise.
|
||||
* sysdeps/unix/sysv/linux/i386/sysdep.h: Likewise.
|
||||
* sysdeps/unix/sysv/linux/ifaddrs.c (__netlink_request,
|
||||
getifaddrs_internal): Likewise.
|
||||
* sysdeps/unix/sysv/linux/linkat.c (linkat): Likewise.
|
||||
* sysdeps/unix/sysv/linux/mkdirat.c (mkdirat): Likewise.
|
||||
* sysdeps/unix/sysv/linux/mq_unlink.c (mq_unlink): Likewise.
|
||||
* sysdeps/unix/sysv/linux/openat.c (OPENAT_NOT_CANCEL): Likewise.
|
||||
* sysdeps/unix/sysv/linux/posix_fallocate64.c
|
||||
(__posix_fallocate64_l64): Likewise.
|
||||
* sysdeps/unix/sysv/linux/posix_fallocate.c (posix_fallocate):
|
||||
Likewise.
|
||||
* sysdeps/unix/sysv/linux/powerpc/fchownat.c (fchownat): Likewise.
|
||||
* sysdeps/unix/sysv/linux/powerpc/get_clockfreq.c (__get_clockfreq):
|
||||
Likewise.
|
||||
* sysdeps/unix/sysv/linux/readlinkat.c (readlinkat): Likewise.
|
||||
* sysdeps/unix/sysv/linux/recvmmsg.c (recvmmsg): Likewise.
|
||||
* sysdeps/unix/sysv/linux/renameat.c (renameat): Likewise.
|
||||
* sysdeps/unix/sysv/linux/s390/s390-32/sysdep.h: Likewise.
|
||||
* sysdeps/unix/sysv/linux/s390/s390-64/sysdep.h: Likewise.
|
||||
* sysdeps/unix/sysv/linux/sched_setaffinity.c: Likewise.
|
||||
* sysdeps/unix/sysv/linux/sendmmsg.c (__sendmmsg): Likewise.
|
||||
* sysdeps/unix/sysv/linux/shm_open.c (where_is_shmfs, shm_open):
|
||||
Likewise.
|
||||
* sysdeps/unix/sysv/linux/sleep.c (__sleep): Likewise.
|
||||
* sysdeps/unix/sysv/linux/symlinkat.c (symlinkat): Likewise.
|
||||
* sysdeps/unix/sysv/linux/tcgetattr.c (__tcgetattr): Likewise.
|
||||
* sysdeps/unix/sysv/linux/ttyname.c (ttyname): Likewise.
|
||||
* sysdeps/unix/sysv/linux/ttyname_r.c (__ttyname_r): Likewise.
|
||||
* sysdeps/unix/sysv/linux/unlinkat.c (unlinkat): Likewise.
|
||||
* sysdeps/unix/sysv/linux/wordsize-64/fxstatat.c (__fxstatat):
|
||||
Likewise.
|
||||
* sysdeps/unix/sysv/linux/wordsize-64/posix_fallocate.c
|
||||
(posix_fallocate): Likewise.
|
||||
* sysdeps/unix/sysv/linux/x86_64/sysdep.h: Likewise.
|
||||
* sysdeps/unix/sysv/linux/xmknodat.c (__xmknodat): Likewise.
|
||||
* sysdeps/x86_64/dl-irel.h (elf_irela): Likewise.
|
||||
* sysdeps/x86_64/dl-machine.h (elf_machine_runtime_setup,
|
||||
elf_machine_rela, elf_machine_rela_relative, elf_machine_lazy_rel):
|
||||
Likewise.
|
||||
* time/asctime.c (asctime_internal): Likewise.
|
||||
* time/tzfile.c (__tzfile_read, __tzfile_compute): Likewise.
|
||||
* time/tzset.c (__tzset_parse_tz): Likewise.
|
||||
* wcsmbs/mbrtoc16.c (mbrtoc16): Likewise.
|
||||
* wcsmbs/mbrtowc.c (__mbrtowc): Likewise.
|
||||
* wcsmbs/wcsmbsload.c (__wcsmbs_load_conv): Likewise.
|
||||
* wcsmbs/wcsmbsload.h: Likewise.
|
||||
|
||||
2014-02-10 Ondřej Bílka <neleai@seznam.cz>
|
||||
|
||||
[BZ #15894]
|
||||
|
||||
@ -67,7 +67,7 @@ __assert_fail_base (const char *fmt, const char *assertion, const char *file,
|
||||
total = (total + 1 + GLRO(dl_pagesize) - 1) & ~(GLRO(dl_pagesize) - 1);
|
||||
struct abort_msg_s *buf = __mmap (NULL, total, PROT_READ | PROT_WRITE,
|
||||
MAP_ANON | MAP_PRIVATE, -1, 0);
|
||||
if (__builtin_expect (buf != MAP_FAILED, 1))
|
||||
if (__glibc_likely (buf != MAP_FAILED))
|
||||
{
|
||||
buf->size = total;
|
||||
strcpy (buf->msg, str);
|
||||
|
||||
@ -43,7 +43,7 @@ simple_memmem (const void *haystack, size_t haystack_len, const void *needle,
|
||||
|
||||
/* Sanity check, otherwise the loop might search through the whole
|
||||
memory. */
|
||||
if (__builtin_expect (haystack_len < needle_len, 0))
|
||||
if (__glibc_unlikely (haystack_len < needle_len))
|
||||
return NULL;
|
||||
|
||||
for (begin = (const char *) haystack; begin <= last_possible; ++begin)
|
||||
|
||||
@ -54,7 +54,7 @@ __open_catalog (const char *cat_name, const char *nlspath, const char *env_var,
|
||||
{
|
||||
const char *run_nlspath = nlspath;
|
||||
#define ENOUGH(n) \
|
||||
if (__builtin_expect (bufact + (n) >= bufmax, 0)) \
|
||||
if (__glibc_unlikely (bufact + (n) >= bufmax)) \
|
||||
{ \
|
||||
char *old_buf = buf; \
|
||||
bufmax += 256 + (n); \
|
||||
@ -253,7 +253,7 @@ __open_catalog (const char *cat_name, const char *nlspath, const char *env_var,
|
||||
/* Determine whether the file is a catalog file and if yes whether
|
||||
it is written using the correct byte order. Else we have to swap
|
||||
the values. */
|
||||
if (__builtin_expect (catalog->file_ptr->magic == CATGETS_MAGIC, 1))
|
||||
if (__glibc_likely (catalog->file_ptr->magic == CATGETS_MAGIC))
|
||||
swapping = 0;
|
||||
else if (catalog->file_ptr->magic == SWAPU32 (CATGETS_MAGIC))
|
||||
swapping = 1;
|
||||
|
||||
@ -214,7 +214,7 @@ LIBC_START_MAIN (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL),
|
||||
#endif
|
||||
|
||||
/* Register the destructor of the dynamic linker if there is any. */
|
||||
if (__builtin_expect (rtld_fini != NULL, 1))
|
||||
if (__glibc_likely (rtld_fini != NULL))
|
||||
__cxa_atexit ((void (*) (void *)) rtld_fini, NULL, NULL);
|
||||
|
||||
#ifndef SHARED
|
||||
@ -245,7 +245,7 @@ LIBC_START_MAIN (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL),
|
||||
|
||||
#ifdef SHARED
|
||||
/* Auditing checkpoint: we have a new object. */
|
||||
if (__builtin_expect (GLRO(dl_naudit) > 0, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_naudit) > 0))
|
||||
{
|
||||
struct audit_ifaces *afct = GLRO(dl_audit);
|
||||
struct link_map *head = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
|
||||
@ -260,7 +260,7 @@ LIBC_START_MAIN (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL),
|
||||
#endif
|
||||
|
||||
#ifdef SHARED
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS))
|
||||
GLRO(dl_debug_printf) ("\ntransferring control: %s\n\n", argv[0]);
|
||||
#endif
|
||||
|
||||
@ -270,7 +270,7 @@ LIBC_START_MAIN (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL),
|
||||
|
||||
int not_first_call;
|
||||
not_first_call = setjmp ((struct __jmp_buf_tag *) unwind_buf.cancel_jmp_buf);
|
||||
if (__builtin_expect (! not_first_call, 1))
|
||||
if (__glibc_likely (! not_first_call))
|
||||
{
|
||||
struct pthread *self = THREAD_SELF;
|
||||
|
||||
|
||||
@ -22,7 +22,7 @@
|
||||
size_t
|
||||
__confstr_chk (int name, char *buf, size_t len, size_t buflen)
|
||||
{
|
||||
if (__builtin_expect (buflen < len, 0))
|
||||
if (__glibc_unlikely (buflen < len))
|
||||
__chk_fail ();
|
||||
|
||||
return confstr (name, buf, len);
|
||||
|
||||
@ -39,7 +39,7 @@ __fread_chk (void *__restrict ptr, size_t ptrlen,
|
||||
__chk_fail ();
|
||||
}
|
||||
|
||||
if (__builtin_expect (bytes_requested > ptrlen, 0))
|
||||
if (__glibc_unlikely (bytes_requested > ptrlen))
|
||||
__chk_fail ();
|
||||
|
||||
CHECK_FILE (stream, 0);
|
||||
|
||||
@ -39,7 +39,7 @@ __fread_unlocked_chk (void *__restrict ptr, size_t ptrlen,
|
||||
__chk_fail ();
|
||||
}
|
||||
|
||||
if (__builtin_expect (bytes_requested > ptrlen, 0))
|
||||
if (__glibc_unlikely (bytes_requested > ptrlen))
|
||||
__chk_fail ();
|
||||
|
||||
CHECK_FILE (stream, 0);
|
||||
|
||||
@ -22,13 +22,13 @@
|
||||
int
|
||||
__getgroups_chk (int size, __gid_t list[], size_t listlen)
|
||||
{
|
||||
if (__builtin_expect (size < 0, 0))
|
||||
if (__glibc_unlikely (size < 0))
|
||||
{
|
||||
__set_errno (EINVAL);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (__builtin_expect (size * sizeof (__gid_t) > listlen, 0))
|
||||
if (__glibc_unlikely (size * sizeof (__gid_t) > listlen))
|
||||
__chk_fail ();
|
||||
|
||||
return __getgroups (size, list);
|
||||
|
||||
@ -23,7 +23,7 @@ size_t
|
||||
__mbsnrtowcs_chk (wchar_t *dst, const char **src, size_t nmc, size_t len,
|
||||
mbstate_t *ps, size_t dstlen)
|
||||
{
|
||||
if (__builtin_expect (dstlen < len, 0))
|
||||
if (__glibc_unlikely (dstlen < len))
|
||||
__chk_fail ();
|
||||
|
||||
return __mbsnrtowcs (dst, src, nmc, len, ps);
|
||||
|
||||
@ -23,7 +23,7 @@ size_t
|
||||
__mbsrtowcs_chk (wchar_t *dst, const char **src, size_t len,
|
||||
mbstate_t *ps, size_t dstlen)
|
||||
{
|
||||
if (__builtin_expect (dstlen < len, 0))
|
||||
if (__glibc_unlikely (dstlen < len))
|
||||
__chk_fail ();
|
||||
|
||||
return __mbsrtowcs (dst, src, len, ps);
|
||||
|
||||
@ -23,7 +23,7 @@
|
||||
size_t
|
||||
__mbstowcs_chk (wchar_t *dst, const char *src, size_t len, size_t dstlen)
|
||||
{
|
||||
if (__builtin_expect (dstlen < len, 0))
|
||||
if (__glibc_unlikely (dstlen < len))
|
||||
__chk_fail ();
|
||||
|
||||
mbstate_t state;
|
||||
|
||||
@ -29,7 +29,7 @@ __memcpy_chk (dstpp, srcpp, len, dstlen)
|
||||
size_t len;
|
||||
size_t dstlen;
|
||||
{
|
||||
if (__builtin_expect (dstlen < len, 0))
|
||||
if (__glibc_unlikely (dstlen < len))
|
||||
__chk_fail ();
|
||||
|
||||
return memcpy (dstpp, srcpp, len);
|
||||
|
||||
@ -33,7 +33,7 @@ MEMMOVE_CHK (dest, src, len, destlen)
|
||||
size_t len;
|
||||
size_t destlen;
|
||||
{
|
||||
if (__builtin_expect (destlen < len, 0))
|
||||
if (__glibc_unlikely (destlen < len))
|
||||
__chk_fail ();
|
||||
|
||||
return memmove (dest, src, len);
|
||||
|
||||
@ -30,7 +30,7 @@ __mempcpy_chk (dstpp, srcpp, len, dstlen)
|
||||
size_t len;
|
||||
size_t dstlen;
|
||||
{
|
||||
if (__builtin_expect (dstlen < len, 0))
|
||||
if (__glibc_unlikely (dstlen < len))
|
||||
__chk_fail ();
|
||||
|
||||
return __mempcpy (dstpp, srcpp, len);
|
||||
|
||||
@ -25,7 +25,7 @@ __memset_chk (dstpp, c, len, dstlen)
|
||||
size_t len;
|
||||
size_t dstlen;
|
||||
{
|
||||
if (__builtin_expect (dstlen < len, 0))
|
||||
if (__glibc_unlikely (dstlen < len))
|
||||
__chk_fail ();
|
||||
|
||||
return memset (dstpp, c, len);
|
||||
|
||||
@ -34,7 +34,7 @@ __stpcpy_chk (dest, src, destlen)
|
||||
|
||||
do
|
||||
{
|
||||
if (__builtin_expect (destlen-- == 0, 0))
|
||||
if (__glibc_unlikely (destlen-- == 0))
|
||||
__chk_fail ();
|
||||
*d++ = *s;
|
||||
}
|
||||
|
||||
@ -33,7 +33,7 @@ __strcat_chk (dest, src, destlen)
|
||||
/* Find the end of the string. */
|
||||
do
|
||||
{
|
||||
if (__builtin_expect (destlen-- == 0, 0))
|
||||
if (__glibc_unlikely (destlen-- == 0))
|
||||
__chk_fail ();
|
||||
c = *s1++;
|
||||
}
|
||||
@ -46,7 +46,7 @@ __strcat_chk (dest, src, destlen)
|
||||
|
||||
do
|
||||
{
|
||||
if (__builtin_expect (destlen-- == 0, 0))
|
||||
if (__glibc_unlikely (destlen-- == 0))
|
||||
__chk_fail ();
|
||||
c = *s2++;
|
||||
*++s1 = c;
|
||||
|
||||
@ -56,7 +56,7 @@ __strcpy_chk (dest, src, destlen)
|
||||
|
||||
do
|
||||
{
|
||||
if (__builtin_expect (destlen-- == 0, 0))
|
||||
if (__glibc_unlikely (destlen-- == 0))
|
||||
__chk_fail ();
|
||||
c = *s;
|
||||
*(s++ + off) = c;
|
||||
|
||||
@ -33,7 +33,7 @@ __strncat_chk (s1, s2, n, s1len)
|
||||
/* Find the end of S1. */
|
||||
do
|
||||
{
|
||||
if (__builtin_expect (s1len-- == 0, 0))
|
||||
if (__glibc_unlikely (s1len-- == 0))
|
||||
__chk_fail ();
|
||||
c = *s1++;
|
||||
}
|
||||
@ -49,25 +49,25 @@ __strncat_chk (s1, s2, n, s1len)
|
||||
size_t n4 = n >> 2;
|
||||
do
|
||||
{
|
||||
if (__builtin_expect (s1len-- == 0, 0))
|
||||
if (__glibc_unlikely (s1len-- == 0))
|
||||
__chk_fail ();
|
||||
c = *s2++;
|
||||
*++s1 = c;
|
||||
if (c == '\0')
|
||||
return s;
|
||||
if (__builtin_expect (s1len-- == 0, 0))
|
||||
if (__glibc_unlikely (s1len-- == 0))
|
||||
__chk_fail ();
|
||||
c = *s2++;
|
||||
*++s1 = c;
|
||||
if (c == '\0')
|
||||
return s;
|
||||
if (__builtin_expect (s1len-- == 0, 0))
|
||||
if (__glibc_unlikely (s1len-- == 0))
|
||||
__chk_fail ();
|
||||
c = *s2++;
|
||||
*++s1 = c;
|
||||
if (c == '\0')
|
||||
return s;
|
||||
if (__builtin_expect (s1len-- == 0, 0))
|
||||
if (__glibc_unlikely (s1len-- == 0))
|
||||
__chk_fail ();
|
||||
c = *s2++;
|
||||
*++s1 = c;
|
||||
@ -79,7 +79,7 @@ __strncat_chk (s1, s2, n, s1len)
|
||||
|
||||
while (n > 0)
|
||||
{
|
||||
if (__builtin_expect (s1len-- == 0, 0))
|
||||
if (__glibc_unlikely (s1len-- == 0))
|
||||
__chk_fail ();
|
||||
c = *s2++;
|
||||
*++s1 = c;
|
||||
@ -90,7 +90,7 @@ __strncat_chk (s1, s2, n, s1len)
|
||||
|
||||
if (c != '\0')
|
||||
{
|
||||
if (__builtin_expect (s1len-- == 0, 0))
|
||||
if (__glibc_unlikely (s1len-- == 0))
|
||||
__chk_fail ();
|
||||
*++s1 = '\0';
|
||||
}
|
||||
|
||||
@ -33,7 +33,7 @@ ___vsnprintf_chk (char *s, size_t maxlen, int flags, size_t slen,
|
||||
Though, maxlen is supposed to be the size of buffer pointed
|
||||
to by s, so a conforming program can't pass such maxlen
|
||||
to *snprintf. */
|
||||
if (__builtin_expect (slen < maxlen, 0))
|
||||
if (__glibc_unlikely (slen < maxlen))
|
||||
__chk_fail ();
|
||||
|
||||
_IO_strnfile sf;
|
||||
|
||||
@ -32,7 +32,7 @@ __vswprintf_chk (wchar_t *s, size_t maxlen, int flags, size_t slen,
|
||||
Though, maxlen is supposed to be the size of buffer pointed
|
||||
to by s, so a conforming program can't pass such maxlen
|
||||
to *snprintf. */
|
||||
if (__builtin_expect (slen < maxlen, 0))
|
||||
if (__glibc_unlikely (slen < maxlen))
|
||||
__chk_fail ();
|
||||
|
||||
_IO_wstrnfile sf;
|
||||
@ -44,7 +44,7 @@ __vswprintf_chk (wchar_t *s, size_t maxlen, int flags, size_t slen,
|
||||
|
||||
/* We need to handle the special case where MAXLEN is 0. Use the
|
||||
overflow buffer right from the start. */
|
||||
if (__builtin_expect (maxlen == 0, 0))
|
||||
if (__glibc_unlikely (maxlen == 0))
|
||||
/* Since we have to write at least the terminating L'\0' a buffer
|
||||
length of zero always makes the function fail. */
|
||||
return -1;
|
||||
|
||||
@ -33,7 +33,7 @@ __wcpcpy_chk (wchar_t *dest, const wchar_t *src, size_t destlen)
|
||||
|
||||
do
|
||||
{
|
||||
if (__builtin_expect (destlen-- == 0, 0))
|
||||
if (__glibc_unlikely (destlen-- == 0))
|
||||
__chk_fail ();
|
||||
c = wcp[off];
|
||||
*++wcp = c;
|
||||
|
||||
@ -23,7 +23,7 @@
|
||||
wchar_t *
|
||||
__wcpncpy_chk (wchar_t *dest, const wchar_t *src, size_t n, size_t destlen)
|
||||
{
|
||||
if (__builtin_expect (destlen < n, 0))
|
||||
if (__glibc_unlikely (destlen < n))
|
||||
__chk_fail ();
|
||||
|
||||
/* This function is not often enough used to justify not using a
|
||||
|
||||
@ -30,7 +30,7 @@ __wcscat_chk (wchar_t *dest, const wchar_t *src, size_t destlen)
|
||||
/* Find the end of the string. */
|
||||
do
|
||||
{
|
||||
if (__builtin_expect (destlen-- == 0, 0))
|
||||
if (__glibc_unlikely (destlen-- == 0))
|
||||
__chk_fail ();
|
||||
c = *s1++;
|
||||
}
|
||||
@ -43,7 +43,7 @@ __wcscat_chk (wchar_t *dest, const wchar_t *src, size_t destlen)
|
||||
|
||||
do
|
||||
{
|
||||
if (__builtin_expect (destlen-- == 0, 0))
|
||||
if (__glibc_unlikely (destlen-- == 0))
|
||||
__chk_fail ();
|
||||
c = *s2++;
|
||||
*++s1 = c;
|
||||
|
||||
@ -35,7 +35,7 @@ __wcscpy_chk (wchar_t *dest, const wchar_t *src, size_t n)
|
||||
|
||||
do
|
||||
{
|
||||
if (__builtin_expect (n-- == 0, 0))
|
||||
if (__glibc_unlikely (n-- == 0))
|
||||
__chk_fail ();
|
||||
c = *wcp++;
|
||||
wcp[off] = c;
|
||||
@ -48,7 +48,7 @@ __wcscpy_chk (wchar_t *dest, const wchar_t *src, size_t n)
|
||||
|
||||
do
|
||||
{
|
||||
if (__builtin_expect (n-- == 0, 0))
|
||||
if (__glibc_unlikely (n-- == 0))
|
||||
__chk_fail ();
|
||||
c = *src++;
|
||||
*wcp++ = c;
|
||||
|
||||
@ -29,7 +29,7 @@ __wcsncat_chk (wchar_t *dest, const wchar_t *src, size_t n, size_t destlen)
|
||||
/* Find the end of DEST. */
|
||||
do
|
||||
{
|
||||
if (__builtin_expect (destlen-- == 0, 0))
|
||||
if (__glibc_unlikely (destlen-- == 0))
|
||||
__chk_fail ();
|
||||
c = *dest++;
|
||||
}
|
||||
@ -45,25 +45,25 @@ __wcsncat_chk (wchar_t *dest, const wchar_t *src, size_t n, size_t destlen)
|
||||
size_t n4 = n >> 2;
|
||||
do
|
||||
{
|
||||
if (__builtin_expect (destlen-- == 0, 0))
|
||||
if (__glibc_unlikely (destlen-- == 0))
|
||||
__chk_fail ();
|
||||
c = *src++;
|
||||
*++dest = c;
|
||||
if (c == L'\0')
|
||||
return s;
|
||||
if (__builtin_expect (destlen-- == 0, 0))
|
||||
if (__glibc_unlikely (destlen-- == 0))
|
||||
__chk_fail ();
|
||||
c = *src++;
|
||||
*++dest = c;
|
||||
if (c == L'\0')
|
||||
return s;
|
||||
if (__builtin_expect (destlen-- == 0, 0))
|
||||
if (__glibc_unlikely (destlen-- == 0))
|
||||
__chk_fail ();
|
||||
c = *src++;
|
||||
*++dest = c;
|
||||
if (c == L'\0')
|
||||
return s;
|
||||
if (__builtin_expect (destlen-- == 0, 0))
|
||||
if (__glibc_unlikely (destlen-- == 0))
|
||||
__chk_fail ();
|
||||
c = *src++;
|
||||
*++dest = c;
|
||||
@ -75,7 +75,7 @@ __wcsncat_chk (wchar_t *dest, const wchar_t *src, size_t n, size_t destlen)
|
||||
|
||||
while (n > 0)
|
||||
{
|
||||
if (__builtin_expect (destlen-- == 0, 0))
|
||||
if (__glibc_unlikely (destlen-- == 0))
|
||||
__chk_fail ();
|
||||
c = *src++;
|
||||
*++dest = c;
|
||||
@ -86,7 +86,7 @@ __wcsncat_chk (wchar_t *dest, const wchar_t *src, size_t n, size_t destlen)
|
||||
|
||||
if (c != L'\0')
|
||||
{
|
||||
if (__builtin_expect (destlen-- == 0, 0))
|
||||
if (__glibc_unlikely (destlen-- == 0))
|
||||
__chk_fail ();
|
||||
*++dest = L'\0';
|
||||
}
|
||||
|
||||
@ -23,7 +23,7 @@
|
||||
wchar_t *
|
||||
__wcsncpy_chk (wchar_t *dest, const wchar_t *src, size_t n, size_t destlen)
|
||||
{
|
||||
if (__builtin_expect (destlen < n, 0))
|
||||
if (__glibc_unlikely (destlen < n))
|
||||
__chk_fail ();
|
||||
|
||||
/* This function is not often enough used to justify not using a
|
||||
|
||||
@ -23,7 +23,7 @@ size_t
|
||||
__wcsnrtombs_chk (char *dst, const wchar_t **src, size_t nwc, size_t len,
|
||||
mbstate_t *ps, size_t dstlen)
|
||||
{
|
||||
if (__builtin_expect (dstlen < len, 0))
|
||||
if (__glibc_unlikely (dstlen < len))
|
||||
__chk_fail ();
|
||||
|
||||
return __wcsnrtombs (dst, src, nwc, len, ps);
|
||||
|
||||
@ -23,7 +23,7 @@ size_t
|
||||
__wcsrtombs_chk (char *dst, const wchar_t **src, size_t len,
|
||||
mbstate_t *ps, size_t dstlen)
|
||||
{
|
||||
if (__builtin_expect (dstlen < len, 0))
|
||||
if (__glibc_unlikely (dstlen < len))
|
||||
__chk_fail ();
|
||||
|
||||
return __wcsrtombs (dst, src, len, ps);
|
||||
|
||||
@ -23,7 +23,7 @@
|
||||
size_t
|
||||
__wcstombs_chk (char *dst, const wchar_t *src, size_t len, size_t dstlen)
|
||||
{
|
||||
if (__builtin_expect (dstlen < len, 0))
|
||||
if (__glibc_unlikely (dstlen < len))
|
||||
__chk_fail ();
|
||||
|
||||
mbstate_t state;
|
||||
|
||||
@ -23,7 +23,7 @@
|
||||
wchar_t *
|
||||
__wmemcpy_chk (wchar_t *s1, const wchar_t *s2, size_t n, size_t ns1)
|
||||
{
|
||||
if (__builtin_expect (ns1 < n, 0))
|
||||
if (__glibc_unlikely (ns1 < n))
|
||||
__chk_fail ();
|
||||
return (wchar_t *) memcpy ((char *) s1, (char *) s2, n * sizeof (wchar_t));
|
||||
}
|
||||
|
||||
@ -23,7 +23,7 @@
|
||||
wchar_t *
|
||||
__wmemmove_chk (wchar_t *s1, const wchar_t *s2, size_t n, size_t ns1)
|
||||
{
|
||||
if (__builtin_expect (ns1 < n, 0))
|
||||
if (__glibc_unlikely (ns1 < n))
|
||||
__chk_fail ();
|
||||
return (wchar_t *) memmove ((char *) s1, (char *) s2, n * sizeof (wchar_t));
|
||||
}
|
||||
|
||||
@ -23,7 +23,7 @@
|
||||
wchar_t *
|
||||
__wmempcpy_chk (wchar_t *s1, const wchar_t *s2, size_t n, size_t ns1)
|
||||
{
|
||||
if (__builtin_expect (ns1 < n, 0))
|
||||
if (__glibc_unlikely (ns1 < n))
|
||||
__chk_fail ();
|
||||
return (wchar_t *) __mempcpy ((char *) s1, (char *) s2,
|
||||
n * sizeof (wchar_t));
|
||||
|
||||
@ -22,7 +22,7 @@
|
||||
wchar_t *
|
||||
__wmemset_chk (wchar_t *s, wchar_t c, size_t n, size_t dstlen)
|
||||
{
|
||||
if (__builtin_expect (dstlen < n, 0))
|
||||
if (__glibc_unlikely (dstlen < n))
|
||||
__chk_fail ();
|
||||
|
||||
return wmemset (s, c, n);
|
||||
|
||||
@ -98,7 +98,7 @@ SCANDIRAT (dfd, dir, namelist, select, cmp)
|
||||
/* Ignore errors from select or readdir */
|
||||
__set_errno (0);
|
||||
|
||||
if (__builtin_expect (c.cnt == vsize, 0))
|
||||
if (__glibc_unlikely (c.cnt == vsize))
|
||||
{
|
||||
DIRENT_TYPE **new;
|
||||
if (vsize == 0)
|
||||
|
||||
@ -32,7 +32,7 @@ int
|
||||
__dladdr (const void *address, Dl_info *info)
|
||||
{
|
||||
# ifdef SHARED
|
||||
if (__builtin_expect (_dlfcn_hook != NULL, 0))
|
||||
if (__glibc_unlikely (_dlfcn_hook != NULL))
|
||||
return _dlfcn_hook->dladdr (address, info);
|
||||
# endif
|
||||
return _dl_addr (address, info, NULL, NULL);
|
||||
|
||||
@ -32,7 +32,7 @@ int
|
||||
__dladdr1 (const void *address, Dl_info *info, void **extra, int flags)
|
||||
{
|
||||
# ifdef SHARED
|
||||
if (__builtin_expect (_dlfcn_hook != NULL, 0))
|
||||
if (__glibc_unlikely (_dlfcn_hook != NULL))
|
||||
return _dlfcn_hook->dladdr1 (address, info, extra, flags);
|
||||
# endif
|
||||
|
||||
|
||||
@ -39,7 +39,7 @@ int
|
||||
__dlclose (void *handle)
|
||||
{
|
||||
# ifdef SHARED
|
||||
if (__builtin_expect (_dlfcn_hook != NULL, 0))
|
||||
if (__glibc_unlikely (_dlfcn_hook != NULL))
|
||||
return _dlfcn_hook->dlclose (handle);
|
||||
# endif
|
||||
|
||||
|
||||
@ -63,7 +63,7 @@ __dlerror (void)
|
||||
struct dl_action_result *result;
|
||||
|
||||
# ifdef SHARED
|
||||
if (__builtin_expect (_dlfcn_hook != NULL, 0))
|
||||
if (__glibc_unlikely (_dlfcn_hook != NULL))
|
||||
return _dlfcn_hook->dlerror ();
|
||||
# endif
|
||||
|
||||
|
||||
@ -111,7 +111,7 @@ int
|
||||
__dlinfo (void *handle, int request, void *arg DL_CALLER_DECL)
|
||||
{
|
||||
# ifdef SHARED
|
||||
if (__builtin_expect (_dlfcn_hook != NULL, 0))
|
||||
if (__glibc_unlikely (_dlfcn_hook != NULL))
|
||||
return _dlfcn_hook->dlinfo (handle, request, arg,
|
||||
DL_CALLER);
|
||||
# endif
|
||||
|
||||
@ -64,7 +64,7 @@ dlmopen_doit (void *a)
|
||||
|
||||
/* It makes no sense to use RTLD_GLOBAL when loading a DSO into
|
||||
a namespace other than the base namespace. */
|
||||
if (__builtin_expect (args->mode & RTLD_GLOBAL, 0))
|
||||
if (__glibc_unlikely (args->mode & RTLD_GLOBAL))
|
||||
GLRO(dl_signal_error) (EINVAL, NULL, NULL, N_("invalid mode"));
|
||||
}
|
||||
|
||||
@ -79,7 +79,7 @@ void *
|
||||
__dlmopen (Lmid_t nsid, const char *file, int mode DL_CALLER_DECL)
|
||||
{
|
||||
# ifdef SHARED
|
||||
if (__builtin_expect (_dlfcn_hook != NULL, 0))
|
||||
if (__glibc_unlikely (_dlfcn_hook != NULL))
|
||||
return _dlfcn_hook->dlmopen (nsid, file, mode, RETURN_ADDRESS (0));
|
||||
# endif
|
||||
|
||||
|
||||
@ -74,7 +74,7 @@ void *
|
||||
__dlopen (const char *file, int mode DL_CALLER_DECL)
|
||||
{
|
||||
# ifdef SHARED
|
||||
if (__builtin_expect (_dlfcn_hook != NULL, 0))
|
||||
if (__glibc_unlikely (_dlfcn_hook != NULL))
|
||||
return _dlfcn_hook->dlopen (file, mode, DL_CALLER);
|
||||
# endif
|
||||
|
||||
|
||||
@ -70,7 +70,7 @@ __dlopen_nocheck (const char *file, int mode)
|
||||
mode |= RTLD_LAZY;
|
||||
args.mode = mode;
|
||||
|
||||
if (__builtin_expect (_dlfcn_hook != NULL, 0))
|
||||
if (__glibc_unlikely (_dlfcn_hook != NULL))
|
||||
return _dlfcn_hook->dlopen (file, mode, RETURN_ADDRESS (0));
|
||||
|
||||
return _dlerror_run (dlopen_doit, &args) ? NULL : args.new;
|
||||
|
||||
@ -55,7 +55,7 @@ void *
|
||||
__dlsym (void *handle, const char *name DL_CALLER_DECL)
|
||||
{
|
||||
# ifdef SHARED
|
||||
if (__builtin_expect (_dlfcn_hook != NULL, 0))
|
||||
if (__glibc_unlikely (_dlfcn_hook != NULL))
|
||||
return _dlfcn_hook->dlsym (handle, name, DL_CALLER);
|
||||
# endif
|
||||
|
||||
|
||||
@ -58,7 +58,7 @@ __dlvsym (void *handle, const char *name, const char *version_str
|
||||
DL_CALLER_DECL)
|
||||
{
|
||||
# ifdef SHARED
|
||||
if (__builtin_expect (_dlfcn_hook != NULL, 0))
|
||||
if (__glibc_unlikely (_dlfcn_hook != NULL))
|
||||
return _dlfcn_hook->dlvsym (handle, name, version_str, DL_CALLER);
|
||||
# endif
|
||||
|
||||
|
||||
@ -65,7 +65,7 @@ do \
|
||||
\
|
||||
/* Actually compare the entry with the key. */ \
|
||||
cmpres = _dl_cache_libcmp (name, cache_data + key); \
|
||||
if (__builtin_expect (cmpres == 0, 0)) \
|
||||
if (__glibc_unlikely (cmpres == 0)) \
|
||||
{ \
|
||||
/* Found it. LEFT now marks the last entry for which we \
|
||||
know the name is correct. */ \
|
||||
@ -187,7 +187,7 @@ _dl_load_cache_lookup (const char *name)
|
||||
const char *best;
|
||||
|
||||
/* Print a message if the loading of libs is traced. */
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS))
|
||||
_dl_debug_printf (" search cache=%s\n", LD_SO_CACHE);
|
||||
|
||||
if (cache == NULL)
|
||||
|
||||
@ -73,7 +73,7 @@ remove_slotinfo (size_t idx, struct dtv_slotinfo_list *listp, size_t disp,
|
||||
|
||||
/* The entry might still be in its unused state if we are closing an
|
||||
object that wasn't fully set up. */
|
||||
if (__builtin_expect (old_map != NULL, 1))
|
||||
if (__glibc_likely (old_map != NULL))
|
||||
{
|
||||
assert (old_map->l_tls_modid == idx);
|
||||
|
||||
@ -123,7 +123,7 @@ _dl_close_worker (struct link_map *map)
|
||||
dl_close_state = rerun;
|
||||
|
||||
/* There are still references to this object. Do nothing more. */
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
|
||||
_dl_debug_printf ("\nclosing file=%s; direct_opencount=%u\n",
|
||||
map->l_name, map->l_direct_opencount);
|
||||
|
||||
@ -280,7 +280,7 @@ _dl_close_worker (struct link_map *map)
|
||||
|
||||
#ifdef SHARED
|
||||
/* Auditing checkpoint: we remove an object. */
|
||||
if (__builtin_expect (do_audit, 0))
|
||||
if (__glibc_unlikely (do_audit))
|
||||
{
|
||||
struct audit_ifaces *afct = GLRO(dl_audit);
|
||||
for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
|
||||
@ -452,7 +452,7 @@ _dl_close_worker (struct link_map *map)
|
||||
|
||||
#ifdef SHARED
|
||||
/* Auditing checkpoint: we will start deleting objects. */
|
||||
if (__builtin_expect (do_audit, 0))
|
||||
if (__glibc_unlikely (do_audit))
|
||||
{
|
||||
struct link_map *head = ns->_ns_loaded;
|
||||
struct audit_ifaces *afct = GLRO(dl_audit);
|
||||
@ -536,7 +536,7 @@ _dl_close_worker (struct link_map *map)
|
||||
object. We can unmap it. */
|
||||
|
||||
/* Remove the object from the dtv slotinfo array if it uses TLS. */
|
||||
if (__builtin_expect (imap->l_tls_blocksize > 0, 0))
|
||||
if (__glibc_unlikely (imap->l_tls_blocksize > 0))
|
||||
{
|
||||
any_tls = true;
|
||||
|
||||
@ -662,7 +662,7 @@ _dl_close_worker (struct link_map *map)
|
||||
free (imap->l_reldeps);
|
||||
|
||||
/* Print debugging message. */
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
|
||||
_dl_debug_printf ("\nfile=%s [%lu]; destroying link map\n",
|
||||
imap->l_name, imap->l_ns);
|
||||
|
||||
@ -704,7 +704,7 @@ _dl_close_worker (struct link_map *map)
|
||||
/* If we removed any object which uses TLS bump the generation counter. */
|
||||
if (any_tls)
|
||||
{
|
||||
if (__builtin_expect (++GL(dl_tls_generation) == 0, 0))
|
||||
if (__glibc_unlikely (++GL(dl_tls_generation) == 0))
|
||||
_dl_fatal_printf ("TLS generation counter wrapped! Please report as described in "REPORT_BUGS_TO".\n");
|
||||
|
||||
if (tls_free_end == GL(dl_tls_static_used))
|
||||
@ -713,7 +713,7 @@ _dl_close_worker (struct link_map *map)
|
||||
|
||||
#ifdef SHARED
|
||||
/* Auditing checkpoint: we have deleted all objects. */
|
||||
if (__builtin_expect (do_audit, 0))
|
||||
if (__glibc_unlikely (do_audit))
|
||||
{
|
||||
struct link_map *head = ns->_ns_loaded;
|
||||
/* Do not call the functions for any auditing object. */
|
||||
@ -757,7 +757,7 @@ _dl_close (void *_map)
|
||||
struct link_map *map = _map;
|
||||
|
||||
/* First see whether we can remove the object at all. */
|
||||
if (__builtin_expect (map->l_flags_1 & DF_1_NODELETE, 0))
|
||||
if (__glibc_unlikely (map->l_flags_1 & DF_1_NODELETE))
|
||||
{
|
||||
assert (map->l_init_called);
|
||||
/* Nope. Do nothing. */
|
||||
|
||||
@ -32,7 +32,7 @@ _dl_resolve_conflicts (struct link_map *l, ElfW(Rela) *conflict,
|
||||
ElfW(Rela) *conflictend)
|
||||
{
|
||||
#if ! ELF_MACHINE_NO_RELA
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_RELOC, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_RELOC))
|
||||
_dl_debug_printf ("\nconflict processing: %s\n", DSO_FILENAME (l->l_name));
|
||||
|
||||
{
|
||||
|
||||
@ -127,7 +127,7 @@ empty dynamic string token substitution")); \
|
||||
else \
|
||||
{ \
|
||||
/* This is for DT_AUXILIARY. */ \
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0))\
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS)) \
|
||||
_dl_debug_printf (N_("\
|
||||
cannot load auxiliary `%s' because of empty dynamic string token " \
|
||||
"substitution\n"), __str); \
|
||||
@ -253,7 +253,7 @@ _dl_map_object_deps (struct link_map *map,
|
||||
bool malloced;
|
||||
int err = _dl_catch_error (&objname, &errstring, &malloced,
|
||||
openaux, &args);
|
||||
if (__builtin_expect (errstring != NULL, 0))
|
||||
if (__glibc_unlikely (errstring != NULL))
|
||||
{
|
||||
char *new_errstring = strdupa (errstring);
|
||||
objname = strdupa (objname);
|
||||
@ -317,7 +317,7 @@ _dl_map_object_deps (struct link_map *map,
|
||||
bool malloced;
|
||||
(void) _dl_catch_error (&objname, &errstring, &malloced,
|
||||
openaux, &args);
|
||||
if (__builtin_expect (errstring != NULL, 0))
|
||||
if (__glibc_unlikely (errstring != NULL))
|
||||
{
|
||||
/* We are not interested in the error message. */
|
||||
assert (errstring != NULL);
|
||||
@ -342,7 +342,7 @@ _dl_map_object_deps (struct link_map *map,
|
||||
bool malloced;
|
||||
int err = _dl_catch_error (&objname, &errstring, &malloced,
|
||||
openaux, &args);
|
||||
if (__builtin_expect (errstring != NULL, 0))
|
||||
if (__glibc_unlikely (errstring != NULL))
|
||||
{
|
||||
char *new_errstring = strdupa (errstring);
|
||||
objname = strdupa (objname);
|
||||
@ -622,7 +622,7 @@ Filters not supported with LD_TRACE_PRELINKING"));
|
||||
itself will always be initialize last. */
|
||||
memcpy (l_initfini, map->l_searchlist.r_list,
|
||||
nlist * sizeof (struct link_map *));
|
||||
if (__builtin_expect (nlist > 1, 1))
|
||||
if (__glibc_likely (nlist > 1))
|
||||
{
|
||||
/* We can skip looking for the binary itself which is at the front
|
||||
of the search list. */
|
||||
@ -645,7 +645,7 @@ Filters not supported with LD_TRACE_PRELINKING"));
|
||||
if (runp != NULL)
|
||||
/* Look through the dependencies of the object. */
|
||||
while (*runp != NULL)
|
||||
if (__builtin_expect (*runp++ == thisp, 0))
|
||||
if (__glibc_unlikely (*runp++ == thisp))
|
||||
{
|
||||
/* Move the current object to the back past the last
|
||||
object with it as the dependency. */
|
||||
|
||||
@ -25,7 +25,7 @@
|
||||
size_t __cnt = 0; \
|
||||
const char *__sf = strchr (name, '$'); \
|
||||
\
|
||||
if (__builtin_expect (__sf != NULL, 0)) \
|
||||
if (__glibc_unlikely (__sf != NULL)) \
|
||||
__cnt = _dl_dst_count (__sf, is_path); \
|
||||
\
|
||||
__cnt; })
|
||||
|
||||
@ -60,7 +60,7 @@ _dl_sort_fini (struct link_map **maps, size_t nmaps, char *used, Lmid_t ns)
|
||||
if (runp != NULL)
|
||||
/* Look through the dependencies of the object. */
|
||||
while (*runp != NULL)
|
||||
if (__builtin_expect (*runp++ == thisp, 0))
|
||||
if (__glibc_unlikely (*runp++ == thisp))
|
||||
{
|
||||
move:
|
||||
/* Move the current object to the back past the last
|
||||
@ -90,21 +90,21 @@ _dl_sort_fini (struct link_map **maps, size_t nmaps, char *used, Lmid_t ns)
|
||||
goto next;
|
||||
}
|
||||
|
||||
if (__builtin_expect (maps[k]->l_reldeps != NULL, 0))
|
||||
if (__glibc_unlikely (maps[k]->l_reldeps != NULL))
|
||||
{
|
||||
unsigned int m = maps[k]->l_reldeps->act;
|
||||
struct link_map **relmaps = &maps[k]->l_reldeps->list[0];
|
||||
|
||||
/* Look through the relocation dependencies of the object. */
|
||||
while (m-- > 0)
|
||||
if (__builtin_expect (relmaps[m] == thisp, 0))
|
||||
if (__glibc_unlikely (relmaps[m] == thisp))
|
||||
{
|
||||
/* If a cycle exists with a link time dependency,
|
||||
preserve the latter. */
|
||||
struct link_map **runp = thisp->l_initfini;
|
||||
if (runp != NULL)
|
||||
while (*runp != NULL)
|
||||
if (__builtin_expect (*runp++ == maps[k], 0))
|
||||
if (__glibc_unlikely (*runp++ == maps[k]))
|
||||
goto ignore;
|
||||
goto move;
|
||||
}
|
||||
@ -286,7 +286,7 @@ _dl_fini (void)
|
||||
goto again;
|
||||
}
|
||||
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_STATISTICS, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_STATISTICS))
|
||||
_dl_debug_printf ("\nruntime linker statistics:\n"
|
||||
" final number of relocations: %lu\n"
|
||||
"final number of relocations from cache: %lu\n",
|
||||
|
||||
@ -209,7 +209,7 @@ _dl_make_fptr (struct link_map *map, const ElfW(Sym) *sym,
|
||||
Elf_Symndx symidx;
|
||||
struct local *l;
|
||||
|
||||
if (__builtin_expect (ftab == NULL, 0))
|
||||
if (__glibc_unlikely (ftab == NULL))
|
||||
ftab = make_fptr_table (map);
|
||||
|
||||
symtab = (const void *) D_PTR (map, l_info[DT_SYMTAB]);
|
||||
|
||||
@ -133,7 +133,7 @@ _dl_important_hwcaps (const char *platform, size_t platform_len, size_t *sz,
|
||||
len = strlen (p);
|
||||
|
||||
/* Skip entries that are not enabled in the mask word. */
|
||||
if (__builtin_expect (mask & ((ElfW(Word)) 1 << bit), 1))
|
||||
if (__glibc_likely (mask & ((ElfW(Word)) 1 << bit)))
|
||||
{
|
||||
temp[m].str = p;
|
||||
temp[m].len = len;
|
||||
|
||||
@ -52,7 +52,7 @@ call_init (struct link_map *l, int argc, char **argv, char **env)
|
||||
return;
|
||||
|
||||
/* Print a debug message if wanted. */
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS))
|
||||
_dl_debug_printf ("\ncalling init: %s\n\n",
|
||||
DSO_FILENAME (l->l_name));
|
||||
|
||||
@ -88,7 +88,7 @@ _dl_init (struct link_map *main_map, int argc, char **argv, char **env)
|
||||
ElfW(Dyn) *preinit_array_size = main_map->l_info[DT_PREINIT_ARRAYSZ];
|
||||
unsigned int i;
|
||||
|
||||
if (__builtin_expect (GL(dl_initfirst) != NULL, 0))
|
||||
if (__glibc_unlikely (GL(dl_initfirst) != NULL))
|
||||
{
|
||||
call_init (GL(dl_initfirst), argc, argv, env);
|
||||
GL(dl_initfirst) = NULL;
|
||||
@ -102,7 +102,7 @@ _dl_init (struct link_map *main_map, int argc, char **argv, char **env)
|
||||
ElfW(Addr) *addrs;
|
||||
unsigned int cnt;
|
||||
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS))
|
||||
_dl_debug_printf ("\ncalling preinit: %s\n\n",
|
||||
DSO_FILENAME (main_map->l_name));
|
||||
|
||||
|
||||
@ -158,7 +158,7 @@ __libc_dlopen_mode (const char *name, int mode)
|
||||
args.caller_dlopen = RETURN_ADDRESS (0);
|
||||
|
||||
#ifdef SHARED
|
||||
if (__builtin_expect (_dl_open_hook != NULL, 0))
|
||||
if (__glibc_unlikely (_dl_open_hook != NULL))
|
||||
return _dl_open_hook->dlopen_mode (name, mode);
|
||||
return (dlerror_run (do_dlopen, &args) ? NULL : (void *) args.map);
|
||||
#else
|
||||
@ -204,7 +204,7 @@ __libc_dlsym (void *map, const char *name)
|
||||
args.name = name;
|
||||
|
||||
#ifdef SHARED
|
||||
if (__builtin_expect (_dl_open_hook != NULL, 0))
|
||||
if (__glibc_unlikely (_dl_open_hook != NULL))
|
||||
return _dl_open_hook->dlsym (map, name);
|
||||
#endif
|
||||
return (dlerror_run (do_dlsym, &args) ? NULL
|
||||
@ -216,7 +216,7 @@ int
|
||||
__libc_dlclose (void *map)
|
||||
{
|
||||
#ifdef SHARED
|
||||
if (__builtin_expect (_dl_open_hook != NULL, 0))
|
||||
if (__glibc_unlikely (_dl_open_hook != NULL))
|
||||
return _dl_open_hook->dlclose (map);
|
||||
#endif
|
||||
return dlerror_run (do_dlclose, map);
|
||||
|
||||
@ -333,7 +333,7 @@ _dl_dst_substitute (struct link_map *l, const char *name, char *result,
|
||||
|
||||
do
|
||||
{
|
||||
if (__builtin_expect (*name == '$', 0))
|
||||
if (__glibc_unlikely (*name == '$'))
|
||||
{
|
||||
const char *repl = NULL;
|
||||
size_t len;
|
||||
@ -565,7 +565,7 @@ fillin_rpath (char *rpath, struct r_search_path_elem **result, const char *sep,
|
||||
dirp->status[cnt] = init_val;
|
||||
|
||||
dirp->what = what;
|
||||
if (__builtin_expect (where != NULL, 1))
|
||||
if (__glibc_likely (where != NULL))
|
||||
dirp->where = memcpy ((char *) dirp + sizeof (*dirp) + len + 1
|
||||
+ (ncapstr * sizeof (enum r_dir_status)),
|
||||
where, where_len);
|
||||
@ -836,7 +836,7 @@ _dl_init_paths (const char *llp)
|
||||
#ifdef SHARED
|
||||
/* Expand DSTs. */
|
||||
size_t cnt = DL_DST_COUNT (llp, 1);
|
||||
if (__builtin_expect (cnt == 0, 1))
|
||||
if (__glibc_likely (cnt == 0))
|
||||
llp_tmp = strdupa (llp);
|
||||
else
|
||||
{
|
||||
@ -935,7 +935,7 @@ _dl_map_object_from_fd (const char *name, int fd, struct filebuf *fbp,
|
||||
bool make_consistent = false;
|
||||
|
||||
/* Get file information. */
|
||||
if (__builtin_expect (__fxstat64 (_STAT_VER, fd, &st) < 0, 0))
|
||||
if (__glibc_unlikely (__fxstat64 (_STAT_VER, fd, &st) < 0))
|
||||
{
|
||||
errstring = N_("cannot stat shared object");
|
||||
call_lose_errno:
|
||||
@ -999,7 +999,7 @@ _dl_map_object_from_fd (const char *name, int fd, struct filebuf *fbp,
|
||||
}
|
||||
|
||||
/* Print debugging message. */
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
|
||||
_dl_debug_printf ("file=%s [%lu]; generating link map\n", name, nsid);
|
||||
|
||||
/* This is the ELF header. We read it in `open_verify'. */
|
||||
@ -1057,7 +1057,7 @@ _dl_map_object_from_fd (const char *name, int fd, struct filebuf *fbp,
|
||||
|
||||
/* Enter the new object in the list of loaded objects. */
|
||||
l = _dl_new_object (realname, name, l_type, loader, mode, nsid);
|
||||
if (__builtin_expect (l == NULL, 0))
|
||||
if (__glibc_unlikely (l == NULL))
|
||||
{
|
||||
#ifdef SHARED
|
||||
fail_new:
|
||||
@ -1226,7 +1226,7 @@ cannot allocate TLS data structures for initial thread");
|
||||
|
||||
/* Now we install the TCB in the thread register. */
|
||||
errstring = TLS_INIT_TP (tcb, 0);
|
||||
if (__builtin_expect (errstring == NULL, 1))
|
||||
if (__glibc_likely (errstring == NULL))
|
||||
{
|
||||
/* Now we are all good. */
|
||||
l->l_tls_modid = ++GL(dl_tls_max_dtv_idx);
|
||||
@ -1256,7 +1256,7 @@ cannot allocate TLS data structures for initial thread");
|
||||
break;
|
||||
}
|
||||
|
||||
if (__builtin_expect (nloadcmds == 0, 0))
|
||||
if (__glibc_unlikely (nloadcmds == 0))
|
||||
{
|
||||
/* This only happens for a bogus object that will be caught with
|
||||
another error below. But we don't want to go through the
|
||||
@ -1294,7 +1294,7 @@ cannot allocate TLS data structures for initial thread");
|
||||
c->prot,
|
||||
MAP_COPY|MAP_FILE,
|
||||
fd, c->mapoff);
|
||||
if (__builtin_expect ((void *) l->l_map_start == MAP_FAILED, 0))
|
||||
if (__glibc_unlikely ((void *) l->l_map_start == MAP_FAILED))
|
||||
{
|
||||
map_error:
|
||||
errstring = N_("failed to map segment from shared object");
|
||||
@ -1321,7 +1321,7 @@ cannot allocate TLS data structures for initial thread");
|
||||
|
||||
/* This object is loaded at a fixed address. This must never
|
||||
happen for objects loaded with dlopen(). */
|
||||
if (__builtin_expect ((mode & __RTLD_OPENEXEC) == 0, 0))
|
||||
if (__glibc_unlikely ((mode & __RTLD_OPENEXEC) == 0))
|
||||
{
|
||||
errstring = N_("cannot dynamically load executable");
|
||||
goto call_lose;
|
||||
@ -1379,7 +1379,7 @@ cannot allocate TLS data structures for initial thread");
|
||||
if (zeropage > zero)
|
||||
{
|
||||
/* Zero the final part of the last page of the segment. */
|
||||
if (__builtin_expect ((c->prot & PROT_WRITE) == 0, 0))
|
||||
if (__glibc_unlikely ((c->prot & PROT_WRITE) == 0))
|
||||
{
|
||||
/* Dag nab it. */
|
||||
if (__mprotect ((caddr_t) (zero
|
||||
@ -1391,7 +1391,7 @@ cannot allocate TLS data structures for initial thread");
|
||||
}
|
||||
}
|
||||
memset ((void *) zero, '\0', zeropage - zero);
|
||||
if (__builtin_expect ((c->prot & PROT_WRITE) == 0, 0))
|
||||
if (__glibc_unlikely ((c->prot & PROT_WRITE) == 0))
|
||||
__mprotect ((caddr_t) (zero & ~(GLRO(dl_pagesize) - 1)),
|
||||
GLRO(dl_pagesize), c->prot);
|
||||
}
|
||||
@ -1403,7 +1403,7 @@ cannot allocate TLS data structures for initial thread");
|
||||
mapat = __mmap ((caddr_t) zeropage, zeroend - zeropage,
|
||||
c->prot, MAP_ANON|MAP_PRIVATE|MAP_FIXED,
|
||||
-1, 0);
|
||||
if (__builtin_expect (mapat == MAP_FAILED, 0))
|
||||
if (__glibc_unlikely (mapat == MAP_FAILED))
|
||||
{
|
||||
errstring = N_("cannot map zero-fill pages");
|
||||
goto call_lose_errno;
|
||||
@ -1417,7 +1417,7 @@ cannot allocate TLS data structures for initial thread");
|
||||
|
||||
if (l->l_ld == 0)
|
||||
{
|
||||
if (__builtin_expect (type == ET_DYN, 0))
|
||||
if (__glibc_unlikely (type == ET_DYN))
|
||||
{
|
||||
errstring = N_("object file has no dynamic section");
|
||||
goto call_lose;
|
||||
@ -1467,7 +1467,7 @@ cannot allocate TLS data structures for initial thread");
|
||||
/* Adjust the PT_PHDR value by the runtime load address. */
|
||||
l->l_phdr = (ElfW(Phdr) *) ((ElfW(Addr)) l->l_phdr + l->l_addr);
|
||||
|
||||
if (__builtin_expect ((stack_flags &~ GL(dl_stack_flags)) & PF_X, 0))
|
||||
if (__glibc_unlikely ((stack_flags &~ GL(dl_stack_flags)) & PF_X))
|
||||
{
|
||||
if (__builtin_expect (__check_caller (RETURN_ADDRESS (0), allow_ldso),
|
||||
0) != 0)
|
||||
@ -1490,7 +1490,7 @@ cannot allocate TLS data structures for initial thread");
|
||||
const uintptr_t relro_end = ((m->l_addr + m->l_relro_addr
|
||||
+ m->l_relro_size)
|
||||
& -GLRO(dl_pagesize));
|
||||
if (__builtin_expect (p + s <= relro_end, 1))
|
||||
if (__glibc_likely (p + s <= relro_end))
|
||||
{
|
||||
/* The variable lies in the region protected by RELRO. */
|
||||
if (__mprotect ((void *) p, s, PROT_READ|PROT_WRITE) < 0)
|
||||
@ -1526,7 +1526,7 @@ cannot enable executable stack as shared object requires");
|
||||
l->l_tls_initimage = (char *) l->l_tls_initimage + l->l_addr;
|
||||
|
||||
/* We are done mapping in the file. We no longer need the descriptor. */
|
||||
if (__builtin_expect (__close (fd) != 0, 0))
|
||||
if (__glibc_unlikely (__close (fd) != 0))
|
||||
{
|
||||
errstring = N_("cannot close file descriptor");
|
||||
goto call_lose_errno;
|
||||
@ -1539,7 +1539,7 @@ cannot enable executable stack as shared object requires");
|
||||
|
||||
l->l_entry += l->l_addr;
|
||||
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
|
||||
_dl_debug_printf ("\
|
||||
dynamic: 0x%0*lx base: 0x%0*lx size: 0x%0*Zx\n\
|
||||
entry: 0x%0*lx phdr: 0x%0*lx phnum: %*u\n\n",
|
||||
@ -1754,7 +1754,7 @@ open_verify (const char *name, struct filebuf *fbp, struct link_map *loader,
|
||||
ehdr = (ElfW(Ehdr) *) fbp->buf;
|
||||
|
||||
/* Now run the tests. */
|
||||
if (__builtin_expect (fbp->len < (ssize_t) sizeof (ElfW(Ehdr)), 0))
|
||||
if (__glibc_unlikely (fbp->len < (ssize_t) sizeof (ElfW(Ehdr))))
|
||||
{
|
||||
errval = errno;
|
||||
errstring = (errval == 0
|
||||
@ -1939,7 +1939,7 @@ open_path (const char *name, size_t namelen, int secure,
|
||||
const char *current_what = NULL;
|
||||
int any = 0;
|
||||
|
||||
if (__builtin_expect (dirs == NULL, 0))
|
||||
if (__glibc_unlikely (dirs == NULL))
|
||||
/* We're called before _dl_init_paths when loading the main executable
|
||||
given on the command line when rtld is run directly. */
|
||||
return -1;
|
||||
@ -1977,7 +1977,7 @@ open_path (const char *name, size_t namelen, int secure,
|
||||
- buf);
|
||||
|
||||
/* Print name we try if this is wanted. */
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS))
|
||||
_dl_debug_printf (" trying file=%s\n", buf);
|
||||
|
||||
fd = open_verify (buf, fbp, loader, whatcode, found_other_class,
|
||||
@ -2059,7 +2059,7 @@ open_path (const char *name, size_t namelen, int secure,
|
||||
while (*++dirs != NULL);
|
||||
|
||||
/* Remove the whole path if none of the directories exists. */
|
||||
if (__builtin_expect (! any, 0))
|
||||
if (__glibc_unlikely (! any))
|
||||
{
|
||||
/* Paths which were allocated using the minimal malloc() in ld.so
|
||||
must not be freed using the general free() in libc. */
|
||||
@ -2165,7 +2165,7 @@ _dl_map_object (struct link_map *loader, const char *name,
|
||||
|
||||
size_t namelen = strlen (name) + 1;
|
||||
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS))
|
||||
_dl_debug_printf ("find library=%s [%lu]; searching\n", name, nsid);
|
||||
|
||||
fd = -1;
|
||||
@ -2268,7 +2268,7 @@ _dl_map_object (struct link_map *loader, const char *name,
|
||||
fd = open_verify (cached,
|
||||
&fb, loader ?: GL(dl_ns)[nsid]._ns_loaded,
|
||||
LA_SER_CONFIG, &found_other_class, false);
|
||||
if (__builtin_expect (fd != -1, 1))
|
||||
if (__glibc_likely (fd != -1))
|
||||
{
|
||||
realname = local_strdup (cached);
|
||||
if (realname == NULL)
|
||||
@ -2291,7 +2291,7 @@ _dl_map_object (struct link_map *loader, const char *name,
|
||||
&realname, &fb, l, LA_SER_DEFAULT, &found_other_class);
|
||||
|
||||
/* Add another newline when we are tracing the library loading. */
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS))
|
||||
_dl_debug_printf ("\n");
|
||||
}
|
||||
else
|
||||
|
||||
@ -110,7 +110,7 @@ do_lookup_x (const char *undef_name, uint_fast32_t new_hash,
|
||||
continue;
|
||||
|
||||
/* Print some debugging info if wanted. */
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_SYMBOLS, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SYMBOLS))
|
||||
_dl_debug_printf ("symbol=%s; lookup in file=%s [%lu]\n",
|
||||
undef_name, DSO_FILENAME (map->l_name),
|
||||
map->l_ns);
|
||||
@ -143,7 +143,7 @@ do_lookup_x (const char *undef_name, uint_fast32_t new_hash,
|
||||
#define ALLOWED_STT \
|
||||
((1 << STT_NOTYPE) | (1 << STT_OBJECT) | (1 << STT_FUNC) \
|
||||
| (1 << STT_COMMON) | (1 << STT_TLS) | (1 << STT_GNU_IFUNC))
|
||||
if (__builtin_expect (((1 << stt) & ALLOWED_STT) == 0, 0))
|
||||
if (__glibc_unlikely (((1 << stt) & ALLOWED_STT) == 0))
|
||||
return NULL;
|
||||
|
||||
if (sym != ref && strcmp (strtab + sym->st_name, undef_name))
|
||||
@ -153,7 +153,7 @@ do_lookup_x (const char *undef_name, uint_fast32_t new_hash,
|
||||
const ElfW(Half) *verstab = map->l_versyms;
|
||||
if (version != NULL)
|
||||
{
|
||||
if (__builtin_expect (verstab == NULL, 0))
|
||||
if (__glibc_unlikely (verstab == NULL))
|
||||
{
|
||||
/* We need a versioned symbol but haven't found any. If
|
||||
this is the object which is referenced in the verneed
|
||||
@ -223,7 +223,7 @@ do_lookup_x (const char *undef_name, uint_fast32_t new_hash,
|
||||
|
||||
const ElfW(Sym) *sym;
|
||||
const ElfW(Addr) *bitmask = map->l_gnu_bitmask;
|
||||
if (__builtin_expect (bitmask != NULL, 1))
|
||||
if (__glibc_likely (bitmask != NULL))
|
||||
{
|
||||
ElfW(Addr) bitmask_word
|
||||
= bitmask[(new_hash / __ELF_NATIVE_CLASS)
|
||||
@ -287,7 +287,7 @@ do_lookup_x (const char *undef_name, uint_fast32_t new_hash,
|
||||
{
|
||||
case STB_WEAK:
|
||||
/* Weak definition. Use this value if we don't find another. */
|
||||
if (__builtin_expect (GLRO(dl_dynamic_weak), 0))
|
||||
if (__glibc_unlikely (GLRO(dl_dynamic_weak)))
|
||||
{
|
||||
if (! result->s)
|
||||
{
|
||||
@ -412,7 +412,7 @@ do_lookup_x (const char *undef_name, uint_fast32_t new_hash,
|
||||
LD_TRACE_PRELINKING in _dl_debug_bindings. Don't
|
||||
allocate anything and don't enter anything into the
|
||||
hash table. */
|
||||
if (__builtin_expect (tab->size, 0))
|
||||
if (__glibc_unlikely (tab->size))
|
||||
{
|
||||
assert (GLRO(dl_debug_mask) & DL_DEBUG_PRELINK);
|
||||
__rtld_lock_unlock_recursive (tab->lock);
|
||||
@ -530,7 +530,7 @@ add_dependency (struct link_map *undef_map, struct link_map *map, int flags)
|
||||
unsigned long long serial = map->l_serial;
|
||||
|
||||
/* Make sure nobody can unload the object while we are at it. */
|
||||
if (__builtin_expect (flags & DL_LOOKUP_GSCOPE_LOCK, 0))
|
||||
if (__glibc_unlikely (flags & DL_LOOKUP_GSCOPE_LOCK))
|
||||
{
|
||||
/* We can't just call __rtld_lock_lock_recursive (GL(dl_load_lock))
|
||||
here, that can result in ABBA deadlock. */
|
||||
@ -617,7 +617,7 @@ add_dependency (struct link_map *undef_map, struct link_map *map, int flags)
|
||||
}
|
||||
|
||||
/* Add the reference now. */
|
||||
if (__builtin_expect (l_reldepsact >= undef_map->l_reldepsmax, 0))
|
||||
if (__glibc_unlikely (l_reldepsact >= undef_map->l_reldepsmax))
|
||||
{
|
||||
/* Allocate more memory for the dependency list. Since this
|
||||
can never happen during the startup phase we can use
|
||||
@ -663,7 +663,7 @@ add_dependency (struct link_map *undef_map, struct link_map *map, int flags)
|
||||
}
|
||||
|
||||
/* Display information if we are debugging. */
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
|
||||
_dl_debug_printf ("\
|
||||
\nfile=%s [%lu]; needed by %s [%lu] (relocation dependency)\n\n",
|
||||
DSO_FILENAME (map->l_name),
|
||||
@ -679,7 +679,7 @@ add_dependency (struct link_map *undef_map, struct link_map *map, int flags)
|
||||
/* Release the lock. */
|
||||
__rtld_lock_unlock_recursive (GL(dl_load_lock));
|
||||
|
||||
if (__builtin_expect (flags & DL_LOOKUP_GSCOPE_LOCK, 0))
|
||||
if (__glibc_unlikely (flags & DL_LOOKUP_GSCOPE_LOCK))
|
||||
THREAD_GSCOPE_SET_FLAG ();
|
||||
|
||||
return result;
|
||||
@ -726,7 +726,7 @@ _dl_lookup_symbol_x (const char *undef_name, struct link_map *undef_map,
|
||||
== 0);
|
||||
|
||||
size_t i = 0;
|
||||
if (__builtin_expect (skip_map != NULL, 0))
|
||||
if (__glibc_unlikely (skip_map != NULL))
|
||||
/* Search the relevant loaded objects for a definition. */
|
||||
while ((*scope)->r_list[i] != skip_map)
|
||||
++i;
|
||||
@ -763,7 +763,7 @@ _dl_lookup_symbol_x (const char *undef_name, struct link_map *undef_map,
|
||||
}
|
||||
}
|
||||
|
||||
if (__builtin_expect (current_value.s == NULL, 0))
|
||||
if (__glibc_unlikely (current_value.s == NULL))
|
||||
{
|
||||
if ((*ref == NULL || ELFW(ST_BIND) ((*ref)->st_info) != STB_WEAK)
|
||||
&& skip_map == NULL
|
||||
@ -787,7 +787,7 @@ _dl_lookup_symbol_x (const char *undef_name, struct link_map *undef_map,
|
||||
|
||||
int protected = (*ref
|
||||
&& ELFW(ST_VISIBILITY) ((*ref)->st_other) == STV_PROTECTED);
|
||||
if (__builtin_expect (protected != 0, 0))
|
||||
if (__glibc_unlikely (protected != 0))
|
||||
{
|
||||
/* It is very tricky. We need to figure out what value to
|
||||
return for the protected symbol. */
|
||||
@ -835,7 +835,7 @@ _dl_lookup_symbol_x (const char *undef_name, struct link_map *undef_map,
|
||||
version, type_class, flags, skip_map);
|
||||
|
||||
/* The object is used. */
|
||||
if (__builtin_expect (current_value.m->l_used == 0, 0))
|
||||
if (__glibc_unlikely (current_value.m->l_used == 0))
|
||||
current_value.m->l_used = 1;
|
||||
|
||||
if (__builtin_expect (GLRO(dl_debug_mask)
|
||||
|
||||
@ -68,7 +68,7 @@ __libc_memalign (size_t align, size_t n)
|
||||
/* Insufficient space left; allocate another page. */
|
||||
caddr_t page;
|
||||
size_t nup = (n + GLRO(dl_pagesize) - 1) & ~(GLRO(dl_pagesize) - 1);
|
||||
if (__builtin_expect (nup == 0, 0))
|
||||
if (__glibc_unlikely (nup == 0))
|
||||
{
|
||||
if (n)
|
||||
return NULL;
|
||||
|
||||
@ -147,7 +147,7 @@ add_to_global (struct link_map *new)
|
||||
ns->_ns_main_searchlist->r_list[new_nlist++] = map;
|
||||
|
||||
/* We modify the global scope. Report this. */
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES))
|
||||
_dl_debug_printf ("\nadd %s [%lu] to global scope\n",
|
||||
map->l_name, map->l_ns);
|
||||
}
|
||||
@ -232,7 +232,7 @@ dl_open_worker (void *a)
|
||||
return;
|
||||
}
|
||||
|
||||
if (__builtin_expect (mode & __RTLD_SPROF, 0))
|
||||
if (__glibc_unlikely (mode & __RTLD_SPROF))
|
||||
/* This happens only if we load a DSO for 'sprof'. */
|
||||
return;
|
||||
|
||||
@ -240,10 +240,10 @@ dl_open_worker (void *a)
|
||||
++new->l_direct_opencount;
|
||||
|
||||
/* It was already open. */
|
||||
if (__builtin_expect (new->l_searchlist.r_list != NULL, 0))
|
||||
if (__glibc_unlikely (new->l_searchlist.r_list != NULL))
|
||||
{
|
||||
/* Let the user know about the opencount. */
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
|
||||
_dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n",
|
||||
new->l_name, new->l_ns, new->l_direct_opencount);
|
||||
|
||||
@ -269,7 +269,7 @@ dl_open_worker (void *a)
|
||||
|
||||
#ifdef SHARED
|
||||
/* Auditing checkpoint: we have added all objects. */
|
||||
if (__builtin_expect (GLRO(dl_naudit) > 0, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_naudit) > 0))
|
||||
{
|
||||
struct link_map *head = GL(dl_ns)[new->l_ns]._ns_loaded;
|
||||
/* Do not call the functions for any auditing object. */
|
||||
@ -294,7 +294,7 @@ dl_open_worker (void *a)
|
||||
LIBC_PROBE (map_complete, 3, args->nsid, r, new);
|
||||
|
||||
/* Print scope information. */
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES))
|
||||
_dl_show_scope (new, 0);
|
||||
|
||||
/* Only do lazy relocation if `LD_BIND_NOW' is not set. */
|
||||
@ -344,7 +344,7 @@ dl_open_worker (void *a)
|
||||
if (runp != NULL)
|
||||
/* Look through the dependencies of the object. */
|
||||
while (*runp != NULL)
|
||||
if (__builtin_expect (*runp++ == thisp, 0))
|
||||
if (__glibc_unlikely (*runp++ == thisp))
|
||||
{
|
||||
/* Move the current object to the back past the last
|
||||
object with it as the dependency. */
|
||||
@ -391,7 +391,7 @@ dl_open_worker (void *a)
|
||||
}
|
||||
|
||||
#ifdef SHARED
|
||||
if (__builtin_expect (GLRO(dl_profile) != NULL, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_profile) != NULL))
|
||||
{
|
||||
/* If this here is the shared object which we want to profile
|
||||
make sure the profile is started. We can find out whether
|
||||
@ -444,7 +444,7 @@ dl_open_worker (void *a)
|
||||
/* Avoid duplicates. */
|
||||
continue;
|
||||
|
||||
if (__builtin_expect (cnt + 1 >= imap->l_scope_max, 0))
|
||||
if (__glibc_unlikely (cnt + 1 >= imap->l_scope_max))
|
||||
{
|
||||
/* The 'r_scope' array is too small. Allocate a new one
|
||||
dynamically. */
|
||||
@ -511,7 +511,7 @@ dl_open_worker (void *a)
|
||||
}
|
||||
|
||||
/* Print scope information. */
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES))
|
||||
_dl_show_scope (imap, from_scope);
|
||||
}
|
||||
|
||||
@ -574,7 +574,7 @@ cannot load any more object with static TLS"));
|
||||
|
||||
/* Mark the object as not deletable if the RTLD_NODELETE flags was
|
||||
passed. */
|
||||
if (__builtin_expect (mode & RTLD_NODELETE, 0))
|
||||
if (__glibc_unlikely (mode & RTLD_NODELETE))
|
||||
new->l_flags_1 |= DF_1_NODELETE;
|
||||
|
||||
#ifndef SHARED
|
||||
@ -584,7 +584,7 @@ cannot load any more object with static TLS"));
|
||||
#endif
|
||||
|
||||
/* Let the user know about the opencount. */
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
|
||||
_dl_debug_printf ("opening file=%s [%lu]; direct_opencount=%u\n\n",
|
||||
new->l_name, new->l_ns, new->l_direct_opencount);
|
||||
}
|
||||
@ -601,14 +601,14 @@ _dl_open (const char *file, int mode, const void *caller_dlopen, Lmid_t nsid,
|
||||
/* Make sure we are alone. */
|
||||
__rtld_lock_lock_recursive (GL(dl_load_lock));
|
||||
|
||||
if (__builtin_expect (nsid == LM_ID_NEWLM, 0))
|
||||
if (__glibc_unlikely (nsid == LM_ID_NEWLM))
|
||||
{
|
||||
/* Find a new namespace. */
|
||||
for (nsid = 1; DL_NNS > 1 && nsid < GL(dl_nns); ++nsid)
|
||||
if (GL(dl_ns)[nsid]._ns_loaded == NULL)
|
||||
break;
|
||||
|
||||
if (__builtin_expect (nsid == DL_NNS, 0))
|
||||
if (__glibc_unlikely (nsid == DL_NNS))
|
||||
{
|
||||
/* No more namespace available. */
|
||||
__rtld_lock_unlock_recursive (GL(dl_load_lock));
|
||||
@ -656,7 +656,7 @@ no more namespaces available for dlmopen()"));
|
||||
#endif
|
||||
|
||||
/* See if an error occurred during loading. */
|
||||
if (__builtin_expect (errstring != NULL, 0))
|
||||
if (__glibc_unlikely (errstring != NULL))
|
||||
{
|
||||
/* Remove the object from memory. It may be in an inconsistent
|
||||
state if relocation failed, for example. */
|
||||
|
||||
@ -183,14 +183,14 @@ _dl_relocate_object (struct link_map *l, struct r_scope_elem *scope[],
|
||||
&& __builtin_expect (l->l_info[DT_BIND_NOW] != NULL, 0))
|
||||
lazy = 0;
|
||||
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_RELOC, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_RELOC))
|
||||
_dl_debug_printf ("\nrelocation processing: %s%s\n",
|
||||
DSO_FILENAME (l->l_name), lazy ? " (lazy)" : "");
|
||||
|
||||
/* DT_TEXTREL is now in level 2 and might phase out at some time.
|
||||
But we rewrite the DT_FLAGS entry to a DT_TEXTREL entry to make
|
||||
testing easier and therefore it will be available at all time. */
|
||||
if (__builtin_expect (l->l_info[DT_TEXTREL] != NULL, 0))
|
||||
if (__glibc_unlikely (l->l_info[DT_TEXTREL] != NULL))
|
||||
{
|
||||
/* Bletch. We must make read-only segments writable
|
||||
long enough to relocate them. */
|
||||
@ -264,7 +264,7 @@ _dl_relocate_object (struct link_map *l, struct r_scope_elem *scope[],
|
||||
ELF_DYNAMIC_RELOCATE (l, lazy, consider_profiling, skip_ifunc);
|
||||
|
||||
#ifndef PROF
|
||||
if (__builtin_expect (consider_profiling, 0))
|
||||
if (__glibc_unlikely (consider_profiling))
|
||||
{
|
||||
/* Allocate the array which will contain the already found
|
||||
relocations. If the shared object lacks a PLT (for example
|
||||
|
||||
@ -142,7 +142,7 @@ _dl_fixup (
|
||||
value = elf_ifunc_invoke (DL_FIXUP_VALUE_ADDR (value));
|
||||
|
||||
/* Finally, fix up the plt itself. */
|
||||
if (__builtin_expect (GLRO(dl_bind_not), 0))
|
||||
if (__glibc_unlikely (GLRO(dl_bind_not)))
|
||||
return value;
|
||||
|
||||
return elf_machine_fixup_plt (l, result, reloc, rel_addr, value);
|
||||
@ -347,7 +347,7 @@ _dl_profile_fixup (
|
||||
#endif
|
||||
|
||||
/* Store the result for later runs. */
|
||||
if (__builtin_expect (! GLRO(dl_bind_not), 1))
|
||||
if (__glibc_likely (! GLRO(dl_bind_not)))
|
||||
*resultp = value;
|
||||
}
|
||||
|
||||
|
||||
@ -128,7 +128,7 @@ do_sym (void *handle, const char *name, void *who,
|
||||
|
||||
THREAD_GSCOPE_RESET_FLAG ();
|
||||
|
||||
if (__builtin_expect (errstring != NULL, 0))
|
||||
if (__glibc_unlikely (errstring != NULL))
|
||||
{
|
||||
/* The lookup was unsuccessful. Rethrow the error. */
|
||||
char *errstring_dup = strdupa (errstring);
|
||||
@ -145,7 +145,7 @@ do_sym (void *handle, const char *name, void *who,
|
||||
}
|
||||
else if (handle == RTLD_NEXT)
|
||||
{
|
||||
if (__builtin_expect (match == GL(dl_ns)[LM_ID_BASE]._ns_loaded, 0))
|
||||
if (__glibc_unlikely (match == GL(dl_ns)[LM_ID_BASE]._ns_loaded))
|
||||
{
|
||||
if (match == NULL
|
||||
|| caller < match->l_map_start
|
||||
@ -183,7 +183,7 @@ RTLD_NEXT used in code not dynamically loaded"));
|
||||
value = DL_SYMBOL_ADDRESS (result, ref);
|
||||
|
||||
/* Resolve indirect function address. */
|
||||
if (__builtin_expect (ELFW(ST_TYPE) (ref->st_info) == STT_GNU_IFUNC, 0))
|
||||
if (__glibc_unlikely (ELFW(ST_TYPE) (ref->st_info) == STT_GNU_IFUNC))
|
||||
{
|
||||
DL_FIXUP_VALUE_TYPE fixup
|
||||
= DL_FIXUP_MAKE_VALUE (result, (ElfW(Addr)) value);
|
||||
@ -195,7 +195,7 @@ RTLD_NEXT used in code not dynamically loaded"));
|
||||
/* Auditing checkpoint: we have a new binding. Provide the
|
||||
auditing libraries the possibility to change the value and
|
||||
tell us whether further auditing is wanted. */
|
||||
if (__builtin_expect (GLRO(dl_naudit) > 0, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_naudit) > 0))
|
||||
{
|
||||
const char *strtab = (const char *) D_PTR (result,
|
||||
l_info[DT_STRTAB]);
|
||||
|
||||
16
elf/dl-tls.c
16
elf/dl-tls.c
@ -720,7 +720,7 @@ tls_get_addr_tail (GET_ADDR_ARGS, dtv_t *dtv, struct link_map *the_map)
|
||||
!= FORCED_DYNAMIC_TLS_OFFSET, 0))
|
||||
{
|
||||
__rtld_lock_lock_recursive (GL(dl_load_lock));
|
||||
if (__builtin_expect (the_map->l_tls_offset == NO_TLS_OFFSET, 1))
|
||||
if (__glibc_likely (the_map->l_tls_offset == NO_TLS_OFFSET))
|
||||
{
|
||||
the_map->l_tls_offset = FORCED_DYNAMIC_TLS_OFFSET;
|
||||
__rtld_lock_unlock_recursive (GL(dl_load_lock));
|
||||
@ -732,7 +732,7 @@ tls_get_addr_tail (GET_ADDR_ARGS, dtv_t *dtv, struct link_map *the_map)
|
||||
!= FORCED_DYNAMIC_TLS_OFFSET, 1))
|
||||
{
|
||||
void *p = dtv[GET_ADDR_MODULE].pointer.val;
|
||||
if (__builtin_expect (p == TLS_DTV_UNALLOCATED, 0))
|
||||
if (__glibc_unlikely (p == TLS_DTV_UNALLOCATED))
|
||||
goto again;
|
||||
|
||||
return (char *) p + GET_ADDR_OFFSET;
|
||||
@ -755,7 +755,7 @@ update_get_addr (GET_ADDR_ARGS)
|
||||
|
||||
void *p = dtv[GET_ADDR_MODULE].pointer.val;
|
||||
|
||||
if (__builtin_expect (p == TLS_DTV_UNALLOCATED, 0))
|
||||
if (__glibc_unlikely (p == TLS_DTV_UNALLOCATED))
|
||||
return tls_get_addr_tail (GET_ADDR_PARAM, dtv, the_map);
|
||||
|
||||
return (void *) p + GET_ADDR_OFFSET;
|
||||
@ -769,12 +769,12 @@ __tls_get_addr (GET_ADDR_ARGS)
|
||||
{
|
||||
dtv_t *dtv = THREAD_DTV ();
|
||||
|
||||
if (__builtin_expect (dtv[0].counter != GL(dl_tls_generation), 0))
|
||||
if (__glibc_unlikely (dtv[0].counter != GL(dl_tls_generation)))
|
||||
return update_get_addr (GET_ADDR_PARAM);
|
||||
|
||||
void *p = dtv[GET_ADDR_MODULE].pointer.val;
|
||||
|
||||
if (__builtin_expect (p == TLS_DTV_UNALLOCATED, 0))
|
||||
if (__glibc_unlikely (p == TLS_DTV_UNALLOCATED))
|
||||
return tls_get_addr_tail (GET_ADDR_PARAM, dtv, NULL);
|
||||
|
||||
return (char *) p + GET_ADDR_OFFSET;
|
||||
@ -787,12 +787,12 @@ __tls_get_addr (GET_ADDR_ARGS)
|
||||
void *
|
||||
_dl_tls_get_addr_soft (struct link_map *l)
|
||||
{
|
||||
if (__builtin_expect (l->l_tls_modid == 0, 0))
|
||||
if (__glibc_unlikely (l->l_tls_modid == 0))
|
||||
/* This module has no TLS segment. */
|
||||
return NULL;
|
||||
|
||||
dtv_t *dtv = THREAD_DTV ();
|
||||
if (__builtin_expect (dtv[0].counter != GL(dl_tls_generation), 0))
|
||||
if (__glibc_unlikely (dtv[0].counter != GL(dl_tls_generation)))
|
||||
{
|
||||
/* This thread's DTV is not completely current,
|
||||
but it might already cover this module. */
|
||||
@ -817,7 +817,7 @@ _dl_tls_get_addr_soft (struct link_map *l)
|
||||
}
|
||||
|
||||
void *data = dtv[l->l_tls_modid].pointer.val;
|
||||
if (__builtin_expect (data == TLS_DTV_UNALLOCATED, 0))
|
||||
if (__glibc_unlikely (data == TLS_DTV_UNALLOCATED))
|
||||
/* The DTV is current, but this thread has not yet needed
|
||||
to allocate this module's segment. */
|
||||
data = NULL;
|
||||
|
||||
@ -82,13 +82,13 @@ match_symbol (const char *name, Lmid_t ns, ElfW(Word) hash, const char *string,
|
||||
int result = 0;
|
||||
|
||||
/* Display information about what we are doing while debugging. */
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_VERSIONS, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_VERSIONS))
|
||||
_dl_debug_printf ("\
|
||||
checking for version `%s' in file %s [%lu] required by file %s [%lu]\n",
|
||||
string, DSO_FILENAME (map->l_name),
|
||||
map->l_ns, name, ns);
|
||||
|
||||
if (__builtin_expect (map->l_info[VERSYMIDX (DT_VERDEF)] == NULL, 0))
|
||||
if (__glibc_unlikely (map->l_info[VERSYMIDX (DT_VERDEF)] == NULL))
|
||||
{
|
||||
/* The file has no symbol versioning. I.e., the dependent
|
||||
object was linked against another version of this file. We
|
||||
@ -145,7 +145,7 @@ no version information available (required by ", name, ")");
|
||||
}
|
||||
|
||||
/* Symbol not found. If it was a weak reference it is not fatal. */
|
||||
if (__builtin_expect (weak, 1))
|
||||
if (__glibc_likely (weak))
|
||||
{
|
||||
if (verbose)
|
||||
{
|
||||
@ -291,7 +291,7 @@ _dl_check_map_versions (struct link_map *map, int verbose, int trace_mode)
|
||||
section. */
|
||||
map->l_versions = (struct r_found_version *)
|
||||
calloc (ndx_high + 1, sizeof (*map->l_versions));
|
||||
if (__builtin_expect (map->l_versions == NULL, 0))
|
||||
if (__glibc_unlikely (map->l_versions == NULL))
|
||||
{
|
||||
errstring = N_("cannot allocate version reference table");
|
||||
errval = ENOMEM;
|
||||
@ -316,7 +316,7 @@ _dl_check_map_versions (struct link_map *map, int verbose, int trace_mode)
|
||||
{
|
||||
ElfW(Half) ndx = aux->vna_other & 0x7fff;
|
||||
/* In trace mode, dependencies may be missing. */
|
||||
if (__builtin_expect (ndx < map->l_nversions, 1))
|
||||
if (__glibc_likely (ndx < map->l_nversions))
|
||||
{
|
||||
map->l_versions[ndx].hash = aux->vna_hash;
|
||||
map->l_versions[ndx].hidden = aux->vna_other & 0x8000;
|
||||
|
||||
@ -42,7 +42,7 @@ _dl_writev (int fd, const struct iovec *iov, size_t niov)
|
||||
errno when it's being used by another thread that cares about it.
|
||||
Yet we must be sure not to try calling the lock functions before
|
||||
the thread library is fully initialized. */
|
||||
if (__builtin_expect (INTUSE (_dl_starting_up), 0))
|
||||
if (__glibc_unlikely (INTUSE (_dl_starting_up)))
|
||||
__writev (fd, iov, niov);
|
||||
else
|
||||
{
|
||||
|
||||
@ -770,7 +770,7 @@ search_dir (const struct dir_entry *entry)
|
||||
lstat_buf.st_mode = DTTOIF (direntry->d_type);
|
||||
else
|
||||
#endif
|
||||
if (__builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))
|
||||
if (__glibc_unlikely (lstat64 (real_file_name, &lstat_buf)))
|
||||
{
|
||||
error (0, errno, _("Cannot lstat %s"), file_name);
|
||||
continue;
|
||||
@ -794,7 +794,7 @@ search_dir (const struct dir_entry *entry)
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (__builtin_expect (stat64 (target_name, &stat_buf), 0))
|
||||
if (__glibc_unlikely (stat64 (target_name, &stat_buf)))
|
||||
{
|
||||
if (opt_verbose)
|
||||
error (0, errno, _("Cannot stat %s"), file_name);
|
||||
|
||||
40
elf/rtld.c
40
elf/rtld.c
@ -344,7 +344,7 @@ _dl_start_final (void *arg, struct dl_start_final_info *info)
|
||||
}
|
||||
#endif
|
||||
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_STATISTICS, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_STATISTICS))
|
||||
{
|
||||
#ifndef HP_TIMING_NONAVAIL
|
||||
print_statistics (&rtld_total_time);
|
||||
@ -517,7 +517,7 @@ _dl_start (void *arg)
|
||||
# else
|
||||
# error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
|
||||
# endif
|
||||
if (__builtin_expect (lossage != NULL, 0))
|
||||
if (__glibc_unlikely (lossage != NULL))
|
||||
_dl_fatal_printf ("cannot set up thread-local storage: %s\n",
|
||||
lossage);
|
||||
|
||||
@ -779,7 +779,7 @@ cannot allocate TLS data structures for initial thread");
|
||||
#else
|
||||
= TLS_INIT_TP (tcbp, 0);
|
||||
#endif
|
||||
if (__builtin_expect (lossage != NULL, 0))
|
||||
if (__glibc_unlikely (lossage != NULL))
|
||||
_dl_fatal_printf ("cannot set up thread-local storage: %s\n", lossage);
|
||||
tls_init_tp_called = true;
|
||||
|
||||
@ -813,7 +813,7 @@ do_preload (char *fname, struct link_map *main_map, const char *where)
|
||||
unsigned int old_nloaded = GL(dl_ns)[LM_ID_BASE]._ns_nloaded;
|
||||
|
||||
(void) _dl_catch_error (&objname, &err_str, &malloced, map_doit, &args);
|
||||
if (__builtin_expect (err_str != NULL, 0))
|
||||
if (__glibc_unlikely (err_str != NULL))
|
||||
{
|
||||
_dl_error_printf ("\
|
||||
ERROR: ld.so: object '%s' from %s cannot be preloaded (%s): ignored.\n",
|
||||
@ -1067,7 +1067,7 @@ of this helper program; chances are you did not intend to run this program.\n\
|
||||
args.mode = __RTLD_OPENEXEC;
|
||||
(void) _dl_catch_error (&objname, &err_str, &malloced, map_doit,
|
||||
&args);
|
||||
if (__builtin_expect (err_str != NULL, 0))
|
||||
if (__glibc_unlikely (err_str != NULL))
|
||||
/* We don't free the returned string, the programs stops
|
||||
anyway. */
|
||||
_exit (EXIT_FAILURE);
|
||||
@ -1394,7 +1394,7 @@ of this helper program; chances are you did not intend to run this program.\n\
|
||||
GL(dl_rtld_map).l_tls_modid = _dl_next_tls_modid ();
|
||||
|
||||
/* If we have auditing DSOs to load, do it now. */
|
||||
if (__builtin_expect (audit_list != NULL, 0))
|
||||
if (__glibc_unlikely (audit_list != NULL))
|
||||
{
|
||||
/* Iterate over all entries in the list. The order is important. */
|
||||
struct audit_ifaces *last_audit = NULL;
|
||||
@ -1428,7 +1428,7 @@ of this helper program; chances are you did not intend to run this program.\n\
|
||||
bool malloced;
|
||||
(void) _dl_catch_error (&objname, &err_str, &malloced, dlmopen_doit,
|
||||
&dlmargs);
|
||||
if (__builtin_expect (err_str != NULL, 0))
|
||||
if (__glibc_unlikely (err_str != NULL))
|
||||
{
|
||||
not_loaded:
|
||||
_dl_error_printf ("\
|
||||
@ -1544,7 +1544,7 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
|
||||
|
||||
/* If we have any auditing modules, announce that we already
|
||||
have two objects loaded. */
|
||||
if (__builtin_expect (GLRO(dl_naudit) > 0, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_naudit) > 0))
|
||||
{
|
||||
struct link_map *ls[2] = { main_map, &GL(dl_rtld_map) };
|
||||
|
||||
@ -1593,7 +1593,7 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
|
||||
|
||||
/* Auditing checkpoint: we are ready to signal that the initial map
|
||||
is being constructed. */
|
||||
if (__builtin_expect (GLRO(dl_naudit) > 0, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_naudit) > 0))
|
||||
{
|
||||
struct audit_ifaces *afct = GLRO(dl_audit);
|
||||
for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
|
||||
@ -1612,7 +1612,7 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
|
||||
struct link_map **preloads = NULL;
|
||||
unsigned int npreloads = 0;
|
||||
|
||||
if (__builtin_expect (preloadlist != NULL, 0))
|
||||
if (__glibc_unlikely (preloadlist != NULL))
|
||||
{
|
||||
/* The LD_PRELOAD environment variable gives list of libraries
|
||||
separated by white space or colons that are loaded before the
|
||||
@ -1643,12 +1643,12 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
|
||||
the work but this does not matter, since it is not for production
|
||||
use. */
|
||||
static const char preload_file[] = "/etc/ld.so.preload";
|
||||
if (__builtin_expect (__access (preload_file, R_OK) == 0, 0))
|
||||
if (__glibc_unlikely (__access (preload_file, R_OK) == 0))
|
||||
{
|
||||
/* Read the contents of the file. */
|
||||
file = _dl_sysdep_read_whole_file (preload_file, &file_size,
|
||||
PROT_READ | PROT_WRITE);
|
||||
if (__builtin_expect (file != MAP_FAILED, 0))
|
||||
if (__glibc_unlikely (file != MAP_FAILED))
|
||||
{
|
||||
/* Parse the file. It contains names of libraries to be loaded,
|
||||
separated by white spaces or `:'. It may also contain
|
||||
@ -1720,7 +1720,7 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
|
||||
}
|
||||
}
|
||||
|
||||
if (__builtin_expect (*first_preload != NULL, 0))
|
||||
if (__glibc_unlikely (*first_preload != NULL))
|
||||
{
|
||||
/* Set up PRELOADS with a vector of the preloaded libraries. */
|
||||
struct link_map *l = *first_preload;
|
||||
@ -1757,7 +1757,7 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
|
||||
break;
|
||||
|
||||
bool rtld_multiple_ref = false;
|
||||
if (__builtin_expect (i < main_map->l_searchlist.r_nlist, 1))
|
||||
if (__glibc_likely (i < main_map->l_searchlist.r_nlist))
|
||||
{
|
||||
/* Some DT_NEEDED entry referred to the interpreter object itself, so
|
||||
put it back in the list of visible objects. We insert it into the
|
||||
@ -1815,7 +1815,7 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
|
||||
if (tcbp == NULL)
|
||||
tcbp = init_tls ();
|
||||
|
||||
if (__builtin_expect (audit_list == NULL, 1))
|
||||
if (__glibc_likely (audit_list == NULL))
|
||||
/* Initialize security features. But only if we have not done it
|
||||
earlier. */
|
||||
security_init ();
|
||||
@ -2099,7 +2099,7 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
|
||||
if (r_list == r_listend && liblist == liblistend)
|
||||
prelinked = true;
|
||||
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_LIBS, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_LIBS))
|
||||
_dl_debug_printf ("\nprelink checking: %s\n",
|
||||
prelinked ? "ok" : "failed");
|
||||
}
|
||||
@ -2117,7 +2117,7 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
|
||||
GLRO(dl_init_all_dirs) = GL(dl_all_dirs);
|
||||
|
||||
/* Print scope information. */
|
||||
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_SCOPES))
|
||||
{
|
||||
_dl_debug_printf ("\nInitial object scopes\n");
|
||||
|
||||
@ -2215,7 +2215,7 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
|
||||
this has to go here because the calls it makes should use the
|
||||
rtld versions of the functions (particularly calloc()), but it
|
||||
needs to have _dl_profile_map set up by the relocator. */
|
||||
if (__builtin_expect (GL(dl_profile_map) != NULL, 0))
|
||||
if (__glibc_unlikely (GL(dl_profile_map) != NULL))
|
||||
/* We must prepare the profiling. */
|
||||
_dl_start_profile ();
|
||||
}
|
||||
@ -2238,7 +2238,7 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
|
||||
#else
|
||||
= TLS_INIT_TP (tcbp, 0);
|
||||
#endif
|
||||
if (__builtin_expect (lossage != NULL, 0))
|
||||
if (__glibc_unlikely (lossage != NULL))
|
||||
_dl_fatal_printf ("cannot set up thread-local storage: %s\n",
|
||||
lossage);
|
||||
}
|
||||
@ -2279,7 +2279,7 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
|
||||
|
||||
#ifdef SHARED
|
||||
/* Auditing checkpoint: we have added all objects. */
|
||||
if (__builtin_expect (GLRO(dl_naudit) > 0, 0))
|
||||
if (__glibc_unlikely (GLRO(dl_naudit) > 0))
|
||||
{
|
||||
struct link_map *head = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
|
||||
/* Do not call the functions for any auditing object. */
|
||||
|
||||
@ -31,7 +31,7 @@ setup_vdso (struct link_map *main_map __attribute__ ((unused)),
|
||||
mapped and relocated it normally. */
|
||||
struct link_map *l = _dl_new_object ((char *) "", "", lt_library, NULL,
|
||||
0, LM_ID_BASE);
|
||||
if (__builtin_expect (l != NULL, 1))
|
||||
if (__glibc_likely (l != NULL))
|
||||
{
|
||||
static ElfW(Dyn) dyn_temp[DL_RO_DYN_TEMP_CNT] attribute_relro;
|
||||
|
||||
|
||||
@ -82,7 +82,7 @@ compat_call (service_user *nip, const char *user, gid_t group, long int *start,
|
||||
{
|
||||
/* Matches user and not yet on the list. Insert
|
||||
this group. */
|
||||
if (__builtin_expect (*start == *size, 0))
|
||||
if (__glibc_unlikely (*start == *size))
|
||||
{
|
||||
/* Need a bigger buffer. */
|
||||
gid_t *newgroups;
|
||||
|
||||
@ -57,7 +57,7 @@ fgetgrent (FILE *stream)
|
||||
char *new_buf;
|
||||
buffer_size += NSS_BUFLEN_GROUP;
|
||||
new_buf = realloc (buffer, buffer_size);
|
||||
if (__builtin_expect (new_buf == NULL, 0))
|
||||
if (__glibc_unlikely (new_buf == NULL))
|
||||
{
|
||||
/* We are out of memory. Free the current buffer so that the
|
||||
process gets a chance for a normal termination. */
|
||||
|
||||
@ -159,7 +159,7 @@ getgrouplist (const char *user, gid_t group, gid_t *groups, int *ngroups)
|
||||
long int size = MAX (1, *ngroups);
|
||||
|
||||
gid_t *newgroups = (gid_t *) malloc (size * sizeof (gid_t));
|
||||
if (__builtin_expect (newgroups == NULL, 0))
|
||||
if (__glibc_unlikely (newgroups == NULL))
|
||||
/* No more memory. */
|
||||
// XXX This is wrong. The user provided memory, we have to use
|
||||
// XXX it. The internal functions must be called with the user
|
||||
@ -212,7 +212,7 @@ initgroups (const char *user, gid_t group)
|
||||
size = 16;
|
||||
|
||||
groups = (gid_t *) malloc (size * sizeof (gid_t));
|
||||
if (__builtin_expect (groups == NULL, 0))
|
||||
if (__glibc_unlikely (groups == NULL))
|
||||
/* No more memory. */
|
||||
return -1;
|
||||
|
||||
|
||||
@ -33,7 +33,7 @@ putgrent (gr, stream)
|
||||
{
|
||||
int retval;
|
||||
|
||||
if (__builtin_expect (gr == NULL, 0) || __builtin_expect (stream == NULL, 0))
|
||||
if (__glibc_unlikely (gr == NULL) || __glibc_unlikely (stream == NULL))
|
||||
{
|
||||
__set_errno (EINVAL);
|
||||
return -1;
|
||||
|
||||
@ -227,7 +227,7 @@ _nss_hesiod_initgroups_dyn (const char *user, gid_t group, long int *start,
|
||||
if (status == NSS_STATUS_SUCCESS
|
||||
&& !internal_gid_in_list (groups, group, *start))
|
||||
{
|
||||
if (__builtin_expect (*start == *size, 0))
|
||||
if (__glibc_unlikely (*start == *size))
|
||||
{
|
||||
/* Need a bigger buffer. */
|
||||
gid_t *newgroups;
|
||||
|
||||
@ -38,7 +38,7 @@ int __libc_argc;
|
||||
error_t
|
||||
_hurd_ports_use (int which, error_t (*operate) (mach_port_t))
|
||||
{
|
||||
if (__builtin_expect (_hurd_ports == NULL, 0))
|
||||
if (__glibc_unlikely (_hurd_ports == NULL))
|
||||
/* This means that _hurd_init has not been called yet, which is
|
||||
normally only the case in the bootstrap filesystem, and there
|
||||
only in the early phases of booting. */
|
||||
|
||||
@ -79,7 +79,7 @@ __gconv_load_cache (void)
|
||||
cache_size = st.st_size;
|
||||
#ifdef _POSIX_MAPPED_FILES
|
||||
gconv_cache = __mmap (NULL, cache_size, PROT_READ, MAP_SHARED, fd, 0);
|
||||
if (__builtin_expect (gconv_cache == MAP_FAILED, 0))
|
||||
if (__glibc_unlikely (gconv_cache == MAP_FAILED))
|
||||
#endif
|
||||
{
|
||||
size_t already_read;
|
||||
|
||||
@ -45,7 +45,7 @@ __gconv_close (__gconv_t cd)
|
||||
struct __gconv_trans_data *curp = transp;
|
||||
transp = transp->__next;
|
||||
|
||||
if (__builtin_expect (curp->__trans_end_fct != NULL, 0))
|
||||
if (__glibc_unlikely (curp->__trans_end_fct != NULL))
|
||||
curp->__trans_end_fct (curp->__data);
|
||||
|
||||
free (curp);
|
||||
|
||||
@ -45,7 +45,7 @@ __gconv_open (const char *toset, const char *fromset, __gconv_t *handle,
|
||||
errhand = strchr (toset, '/');
|
||||
if (errhand != NULL)
|
||||
errhand = strchr (errhand + 1, '/');
|
||||
if (__builtin_expect (errhand != NULL, 1))
|
||||
if (__glibc_likely (errhand != NULL))
|
||||
{
|
||||
if (*++errhand == '\0')
|
||||
errhand = NULL;
|
||||
@ -318,7 +318,7 @@ __gconv_open (const char *toset, const char *fromset, __gconv_t *handle,
|
||||
struct __gconv_trans_data *curp = transp;
|
||||
transp = transp->__next;
|
||||
|
||||
if (__builtin_expect (curp->__trans_end_fct != NULL, 0))
|
||||
if (__glibc_unlikely (curp->__trans_end_fct != NULL))
|
||||
curp->__trans_end_fct (curp->__data);
|
||||
|
||||
free (curp);
|
||||
|
||||
@ -177,7 +177,7 @@ internal_ucs4_loop_single (struct __gconv_step *step,
|
||||
while (*inptrp < inend && cnt < 4)
|
||||
state->__value.__wchb[cnt++] = *(*inptrp)++;
|
||||
|
||||
if (__builtin_expect (cnt < 4, 0))
|
||||
if (__glibc_unlikely (cnt < 4))
|
||||
{
|
||||
/* Still not enough bytes. Store the ones in the input buffer. */
|
||||
state->__count &= ~7;
|
||||
@ -249,7 +249,7 @@ ucs4_internal_loop (struct __gconv_step *step,
|
||||
inval = *(const uint32_t *) inptr;
|
||||
#endif
|
||||
|
||||
if (__builtin_expect (inval > 0x7fffffff, 0))
|
||||
if (__glibc_unlikely (inval > 0x7fffffff))
|
||||
{
|
||||
/* The value is too large. We don't try transliteration here since
|
||||
this is not an error because of the lack of possibilities to
|
||||
@ -308,7 +308,7 @@ ucs4_internal_loop_unaligned (struct __gconv_step *step,
|
||||
|
||||
for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
|
||||
{
|
||||
if (__builtin_expect (inptr[0] > 0x80, 0))
|
||||
if (__glibc_unlikely (inptr[0] > 0x80))
|
||||
{
|
||||
/* The value is too large. We don't try transliteration here since
|
||||
this is not an error because of the lack of possibilities to
|
||||
@ -376,7 +376,7 @@ ucs4_internal_loop_single (struct __gconv_step *step,
|
||||
while (*inptrp < inend && cnt < 4)
|
||||
state->__value.__wchb[cnt++] = *(*inptrp)++;
|
||||
|
||||
if (__builtin_expect (cnt < 4, 0))
|
||||
if (__glibc_unlikely (cnt < 4))
|
||||
{
|
||||
/* Still not enough bytes. Store the ones in the input buffer. */
|
||||
state->__count &= ~7;
|
||||
@ -546,7 +546,7 @@ internal_ucs4le_loop_single (struct __gconv_step *step,
|
||||
while (*inptrp < inend && cnt < 4)
|
||||
state->__value.__wchb[cnt++] = *(*inptrp)++;
|
||||
|
||||
if (__builtin_expect (cnt < 4, 0))
|
||||
if (__glibc_unlikely (cnt < 4))
|
||||
{
|
||||
/* Still not enough bytes. Store the ones in the input buffer. */
|
||||
state->__count &= ~7;
|
||||
@ -617,7 +617,7 @@ ucs4le_internal_loop (struct __gconv_step *step,
|
||||
inval = *(const uint32_t *) inptr;
|
||||
#endif
|
||||
|
||||
if (__builtin_expect (inval > 0x7fffffff, 0))
|
||||
if (__glibc_unlikely (inval > 0x7fffffff))
|
||||
{
|
||||
/* The value is too large. We don't try transliteration here since
|
||||
this is not an error because of the lack of possibilities to
|
||||
@ -677,7 +677,7 @@ ucs4le_internal_loop_unaligned (struct __gconv_step *step,
|
||||
|
||||
for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
|
||||
{
|
||||
if (__builtin_expect (inptr[3] > 0x80, 0))
|
||||
if (__glibc_unlikely (inptr[3] > 0x80))
|
||||
{
|
||||
/* The value is too large. We don't try transliteration here since
|
||||
this is not an error because of the lack of possibilities to
|
||||
@ -749,7 +749,7 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
||||
while (*inptrp < inend && cnt < 4)
|
||||
state->__value.__wchb[cnt++] = *(*inptrp)++;
|
||||
|
||||
if (__builtin_expect (cnt < 4, 0))
|
||||
if (__glibc_unlikely (cnt < 4))
|
||||
{
|
||||
/* Still not enough bytes. Store the ones in the input buffer. */
|
||||
state->__count &= ~7;
|
||||
@ -810,7 +810,7 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
||||
#define LOOPFCT FROM_LOOP
|
||||
#define BODY \
|
||||
{ \
|
||||
if (__builtin_expect (*inptr > '\x7f', 0)) \
|
||||
if (__glibc_unlikely (*inptr > '\x7f')) \
|
||||
{ \
|
||||
/* The value is too large. We don't try transliteration here since \
|
||||
this is not an error because of the lack of possibilities to \
|
||||
@ -846,7 +846,7 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
||||
#define LOOPFCT FROM_LOOP
|
||||
#define BODY \
|
||||
{ \
|
||||
if (__builtin_expect (*((const uint32_t *) inptr) > 0x7f, 0)) \
|
||||
if (__glibc_unlikely (*((const uint32_t *) inptr) > 0x7f)) \
|
||||
{ \
|
||||
UNICODE_TAG_HANDLER (*((const uint32_t *) inptr), 4); \
|
||||
STANDARD_TO_LOOP_ERR_HANDLER (4); \
|
||||
@ -883,10 +883,10 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
||||
{ \
|
||||
uint32_t wc = *((const uint32_t *) inptr); \
|
||||
\
|
||||
if (__builtin_expect (wc < 0x80, 1)) \
|
||||
if (__glibc_likely (wc < 0x80)) \
|
||||
/* It's an one byte sequence. */ \
|
||||
*outptr++ = (unsigned char) wc; \
|
||||
else if (__builtin_expect (wc <= 0x7fffffff, 1)) \
|
||||
else if (__glibc_likely (wc <= 0x7fffffff)) \
|
||||
{ \
|
||||
size_t step; \
|
||||
unsigned char *start; \
|
||||
@ -895,7 +895,7 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
||||
if ((wc & (~(uint32_t)0 << (5 * step + 1))) == 0) \
|
||||
break; \
|
||||
\
|
||||
if (__builtin_expect (outptr + step > outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + step > outend)) \
|
||||
{ \
|
||||
/* Too long. */ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
@ -946,7 +946,7 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
||||
/* Next input byte. */ \
|
||||
uint32_t ch = *inptr; \
|
||||
\
|
||||
if (__builtin_expect (ch < 0x80, 1)) \
|
||||
if (__glibc_likely (ch < 0x80)) \
|
||||
{ \
|
||||
/* One byte sequence. */ \
|
||||
++inptr; \
|
||||
@ -964,25 +964,25 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
||||
cnt = 2; \
|
||||
ch &= 0x1f; \
|
||||
} \
|
||||
else if (__builtin_expect ((ch & 0xf0) == 0xe0, 1)) \
|
||||
else if (__glibc_likely ((ch & 0xf0) == 0xe0)) \
|
||||
{ \
|
||||
/* We expect three bytes. */ \
|
||||
cnt = 3; \
|
||||
ch &= 0x0f; \
|
||||
} \
|
||||
else if (__builtin_expect ((ch & 0xf8) == 0xf0, 1)) \
|
||||
else if (__glibc_likely ((ch & 0xf8) == 0xf0)) \
|
||||
{ \
|
||||
/* We expect four bytes. */ \
|
||||
cnt = 4; \
|
||||
ch &= 0x07; \
|
||||
} \
|
||||
else if (__builtin_expect ((ch & 0xfc) == 0xf8, 1)) \
|
||||
else if (__glibc_likely ((ch & 0xfc) == 0xf8)) \
|
||||
{ \
|
||||
/* We expect five bytes. */ \
|
||||
cnt = 5; \
|
||||
ch &= 0x03; \
|
||||
} \
|
||||
else if (__builtin_expect ((ch & 0xfe) == 0xfc, 1)) \
|
||||
else if (__glibc_likely ((ch & 0xfe) == 0xfc)) \
|
||||
{ \
|
||||
/* We expect six bytes. */ \
|
||||
cnt = 6; \
|
||||
@ -1003,7 +1003,7 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
||||
STANDARD_FROM_LOOP_ERR_HANDLER (i); \
|
||||
} \
|
||||
\
|
||||
if (__builtin_expect (inptr + cnt > inend, 0)) \
|
||||
if (__glibc_unlikely (inptr + cnt > inend)) \
|
||||
{ \
|
||||
/* We don't have enough input. But before we report that check \
|
||||
that all the bytes are correct. */ \
|
||||
@ -1011,7 +1011,7 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
||||
if ((inptr[i] & 0xc0) != 0x80) \
|
||||
break; \
|
||||
\
|
||||
if (__builtin_expect (inptr + i == inend, 1)) \
|
||||
if (__glibc_likely (inptr + i == inend)) \
|
||||
{ \
|
||||
result = __GCONV_INCOMPLETE_INPUT; \
|
||||
break; \
|
||||
@ -1073,19 +1073,19 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
||||
cnt = 2; \
|
||||
ch &= 0x1f; \
|
||||
} \
|
||||
else if (__builtin_expect ((ch & 0xf0) == 0xe0, 1)) \
|
||||
else if (__glibc_likely ((ch & 0xf0) == 0xe0)) \
|
||||
{ \
|
||||
/* We expect three bytes. */ \
|
||||
cnt = 3; \
|
||||
ch &= 0x0f; \
|
||||
} \
|
||||
else if (__builtin_expect ((ch & 0xf8) == 0xf0, 1)) \
|
||||
else if (__glibc_likely ((ch & 0xf8) == 0xf0)) \
|
||||
{ \
|
||||
/* We expect four bytes. */ \
|
||||
cnt = 4; \
|
||||
ch &= 0x07; \
|
||||
} \
|
||||
else if (__builtin_expect ((ch & 0xfc) == 0xf8, 1)) \
|
||||
else if (__glibc_likely ((ch & 0xfc) == 0xf8)) \
|
||||
{ \
|
||||
/* We expect five bytes. */ \
|
||||
cnt = 5; \
|
||||
@ -1164,7 +1164,7 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
||||
{ \
|
||||
uint16_t u1 = get16 (inptr); \
|
||||
\
|
||||
if (__builtin_expect (u1 >= 0xd800 && u1 < 0xe000, 0)) \
|
||||
if (__glibc_unlikely (u1 >= 0xd800 && u1 < 0xe000)) \
|
||||
{ \
|
||||
/* Surrogate characters in UCS-2 input are not valid. Reject \
|
||||
them. (Catching this here is not security relevant.) */ \
|
||||
@ -1198,12 +1198,12 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
||||
{ \
|
||||
uint32_t val = *((const uint32_t *) inptr); \
|
||||
\
|
||||
if (__builtin_expect (val >= 0x10000, 0)) \
|
||||
if (__glibc_unlikely (val >= 0x10000)) \
|
||||
{ \
|
||||
UNICODE_TAG_HANDLER (val, 4); \
|
||||
STANDARD_TO_LOOP_ERR_HANDLER (4); \
|
||||
} \
|
||||
else if (__builtin_expect (val >= 0xd800 && val < 0xe000, 0)) \
|
||||
else if (__glibc_unlikely (val >= 0xd800 && val < 0xe000)) \
|
||||
{ \
|
||||
/* Surrogate characters in UCS-4 input are not valid. \
|
||||
We must catch this, because the UCS-2 output might be \
|
||||
@ -1248,7 +1248,7 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
||||
{ \
|
||||
uint16_t u1 = bswap_16 (get16 (inptr)); \
|
||||
\
|
||||
if (__builtin_expect (u1 >= 0xd800 && u1 < 0xe000, 0)) \
|
||||
if (__glibc_unlikely (u1 >= 0xd800 && u1 < 0xe000)) \
|
||||
{ \
|
||||
/* Surrogate characters in UCS-2 input are not valid. Reject \
|
||||
them. (Catching this here is not security relevant.) */ \
|
||||
@ -1288,12 +1288,12 @@ ucs4le_internal_loop_single (struct __gconv_step *step,
|
||||
#define BODY \
|
||||
{ \
|
||||
uint32_t val = *((const uint32_t *) inptr); \
|
||||
if (__builtin_expect (val >= 0x10000, 0)) \
|
||||
if (__glibc_unlikely (val >= 0x10000)) \
|
||||
{ \
|
||||
UNICODE_TAG_HANDLER (val, 4); \
|
||||
STANDARD_TO_LOOP_ERR_HANDLER (4); \
|
||||
} \
|
||||
else if (__builtin_expect (val >= 0xd800 && val < 0xe000, 0)) \
|
||||
else if (__glibc_unlikely (val >= 0xd800 && val < 0xe000)) \
|
||||
{ \
|
||||
/* Surrogate characters in UCS-4 input are not valid. \
|
||||
We must catch this, because the UCS-2 output might be \
|
||||
|
||||
@ -36,7 +36,7 @@ iconv (iconv_t cd, char **inbuf, size_t *inbytesleft, char **outbuf,
|
||||
size_t irreversible;
|
||||
int result;
|
||||
|
||||
if (__builtin_expect (inbuf == NULL || *inbuf == NULL, 0))
|
||||
if (__glibc_unlikely (inbuf == NULL || *inbuf == NULL))
|
||||
{
|
||||
if (outbuf == NULL || *outbuf == NULL)
|
||||
result = __gconv (gcd, NULL, NULL, NULL, NULL, &irreversible);
|
||||
|
||||
@ -26,7 +26,7 @@
|
||||
int
|
||||
iconv_close (iconv_t cd)
|
||||
{
|
||||
if (__builtin_expect (cd == (iconv_t *) -1L, 0))
|
||||
if (__glibc_unlikely (cd == (iconv_t *) -1L))
|
||||
{
|
||||
__set_errno (EBADF);
|
||||
return -1;
|
||||
|
||||
@ -241,7 +241,7 @@
|
||||
/* If any of them recognized the input continue with the loop. */ \
|
||||
if (result != __GCONV_ILLEGAL_INPUT) \
|
||||
{ \
|
||||
if (__builtin_expect (result == __GCONV_FULL_OUTPUT, 0)) \
|
||||
if (__glibc_unlikely (result == __GCONV_FULL_OUTPUT)) \
|
||||
break; \
|
||||
\
|
||||
continue; \
|
||||
@ -442,7 +442,7 @@ SINGLE(LOOPFCT) (struct __gconv_step *step,
|
||||
bytes from the state and at least one more, or the character is still
|
||||
incomplete, or we have some other error (like illegal input character,
|
||||
no space in output buffer). */
|
||||
if (__builtin_expect (inptr != bytebuf, 1))
|
||||
if (__glibc_likely (inptr != bytebuf))
|
||||
{
|
||||
/* We found a new character. */
|
||||
assert (inptr - bytebuf > (state->__count & 7));
|
||||
|
||||
@ -410,7 +410,7 @@ FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
|
||||
/* If the function is called with no input this means we have to reset
|
||||
to the initial state. The possibly partly converted input is
|
||||
dropped. */
|
||||
if (__builtin_expect (do_flush, 0))
|
||||
if (__glibc_unlikely (do_flush))
|
||||
{
|
||||
/* This should never happen during error handling. */
|
||||
assert (outbufstart == NULL);
|
||||
@ -461,7 +461,7 @@ FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
|
||||
|
||||
if (result != __GCONV_EMPTY_INPUT)
|
||||
{
|
||||
if (__builtin_expect (outerr != outbuf, 0))
|
||||
if (__glibc_unlikely (outerr != outbuf))
|
||||
{
|
||||
/* We have a problem. Undo the conversion. */
|
||||
outbuf = outstart;
|
||||
@ -604,7 +604,7 @@ FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
|
||||
SAVE_RESET_STATE (1);
|
||||
#endif
|
||||
|
||||
if (__builtin_expect (!unaligned, 1))
|
||||
if (__glibc_likely (!unaligned))
|
||||
{
|
||||
if (FROM_DIRECTION)
|
||||
/* Run the conversion loop. */
|
||||
@ -635,7 +635,7 @@ FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
|
||||
|
||||
/* If we were called as part of an error handling module we
|
||||
don't do anything else here. */
|
||||
if (__builtin_expect (outbufstart != NULL, 0))
|
||||
if (__glibc_unlikely (outbufstart != NULL))
|
||||
{
|
||||
*outbufstart = outbuf;
|
||||
return status;
|
||||
@ -653,7 +653,7 @@ FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
|
||||
|
||||
/* If this is the last step leave the loop, there is nothing
|
||||
we can do. */
|
||||
if (__builtin_expect (data->__flags & __GCONV_IS_LAST, 0))
|
||||
if (__glibc_unlikely (data->__flags & __GCONV_IS_LAST))
|
||||
{
|
||||
/* Store information about how many bytes are available. */
|
||||
data->__outbuf = outbuf;
|
||||
@ -666,7 +666,7 @@ FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
|
||||
}
|
||||
|
||||
/* Write out all output which was produced. */
|
||||
if (__builtin_expect (outbuf > outstart, 1))
|
||||
if (__glibc_likely (outbuf > outstart))
|
||||
{
|
||||
const unsigned char *outerr = data->__outbuf;
|
||||
int result;
|
||||
@ -677,7 +677,7 @@ FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
|
||||
|
||||
if (result != __GCONV_EMPTY_INPUT)
|
||||
{
|
||||
if (__builtin_expect (outerr != outbuf, 0))
|
||||
if (__glibc_unlikely (outerr != outbuf))
|
||||
{
|
||||
#ifdef RESET_INPUT_BUFFER
|
||||
RESET_INPUT_BUFFER;
|
||||
@ -695,7 +695,7 @@ FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
|
||||
SAVE_RESET_STATE (0);
|
||||
# endif
|
||||
|
||||
if (__builtin_expect (!unaligned, 1))
|
||||
if (__glibc_likely (!unaligned))
|
||||
{
|
||||
if (FROM_DIRECTION)
|
||||
/* Run the conversion loop. */
|
||||
@ -738,7 +738,7 @@ FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
|
||||
|
||||
/* If we haven't consumed a single byte decrement
|
||||
the invocation counter. */
|
||||
if (__builtin_expect (outbuf == outstart, 0))
|
||||
if (__glibc_unlikely (outbuf == outstart))
|
||||
--data->__invocation_counter;
|
||||
#endif /* reset input buffer */
|
||||
}
|
||||
|
||||
@ -88,7 +88,7 @@ struct gap
|
||||
uint32_t ch = get32 (inptr); \
|
||||
unsigned char res; \
|
||||
\
|
||||
if (__builtin_expect (ch >= 0xffff, 0)) \
|
||||
if (__glibc_unlikely (ch >= 0xffff)) \
|
||||
{ \
|
||||
UNICODE_TAG_HANDLER (ch, 4); \
|
||||
rp = NULL; \
|
||||
|
||||
@ -567,7 +567,7 @@ static const char from_ucs4[][2] =
|
||||
/* Now test for a possible second byte and write this if possible. */ \
|
||||
if (cp[1] != '\0') \
|
||||
{ \
|
||||
if (__builtin_expect (outptr >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr >= outend)) \
|
||||
{ \
|
||||
/* The result does not fit into the buffer. */ \
|
||||
--outptr; \
|
||||
|
||||
@ -8401,7 +8401,7 @@ static const char from_ucs4_tab15[][2] =
|
||||
uint32_t ch2; \
|
||||
int idx; \
|
||||
\
|
||||
if (__builtin_expect (inptr + 1 >= inend, 0)) \
|
||||
if (__glibc_unlikely (inptr + 1 >= inend)) \
|
||||
{ \
|
||||
/* The second character is not available. */ \
|
||||
result = __GCONV_INCOMPLETE_INPUT; \
|
||||
@ -8426,7 +8426,7 @@ static const char from_ucs4_tab15[][2] =
|
||||
ch = big5_to_ucs[idx]; \
|
||||
\
|
||||
/* Is this character defined? */ \
|
||||
if (__builtin_expect (ch == 0, 0)) \
|
||||
if (__glibc_unlikely (ch == 0)) \
|
||||
{ \
|
||||
/* This is an illegal character. */ \
|
||||
STANDARD_FROM_LOOP_ERR_HANDLER (2); \
|
||||
|
||||
@ -17774,7 +17774,7 @@ static struct
|
||||
{ \
|
||||
if (FROM_DIRECTION) \
|
||||
{ \
|
||||
if (__builtin_expect (outbuf + 4 <= outend, 1)) \
|
||||
if (__glibc_likely (outbuf + 4 <= outend)) \
|
||||
{ \
|
||||
/* Write out the last character. */ \
|
||||
*((uint32_t *) outbuf) = data->__statep->__count >> 3; \
|
||||
@ -17787,7 +17787,7 @@ static struct
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
if (__builtin_expect (outbuf + 2 <= outend, 1)) \
|
||||
if (__glibc_likely (outbuf + 2 <= outend)) \
|
||||
{ \
|
||||
/* Write out the last character. */ \
|
||||
uint32_t lasttwo = data->__statep->__count >> 3; \
|
||||
@ -17814,7 +17814,7 @@ static struct
|
||||
\
|
||||
/* Determine whether there is a buffered character pending. */ \
|
||||
ch = *statep >> 3; \
|
||||
if (__builtin_expect (ch == 0, 1)) \
|
||||
if (__glibc_likely (ch == 0)) \
|
||||
{ \
|
||||
/* No - so look at the next input byte. */ \
|
||||
ch = *inptr; \
|
||||
@ -17826,7 +17826,7 @@ static struct
|
||||
uint32_t ch2; \
|
||||
int idx; \
|
||||
\
|
||||
if (__builtin_expect (inptr + 1 >= inend, 0)) \
|
||||
if (__glibc_unlikely (inptr + 1 >= inend)) \
|
||||
{ \
|
||||
/* The second character is not available. */ \
|
||||
result = __GCONV_INCOMPLETE_INPUT; \
|
||||
@ -17887,7 +17887,7 @@ static struct
|
||||
\
|
||||
inptr += 2; \
|
||||
} \
|
||||
else if (__builtin_expect (ch == 0xff, 0)) \
|
||||
else if (__glibc_unlikely (ch == 0xff)) \
|
||||
{ \
|
||||
STANDARD_FROM_LOOP_ERR_HANDLER (1); \
|
||||
} \
|
||||
@ -17937,7 +17937,7 @@ static struct
|
||||
goto not_combining; \
|
||||
\
|
||||
/* Output the combined character. */ \
|
||||
if (__builtin_expect (outptr + 1 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 1 >= outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
@ -17950,7 +17950,7 @@ static struct
|
||||
\
|
||||
not_combining: \
|
||||
/* Output the buffered character. */ \
|
||||
if (__builtin_expect (outptr + 1 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 1 >= outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
@ -17992,7 +17992,7 @@ static struct
|
||||
else \
|
||||
{ \
|
||||
/* Check for possible combining character. */ \
|
||||
if (__builtin_expect (ch == 0xca || ch == 0xea, 0)) \
|
||||
if (__glibc_unlikely (ch == 0xca || ch == 0xea)) \
|
||||
{ \
|
||||
*statep = ((cp[0] << 8) | cp[1]) << 3; \
|
||||
inptr += 4; \
|
||||
@ -18009,7 +18009,7 @@ static struct
|
||||
} \
|
||||
\
|
||||
*outptr++ = cp[0]; \
|
||||
if (__builtin_expect (cp[1] != '\0', 1)) \
|
||||
if (__glibc_likely (cp[1] != '\0')) \
|
||||
*outptr++ = cp[1]; \
|
||||
} \
|
||||
} \
|
||||
|
||||
@ -65,7 +65,7 @@
|
||||
{ \
|
||||
if (FROM_DIRECTION) \
|
||||
{ \
|
||||
if (__builtin_expect (outbuf + 4 <= outend, 1)) \
|
||||
if (__glibc_likely (outbuf + 4 <= outend)) \
|
||||
{ \
|
||||
/* Write out the last character. */ \
|
||||
*((uint32_t *) outbuf) = data->__statep->__count >> 3; \
|
||||
@ -201,7 +201,7 @@ static const struct { unsigned int idx; unsigned int len; } comp_table[8] = {
|
||||
if (ch >= 0x80) \
|
||||
{ \
|
||||
ch = to_ucs4[ch - 0x80]; \
|
||||
if (__builtin_expect (ch == L'\0', 0)) \
|
||||
if (__glibc_unlikely (ch == L'\0')) \
|
||||
{ \
|
||||
/* This is an illegal character. */ \
|
||||
STANDARD_FROM_LOOP_ERR_HANDLER (1); \
|
||||
@ -463,7 +463,7 @@ static const struct {
|
||||
res = 0; \
|
||||
} \
|
||||
\
|
||||
if (__builtin_expect (res != 0, 1)) \
|
||||
if (__glibc_likely (res != 0)) \
|
||||
{ \
|
||||
*outptr++ = res; \
|
||||
inptr += 4; \
|
||||
@ -515,7 +515,7 @@ static const struct {
|
||||
if (decomp_table[i].comb2 < 0) \
|
||||
{ \
|
||||
/* See whether we have room for two bytes. */ \
|
||||
if (__builtin_expect (outptr + 1 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 1 >= outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
@ -527,7 +527,7 @@ static const struct {
|
||||
else \
|
||||
{ \
|
||||
/* See whether we have room for three bytes. */ \
|
||||
if (__builtin_expect (outptr + 2 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 2 >= outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
|
||||
@ -66,7 +66,7 @@
|
||||
{ \
|
||||
if (FROM_DIRECTION) \
|
||||
{ \
|
||||
if (__builtin_expect (outbuf + 4 <= outend, 1)) \
|
||||
if (__glibc_likely (outbuf + 4 <= outend)) \
|
||||
{ \
|
||||
/* Write out the last character. */ \
|
||||
*((uint32_t *) outbuf) = data->__statep->__count >> 3; \
|
||||
@ -375,7 +375,7 @@ static const struct
|
||||
if (ch >= 0x80) \
|
||||
{ \
|
||||
ch = to_ucs4[ch - 0x80]; \
|
||||
if (__builtin_expect (ch == L'\0', 0)) \
|
||||
if (__glibc_unlikely (ch == L'\0')) \
|
||||
{ \
|
||||
/* This is an illegal character. */ \
|
||||
STANDARD_FROM_LOOP_ERR_HANDLER (1); \
|
||||
@ -802,7 +802,7 @@ static const struct
|
||||
res = 0; \
|
||||
} \
|
||||
\
|
||||
if (__builtin_expect (res != 0, 1)) \
|
||||
if (__glibc_likely (res != 0)) \
|
||||
{ \
|
||||
*outptr++ = res; \
|
||||
inptr += 4; \
|
||||
@ -845,7 +845,7 @@ static const struct
|
||||
} \
|
||||
\
|
||||
/* See whether we have room for two bytes. */ \
|
||||
if (__builtin_expect (outptr + 1 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 1 >= outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
|
||||
@ -4574,7 +4574,7 @@ static const char from_ucs4_extra[229][2] =
|
||||
uint32_t ch2; \
|
||||
uint_fast32_t idx; \
|
||||
\
|
||||
if (__builtin_expect (inptr + 1 >= inend, 0)) \
|
||||
if (__glibc_unlikely (inptr + 1 >= inend)) \
|
||||
{ \
|
||||
/* The second character is not available. Store \
|
||||
the intermediate result. */ \
|
||||
@ -4704,7 +4704,7 @@ static const char from_ucs4_extra[229][2] =
|
||||
/* Now test for a possible second byte and write this if possible. */\
|
||||
if (cp[1] != '\0') \
|
||||
{ \
|
||||
if (__builtin_expect (outptr + 1 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 1 >= outend)) \
|
||||
{ \
|
||||
/* The result does not fit into the buffer. */ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
|
||||
@ -56,7 +56,7 @@
|
||||
next byte is also available. */ \
|
||||
const unsigned char *endp; \
|
||||
\
|
||||
if (__builtin_expect (inptr + 1 >= inend, 0)) \
|
||||
if (__glibc_unlikely (inptr + 1 >= inend)) \
|
||||
{ \
|
||||
/* The second character is not available. Store \
|
||||
the intermediate result. */ \
|
||||
@ -67,14 +67,14 @@
|
||||
ch = inptr[1]; \
|
||||
\
|
||||
/* All second bytes of a multibyte character must be >= 0xa1. */ \
|
||||
if (__builtin_expect (ch < 0xa1, 0)) \
|
||||
if (__glibc_unlikely (ch < 0xa1)) \
|
||||
STANDARD_FROM_LOOP_ERR_HANDLER (1); \
|
||||
\
|
||||
/* This is code set 1: GB 2312-80. */ \
|
||||
endp = inptr; \
|
||||
\
|
||||
ch = gb2312_to_ucs4 (&endp, 2, 0x80); \
|
||||
if (__builtin_expect (ch == __UNKNOWN_10646_CHAR, 0)) \
|
||||
if (__glibc_unlikely (ch == __UNKNOWN_10646_CHAR)) \
|
||||
{ \
|
||||
/* This is an illegal character. */ \
|
||||
STANDARD_FROM_LOOP_ERR_HANDLER (2); \
|
||||
|
||||
@ -79,7 +79,7 @@
|
||||
{ \
|
||||
if (FROM_DIRECTION) \
|
||||
{ \
|
||||
if (__builtin_expect (outbuf + 4 <= outend, 1)) \
|
||||
if (__glibc_likely (outbuf + 4 <= outend)) \
|
||||
{ \
|
||||
/* Write out the last character. */ \
|
||||
*((uint32_t *) outbuf) = data->__statep->__count >> 3; \
|
||||
@ -92,7 +92,7 @@
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
if (__builtin_expect (outbuf + 2 <= outend, 1)) \
|
||||
if (__glibc_likely (outbuf + 2 <= outend)) \
|
||||
{ \
|
||||
/* Write out the last character. */ \
|
||||
uint32_t lasttwo = data->__statep->__count >> 3; \
|
||||
@ -119,7 +119,7 @@
|
||||
\
|
||||
/* Determine whether there is a buffered character pending. */ \
|
||||
ch = *statep >> 3; \
|
||||
if (__builtin_expect (ch == 0, 1)) \
|
||||
if (__glibc_likely (ch == 0)) \
|
||||
{ \
|
||||
/* No - so look at the next input byte. */ \
|
||||
ch = *inptr; \
|
||||
@ -132,7 +132,7 @@
|
||||
/* Two or three byte character. */ \
|
||||
uint32_t ch2; \
|
||||
\
|
||||
if (__builtin_expect (inptr + 1 >= inend, 0)) \
|
||||
if (__glibc_unlikely (inptr + 1 >= inend)) \
|
||||
{ \
|
||||
/* The second byte is not available. */ \
|
||||
result = __GCONV_INCOMPLETE_INPUT; \
|
||||
@ -142,7 +142,7 @@
|
||||
ch2 = inptr[1]; \
|
||||
\
|
||||
/* The second byte must be >= 0xa1 and <= 0xfe. */ \
|
||||
if (__builtin_expect (ch2 < 0xa1 || ch2 > 0xfe, 0)) \
|
||||
if (__glibc_unlikely (ch2 < 0xa1 || ch2 > 0xfe)) \
|
||||
{ \
|
||||
/* This is an illegal character. */ \
|
||||
STANDARD_FROM_LOOP_ERR_HANDLER (1); \
|
||||
@ -151,7 +151,7 @@
|
||||
if (ch == 0x8e) \
|
||||
{ \
|
||||
/* Half-width katakana. */ \
|
||||
if (__builtin_expect (ch2 > 0xdf, 0)) \
|
||||
if (__glibc_unlikely (ch2 > 0xdf)) \
|
||||
STANDARD_FROM_LOOP_ERR_HANDLER (1); \
|
||||
\
|
||||
ch = ch2 + 0xfec0; \
|
||||
@ -166,7 +166,7 @@
|
||||
/* JISX 0213 plane 2. */ \
|
||||
uint32_t ch3; \
|
||||
\
|
||||
if (__builtin_expect (inptr + 2 >= inend, 0)) \
|
||||
if (__glibc_unlikely (inptr + 2 >= inend)) \
|
||||
{ \
|
||||
/* The third byte is not available. */ \
|
||||
result = __GCONV_INCOMPLETE_INPUT; \
|
||||
@ -323,7 +323,7 @@ static const struct
|
||||
if (len > 0) \
|
||||
{ \
|
||||
/* Output the combined character. */ \
|
||||
if (__builtin_expect (outptr + 1 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 1 >= outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
@ -338,7 +338,7 @@ static const struct
|
||||
\
|
||||
not_combining: \
|
||||
/* Output the buffered character. */ \
|
||||
if (__builtin_expect (outptr + 1 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 1 >= outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
@ -355,7 +355,7 @@ static const struct
|
||||
else if (ch >= 0xff61 && ch <= 0xff9f) \
|
||||
{ \
|
||||
/* Half-width katakana. */ \
|
||||
if (__builtin_expect (outptr + 1 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 1 >= outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
@ -389,7 +389,7 @@ static const struct
|
||||
if (jch & 0x8000) \
|
||||
{ \
|
||||
/* JISX 0213 plane 2. */ \
|
||||
if (__builtin_expect (outptr + 2 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 2 >= outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
@ -399,7 +399,7 @@ static const struct
|
||||
else \
|
||||
{ \
|
||||
/* JISX 0213 plane 1. */ \
|
||||
if (__builtin_expect (outptr + 1 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 1 >= outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
|
||||
@ -4673,7 +4673,7 @@ static const unsigned char from_ucs4_extra[229][2] =
|
||||
character is also available. */ \
|
||||
unsigned char ch2; \
|
||||
\
|
||||
if (__builtin_expect (inptr + 1 >= inend, 0)) \
|
||||
if (__glibc_unlikely (inptr + 1 >= inend)) \
|
||||
{ \
|
||||
/* The second character is not available. Store the \
|
||||
intermediate result. */ \
|
||||
@ -4684,7 +4684,7 @@ static const unsigned char from_ucs4_extra[229][2] =
|
||||
ch2 = (unsigned char)inptr[1]; \
|
||||
\
|
||||
/* All second bytes of a multibyte character must be >= 0xa1. */ \
|
||||
if (__builtin_expect (ch2 < 0xa1, 0)) \
|
||||
if (__glibc_unlikely (ch2 < 0xa1)) \
|
||||
{ \
|
||||
/* This is an illegal character. */ \
|
||||
if (! ignore_errors_p ()) \
|
||||
@ -4703,7 +4703,7 @@ static const unsigned char from_ucs4_extra[229][2] =
|
||||
/* This is code set 2: half-width katakana. */ \
|
||||
ch = jisx0201_to_ucs4 (ch2); \
|
||||
/*if (__builtin_expect (ch, 0) == __UNKNOWN_10646_CHAR)*/ \
|
||||
if (__builtin_expect (ch == __UNKNOWN_10646_CHAR, 0)) \
|
||||
if (__glibc_unlikely (ch == __UNKNOWN_10646_CHAR)) \
|
||||
{ \
|
||||
/* Illegal character. */ \
|
||||
if (! ignore_errors_p ()) \
|
||||
@ -4896,15 +4896,15 @@ static const unsigned char from_ucs4_extra[229][2] =
|
||||
/* Now test for a possible second byte and write this if possible. */\
|
||||
if (cp[1] != '\0') \
|
||||
{ \
|
||||
if (__builtin_expect (outptr + 1 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 1 >= outend)) \
|
||||
{ \
|
||||
/* The result does not fit into the buffer. */ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
} \
|
||||
if (__builtin_expect (cp[1] < 0x80, 0)) \
|
||||
if (__glibc_unlikely (cp[1] < 0x80)) \
|
||||
{ \
|
||||
if (__builtin_expect (outptr + 2 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 2 >= outend)) \
|
||||
{ \
|
||||
/* The result does not fit into the buffer. */ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
|
||||
@ -57,7 +57,7 @@
|
||||
byte is also available. */ \
|
||||
int ch2; \
|
||||
\
|
||||
if (__builtin_expect (inptr + 1 >= inend, 0)) \
|
||||
if (__glibc_unlikely (inptr + 1 >= inend)) \
|
||||
{ \
|
||||
/* The second byte is not available. Store the \
|
||||
intermediate result. */ \
|
||||
@ -68,7 +68,7 @@
|
||||
ch2 = inptr[1]; \
|
||||
\
|
||||
/* All second bytes of a multibyte character must be >= 0xa1. */ \
|
||||
if (__builtin_expect (ch2 < 0xa1, 0)) \
|
||||
if (__glibc_unlikely (ch2 < 0xa1)) \
|
||||
STANDARD_FROM_LOOP_ERR_HANDLER (1); \
|
||||
\
|
||||
if (ch == 0x8e) \
|
||||
@ -105,7 +105,7 @@
|
||||
result = __GCONV_INCOMPLETE_INPUT; \
|
||||
break; \
|
||||
} \
|
||||
if (__builtin_expect (ch == __UNKNOWN_10646_CHAR, 0)) \
|
||||
if (__glibc_unlikely (ch == __UNKNOWN_10646_CHAR)) \
|
||||
/* Illegal character. */ \
|
||||
STANDARD_FROM_LOOP_ERR_HANDLER (1); \
|
||||
\
|
||||
@ -151,7 +151,7 @@
|
||||
size_t found; \
|
||||
\
|
||||
/* See whether we have room for at least two characters. */ \
|
||||
if (__builtin_expect (outptr + 1 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 1 >= outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
|
||||
@ -93,13 +93,13 @@ euckr_from_ucs4 (uint32_t ch, unsigned char *cp)
|
||||
/* Two-byte character. First test whether the next byte \
|
||||
is also available. */ \
|
||||
ch = ksc5601_to_ucs4 (&inptr, inend - inptr, 0x80); \
|
||||
if (__builtin_expect (ch == 0, 0)) \
|
||||
if (__glibc_unlikely (ch == 0)) \
|
||||
{ \
|
||||
/* The second byte is not available. */ \
|
||||
result = __GCONV_INCOMPLETE_INPUT; \
|
||||
break; \
|
||||
} \
|
||||
if (__builtin_expect (ch == __UNKNOWN_10646_CHAR, 0)) \
|
||||
if (__glibc_unlikely (ch == __UNKNOWN_10646_CHAR)) \
|
||||
/* This is an illegal character. */ \
|
||||
STANDARD_FROM_LOOP_ERR_HANDLER (2); \
|
||||
} \
|
||||
@ -144,7 +144,7 @@ euckr_from_ucs4 (uint32_t ch, unsigned char *cp)
|
||||
/* Now test for a possible second byte and write this if possible. */ \
|
||||
if (cp[1] != '\0') \
|
||||
{ \
|
||||
if (__builtin_expect (outptr >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr >= outend)) \
|
||||
{ \
|
||||
/* The result does not fit into the buffer. */ \
|
||||
--outptr; \
|
||||
|
||||
@ -24212,7 +24212,7 @@ static const unsigned char __ucs_to_gb18030_tab2[][2] =
|
||||
\
|
||||
inptr += 4; \
|
||||
} \
|
||||
else if (__builtin_expect (ch2 >= 0x40, 1)) \
|
||||
else if (__glibc_likely (ch2 >= 0x40)) \
|
||||
{ \
|
||||
/* A two-byte character */ \
|
||||
idx = (ch - 0x81) * 192 + (ch2 - 0x40); \
|
||||
@ -24375,7 +24375,7 @@ static const unsigned char __ucs_to_gb18030_tab2[][2] =
|
||||
{ \
|
||||
/* See whether there is enough room for all four bytes we \
|
||||
write. */ \
|
||||
if (__builtin_expect (outptr + 3 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 3 >= outend)) \
|
||||
{ \
|
||||
/* We have not enough room. */ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
|
||||
@ -4805,7 +4805,7 @@ const char __from_big5_to_gb2312 [13973][2] =
|
||||
const char *cp; \
|
||||
int idx; \
|
||||
\
|
||||
if (__builtin_expect (inptr + 1 >= inend, 0)) \
|
||||
if (__glibc_unlikely (inptr + 1 >= inend)) \
|
||||
{ \
|
||||
/* The second character is not available. Store \
|
||||
the intermediate result. */ \
|
||||
@ -4817,7 +4817,7 @@ const char __from_big5_to_gb2312 [13973][2] =
|
||||
ch = inptr[1]; \
|
||||
\
|
||||
/* All second bytes of a multibyte character must be >= 0xa1. */ \
|
||||
if (__builtin_expect (ch < 0xa1, 0)) \
|
||||
if (__glibc_unlikely (ch < 0xa1)) \
|
||||
{ \
|
||||
/* This is an illegal character. */ \
|
||||
STANDARD_FROM_LOOP_ERR_HANDLER (1); \
|
||||
@ -4827,7 +4827,7 @@ const char __from_big5_to_gb2312 [13973][2] =
|
||||
\
|
||||
/* Get the value from the table. */ \
|
||||
cp = __from_gb2312_to_big5[idx]; \
|
||||
if (__builtin_expect (cp[0] == '\0', 0)) \
|
||||
if (__glibc_unlikely (cp[0] == '\0')) \
|
||||
{ \
|
||||
/* We do not have a mapping for this character. \
|
||||
If ignore errors, map it to 0xa1bc - big5 box character */ \
|
||||
@ -4836,7 +4836,7 @@ const char __from_big5_to_gb2312 [13973][2] =
|
||||
break; \
|
||||
\
|
||||
/* See if there is enough room to write the second byte. */ \
|
||||
if (__builtin_expect (outptr + 1 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 1 >= outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
@ -4894,7 +4894,7 @@ const char __from_big5_to_gb2312 [13973][2] =
|
||||
const char *cp; \
|
||||
int idx; \
|
||||
\
|
||||
if (__builtin_expect (inptr + 1 >= inend, 0)) \
|
||||
if (__glibc_unlikely (inptr + 1 >= inend)) \
|
||||
{ \
|
||||
/* The second character is not available. Store \
|
||||
the intermediate result. */ \
|
||||
@ -4918,7 +4918,7 @@ const char __from_big5_to_gb2312 [13973][2] =
|
||||
\
|
||||
/* Get the value from the table. */ \
|
||||
cp = __from_big5_to_gb2312 [idx]; \
|
||||
if (__builtin_expect (cp[0] == '\0', 0)) \
|
||||
if (__glibc_unlikely (cp[0] == '\0')) \
|
||||
{ \
|
||||
/* We do not have a mapping for this character. \
|
||||
If ignore errors, map it to 0xa1f5 - gb box character */ \
|
||||
@ -4927,7 +4927,7 @@ const char __from_big5_to_gb2312 [13973][2] =
|
||||
break; \
|
||||
\
|
||||
/* See if there is enough room to write the second byte. */ \
|
||||
if (__builtin_expect (outptr + 1 >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 1 >= outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
|
||||
@ -73,7 +73,7 @@
|
||||
UCS4 -> GB2312 -> GBK -> UCS4 \
|
||||
\
|
||||
might not produce identical text. */ \
|
||||
if (__builtin_expect (inptr + 1 >= inend, 0)) \
|
||||
if (__glibc_unlikely (inptr + 1 >= inend)) \
|
||||
{ \
|
||||
/* The second character is not available. Store \
|
||||
the intermediate result. */ \
|
||||
@ -81,7 +81,7 @@
|
||||
break; \
|
||||
} \
|
||||
\
|
||||
if (__builtin_expect (outend - outptr < 2, 0)) \
|
||||
if (__glibc_unlikely (outend - outptr < 2)) \
|
||||
{ \
|
||||
/* We ran out of space. */ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
@ -91,7 +91,7 @@
|
||||
ch = (ch << 8) | inptr[1]; \
|
||||
\
|
||||
/* Map 0xA844 (U2015 in GBK) to 0xA1AA (U2015 in GB2312). */ \
|
||||
if (__builtin_expect (ch == 0xa844, 0)) \
|
||||
if (__glibc_unlikely (ch == 0xa844)) \
|
||||
ch = 0xa1aa; \
|
||||
\
|
||||
/* Now determine whether the character is valid. */ \
|
||||
@ -134,7 +134,7 @@
|
||||
\
|
||||
if (ch > 0x7f) \
|
||||
{ \
|
||||
if (__builtin_expect (inptr + 1 >= inend, 0)) \
|
||||
if (__glibc_unlikely (inptr + 1 >= inend)) \
|
||||
{ \
|
||||
/* The second character is not available. Store \
|
||||
the intermediate result. */ \
|
||||
@ -142,7 +142,7 @@
|
||||
break; \
|
||||
} \
|
||||
\
|
||||
if (__builtin_expect (outend - outptr < 2, 0)) \
|
||||
if (__glibc_unlikely (outend - outptr < 2)) \
|
||||
{ \
|
||||
/* We ran out of space. */ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
|
||||
@ -13157,7 +13157,7 @@ static const char __gbk_from_ucs4_tab12[][2] =
|
||||
uint32_t ch2; \
|
||||
int idx; \
|
||||
\
|
||||
if (__builtin_expect (inptr + 1 >= inend, 0)) \
|
||||
if (__glibc_unlikely (inptr + 1 >= inend)) \
|
||||
{ \
|
||||
/* The second character is not available. Store \
|
||||
the intermediate result. */ \
|
||||
|
||||
@ -77,7 +77,7 @@
|
||||
{ \
|
||||
/* We are not in the initial state. To switch back we have \
|
||||
to emit `SI'. */ \
|
||||
if (__builtin_expect (outbuf >= outend, 0)) \
|
||||
if (__glibc_unlikely (outbuf >= outend)) \
|
||||
/* We don't have enough room in the output buffer. */ \
|
||||
status = __GCONV_FULL_OUTPUT; \
|
||||
else \
|
||||
@ -120,7 +120,7 @@ enum
|
||||
else \
|
||||
{ \
|
||||
/* This is a combined character. Make sure we have room. */ \
|
||||
if (__builtin_expect (outptr + 8 > outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 8 > outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
@ -204,7 +204,7 @@ enum
|
||||
{ \
|
||||
assert (curcs == db); \
|
||||
\
|
||||
if (__builtin_expect (inptr + 1 >= inend, 0)) \
|
||||
if (__glibc_unlikely (inptr + 1 >= inend)) \
|
||||
{ \
|
||||
/* The second character is not available. Store the \
|
||||
intermediate result. */ \
|
||||
@ -274,7 +274,7 @@ enum
|
||||
curcs = db; \
|
||||
} \
|
||||
\
|
||||
if (__builtin_expect (outptr + 2 > outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 2 > outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
@ -301,7 +301,7 @@ enum
|
||||
{ \
|
||||
uint32_t ch = get32 (inptr); \
|
||||
\
|
||||
if (__builtin_expect (ch >= UCS_LIMIT, 0)) \
|
||||
if (__glibc_unlikely (ch >= UCS_LIMIT)) \
|
||||
{ \
|
||||
UNICODE_TAG_HANDLER (ch, 4); \
|
||||
\
|
||||
@ -353,7 +353,7 @@ enum
|
||||
curcs = db; \
|
||||
} \
|
||||
\
|
||||
if (__builtin_expect (outptr + 2 > outend, 0)) \
|
||||
if (__glibc_unlikely (outptr + 2 > outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
@ -364,13 +364,13 @@ enum
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
if (__builtin_expect (curcs == db, 0)) \
|
||||
if (__glibc_unlikely (curcs == db)) \
|
||||
{ \
|
||||
/* We know there is room for at least one byte. */ \
|
||||
*outptr++ = SI; \
|
||||
curcs = sb; \
|
||||
\
|
||||
if (__builtin_expect (outptr >= outend, 0)) \
|
||||
if (__glibc_unlikely (outptr >= outend)) \
|
||||
{ \
|
||||
result = __GCONV_FULL_OUTPUT; \
|
||||
break; \
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user