procyberian/emacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Avoid name clashes with static GnuTLS

Browse source 
Work around a bug in GnuTLS 3.7.11 and earlier: when built
statically, its mistakenly exports symbols hash_lookup and
hash_string, which collide with Emacs symbols of the same name,
preventing temacs from linking statically.  Problem reported by
Greg A. Woods (Bug#77476).

Because GnuTLS never uses hash_lookup or hash_string this issue
ordinarily doesn’t seem to prevent temacs from linking to GnuTLS
on GNU/Linux, as it’s linked dynamically and the dynamic linker
never needs to resolve references to either symbol.  However, I
suppose a clash or bug could occur even with dynamic linking if
Emacs later loads a module that uses either symbol.

Although GnuTLS should be fixed, Emacs should link statically to
current and older GnuTLS versions in the meantime, and it should
avoid potential problems with dynamic linking.  Renaming the two
clashing names is an easy way to do this.  For consistency with
the new name for hash_lookup, also rename hash_lookup_with_hash
and hash_lookup_get_hash.

* src/fns.c (hash_find_with_hash): Rename from hash_lookup_with_hash.
(hash_find): Rename from hash_lookup.
(hash_find_get_hash): Rename from hash_lookup_get_hash.
(hash_char_array): Rename from hash_string.
All uses changed.
This commit is contained in:
Paul Eggert 2025-04-19 18:44:52 -07:00
parent 71ee484cac
commit c8eed90eb4
15 changed files with 44 additions and 45 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/bytecode.c
View file

@ -1763,7 +1763,7 @@ exec_byte_code (Lisp_Object fun, ptrdiff_t args_template,
}
else
{
ptrdiff_t i = hash_lookup (h, v1);
ptrdiff_t i = hash_find (h, v1);
if (i >= 0)
{
op = XFIXNUM (HASH_VALUE (h, i));

2
src/category.c
View file

@ -54,7 +54,7 @@ hash_get_category_set (Lisp_Object table, Lisp_Object category_set)
make_hash_table (&hashtest_equal, DEFAULT_HASH_SIZE, Weak_None));
struct Lisp_Hash_Table *h = XHASH_TABLE (XCHAR_TABLE (table)->extras[1]);
hash_hash_t hash;
ptrdiff_t i = hash_lookup_get_hash (h, category_set, &hash);
ptrdiff_t i = hash_find_get_hash (h, category_set, &hash);
if (i >= 0)
return HASH_KEY (h, i);
hash_put (h, category_set, Qnil, hash);

4
src/ccl.c
View file

@ -1375,7 +1375,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
eop = (FIXNUM_OVERFLOW_P (reg[RRR])
? -1
: hash_lookup (h, make_fixnum (reg[RRR])));
: hash_find (h, make_fixnum (reg[RRR])));
if (eop >= 0)
{
Lisp_Object opl;
@ -1404,7 +1404,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
eop = (FIXNUM_OVERFLOW_P (i)
? -1
: hash_lookup (h, make_fixnum (i)));
: hash_find (h, make_fixnum (i)));
if (eop >= 0)
{
Lisp_Object opl;

3
src/charset.c
View file

@ -1112,8 +1112,7 @@ usage: (define-charset-internal ...) */)
hash_hash_t hash_code;
ptrdiff_t hash_index
= hash_lookup_get_hash (hash_table, args[charset_arg_name],
&hash_code);
= hash_find_get_hash (hash_table, args[charset_arg_name], &hash_code);
if (hash_index >= 0)
{
new_definition_p = false;

2
src/charset.h
View file

@ -285,7 +285,7 @@ extern int emacs_mule_charset[256];
/* Return an index to Vcharset_hash_table of the charset whose symbol
is SYMBOL. */
#define CHARSET_SYMBOL_HASH_INDEX(symbol) \
hash_lookup (XHASH_TABLE (Vcharset_hash_table), symbol)
hash_find (XHASH_TABLE (Vcharset_hash_table), symbol)
/* Return the attribute vector of CHARSET. */
#define CHARSET_ATTRIBUTES(charset) (charset)->attributes

2
src/coding.h
View file

@ -193,7 +193,7 @@ enum coding_attr_index
/* Return the ID of CODING_SYSTEM_SYMBOL. */
#define CODING_SYSTEM_ID(coding_system_symbol) \
hash_lookup (XHASH_TABLE (Vcoding_system_hash_table), \
hash_find (XHASH_TABLE (Vcoding_system_hash_table), \
coding_system_symbol)
/* Return true if CODING_SYSTEM_SYMBOL is a coding system. */

2
src/composite.c
View file

@ -241,7 +241,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
goto invalid_composition;
hash_hash_t hash_code;
hash_index = hash_lookup_get_hash (hash_table, key, &hash_code);
hash_index = hash_find_get_hash (hash_table, key, &hash_code);
if (hash_index >= 0)
{
/* We have already registered the same composition. Change PROP

6
src/emacs-module.c
View file

@ -413,7 +413,7 @@ static bool
module_global_reference_p (emacs_value v, ptrdiff_t *n)
{
struct Lisp_Hash_Table *h = XHASH_TABLE (Vmodule_refs_hash);
/* Note that we can't use `hash_lookup' because V might be a local
/* Note that we can't use `hash_find' because V might be a local
reference that's identical to some global reference. */
DOHASH (h, k, val)
if (&XMODULE_GLOBAL_REFERENCE (val)->value == v)
@ -431,7 +431,7 @@ module_make_global_ref (emacs_env *env, emacs_value value)
struct Lisp_Hash_Table *h = XHASH_TABLE (Vmodule_refs_hash);
Lisp_Object new_obj = value_to_lisp (value);
hash_hash_t hashcode;
ptrdiff_t i = hash_lookup_get_hash (h, new_obj, &hashcode);
ptrdiff_t i = hash_find_get_hash (h, new_obj, &hashcode);
/* Note: This approach requires the garbage collector to never move
objects. */
@ -470,7 +470,7 @@ module_free_global_ref (emacs_env *env, emacs_value global_value)
MODULE_FUNCTION_BEGIN ();
struct Lisp_Hash_Table *h = XHASH_TABLE (Vmodule_refs_hash);
Lisp_Object obj = value_to_lisp (global_value);
ptrdiff_t i = hash_lookup (h, obj);
ptrdiff_t i = hash_find (h, obj);
if (module_assertions)
{

28
src/fns.c
View file

@ -2815,8 +2815,8 @@ equal_no_quit (Lisp_Object o1, Lisp_Object o2)
return internal_equal (o1, o2, EQUAL_NO_QUIT, 0, Qnil);
}
static ptrdiff_t hash_lookup_with_hash (struct Lisp_Hash_Table *h,
Lisp_Object key, hash_hash_t hash);
static ptrdiff_t hash_find_with_hash (struct Lisp_Hash_Table *h,
Lisp_Object key, hash_hash_t hash);
/* Return true if O1 and O2 are equal. EQUAL_KIND specifies what kind
@ -2848,7 +2848,7 @@ internal_equal_1 (Lisp_Object o1, Lisp_Object o2, enum equal_kind equal_kind,
{
struct Lisp_Hash_Table *h = XHASH_TABLE (*ht);
hash_hash_t hash = hash_from_key (h, o1);
ptrdiff_t i = hash_lookup_with_hash (h, o1, hash);
ptrdiff_t i = hash_find_with_hash (h, o1, hash);
if (i >= 0)
{ /* `o1' was seen already. */
Lisp_Object o2s = HASH_VALUE (h, i);
@ -5031,8 +5031,8 @@ hash_table_thaw (Lisp_Object hash_table)
/* Look up KEY with hash HASH in table H.
Return entry index or -1 if none. */
static ptrdiff_t
hash_lookup_with_hash (struct Lisp_Hash_Table *h,
Lisp_Object key, hash_hash_t hash)
hash_find_with_hash (struct Lisp_Hash_Table *h,
Lisp_Object key, hash_hash_t hash)
{
ptrdiff_t start_of_bucket = hash_index_index (h, hash);
for (ptrdiff_t i = HASH_INDEX (h, start_of_bucket);
@ -5048,20 +5048,20 @@ hash_lookup_with_hash (struct Lisp_Hash_Table *h,
/* Look up KEY in table H. Return entry index or -1 if none. */
ptrdiff_t
hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key)
hash_find (struct Lisp_Hash_Table *h, Lisp_Object key)
{
return hash_lookup_with_hash (h, key, hash_from_key (h, key));
return hash_find_with_hash (h, key, hash_from_key (h, key));
}
/* Look up KEY in hash table H. Return its hash value in *PHASH.
Value is the index of the entry in H matching KEY, or -1 if not found. */
ptrdiff_t
hash_lookup_get_hash (struct Lisp_Hash_Table *h, Lisp_Object key,
hash_hash_t *phash)
hash_find_get_hash (struct Lisp_Hash_Table *h, Lisp_Object key,
hash_hash_t *phash)
{
EMACS_UINT hash = hash_from_key (h, key);
*phash = hash;
return hash_lookup_with_hash (h, key, hash);
return hash_find_with_hash (h, key, hash);
}
static void
@ -5286,7 +5286,7 @@ sweep_weak_table (struct Lisp_Hash_Table *h, bool remove_entries_p)
can be any EMACS_UINT value. */
EMACS_UINT
hash_string (char const *ptr, ptrdiff_t len)
hash_char_array (char const *ptr, ptrdiff_t len)
{
char const *p = ptr;
char const *end = ptr + len;
@ -5459,7 +5459,7 @@ sxhash_obj (Lisp_Object obj, int depth)
return XHASH (obj);
case Lisp_String:
return hash_string (SSDATA (obj), SBYTES (obj));
return hash_char_array (SSDATA (obj), SBYTES (obj));
case Lisp_Vectorlike:
{
@ -5861,7 +5861,7 @@ usage: (gethash KEY TABLE &optional DEFAULT) */)
(Lisp_Object key, Lisp_Object table, Lisp_Object dflt)
{
struct Lisp_Hash_Table *h = check_hash_table (table);
ptrdiff_t i = hash_lookup (h, key);
ptrdiff_t i = hash_find (h, key);
return i >= 0 ? HASH_VALUE (h, i) : dflt;
}
@ -5876,7 +5876,7 @@ VALUE. In any case, return VALUE. */)
check_mutable_hash_table (table, h);
EMACS_UINT hash = hash_from_key (h, key);
ptrdiff_t i = hash_lookup_with_hash (h, key, hash);
ptrdiff_t i = hash_find_with_hash (h, key, hash);
if (i >= 0)
set_hash_value_slot (h, i, value);
else

6
src/image.c
View file

@ -5552,7 +5552,7 @@ xpm_free_color_cache (void)
static int
xpm_color_bucket (char *color_name)
{
EMACS_UINT hash = hash_string (color_name, strlen (color_name));
EMACS_UINT hash = hash_char_array (color_name, strlen (color_name));
return hash % XPM_COLOR_CACHE_BUCKETS;
}
@ -6238,7 +6238,7 @@ xpm_put_color_table_h (Lisp_Object color_table,
Lisp_Object chars = make_unibyte_string (chars_start, chars_len);
hash_hash_t hash_code;
hash_lookup_get_hash (table, chars, &hash_code);
hash_find_get_hash (table, chars, &hash_code);
hash_put (table, chars, color, hash_code);
}
@ -6249,7 +6249,7 @@ xpm_get_color_table_h (Lisp_Object color_table,
{
struct Lisp_Hash_Table *table = XHASH_TABLE (color_table);
ptrdiff_t i =
hash_lookup (table, make_unibyte_string (chars_start, chars_len));
hash_find (table, make_unibyte_string (chars_start, chars_len));
return i >= 0 ? HASH_VALUE (table, i) : Qnil;
}

2
src/json.c
View file

@ -1571,7 +1571,7 @@ json_parse_object (struct json_parser *parser)
hash_hash_t hash;
Lisp_Object key = parser->object_workspace[i];
Lisp_Object value = parser->object_workspace[i + 1];
ptrdiff_t i = hash_lookup_get_hash (h, key, &hash);
ptrdiff_t i = hash_find_get_hash (h, key, &hash);
if (i < 0)
hash_put (h, key, value, hash);
else

8
src/lisp.h
View file

@ -4261,14 +4261,14 @@ extern Lisp_Object larger_vector (Lisp_Object, ptrdiff_t, ptrdiff_t);
extern bool sweep_weak_table (struct Lisp_Hash_Table *, bool);
extern void hexbuf_digest (char *, void const *, int);
extern char *extract_data_from_object (Lisp_Object, ptrdiff_t *, ptrdiff_t *);
EMACS_UINT hash_string (char const *, ptrdiff_t);
EMACS_UINT hash_char_array (char const *, ptrdiff_t);
EMACS_UINT sxhash (Lisp_Object);
Lisp_Object make_hash_table (const struct hash_table_test *, EMACS_INT,
hash_table_weakness_t);
Lisp_Object hash_table_weakness_symbol (hash_table_weakness_t weak);
ptrdiff_t hash_lookup (struct Lisp_Hash_Table *, Lisp_Object);
ptrdiff_t hash_lookup_get_hash (struct Lisp_Hash_Table *h, Lisp_Object key,
hash_hash_t *phash);
ptrdiff_t hash_find (struct Lisp_Hash_Table *, Lisp_Object);
ptrdiff_t hash_find_get_hash (struct Lisp_Hash_Table *h, Lisp_Object key,
hash_hash_t *phash);
ptrdiff_t hash_put (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object,
hash_hash_t);
void hash_remove_from_table (struct Lisp_Hash_Table *, Lisp_Object);

16
src/lread.c
View file

@ -4266,7 +4266,7 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
= XHASH_TABLE (read_objects_map);
Lisp_Object number = make_fixnum (n);
hash_hash_t hash;
ptrdiff_t i = hash_lookup_get_hash (h, number, &hash);
ptrdiff_t i = hash_find_get_hash (h, number, &hash);
if (i >= 0)
/* Not normal, but input could be malformed. */
set_hash_value_slot (h, i, placeholder);
@ -4284,7 +4284,7 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
/* #N# -- reference to numbered object */
struct Lisp_Hash_Table *h
= XHASH_TABLE (read_objects_map);
ptrdiff_t i = hash_lookup (h, make_fixnum (n));
ptrdiff_t i = hash_find (h, make_fixnum (n));
if (i < 0)
INVALID_SYNTAX_WITH_BUFFER ();
obj = HASH_VALUE (h, i);
@ -4579,7 +4579,7 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
struct Lisp_Hash_Table *h2
= XHASH_TABLE (read_objects_completed);
hash_hash_t hash;
ptrdiff_t i = hash_lookup_get_hash (h2, placeholder, &hash);
ptrdiff_t i = hash_find_get_hash (h2, placeholder, &hash);
eassert (i < 0);
hash_put (h2, placeholder, Qnil, hash);
obj = placeholder;
@ -4594,7 +4594,7 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
struct Lisp_Hash_Table *h2
= XHASH_TABLE (read_objects_completed);
hash_hash_t hash;
ptrdiff_t i = hash_lookup_get_hash (h2, obj, &hash);
ptrdiff_t i = hash_find_get_hash (h2, obj, &hash);
eassert (i < 0);
hash_put (h2, obj, Qnil, hash);
}
@ -4606,8 +4606,8 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
/* ...and #n# will use the real value from now on. */
struct Lisp_Hash_Table *h = XHASH_TABLE (read_objects_map);
hash_hash_t hash;
ptrdiff_t i = hash_lookup_get_hash (h, e->u.numbered.number,
&hash);
ptrdiff_t i = hash_find_get_hash (h, e->u.numbered.number,
&hash);
eassert (i >= 0);
set_hash_value_slot (h, i, obj);
}
@ -4661,7 +4661,7 @@ substitute_object_recurse (struct subst *subst, Lisp_Object subtree)
by #n=, which means that we can find it as a value in
COMPLETED. */
if (EQ (subst->completed, Qt)
|| hash_lookup (XHASH_TABLE (subst->completed), subtree) >= 0)
|| hash_find (XHASH_TABLE (subst->completed), subtree) >= 0)
subst->seen = Fcons (subtree, subst->seen);
/* Recurse according to subtree's type.
@ -5173,7 +5173,7 @@ OBARRAY, if nil, defaults to the value of the variable `obarray'. */)
static ptrdiff_t
obarray_index (struct Lisp_Obarray *oa, const char *str, ptrdiff_t size_byte)
{
EMACS_UINT hash = hash_string (str, size_byte);
EMACS_UINT hash = hash_char_array (str, size_byte);
return knuth_hash (reduce_emacs_uint_to_hash_hash (hash), oa->size_bits);
}

4
src/macfont.m
View file

@ -1018,7 +1018,7 @@ static void mac_font_get_glyphs_for_variants (CFDataRef, UTF32Char,
if (HASH_TABLE_P (macfont_family_cache))
{
struct Lisp_Hash_Table *h = XHASH_TABLE (macfont_family_cache);
ptrdiff_t i = hash_lookup (h, symbol);
ptrdiff_t i = hash_find (h, symbol);
if (i >= 0)
{
@ -1045,7 +1045,7 @@ static void mac_font_get_glyphs_for_variants (CFDataRef, UTF32Char,
h = XHASH_TABLE (macfont_family_cache);
hash_hash_t hash;
i = hash_lookup_get_hash (h, symbol, &hash);
i = hash_find_get_hash (h, symbol, &hash);
value = string ? make_mint_ptr ((void *) CFRetain (string)) : Qnil;
if (i >= 0)
{

2
src/minibuf.c
View file

@ -2103,7 +2103,7 @@ the values STRING, PREDICATE and `lambda'. */)
else if (HASH_TABLE_P (collection))
{
struct Lisp_Hash_Table *h = XHASH_TABLE (collection);
ptrdiff_t i = hash_lookup (h, string);
ptrdiff_t i = hash_find (h, string);
if (i >= 0)
{
tem = HASH_KEY (h, i);