rbdc 1.0.0 → 1.1.0

data/dyncall/dyncallback/dyncall_args_mips64.c

@@ -30,7 +30,7 @@
 DClonglong dcbArgLongLong(DCArgs* p)
 {
   DClonglong value;
-  if(p->reg_count < DCARGS_MIPS_NUM_IREGS)
+  if(p->reg_count < DCARGS_MIPS_NUM_REGS)
     value = p->ireg_data[p->reg_count++];
   else {
     value = *((DClonglong*)p->stackptr);
@@ -54,7 +54,7 @@ DCpointer   dcbArgPointer(DCArgs* p) { return (DCpointer)dcbArgLongLong(p); }
 DCdouble dcbArgDouble(DCArgs* p)
 {
   DCdouble result;
-  if(p->reg_count < DCARGS_MIPS_NUM_FREGS)
+  if(p->reg_count < DCARGS_MIPS_NUM_REGS)
     result = p->freg_data[p->reg_count++];
   else {
     result = *((DCdouble*)p->stackptr);
@@ -65,7 +65,7 @@ DCdouble dcbArgDouble(DCArgs* p)
 DCfloat dcbArgFloat(DCArgs* p)
 {
   DCfloat result;
-  if(p->reg_count < DCARGS_MIPS_NUM_FREGS) {
+  if(p->reg_count < DCARGS_MIPS_NUM_REGS) {
     result = ((DCfloat*)&p->freg_data[p->reg_count++])
 #if defined(DC__Endian_LITTLE)
       [0];

data/dyncall/dyncallback/dyncall_args_mips_o32.c

@@ -29,7 +29,12 @@
 DCint dcbArgInt(DCArgs* p)
 {
   DCint value;
-  p->freg_count = 2; /* first int will disable float reg use. */
+
+#if defined(DC__ABI_HARDFLOAT)
+  /* first int will disable float reg use. */
+  p->freg_count = 2;
+#endif /* DC__ABI_HARDFLOAT */
+
   value = *((int*)p->stackptr);
   p->stackptr += sizeof(int);
   return value;
@@ -63,19 +68,23 @@ DCpointer   dcbArgPointer(DCArgs* p) { return (DCpointer)dcbArgUInt(p); }
 DCfloat dcbArgFloat(DCArgs* p)
 {
   DCfloat result;
+
+#if defined(DC__ABI_HARDFLOAT)
   if(p->freg_count < 2) {
 	/* Stored float regs (max 2) are always 8b aligned. The way we look them up, */
 	/* relative to a diverging p->stackptr, we need consider this. Only works    */
 	/* with up to two float args, which is all we need. Hacky, but saves us      */
 	/* from one more variable and more bookkeeping in DCArgs.                    */
     result = ((DCfloat*)(p->stackptr + ((int)p->stackptr & 4)) - 4) /* '-4' b/c those regs are stored right before the args */
-#if defined(DC__Endian_LITTLE)
+# if defined(DC__Endian_LITTLE)
       [0];
-#else
+# else
       [1];
-#endif
+# endif
 	++p->freg_count;
-  } else {
+  } else
+#endif /* DC__ABI_HARDFLOAT */
+  {
     result = *((DCfloat*)p->stackptr);
   }
   p->stackptr += sizeof(DCfloat);
@@ -88,12 +97,16 @@ DCdouble dcbArgDouble(DCArgs* p)
     DCfloat f[2];
   } d;
   p->stackptr += ((int)p->stackptr & 4); /* Skip one slot if not aligned. */
+
+#if defined(DC__ABI_HARDFLOAT)
   if(p->freg_count < 2) {
     /*result = *((DCdouble*)p->stackptr-2); this changes the value, slightly*/
     d.f[0] = ((DCfloat*)p->stackptr-4)[0]; /* '-4' b/c those regs are stored right before the args */
     d.f[1] = ((DCfloat*)p->stackptr-4)[1];
     ++p->freg_count;
-  } else {
+  } else
+#endif /* DC__ABI_HARDFLOAT */
+  {
     /*result = *((DCdouble*)p->stackptr); this changes the value, slightly*/
     d.f[0] = ((DCfloat*)p->stackptr)[0];
     d.f[1] = ((DCfloat*)p->stackptr)[1];

data/dyncall/dyncallback/dyncall_callback_arch.S

@@ -65,7 +65,17 @@
 #  elif defined(DC__Arch_PPC64)
 #    include "dyncall_callback_ppc64.S"
 #  elif defined(DC__Arch_MIPS) || defined(DC__Arch_MIPS64)
-#    include "dyncall_callback_mips_gas.S"
+#    if defined(DC__ABI_MIPS_O32)
+#      include "dyncall_callback_mips_o32.S"
+#    elif defined(DC__ABI_MIPS_N64)
+#      include "dyncall_callback_mips_n64.S"
+#    elif defined(DC__ABI_MIPS_N32)
+#      include "dyncall_callback_mips_n32.S"
+#    elif defined(DC__ABI_MIPS_EABI)
+#      include "dyncall_callback_mips_eabi_gas.s"
+#    else
+#      error Unknown MIPS ABI.
+#    endif
 #  elif defined(DC__Arch_ARM_ARM)
 #    include "dyncall_callback_arm32_arm_gas.S"
 #  elif defined(DC__Arch_ARM_THUMB)

data/dyncall/dyncallback/{dyncall_callback_mips_n32_gas.s → dyncall_callback_mips_n32.S}

@@ -2,7 +2,7 @@
 
  Package: dyncall
  Library: dyncallback
- File: dyncallback/dyncall_callback_mips_n32_gas.s
+ File: dyncallback/dyncall_callback_mips_n32.S
  Description: Callback Thunk - Implementation for mips64 n32
  License:
 

data/dyncall/dyncallback/{dyncall_callback_mips_n64_gas.s → dyncall_callback_mips_n64.S}

@@ -2,11 +2,11 @@
 
  Package: dyncall
  Library: dyncallback
- File: dyncallback/dyncall_callback_mips_n64_gas.s
+ File: dyncallback/dyncall_callback_mips_n64.S
  Description: Callback Thunk - Implementation for mips64 n64
  License:
 
-   Copyright (c) 2016 Tassilo Philipp <tphilipp@potion-studios.com>
+   Copyright (c) 2016-2018 Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
    purpose with or without fee is hereby granted, provided that the above
@@ -28,6 +28,18 @@
 		$t8+64 -> userdata
 	*/
 
+/* Frame size is 160b for hard- and 128b for soft-float, as follows: */
+/*   DCargs(fregs:64? + iregs:64 + regcnts:8 + sp:8) + rval:8 + ra:8 */
+#if defined(DC__ABI_HARDFLOAT)
+SP_SP = 160
+#else
+SP_SP = 96
+#endif
+SP_LR     = SP_SP-8
+SP_RVAL   = SP_SP-16
+SP_ARG_SP = SP_SP-24
+SP_ARG_RC = SP_SP-32
+
 	.section .mdebug.abi64
 	.previous
 	.abicalls
@@ -39,17 +51,15 @@ dcCallbackThunkEntry:
 	.set    noreorder
 
 	/* Prolog. */
-	/* Frame size of 160b comes from following: */
-	/*   DCargs(fregs:64 + iregs:64 + regcounts:8 + stackptr:8) + retval:8 + ra:8 */
-	daddiu $sp, $sp, -160 /* open frame */
-	sd     $ra, 152($sp)  /* save link register */
+	daddiu $sp, $sp, -SP_SP   /* open frame */
+	sd     $ra, SP_LR($sp)    /* save link register */
 
-	.frame $fp,160,$31    /* specify our frame: fp,size,lr; creates virt $fp */
+	.frame $fp,SP_SP,$31  /* specify our frame: fp,size,lr; creates virt $fp */
 	                      /* code below doesn't use $fp though, as n/a with -O1 */
 	/* Init return value */
-	sd $zero, 144($sp)
+	sd $zero, SP_RVAL($sp)
 
-	/* Store float and int args where our DCargs member arrays are, in local area. */
+	/* Store reg args where our DCargs member arrays are, in local stack area */
 	sd  $4,     0($sp)
 	sd  $5,     8($sp)
 	sd  $6,    16($sp)
@@ -58,6 +68,7 @@ dcCallbackThunkEntry:
 	sd  $9,    40($sp)
 	sd $10,    48($sp)
 	sd $11,    56($sp)
+#if defined(DC__ABI_HARDFLOAT)
 	s.d $f12,  64($sp)
 	s.d $f13,  72($sp)
 	s.d $f14,  80($sp)
@@ -66,31 +77,34 @@ dcCallbackThunkEntry:
 	s.d $f17, 104($sp)
 	s.d $f18, 112($sp)
 	s.d $f19, 120($sp)
+#endif
 
 	/* Init DCarg's reg_counts and stackptr. */
-	sd $zero, 128($sp)    /* reg_count */
-	daddiu $4, $sp, 160
-	sd     $4, 136($sp)   /* stackptr */
+	sd  $zero, SP_ARG_RC($sp)   /* reg_count */
+	daddiu $4, $sp, SP_SP
+	sd     $4, SP_ARG_SP($sp)   /* stackptr */
 
 	/* Prepare callback handler call. */
-	move   $4, $24        /* Param 0 = DCCallback*, $24 ($t8) holds pointer to thunk */
-	move   $5, $sp        /* Param 1 = DCArgs*, pointer to where pointer to args is stored */
-	daddiu $6, $sp, 144   /* Param 2 = results pointer to 8b of local data on stack */
-	ld     $7, 64($24)    /* Param 3 = userdata pointer */
+	move   $4, $24          /* Param 0 = DCCallback*, $24/$t8 holds DCThunk* */
+	move   $5, $sp          /* Param 1 = ptr to where DCArgs* is stored */
+	daddiu $6, $sp, SP_RVAL /* Param 2 = results ptr to 8b of local stack data */
+	ld     $7, 64($24)      /* Param 3 = userdata pointer */
 
-	ld     $25, 56($24)   /* store handler entry in $25 ($t9), required for PIC */
-	jalr   $25            /* jump */
-	nop                   /* branch delay nop */
+	ld     $25, 56($24)     /* store handler entry in $25/$t9, required for PIC */
+	jalr   $25              /* jump */
+	nop                     /* branch delay nop */
 
 	/* Copy result in corresponding registers $2-$3 ($v0-$v1) and $f0 */
-	ld     $2, 144($sp)   /* note: ignoring second possible retval in $3, here */
-	l.d   $f0, 144($sp)
+	ld     $2, SP_RVAL($sp)   /* note: ignoring 2nd possible retval in $3, here */
+#if defined(DC__ABI_HARDFLOAT)
+	l.d    $f0, SP_RVAL($sp)
+#endif
 
 	/* Epilog. Tear down frame and return. */
-	ld    $ra, 152($sp)   /* restore return address */
-	daddiu $sp, $sp, 160  /* close frame */
-	j     $ra             /* return */
-	nop                   /* branch delay nop */
+	ld     $ra, SP_LR($sp)  /* restore return address */
+	daddiu $sp, $sp, SP_SP  /* close frame */
+	j      $ra              /* return */
+	nop                     /* branch delay nop */
 
 	.set    reorder
 	.end    dcCallbackThunkEntry

data/dyncall/dyncallback/{dyncall_callback_mips_o32_gas.s → dyncall_callback_mips_o32.S}

@@ -2,7 +2,7 @@
 
  Package: dyncall
  Library: dyncallback
- File: dyncallback/dyncall_callback_mips_o32_gas.s
+ File: dyncallback/dyncall_callback_mips_o32.S
  Description: Callback Thunk - Implementation mips32 o32
  License:
 
@@ -60,18 +60,22 @@ dcCallbackThunkEntry:
 	/* For $4-$7 ($a0-$a3), use dedicated spill area (caller doesn't spill, but */
 	/* provides it at end of _caller's_ frame, so $fp points right to it).      */
 	/* For $f12 and $f14 use our space (in local data), which is adjacent.      */
-	s.d $f12, 40($sp) /* -16($fp) */
-	s.d $f14, 48($sp) /*  -8($fp) */
-	sw $4,    56($sp) /*   0($fp) */
-	sw $5,    60($sp) /*   4($fp) */
-	sw $6,    64($sp) /*   8($fp) */
-	sw $7,    68($sp) /*  12($fp) */
+#if defined(DC__ABI_HARDFLOAT)
+	s.d $f12, 40($sp)   /* -16($fp) */
+	s.d $f14, 48($sp)   /*  -8($fp) */
+#endif /* DC__ABI_HARDFLOAT */
+	sw $4,    56($sp)   /*   0($fp) */
+	sw $5,    60($sp)   /*   4($fp) */
+	sw $6,    64($sp)   /*   8($fp) */
+	sw $7,    68($sp)   /*  12($fp) */
 
 	/* Init DCArg, which contains reg_count and stackptr* to the args. Point  */
 	/* stackptr to the area where the non-float args start (which is at $fp). */
-	addiu $4, $sp, 56 /* non-$fp replacement for: */
-	sw    $4, 28($sp) /*   sw $fp, 28($sp) */
-	sw $zero, 24($sp)
+	addiu $4, $sp, 56   /* <- non-$fp replacement for: */
+	sw    $4, 28($sp)   /* <-   sw $fp, 28($sp)        */
+#if defined(DC__ABI_HARDFLOAT)
+	sw $zero, 24($sp)   /* init num float-regs (unused for soft-float) */
+#endif /* DC__ABI_HARDFLOAT */
 
 	/* Prepare callback handler call. */
 	move  $4, $12       /* Param 0 = DCCallback*, $12 ($t4) holds pointer to thunk */
@@ -83,10 +87,22 @@ dcCallbackThunkEntry:
 	jalr  $25           /* jump */
 	nop                 /* branch delay nop */
 
-	/* Copy result in corresponding registers $2-$3 ($v0-$v1) and $f0 */
-	lw     $2, 32($sp)
-	lw     $3, 36($sp)
+	/* Copy result to corresponding registers */
+	/* Handle single precision soft-float retvals differently on big-endian */
+	/* targets as they are right-justified in their 8b stack lots           */
+#if !defined(DC__ABI_HARDFLOAT) && defined(DC__Endian_BIG)
+	xori  $4, $2, 'f'   /* $4 = 0 if cb-handler returned 'f' in $2 */
+#endif
+	lw    $2, 32($sp)
+	lw    $3, 36($sp)
+#if defined(DC__ABI_HARDFLOAT)
 	l.d   $f0, 32($sp)
+#elif defined(DC__Endian_BIG)
+	bgtz  $4, .nonf32r  /* if no 'f' returned, $2 and $3 are good */
+	nop                 /* branch delay nop */
+	move  $2, $3
+.nonf32r:
+#endif /* DC__ABI_HARDFLOAT */
 
 	/* Epilog. Tear down frame and return. */
 	lw    $ra, 20($sp)  /* restore return address */

data/dyncall/dyncallback/dyncall_callback_x86_masm.asm

@@ -2,7 +2,6 @@
 .386
 .MODEL FLAT
 .CODE
-
 DCThunk_size = 16
 DCArgs_size = 20
 DCValue_size = 8

data/dyncall/dyncallback/dyncall_thunk.h

@@ -51,7 +51,7 @@
  **
  **/
 
-#include "../dyncall/dyncall_macros.h"
+#include "dyncall_macros.h"
 
 typedef struct DCThunk_ DCThunk;
 

data/dyncall/dyncallback/gen-masm.sh

@@ -1,8 +1,6 @@
 #!/bin/sh
+cd `dirname $0`
 
-# Uses portasm to generates MASM sources for intel platforms.
-printf "; auto-generated by `basename $0`\r\n" >dyncall_callback_x86_masm.asm
-printf "; auto-generated by `basename $0`\r\n" >dyncall_callback_x64_masm.asm
-gcc -E -P -DGEN_MASM dyncall_callback_x86.S | awk '{printf "%s\r\n", $0}' >> dyncall_callback_x86_masm.asm
-gcc -E -P -DGEN_MASM dyncall_callback_x64.S | awk '{printf "%s\r\n", $0}' >> dyncall_callback_x64_masm.asm
+../portasm/gen-masm.sh dyncall_callback_x86 _masm
+../portasm/gen-masm.sh dyncall_callback_x64 _masm
 

data/dyncall/dynload/dynload.3

@@ -54,7 +54,9 @@ and
 .Fn dlFindSymbol
 calls. Passing a null pointer for the
 .Ar libpath
-argument is valid, and returns a handle to the main executable of the calling code. Also, searching libraries in library paths (e.g. by just passing the library's leaf name) should work, however, they are OS specific. Returns a null pointer on error.
+argument is valid, and returns a handle to the main executable of the calling code. Also, searching libraries in library paths (e.g. by just passing the library's leaf name) should work, however, they are OS specific. The
+.Ar libPath
+argument is expected to be UTF-8 encoded. Returns a null pointer on error.
 .Pp
 .Fn dlFreeLibrary 
 frees the loaded library with handle
@@ -74,11 +76,13 @@ The parameter
 .Ar sOut
 is a pointer to a buffer of size
 .Ar bufSize
-(in bytes), to hold the output string. The return value is the size of the buffer (in bytes) needed to hold the null-terminated string, or 0 if it can't be looked up. If
+(in bytes), to hold the output string (UTF-8 encoded). The return value is the size of the buffer (in bytes) needed to hold the null-terminated string, or 0 if it can't be looked up. If
 .Ar bufSize
->= return value > 1, a null-terminted string with the path to the library should be in
+>= return value >= 1, a null-terminted string with the path to the library should be in
 .Ar sOut .
-If it returns 0, the library name wasn't able to be found. Please note that this might happen in some rare cases, so make sure to always check.
+If it returns 0, the library name wasn't able to be found. Please note that this might happen in some rare cases, so make sure to always check. Passing a null pointer as
+.Ar pLib
+returns the path to the executable (not guaranteed to be absolute - if it isn't it's relative to the working directory the process was started in, not the current one).
 .Pp
 The dlSyms* functions can be used to iterate over symbols. Since they can be used on libraries that are not linked, they are made
 for symbol name lookups, not to get symbols' addresses. For that refer to
@@ -99,14 +103,22 @@ must point to a loaded symbol.
 .Sh BUGS
 .Fn dlGetLibraryPath
 is not thread-safe on Darwin (macOS, iOS, ...) and OpenBSD.
+.Pp
 .Fn dlSymsInit
 is not thread-safe on Darwin.
+.Pp
 .Fn dlGetLibraryPath
 will not work on the following platforms when the library in question doesn't have the (default)
 .Fn _init
 and
 .Fn _fini
 symbols exported (rare, but possible): Haiku (all versions), OpenBSD < 3.7, NetBSD < 5.1, FreeBSD < 4.8
+.Pp
+Getting the executable's path by passing NULL in
+.Ar pLib
+to
+.Fn dlGetLibraryPath
+fails on the following platforms: Haiku (all versions), OpenBSD < 3.7, NetBSD < 5.1, FreeBSD < 4.8
 .Sh CONFORMING TO
 The dynload library conforms to c99.
 .Ed

data/dyncall/dynload/dynload_unix.c

@@ -38,7 +38,12 @@
 
 #include <string.h>
 
-#if defined(__GLIBC__) /* to access dlinfo */
+#if defined(__GLIBC__)
+/* @@@ version check glibc more precisely... dl_iterate_phdr(): glibc ver >= 2.2.4*/
+#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 3)
+#  define DL_USE_GLIBC_ITER_PHDR
+#endif
+/* to access dl_iterate_phdr(), and related w/ glibc */
 #  define _GNU_SOURCE
 #  define __USE_GNU
 #endif
@@ -69,32 +74,42 @@ void dlFreeLibrary(DLLib* pLib)
 
 
 
-/* for dlopen-based dlGetLibraryPath impls below, prefer RTLD_NOLOAD */
-/* that merely checks lib names */
+/* for dlopen-based dlGetLibraryPath impls below, prefer RTLD_NOLOAD that
+ * merely checks lib names */
 #if defined(RTLD_NOLOAD)
-#  define RTLD_LIGHTEST RTLD_NOLOAD
+#  define RTLD_LIGHTEST RTLD_LAZY|RTLD_NOLOAD
 #else
 #  define RTLD_LIGHTEST RTLD_LAZY
 #endif
 
 
-/* code for dlGetLibraryPath is platform specific - if dlinfo() exists use */
-/* that: check for RTLD_DI_LINKMAP (#define for dlinfo()), or if GNU C Lib */
-/* is used (where RTLD_DI_LINKMAP is an enum), or by OS (dlinfo comes from */
-/* Solaris), etc. */
-#if defined(RTLD_DI_LINKMAP) || defined(OS_SunOS) || defined(__GLIBC__) /* @@@ dlinfo() was introduced in glibc 2.3.3 (in 2003), somehow check for that, also */
+/* helper copying string if buffer big enough, returning length (without \0) */
+static int dl_strlen_strcpy(char* dst, const char* src, int dstSize)
+{
+  int l = strlen(src);
+  if(l < dstSize) /* l+'\0' <= bufSize */
+    strcpy(dst, src);
+  return l;
+}
+
+/* code for dlGetLibraryPath() is platform specific */
+
+/* if dlinfo() exists use it (except on glibc, where it exists since version
+ * 2.3.3, but its implementation is dangerous, as no checks are done whether
+ * the handle is valid, thus rendering the returned values useless) check for
+ * RTLD_DI_LINKMAP which is a #define for dlinfo() on most supported targets,
+ * or specifically check the OS (e.g. dlinfo() is originally from Solaris) */
+#if (defined(RTLD_DI_LINKMAP) || defined(OS_SunOS)) && !defined(DL_USE_GLIBC_ITER_PHDR)
 
 #include <link.h>
 
 int dlGetLibraryPath(DLLib* pLib, char* sOut, int bufSize)
 {
-  struct link_map* p;
+  struct link_map* p = NULL;
   int l = -1;
-  if(dlinfo(pLib, RTLD_DI_LINKMAP, &p) == 0) {
-    l = strlen(p->l_name);
-    if(l < bufSize) /* l+'\0' <= bufSize */
-      strcpy(sOut, p->l_name);
-  }
+  if(dlinfo(pLib ? pLib : RTLD_SELF, RTLD_DI_LINKMAP, &p) == 0)
+    l = dl_strlen_strcpy(sOut, p->l_name, bufSize);
+
   return l+1; /* strlen + '\0' */
 }
 
@@ -110,26 +125,30 @@ int dlGetLibraryPath(DLLib* pLib, char* sOut, int bufSize)
   uint32_t i;
   int l = -1;
 
-  /*if(pLib == RTLD_DEFAULT)
-    return NULL; @@@ return exec's path */
-
-  /* Darwin's code doesn't come with (non-standard) dlinfo(), so use dyld(1) */
-  /* code. There doesn't seem to be a direct way to query the library path,  */
-  /* so "double-load" temporarily all already loaded images (just increases  */
-  /* ref count) and compare handles until we found ours. Return the name.    */
-  for(i=_dyld_image_count(); i>0;) /* iterate libs from end, more likely ours */
-  {
-    const char* libPath = _dyld_get_image_name(--i);
-    void* lib = dlopen(libPath, RTLD_LIGHTEST);
-    if(lib) {
-      dlclose(lib);
-      /* compare handle pointers' high bits (in low 2 bits some flags might */
-      /* be stored - should be safe b/c address needs alignment, anywas) */
-      if(((intptr_t)pLib ^ (intptr_t)lib) < 4) {
-        l = strlen(libPath);
-        if(l < bufSize) /* l+'\0' <= bufSize */
-          strcpy(sOut, libPath);
-        break;
+  /* request info about own process? lookup first loaded image */
+  if(pLib == NULL) {
+    const char* libPath = _dyld_get_image_name(0); //@@@ consider using _NSGetExecutablePath()
+    if(libPath)
+      l = dl_strlen_strcpy(sOut, libPath, bufSize);
+  }
+  else {
+    /* Darwin's code doesn't come with (non-standard) dlinfo(), so use dyld(1)
+     * code. There doesn't seem to be a direct way to query the library path,
+     * so "double-load" temporarily all already loaded images (just increases
+     * ref count) and compare handles until we found ours. Return the name. */
+    for(i=_dyld_image_count(); i>0;) /* backwards, ours is more likely at end */
+    {
+      const char* libPath = _dyld_get_image_name(--i);
+      void* lib = dlopen(libPath, RTLD_LIGHTEST);
+      if(lib) {
+        dlclose(lib);
+
+        /* compare handle pointers' high bits (in low 2 bits some flags might */
+        /* be stored - should be safe b/c address needs alignment, anyways) */
+        if(((uintptr_t)pLib ^ (uintptr_t)lib) < 4) {
+          l = dl_strlen_strcpy(sOut, libPath, bufSize);
+          break;
+        }
       }
     }
   }
@@ -138,9 +157,10 @@ int dlGetLibraryPath(DLLib* pLib, char* sOut, int bufSize)
 }
 
 
-/* OpenBSD >= 3.7 has dl_iterate_phdr(), use it if not explicitly requesting */
-/* to use dladdr()-based guessing (set by configure) -----> */
-#elif defined(OS_OpenBSD) && !defined(DL_DLADDR_TO_LIBPATH)
+/* OpenBSD >= 3.7 has dl_iterate_phdr(), as well as glibc >= 2.2.4, however
+ * skip and use on dladdr()-based guessing if if explicitly requested, e.g. by
+ * ./configure */
+#elif !defined(DL_DLADDR_TO_LIBPATH) && (defined(OS_OpenBSD) || defined(DL_USE_GLIBC_ITER_PHDR))
 
 #include <sys/types.h>
 #include <link.h>
@@ -155,18 +175,41 @@ static int iter_phdr_cb(struct dl_phdr_info* info, size_t size, void* data)
 {
   int l = -1;
   iter_phdr_data* d = (iter_phdr_data*)data;
-  /* unable to relate info->dlpi_addr directly to our dlopen handle, let's */
-  /* do what we do on macOS above, re-dlopen the already loaded lib (just  */
-  /* increases ref count) and compare handles. */
-  void* lib = dlopen(info->dlpi_name, RTLD_LIGHTEST);
-  if(lib) {
-    dlclose(lib);
-    if(lib == (void*)d->pLib) {
-      l = strlen(info->dlpi_name);
-      if(l < d->bufSize) /* l+'\0' <= bufSize */
-        strcpy(d->sOut, info->dlpi_name);
+  void* lib = NULL;
+
+  /* get loaded object's handle if not requesting info about process itself */
+  if(d->pLib != NULL) {
+    /* unable to relate info->dlpi_addr directly to our dlopen handle, let's
+     * do what we do on macOS above, re-dlopen the already loaded lib (just
+     * increases ref count) and compare handles */
+	/* @@@ might be b/c it's the reloc addr... see below */
+    lib = dlopen(info->dlpi_name, RTLD_LIGHTEST);
+    if(lib)
+      dlclose(lib);
+  }
+
+  /* compare handles and get name if found; if d->pLib == NULL this will
+     enter info on first iterated object, which is the process itself */
+  if(lib == (void*)d->pLib) {
+    l = dl_strlen_strcpy(d->sOut, info->dlpi_name, d->bufSize);
+
+    /* if dlpi_name is empty, lookup name via dladdr(proc_load_addr, ...) */
+    if(l == 0 && d->pLib == NULL) {
+      /* dlpi_addr is the reloc base (0 if PIE), find real virtual load addr */
+      void* vladdr = (void*)info->dlpi_addr;
+      int i = 0;
+      for(; i < info->dlpi_phnum; ++i) {
+        if(info->dlpi_phdr[i].p_type == PT_LOAD) {
+          vladdr = (void*)(info->dlpi_addr + info->dlpi_phdr[i].p_vaddr);
+          break;
+        }
+      }
+      Dl_info di;
+      if(dladdr(vladdr, &di) != 0)
+        l = dl_strlen_strcpy(d->sOut, di.dli_fname, d->bufSize);
     }
   }
+
   return l+1; /* strlen + '\0'; is 0 if lib not found, which continues iter */
 }
 
@@ -177,9 +220,16 @@ int dlGetLibraryPath(DLLib* pLib, char* sOut, int bufSize)
 }
 
 
+/* glibc with neither dl_iterate_phdr() nor dlinfo() (latter introduced after former) @@@
+#elif defined(__GLIBC__) && !defined(DL_USE_GLIBC_ITER_PHDR)
+
+@@@impl */
+
 /* fallback to dladdr() hack */
 #else
 
+#warning "Using non-optimal code for dlGetLibraryPath() b/c of platform limitations."
+
 /* if nothing else is available, fall back to guessing using dladdr() - this */
 /* might not always work, as it's trying to getit via the _fini() symbol,    */
 /* which is usually defined in ELF files, but not guaranteed                 */
@@ -190,16 +240,14 @@ int dlGetLibraryPath(DLLib* pLib, char* sOut, int bufSize)
 
 int dlGetLibraryPath(DLLib* pLib, char* sOut, int bufSize)
 {
+/*@@@ missing handler for pLib == NULL*/
   /* cross fingers that shared object is standard ELF and look for _fini */
   int l = -1;
   void* s = dlsym((void*)pLib, "_fini");
   if(s) {
     Dl_info i;
-    if(dladdr(s, &i) != 0) {
-      l = strlen(i.dli_fname);
-      if(l < bufSize) /* l+'\0' <= bufSize */
-        strcpy(sOut, i.dli_fname);
-    }
+    if(dladdr(s, &i) != 0)
+      l = dl_strlen_strcpy(sOut, i.dli_fname, bufSize);
   }
   return l+1; /* strlen + '\0' */
 }