cheri: elf: elfptr_t fixes for preinit/init/fini array

According to the ELF spec:

 "Each element of this array is a pointer to a function to be executed
  by the dynamic linker."

 "Note that the address of a function need not be the same as a pointer
  to a function as defined by the processor supplement."

so these should be accessed via uintptr_t type instead of ElfW(Addr) and
the pointers are derived from the RX pointer of the elf module.

diff --git a/csu/libc-start.c b/csu/libc-start.c
index 09235865bd84f4142cbd2e0ad3af0c553b53323b..d71fbec3fe0cc0d355d20bd00425598c7d224077 100644 (file)
--- a/csu/libc-start.c
+++ b/csu/libc-start.c
@@ -132,15 +132,15 @@ call_init (int argc, char **argv, char **env)
      the same file.  */
 
   if (ELF_INITFINI && l->l_info[DT_INIT] != NULL)
-    DL_CALL_DT_INIT(l, l->l_addr + l->l_info[DT_INIT]->d_un.d_ptr,
+    DL_CALL_DT_INIT(l, dl_rx_ptr (l, l->l_info[DT_INIT]->d_un.d_ptr),
                    argc, argv, env);
 
   ElfW(Dyn) *init_array = l->l_info[DT_INIT_ARRAY];
   if (init_array != NULL)
     {
       unsigned int jm
-       = l->l_info[DT_INIT_ARRAYSZ]->d_un.d_val / sizeof (ElfW(Addr));
-      ElfW(Addr) *addrs = (void *) (init_array->d_un.d_ptr + l->l_addr);
+       = l->l_info[DT_INIT_ARRAYSZ]->d_un.d_val / sizeof (elfptr_t);
+      elfptr_t *addrs = (void *) dl_rx_ptr (l, init_array->d_un.d_ptr);
       for (unsigned int j = 0; j < jm; ++j)
        ((dl_init_t) addrs[j]) (argc, argv, env);
     }

diff --git a/elf/dl-close.c b/elf/dl-close.c
index bcd6e206e94b1c67cbe0b884f82eed847ccd228e..5a45062f099822563fa94d0f2199dfa06fd08422 100644 (file)
--- a/elf/dl-close.c
+++ b/elf/dl-close.c
@@ -119,11 +119,10 @@ call_destructors (void *closure)
 
   if (map->l_info[DT_FINI_ARRAY] != NULL)
     {
-      ElfW(Addr) *array =
-       (ElfW(Addr) *) (map->l_addr
-                       + map->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
+      elfptr_t *array =
+       (elfptr_t *) dl_rx_ptr (map, map->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
       unsigned int sz = (map->l_info[DT_FINI_ARRAYSZ]->d_un.d_val
-                        / sizeof (ElfW(Addr)));
+                        / sizeof (elfptr_t));
 
       while (sz-- > 0)
        ((fini_t) array[sz]) ();
@@ -131,8 +130,7 @@ call_destructors (void *closure)
 
   /* Next try the old-style destructor.  */
   if (map->l_info[DT_FINI] != NULL)
-    DL_CALL_DT_FINI (map, ((void *) map->l_addr
-                          + map->l_info[DT_FINI]->d_un.d_ptr));
+    DL_CALL_DT_FINI (map, dl_rx_ptr (map, map->l_info[DT_FINI]->d_un.d_ptr));
 }
 
 void

diff --git a/elf/dl-fini.c b/elf/dl-fini.c
index 030b1fcbcdc3018d7874ca4760eacbfb5fa66760..18135b2191b911a12f3850301f30c24eb422d883 100644 (file)
--- a/elf/dl-fini.c
+++ b/elf/dl-fini.c
@@ -133,11 +133,10 @@ _dl_fini (void)
                      /* First see whether an array is given.  */
                      if (l->l_info[DT_FINI_ARRAY] != NULL)
                        {
-                         ElfW(Addr) *array =
-                           (ElfW(Addr) *) (l->l_addr
-                                           + l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
+                         ElfW(Addr) v = l->l_info[DT_FINI_ARRAY]->d_un.d_ptr;
+                         elfptr_t *array = (elfptr_t *) dl_rx_ptr (l, v);
                          unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val
-                                           / sizeof (ElfW(Addr)));
+                                           / sizeof (elfptr_t));
                          while (i-- > 0)
                            ((fini_t) array[i]) ();
                        }
@@ -145,7 +144,7 @@ _dl_fini (void)
                      /* Next try the old-style destructor.  */
                      if (ELF_INITFINI && l->l_info[DT_FINI] != NULL)
                        DL_CALL_DT_FINI
-                         (l, l->l_addr + l->l_info[DT_FINI]->d_un.d_ptr);
+                         (l, dl_rx_ptr (l, l->l_info[DT_FINI]->d_un.d_ptr));
                    }
 
 #ifdef SHARED

diff --git a/elf/dl-init.c b/elf/dl-init.c
index deefeb099a856d1f590626f6c5fb5727b94e11d8..7fb2af6a3f433f744b60bb7514b1d058d22835ac 100644 (file)
--- a/elf/dl-init.c
+++ b/elf/dl-init.c
@@ -53,7 +53,8 @@ call_init (struct link_map *l, int argc, char **argv, char **env)
      - the others in the DT_INIT_ARRAY.
   */
   if (ELF_INITFINI && l->l_info[DT_INIT] != NULL)
-    DL_CALL_DT_INIT(l, l->l_addr + l->l_info[DT_INIT]->d_un.d_ptr, argc, argv, env);
+    DL_CALL_DT_INIT(l, dl_rx_ptr (l, l->l_info[DT_INIT]->d_un.d_ptr),
+                   argc, argv, env);
 
   /* Next see whether there is an array with initialization functions.  */
   ElfW(Dyn) *init_array = l->l_info[DT_INIT_ARRAY];
@@ -61,11 +62,11 @@ call_init (struct link_map *l, int argc, char **argv, char **env)
     {
       unsigned int j;
       unsigned int jm;
-      ElfW(Addr) *addrs;
+      elfptr_t *addrs;
 
-      jm = l->l_info[DT_INIT_ARRAYSZ]->d_un.d_val / sizeof (ElfW(Addr));
+      jm = l->l_info[DT_INIT_ARRAYSZ]->d_un.d_val / sizeof (elfptr_t);
 
-      addrs = (ElfW(Addr) *) (init_array->d_un.d_ptr + l->l_addr);
+      addrs = (elfptr_t *) dl_rx_ptr (l, init_array->d_un.d_ptr);
       for (j = 0; j < jm; ++j)
        ((dl_init_t) addrs[j]) (argc, argv, env);
     }
@@ -88,16 +89,16 @@ _dl_init (struct link_map *main_map, int argc, char **argv, char **env)
   /* Don't do anything if there is no preinit array.  */
   if (__builtin_expect (preinit_array != NULL, 0)
       && preinit_array_size != NULL
-      && (i = preinit_array_size->d_un.d_val / sizeof (ElfW(Addr))) > 0)
+      && (i = preinit_array_size->d_un.d_val / sizeof (elfptr_t)) > 0)
     {
-      ElfW(Addr) *addrs;
+      elfptr_t *addrs;
       unsigned int cnt;
 
       if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS))
        _dl_debug_printf ("\ncalling preinit: %s\n\n",
                          DSO_FILENAME (main_map->l_name));
 
-      addrs = (ElfW(Addr) *) (preinit_array->d_un.d_ptr + main_map->l_addr);
+      addrs = (elfptr_t *) dl_rx_ptr (main_map, preinit_array->d_un.d_ptr);
       for (cnt = 0; cnt < i; ++cnt)
        ((dl_init_t) addrs[cnt]) (argc, argv, env);
     }