if (__builtin_expect (current_value.m->l_type == lt_loaded, 0)  && flags != 0  && add_dependency (undef_map, current_value.m) < 0)  return INTUSE(_dl_lookup_versioned_symbol) (undef_name, undef_map, ref, symbol_scope, version, type_class, flags);
_dl_lookup_versioned_symbol (const char *undef_name,			     struct link_map *undef_map, const ElfW(Sym) **ref,			     struct r_scope_elem *symbol_scope[],			     const struct r_found_version *version,			     int type_class, int flags){  const unsigned long int hash = _dl_elf_hash (undef_name);  struct sym_val current_value = { NULL, NULL };  struct r_scope_elem **scope;  int protected;  bump_num_relocations ();  /* No other flag than DL_LOOKUP_ADD_DEPENDENCY is allowed.  */  assert (flags == 0 || flags == DL_LOOKUP_ADD_DEPENDENCY);  /* Search the relevant loaded objects for a definition.  */  for (scope = symbol_scope; *scope; ++scope)    {      int res = do_lookup_versioned (undef_name, hash, *ref, &current_value,				     *scope, 0, version, NULL, type_class);      if (res > 0)	{	  /* We have to check whether this would bind UNDEF_MAP to an object	     in the global scope which was dynamically loaded.  In this case	     we have to prevent the latter from being unloaded unless the	     UNDEF_MAP object is also unloaded.  */	  if (__builtin_expect (current_value.m->l_type == lt_loaded, 0)	      /* Don't do this for explicit lookups as opposed to implicit		 runtime lookups.  */	      && flags != 0	      /* Add UNDEF_MAP to the dependencies.  */	      && add_dependency (undef_map, current_value.m) < 0)	    /* Something went wrong.  Perhaps the object we tried to reference	       was just removed.  Try finding another definition.  */	    return INTUSE(_dl_lookup_versioned_symbol) (undef_name, undef_map,							ref, symbol_scope,							version, type_class,							0);	  break;	}      if (__builtin_expect (res, 0) < 0)	{	  /* Oh, oh.  The file named in the relocation entry does not	     contain the needed symbol.  */	  const char *reference_name = undef_map ? undef_map->l_name : NULL;	  /* XXX We cannot translate the message.  */	  _dl_signal_cerror (0, (reference_name[0]				 ? reference_name				 : (rtld_progname ?: "<main program>")),			     N_("relocation error"),			     make_string ("symbol ", undef_name, ", version ",					  version->name,					  " not defined in file ",					  version->filename,					  " with link time reference",					  res == -2					  ? " (no version symbols)" : ""));	  *ref = NULL;	  return 0;	}    }  if (__builtin_expect (current_value.s == NULL, 0))    {      if (*ref == NULL || ELFW(ST_BIND) ((*ref)->st_info) != STB_WEAK)	{	  /* We could find no value for a strong reference.  */	  const char *reference_name = undef_map ? undef_map->l_name : NULL;	  /* XXX We cannot translate the message.  */	  _dl_signal_cerror (0, (reference_name[0]				 ? reference_name				 : (rtld_progname ?: "<main program>")), NULL,			     make_string (undefined_msg, undef_name,					  ", version ",					  version->name ?: NULL));	}      *ref = NULL;      return 0;    }  protected = *ref && ELFW(ST_VISIBILITY) ((*ref)->st_other) == STV_PROTECTED;  if (__builtin_expect (protected != 0, 0))    {      /* It is very tricky. We need to figure out what value to         return for the protected symbol */      struct sym_val protected_value = { NULL, NULL };      for (scope = symbol_scope; *scope; ++scope)	if (_dl_do_lookup_versioned (undef_name, hash, *ref, &protected_value,				     *scope, 0, version, NULL,				     ELF_RTYPE_CLASS_PLT))	  break;      if (protected_value.s != NULL && protected_value.m != undef_map)	{	  current_value.s = *ref;	  current_value.m = undef_map;	}    }  if (__builtin_expect (GL(dl_debug_mask)			& (DL_DEBUG_BINDINGS|DL_DEBUG_PRELINK), 0))    _dl_debug_bindings (undef_name, undef_map, ref, symbol_scope,			&current_value, version, type_class, protected);  *ref = current_value.s;  return LOOKUP_VALUE (current_value.m);}