dl_main源码分析（一）

dl_main源码分析（一）

因为dl_main函数太长，分多个章节分析，本章先分析前面的几部分代码。

elf/rtld.c
dl_main第一部分

static void
dl_main (const ElfW(Phdr) *phdr,
     ElfW(Word) phnum,
     ElfW(Addr) *user_entry,
     ElfW(auxv_t) *auxv)
{
  const ElfW(Phdr) *ph;
  enum mode mode;
  struct link_map *main_map;
  size_t file_size;
  char *file;
  bool has_interp = false;
  unsigned int i;
  bool prelinked = false;
  bool rtld_is_main = false;
  void *tcbp = NULL;

  GL(dl_error_catch_tsd) = &_dl_initial_error_catch_tsd;
  GL(dl_init_static_tls) = &_dl_nothread_init_static_tls;
  GL(dl_rtld_lock_recursive) = rtld_lock_default_lock_recursive;
  GL(dl_rtld_unlock_recursive) = rtld_lock_default_unlock_recursive;
  GL(dl_make_stack_executable_hook) = &_dl_make_stack_executable;

  process_envvars (&mode);

首先设置一些全局变量，这些变量等使用的时候再介绍，然后调用process_envvars函数处理环境变量。

elf/rtld.c
dl_main->process_envvars

static void
process_envvars (enum mode *modep)
{
  char **runp = _environ;
  char *envline;
  enum mode mode = normal;
  char *debug_output = NULL;

  GLRO(dl_profile_output)
    = &"/var/tmp\0/var/profile"[INTUSE(__libc_enable_secure) ? 9 : 0];

  while ((envline = _dl_next_ld_env_entry (&runp)) != NULL)
    {
      size_t len = 0;

      while (envline[len] != '\0' && envline[len] != '=')
        ++len;

      if (envline[len] != '=')
        continue;

      switch (len)
    {

    ...

    case 12:
      if (memcmp (envline, "LIBRARY_PATH", 12) == 0)
        {
          library_path = &envline[13];
          break;
        }

    ...

    }
    }

  *modep = mode;

  ...
}

_environ是环境变量的指针，从上一章_dl_sysdep_start函数中的宏定义DL_FIND_ARG_COMPONENTS获得。
_dl_profile_output取/var/tmp或/var/profile，该变量用于为共享库生成profile数据。
dl_next_ld_env_entry函数依次找到环境变量中以‘LD’开头的后一个字符的地址，例如LD_PRELOAD，最后返回‘P’所在的地址。
接下来统计LD_’开头后的字符长度，保存在len中，例如LD_PRELOAD，则返回‘PRELOAD’的长度，即7。
如果下一个字符不是‘=’号，则继续循环，例如LD_PRELOAD后不是‘=’号，则直接返回。
再往下根据前面统计的len不同长度进行不同的处理，这里只看最重要的LIBRARY_PATH，也即LD_LIBRARY_PATH环境变量，内部存储了共享库的搜索路径，将其设置到library_path即可。

elf/rtld.c
dl_main->process_envvars->_dl_next_ld_env_entry

char* internal_function _dl_next_ld_env_entry (char ***position)
{
  char **current = *position;
  char *result = NULL;

  while (*current != NULL)
    {
      if (__builtin_expect ((*current)[0] == 'L', 0)
      && (*current)[1] == 'D' && (*current)[2] == '_')
    {
      result = &(*current)[3];
      *position = ++current;
      break;
    }
      ++current;
    }

  return result;
}

该函数举个例子就明白了，假设环境变量LD_PRELOAD，经过while循环，if语句判断前三个字符分别为‘L’、‘D’和‘_’，于是result变量从第四个字符开始，最后返回‘P’所在的地址。

elf/rtld.c
dl_main第二部分

  if (*user_entry == (ElfW(Addr)) ENTRY_POINT)
    {
      ...
    }
  else
    {
      main_map = _dl_new_object ((char *) "", "", lt_executable, NULL,
                 __RTLD_OPENEXEC, LM_ID_BASE);
      main_map->l_phdr = phdr;
      main_map->l_phnum = phnum;
      main_map->l_entry = *user_entry;
      _dl_add_to_namespace_list (main_map, LM_ID_BASE);
    }

  main_map->l_map_end = 0;
  main_map->l_text_end = 0;
  main_map->l_map_start = ~0;
  ++main_map->l_direct_opencount;

如果用户程序的入口地址user_entry为ENTRY_POINT也即ld.so的_start函数的起始地址，则表示ld.so是被调用的程序，本章不考虑这种情况。另一种情况ld.so就是作为解释器被调用了。
此时首先通过_dl_new_object函数为用户程序构造link_map，即main_map，对其进行初始化。
然后通过_dl_add_to_namespace_list函数将该main_map添加到全局链表中。

elf/object.c
dl_main->_dl_new_object

struct link_map *
internal_function
_dl_new_object (char *realname, const char *libname, int type,
        struct link_map *loader, int mode, Lmid_t nsid)
{
  size_t libname_len = strlen (libname) + 1;
  struct link_map *new;
  struct libname_list *newname;

  new = (struct link_map *) calloc (sizeof (*new) + sizeof (struct link_map *)
                    + sizeof (*newname) + libname_len, 1);

  new->l_real = new;
  new->l_symbolic_searchlist.r_list = (struct link_map **) ((char *) (new + 1));

  new->l_libname = newname
    = (struct libname_list *) (new->l_symbolic_searchlist.r_list + 1);
  newname->name = (char *) memcpy (newname + 1, libname, libname_len);
  newname->dont_free = 1;

  new->l_name = realname;
  new->l_type = type;
  if ((GLRO(dl_debug_mask) & DL_DEBUG_UNUSED) == 0)
    new->l_used = 1;
  new->l_loader = loader;
  new->l_ns = nsid;
  new->l_scope = new->l_scope_mem;
  new->l_scope_max = sizeof (new->l_scope_mem) / sizeof (new->l_scope_mem[0]);

  int idx = 0;
  loader = new;

  if (idx == 0 || &loader->l_searchlist != new->l_scope[0])
    {
      new->l_scope[idx] = &loader->l_searchlist;
    }
  new->l_local_scope[0] = &new->l_searchlist;

  if (realname[0] != '\0')
    {
      size_t realname_len = strlen (realname) + 1;
      char *origin;
      char *cp;

      if (realname[0] == '/')
    {
      cp = origin = (char *) malloc (realname_len);
      if (origin == NULL)
        {
          origin = (char *) -1;
          goto out;
        }
    }
      else
    {
      size_t len = realname_len;
      char *result = NULL;

      origin = NULL;
      do
        {
          char *new_origin;

          len += 128;
          new_origin = (char *) realloc (origin, len);
          if (new_origin == NULL)
        break;
          origin = new_origin;
        }
      while ((result = __getcwd (origin, len - realname_len)) == NULL
         && errno == ERANGE);

      if (result == NULL)
        {
          free (origin);
          origin = (char *) -1;
          goto out;
        }

      cp = (strchr) (origin, '\0');
      if (cp[-1] != '/')
        *cp++ = '/';
    }

      cp = __mempcpy (cp, realname, realname_len);

      do
    --cp;
      while (*cp != '/');

      if (cp == origin)
    ++cp;
      *cp = '\0';

    out:
      new->l_origin = origin;
    }
  return new;
}

_dl_new_object函数主要创建了一个link_map结构并进行相应的初始化，一些相关的变量后面遇到了再分析。值得注意的是glibc很多地方在为一个结构分配内存的时，都多分配了一些内存，本函数中就多分配了sizeof (struct link_map *) + sizeof (*newname) + libname_len这么多的内存（其实还有audit_space，本章不关心audit的内容），前面用于存放l_symbolic_searchlist.r_list的指针，后面用于存放路径字符串。
接着为库路径realname（如果存在）分配内存，如果realname是绝对路径，则直接分配内存并通过__mempcpy函数拷贝字符串到新分配的内存，如果是相对路径，则先通过__getcwd函数获取当前工作路径，再拼接成最后的绝对路径。
最后返回新创建的link_map结构指针new。

elf/dl-object.c
dl_main->_dl_add_to_namespace_list

void
internal_function
_dl_add_to_namespace_list (struct link_map *new, Lmid_t nsid)
{
  if (GL(dl_ns)[nsid]._ns_loaded != NULL)
    {
      struct link_map *l = GL(dl_ns)[nsid]._ns_loaded;
      while (l->l_next != NULL)
    l = l->l_next;
      new->l_prev = l;
      l->l_next = new;
    }
  else
    GL(dl_ns)[nsid]._ns_loaded = new;

  ++GL(dl_ns)[nsid]._ns_nloaded;
  new->l_serial = GL(dl_load_adds);
  ++GL(dl_load_adds);
}

这里就是将新创建的link_map即new插入到全局列表dl_ns当中，nsid确定插入的位置，并更新相应参数。

elf/rtld.c
dl_main第三部分

  for (ph = phdr; ph < &phdr[phnum]; ++ph)
    switch (ph->p_type)
      {
      case PT_PHDR:
    main_map->l_addr = (ElfW(Addr)) phdr - ph->p_vaddr;
    break;
      case PT_DYNAMIC:
    main_map->l_ld = (void *) main_map->l_addr + ph->p_vaddr;
    break;
      case PT_INTERP:
    _dl_rtld_libname.name = ((const char *) main_map->l_addr
                 + ph->p_vaddr);
    GL(dl_rtld_map).l_libname = &_dl_rtld_libname;
    if (GL(dl_rtld_map).l_ld == NULL)
      {
        const char *p = NULL;
        const char *cp = _dl_rtld_libname.name;

        while (*cp != '\0')
          if (*cp++ == '/')
        p = cp;

        if (p != NULL)
          {
        _dl_rtld_libname2.name = p;
        _dl_rtld_libname.next = &_dl_rtld_libname2;
          }
      }

    has_interp = true;
    break;
      case PT_LOAD:
    {
      ElfW(Addr) mapstart;
      ElfW(Addr) allocend;

      mapstart = (main_map->l_addr
              + (ph->p_vaddr & ~(GLRO(dl_pagesize) - 1)));
      if (main_map->l_map_start > mapstart)
        main_map->l_map_start = mapstart;

      allocend = main_map->l_addr + ph->p_vaddr + ph->p_memsz;
      if (main_map->l_map_end < allocend)
        main_map->l_map_end = allocend;
      if ((ph->p_flags & PF_X) && allocend > main_map->l_text_end)
        main_map->l_text_end = allocend;
    }
    break;

      case PT_TLS:
    if (ph->p_memsz > 0)
      {
        main_map->l_tls_blocksize = ph->p_memsz;
        main_map->l_tls_align = ph->p_align;
        if (ph->p_align == 0)
          main_map->l_tls_firstbyte_offset = 0;
        else
          main_map->l_tls_firstbyte_offset = (ph->p_vaddr
                          & (ph->p_align - 1));
        main_map->l_tls_initimage_size = ph->p_filesz;
        main_map->l_tls_initimage = (void *) ph->p_vaddr;

        GL(dl_tls_max_dtv_idx) = main_map->l_tls_modid = 1;
      }
    break;

      case PT_GNU_STACK:
    GL(dl_stack_flags) = ph->p_flags;
    break;

      case PT_GNU_RELRO:
    main_map->l_relro_addr = ph->p_vaddr;
    main_map->l_relro_size = ph->p_memsz;
    break;
      }

接下来遍历用户程序的Segment头。
类型为PT_PHDR的Segment标识了第一个Segment头的装载地址p_vaddr，将实际的装载地址phdr减去该值就是整个elf文件的装载地址，存储在l_addr中。
用上面确定的装载地址加上.dynamic节的装载地址p_vaddr就得到该节实际的装载地址，将其存储在l_ld中。
再往下找到类型为PT_INTERP的Segment头，其装载地址就是解释器自身路径的起始地址，将该路径保存在_dl_rtld_libname中，将标准的路径保存在_dl_rtld_libname2中，两个变量的类型都是libname_list，用来形成字符串链表。
接下来计算代码段、数据段、bss段（这些段的类型都为PT_LOAD）的最低起始地址，保存在main_map的l_map_start中，最高结束地址保存在l_map_end中。
再往下是类型分别为PT_TLS、PT_GNU_STACK和PT_GNU_RELRO的Segment头，依次存储其中的信息，这里就不仔细看了。

elf/rtld.c
dl_main第四部分

  if (main_map->l_tls_initimage != NULL)
    main_map->l_tls_initimage
      = (char *) main_map->l_tls_initimage + main_map->l_addr;
  if (! main_map->l_map_end)
    main_map->l_map_end = ~0;
  if (! main_map->l_text_end)
    main_map->l_text_end = ~0;
  if (! GL(dl_rtld_map).l_libname && GL(dl_rtld_map).l_name)
    {
      _dl_rtld_libname.name = GL(dl_rtld_map).l_name;
      GL(dl_rtld_map).l_libname =  &_dl_rtld_libname;
    }

  if (GL(dl_rtld_map).l_info[DT_SONAME] != NULL
      && strcmp (GL(dl_rtld_map).l_libname->name,
         (const char *) D_PTR (&GL(dl_rtld_map), l_info[DT_STRTAB])
         + GL(dl_rtld_map).l_info[DT_SONAME]->d_un.d_val) != 0)
    {
      static struct libname_list newname;
      newname.name = ((char *) D_PTR (&GL(dl_rtld_map), l_info[DT_STRTAB])
              + GL(dl_rtld_map).l_info[DT_SONAME]->d_un.d_ptr);
      newname.next = NULL;
      newname.dont_free = 1;

      GL(dl_rtld_map).l_libname->next = &newname;
    }

l_tls_initimage是tls数据映像地址，需要加上装载地址l_addr。
接下来如果没有设置l_map_end和l_text_end就对其进行重置。
接下来如果没有使用解释器，或者ld.so被单独调用，就设置_dl_rtld_libname为l_name。
再往下如果指定了DT_SONAME，就将其加入到全局的l_libname中。

elf/rtld.c
dl_main第六部分

  if (! rtld_is_main)
    {
      elf_get_dynamic_info (main_map, NULL);
      _dl_setup_hash (main_map);
    }

  struct link_map **first_preload = &GL(dl_rtld_map).l_next;
  _dl_init_paths (library_path);
  struct r_debug *r = _dl_debug_initialize (GL(dl_rtld_map).l_addr,
                        LM_ID_BASE);
  r->r_state = RT_CONSISTENT;

如果ld.so以解释器身份运行，这里通过elf_get_dynamic_info获取用户程序.dynamic段的信息，然后通过_dl_setup_hash函数获取.hash节的信息并初始化，这两个函数在上一章分析过了。
接下来通过_dl_init_paths函数设置库的搜索路径，传入的参数library_path是在process_envvars函数中从堆栈中取出的LD_LIBRARY_PATH的值。
剩余的代码和调试相关，本章不关心，后面有时间再来研究。

elf/dl-load.c
dl_main->_dl_init_paths第一部分

void internal_function _dl_init_paths (const char *llp)
{
  size_t idx;
  const char *strp;
  struct r_search_path_elem *pelem, **aelem;
  size_t round_size;
  struct link_map *l;

  const char *errstring = NULL;

  capstr = _dl_important_hwcaps (GLRO(dl_platform), GLRO(dl_platformlen),
                 &ncapstr, &max_capstrlen);
  aelem = rtld_search_dirs.dirs = (struct r_search_path_elem **)
    malloc ((nsystem_dirs_len + 1) * sizeof (struct r_search_path_elem *));

  round_size = ((2 * sizeof (struct r_search_path_elem) - 1
         + ncapstr * sizeof (enum r_dir_status))
        / sizeof (struct r_search_path_elem));

  rtld_search_dirs.dirs[0] = (struct r_search_path_elem *)
    malloc ((sizeof (system_dirs) / sizeof (system_dirs[0]))
        * round_size * sizeof (struct r_search_path_elem));

  rtld_search_dirs.malloced = 0;
  pelem = GL(dl_all_dirs) = rtld_search_dirs.dirs[0];
  strp = system_dirs;
  idx = 0;

  do
    {
      size_t cnt;

      *aelem++ = pelem;
      pelem->what = "system search path";
      pelem->where = NULL;
      pelem->dirname = strp;
      pelem->dirnamelen = system_dirs_len[idx];
      strp += system_dirs_len[idx] + 1;
      for (cnt = 0; cnt < ncapstr; ++cnt)
    pelem->status[cnt] = unknown;
      pelem->next = (++idx == nsystem_dirs_len ? NULL : (pelem + round_size));
      pelem += round_size;
    }
  while (idx < nsystem_dirs_len);

  max_dirnamelen = SYSTEM_DIRS_MAX_LEN;
  *aelem = NULL;

  ...

_dl_init_paths函数的第一部分代码首先分配内存空间，然后遍历system_dirs，将其中的nsystem_dirs_len个路径依次添加到pelem中，通过next变量形成链表，最后其实都添加到_dl_all_dirs中。system_dirs、system_dirs_len和nsystem_dirs_len三个变量的宏定义如下，

#include "trusted-dirs.h"
static const char system_dirs[] = SYSTEM_DIRS;
static const size_t system_dirs_len[] =
{
  SYSTEM_DIRS_LEN
};
#define nsystem_dirs_len \
  (sizeof (system_dirs_len) / sizeof (system_dirs_len[0]))

SYSTEM_DIRS、SYSTEM_DIRS_LEN两个宏定义定义在trusted-dirs.h头文件中，trusted-dirs.h头文件并不是glibc源文件，而是在Makefile中，在gcc编译阶段形成。

elf/dl-load.c
dl_main->_dl_init_paths第二部分

  ...

  l = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
  if (l != NULL)
    {
      if (l->l_info[DT_RUNPATH])
    {
      decompose_rpath (&l->l_runpath_dirs,
               (const void *) (D_PTR (l, l_info[DT_STRTAB])
                       + l->l_info[DT_RUNPATH]->d_un.d_val),
               l, "RUNPATH");
      l->l_rpath_dirs.dirs = (void *) -1;
    }
      else
    {
      l->l_runpath_dirs.dirs = (void *) -1;

      if (l->l_info[DT_RPATH])
        {
          decompose_rpath (&l->l_rpath_dirs,
                   (const void *) (D_PTR (l, l_info[DT_STRTAB])
                           + l->l_info[DT_RPATH]->d_un.d_val),
                   l, "RPATH");
          l->l_rpath_dirs.malloced = 0;
        }
      else
        l->l_rpath_dirs.dirs = (void *) -1;
    }
    }

  ...

这里的_ns_loaded是在前面通过_dl_add_to_namespace_list添加到全局中去的，该link_map就是用户程序对应的link_map。
其.dynamic段中的信息DT_RUNPATH和DT_RPATH都是应用程序本身提供的库搜索路径，glibc的老版本使用DT_RPATH，而新版本使用DT_RUNPATH，因此这里先查看是否有DT_RUNPATH，再查看是否有DT_RPATH。
无论是哪种，最关键的就是通过decompose_rpath函数对其进行解析并设置到link_map中。

elf/dl-load.c
dl_main->_dl_init_paths->decompose_rpath

static bool internal_function
decompose_rpath (struct r_search_path_struct *sps,
         const char *rpath, struct link_map *l, const char *what)
{
  const char *where = l->l_name;
  char *copy;
  char *cp;
  struct r_search_path_elem **result;
  size_t nelems;
  const char *errstring = NULL;

  if (__builtin_expect (GLRO(dl_inhibit_rpath) != NULL, 0)
      && !INTUSE(__libc_enable_secure))
    {
      const char *inhp = GLRO(dl_inhibit_rpath);

      do
    {
      const char *wp = where;

      while (*inhp == *wp && *wp != '\0')
        {
          ++inhp;
          ++wp;
        }

      if (*wp == '\0' && (*inhp == '\0' || *inhp == ':'))
        {
          sps->dirs = (void *) -1;
          return false;
        }

      while (*inhp != '\0')
        if (*inhp++ == ':')
          break;
    }
      while (*inhp != '\0');
    }

  copy = expand_dynamic_string_token (l, rpath, 1);

  nelems = 0;
  for (cp = copy; *cp != '\0'; ++cp)
    if (*cp == ':')
      ++nelems;

  result = (struct r_search_path_elem **) malloc ((nelems + 1 + 1)
                          * sizeof (*result));

  fillin_rpath (copy, result, ":", 0, what, where);
  free (copy);

  sps->dirs = result;
  sps->malloced = 1;
  return true;
}

第一个if语句检查用户程序对应的link_map是否在dl_inhibit_rpath中，dl_inhibit_rpath变量用“:”分割路径，用于忽略RUNPATH或者RPATH中提供的信息，如果找到一个路径inhp和where一致，则直接退出。
expand_dynamic_string_token检查rpath中是否有例如$ORIGINAL字符，如果有，要进行替换。该函数在后面会进行分析。
再往下统计rpath中路径的个数nelems，然后根据nelems分配内存，用于存储r_search_path_elem结构。
然后通过fillin_rpath函数解析copy，将其中的路径存储在刚分配的内存result中。

elf/dl-load.c
dl_main->_dl_init_paths->decompose_rpath->expand_dynamic_string_token

static char * expand_dynamic_string_token (struct link_map *l, const char *s, int is_path)
{
  size_t cnt;
  size_t total;
  char *result;

  cnt = DL_DST_COUNT (s, is_path);
  if (__builtin_expect (cnt, 0) == 0)
    return local_strdup (s);

  total = DL_DST_REQUIRED (l, s, strlen (s), cnt);
  result = (char *) malloc (total + 1);

  return _dl_dst_substitute (l, s, result, is_path);
}

DL_DST_COUNT用于统计路径s中特殊符号的个数，这些特殊符号包括“ORIGIN”，“PLATFORM”，“LIB”等，具体这些符号的作用可以上网上查，例如ORIGIN就代表可执行文件所在目录。
接下来如果路径中没有这些特殊符号，则通过local_strdup函数拷贝路径s并返回。
如果包含了这些特殊符号，首先通过DL_DST_REQUIRED宏计算将特殊符号替换成实际值后的路径长度total，并根据该长度分配内存空间result，最后通过_dl_dst_substitute函数替换特殊字符串并返回替换后的字符串。

elf/dl-load.c
dl_main->_dl_init_paths->decompose_rpath->expand_dynamic_string_token->_dl_dst_substitute

char * _dl_dst_substitute (struct link_map *l, const char *name, char *result,
            int is_path)
{
  const char *const start = name;

  char *wp = result;
  char *last_elem = result;
  bool check_for_trusted = false;

  do
    {
      if (__builtin_expect (*name == '$', 0))
    {
      const char *repl = NULL;
      size_t len;

      ++name;
      if ((len = is_dst (start, name, "ORIGIN", is_path,
                 INTUSE(__libc_enable_secure))) != 0)
        {
          if (l == NULL)
        repl = _dl_get_origin ();
          else
        repl = l->l_origin;

          check_for_trusted = (INTUSE(__libc_enable_secure)
                   && l->l_type == lt_executable);
        }
      else if ((len = is_dst (start, name, "PLATFORM", is_path, 0)) != 0)
        repl = GLRO(dl_platform);
      else if ((len = is_dst (start, name, "LIB", is_path, 0)) != 0)
        repl = DL_DST_LIB;

      if (repl != NULL && repl != (const char *) -1)
        {
          wp = __stpcpy (wp, repl);
          name += len;
        }
      else if (len > 1)
        {
          wp = last_elem;
          name += len;
          while (*name != '\0' && (!is_path || *name != ':'))
        ++name;
          if (wp == result && is_path && *name == ':' && name[1] != '\0')
        ++name;
        }
      else
        *wp++ = '$';
    }
      else
    {
      *wp++ = *name++;
      if (is_path && *name == ':')
        {
          if (__builtin_expect (check_for_trusted, false)
          && !is_trusted_path_normalize (last_elem, wp - last_elem))
        wp = last_elem;
          else
        last_elem = wp;

          check_for_trusted = false;
        }
    }
    }
  while (*name != '\0');

  if (__builtin_expect (check_for_trusted, false)
      && !is_trusted_path_normalize (last_elem, wp - last_elem))
    wp = last_elem;

  *wp = '\0';

  return result;
}

简单分析下这个函数，首先通过while循环遍历name中的所有路径，如果没有特殊字符，即路径中没有特殊符号“$”，则进入else代码部分，该部分代码其实就是简单的复制name中的对应路径到result中。
如果包含了特殊字符，则进入if代码部分，is_dst计算name中特殊字符的长度存储在len中，repl变量存储了替换的字符串，如果是ORIGIN特殊字符，则替换为环境变量LD_ORIGIN_PATH指向的路径或者link_map中的l_origin指向的路径，如果是PLATFORM特殊字符，则替换为_dl_platform，如果是LIB特殊字符，则替换为DL_DST_LIB，DL_DST_LIB宏在编译阶段确定，这里不深入看了。下面的代码就是将特殊字符替换成repl，如果找不到repl用来替换，也即不是上述三个任何特殊字符的其中一个，则忽略该路径。

elf/dl-load.c
dl_main->_dl_init_paths->decompose_rpath->fillin_rpath

static struct r_search_path_elem **
fillin_rpath (char *rpath, struct r_search_path_elem **result, const char *sep,
          int check_trusted, const char *what, const char *where)
{
  char *cp;
  size_t nelems = 0;

  while ((cp = __strsep (&rpath, sep)) != NULL)
    {
      struct r_search_path_elem *dirp;
      size_t len = strlen (cp);

      if (len == 0)
    {
      static const char curwd[] = "./";
      cp = (char *) curwd;
    }

      while (len > 1 && cp[len - 1] == '/')
    --len;

      if (len > 0 && cp[len - 1] != '/')
    cp[len++] = '/';

      if (__builtin_expect (check_trusted, 0) && !is_trusted_path (cp, len))
    continue;

      for (dirp = GL(dl_all_dirs); dirp != NULL; dirp = dirp->next)
    if (dirp->dirnamelen == len && memcmp (cp, dirp->dirname, len) == 0)
      break;

      if (dirp != NULL)
    {
      size_t cnt;
      for (cnt = 0; cnt < nelems; ++cnt)
        if (result[cnt] == dirp)
          break;

      if (cnt == nelems)
        result[nelems++] = dirp;
    }
      else
    {
      size_t cnt;
      enum r_dir_status init_val;
      size_t where_len = where ? strlen (where) + 1 : 0;

      dirp = (struct r_search_path_elem *)
        malloc (sizeof (*dirp) + ncapstr * sizeof (enum r_dir_status)
            + where_len + len + 1);

      dirp->dirname = ((char *) dirp + sizeof (*dirp)
               + ncapstr * sizeof (enum r_dir_status));
      *((char *) __mempcpy ((char *) dirp->dirname, cp, len)) = '\0';
      dirp->dirnamelen = len;

      if (len > max_dirnamelen)
        max_dirnamelen = len;

      init_val = cp[0] != '/' ? existing : unknown;
      for (cnt = 0; cnt < ncapstr; ++cnt)
        dirp->status[cnt] = init_val;

      dirp->what = what;
      if (__builtin_expect (where != NULL, 1))
        dirp->where = memcpy ((char *) dirp + sizeof (*dirp) + len + 1
                  + (ncapstr * sizeof (enum r_dir_status)),
                  where, where_len);
      else
        dirp->where = NULL;

      dirp->next = GL(dl_all_dirs);
      GL(dl_all_dirs) = dirp;
      result[nelems++] = dirp;
    }
    }

  result[nelems] = NULL;

  return result;
}

while循环首先通过函数__strsep，利用分割符号sep，也就是“:”遍历字符串rpath中的所有路径cp，再往下通过strlen函数计算路径cp的长度len。
如果长度为0，也就是空路径，则默认为当前路径，也就是“./”。
接下来的while循环和再往下的if语句配合，删除路径最后的多个“/”，只保留最后一个。
再往下如果需要，则通过is_trusted_path检查路径，如果不安全，则忽略当前路径。
再往下检查是否已经向_dl_all_dirs中添加了对应路径的r_search_path_elem结构。
如果已经添加了对应路径的r_search_path_elem结构，也即dirp不为null，则继续查找结果result中是否已经添加了该dirp，如果没有，则添加到result数组最后。
相反，如果并未向_dl_all_dirs链表中添加相应路径对应的dirp，则为其分配内存，设置相应的信息，其中在设置dirname和where变量时，需要先进行指针的移动，该两个字符串的存放位置紧挨着r_search_path_elem结构，然后将新创建的dirp添加到全局_dl_all_dirs链表中，并添加到结果数据result中。

elf/dl-load.c
dl_main->_dl_init_paths第三部分

  ...

  if (llp != NULL && *llp != '\0')
    {
      size_t nllp;
      const char *cp = llp;
      char *llp_tmp;

      size_t cnt = DL_DST_COUNT (llp, 1);
      if (__builtin_expect (cnt == 0, 1))
    llp_tmp = strdupa (llp);
      else
    {
      size_t total = DL_DST_REQUIRED (l, llp, strlen (llp), cnt);

      llp_tmp = (char *) alloca (total + 1);
      llp_tmp = _dl_dst_substitute (l, llp, llp_tmp, 1);
    }

      nllp = 1;
      while (*cp)
    {
      if (*cp == ':' || *cp == ';')
        ++nllp;
      ++cp;
    }

      env_path_list.dirs = (struct r_search_path_elem **)
    malloc ((nllp + 1) * sizeof (struct r_search_path_elem *));
      if (env_path_list.dirs == NULL)
    {
      errstring = N_("cannot create cache for search path");
      goto signal_error;
    }

      (void) fillin_rpath (llp_tmp, env_path_list.dirs, ":;",
               INTUSE(__libc_enable_secure), "LD_LIBRARY_PATH",
               NULL);

      if (env_path_list.dirs[0] == NULL)
    {
      free (env_path_list.dirs);
      env_path_list.dirs = (void *) -1;
    }

      env_path_list.malloced = 0;
    }
  else
    env_path_list.dirs = (void *) -1;
}

这部分代码根据环境变量LD_LIBRARY_PATH，也即指针llp设置搜索路径。
首先通过宏DL_DST_COUNT、DL_DST_REQUIRED以及函数_dl_dst_substitute查找并替换LD_LIBRARY_PATH中的特殊符号ORIGIN、PLATFORM和LIB，这些宏和函数在前面都分析了。
接下来通过分隔符“:”或者“;”统计LD_LIBRARY_PATH中的路径个数nllp，然后根据该路径个数分配内存空间env_path_list.dirs。
最后通过fillin_rpath函数将LD_LIBRARY_PATH中的各个路径分开并保存在env_path_list.dirs和全局的_dl_all_dirs链表中。

elf/rtld.c
dl_main第七部分

  if (! GL(dl_rtld_map).l_name)
    GL(dl_rtld_map).l_name = (char *) GL(dl_rtld_map).l_libname->name;
  GL(dl_rtld_map).l_type = lt_library;
  main_map->l_next = &GL(dl_rtld_map);
  GL(dl_rtld_map).l_prev = main_map;
  ++GL(dl_ns)[LM_ID_BASE]._ns_nloaded;
  ++GL(dl_load_adds);

  if (GLRO(dl_use_load_bias) == (ElfW(Addr)) -2)
    GLRO(dl_use_load_bias) = main_map->l_addr == 0 ? -1 : 0;

  ElfW(Ehdr) *rtld_ehdr = (ElfW(Ehdr) *) GL(dl_rtld_map).l_map_start;
  ElfW(Phdr) *rtld_phdr = (ElfW(Phdr) *) (GL(dl_rtld_map).l_map_start
                      + rtld_ehdr->e_phoff);
  GL(dl_rtld_map).l_phdr = rtld_phdr;
  GL(dl_rtld_map).l_phnum = rtld_ehdr->e_phnum;

  size_t cnt = rtld_ehdr->e_phnum;
  while (cnt-- > 0)
    if (rtld_phdr[cnt].p_type == PT_GNU_RELRO)
      {
    GL(dl_rtld_map).l_relro_addr = rtld_phdr[cnt].p_vaddr;
    GL(dl_rtld_map).l_relro_size = rtld_phdr[cnt].p_memsz;
    break;
      }

  if (GL(dl_rtld_map).l_tls_blocksize != 0)
    GL(dl_rtld_map).l_tls_modid = _dl_next_tls_modid ();

如果ld.so作为解释器执行，则GL(dl_rtld_map).l_name不被设置，此时设置其为elf应用程序的PT_INTERP段给出的解释器路径，也即l_libname->name。
接下来将应用程序对应的link_map，也即main_map插入到GL(dl_rtld_map)链表中，然后递增link_namespaces的_ns_nloaded和_dl_load_adds表示链表中link_map的个数。
再往下获取ld.so的elf头rtld_ehdr和Segment头rtld_phdr，将其设置到GL(dl_rtld_map)中，这里的l_map_start是在前面的_dl_start_final函数中设置为_begin，而_begin在重定位后指向elf的文件头地址。
然后找到ld.so中类型为PT_GNU_RELRO的Segment头，将其信息设置到dl_rtld_map中，该信息和只读段有关。
最后如果包含了tls信息，该信息在类型为PT_TLS的Segment头中，则通过_dl_next_tls_modid函数设置l_tls_modid，即载入的模块数。

下一章开始分析dl_main的后续代码。