Index: app/main.c
===================================================================
--- app/main.c	(revision 6)
+++ app/main.c	(working copy)
@@ -36,6 +36,7 @@
 #include <glib-object.h>
 
 #include "libgimpbase/gimpbase.h"
+#include "libgimpbase/gimpreloc.h"
 
 #include "core/core-types.h"
 
@@ -78,6 +79,7 @@
 
 static void      gimp_init_i18n               (void);
 static void      gimp_init_malloc             (void);
+static void      gimp_init_binreloc           (void);
 static void      gimp_init_signal_handlers    (void);
 
 #ifndef G_OS_WIN32
@@ -243,6 +245,8 @@
 
   gimp_init_malloc ();
 
+  gimp_init_binreloc ();
+
   gimp_init_i18n ();
 
   g_set_application_name (_("GNU Image Manipulation Program"));
@@ -490,6 +494,29 @@
 }
 
 static void
+gimp_init_binreloc (void)
+{
+#ifndef G_OS_WIN32
+  if (_gimp_binreloc_init (NULL))
+    {
+      gchar *libdir, *ldpath;
+
+      /* Set $LD_LIBRARY_PATH to ensure that plugins can be loaded. */
+      libdir = _gimp_binreloc_find_lib_dir (NULL);
+      ldpath = (gchar *) g_getenv ("LD_LIBRARY_PATH");
+      if (ldpath && *ldpath)
+        {
+          ldpath = g_strdup_printf ("%s:%s\n", libdir, ldpath);
+	  g_free (libdir);
+	  g_setenv ("LD_LIBRARY_PATH", ldpath, TRUE);
+	}
+      else
+          g_setenv ("LD_LIBRARY_PATH", libdir, TRUE);
+    }
+#endif
+}
+
+static void
 gimp_init_signal_handlers (void)
 {
 #ifndef G_OS_WIN32
Index: app/Makefile.am
===================================================================
--- app/Makefile.am	(revision 6)
+++ app/Makefile.am	(working copy)
@@ -71,6 +71,9 @@
 if OS_WIN32
 mwindows = -mwindows
 endif
+if OS_UNIX
+munix = -Wl,-rpath '-Wl,$$ORIGIN/../lib'
+endif
 
 if HAVE_WINDRES
 GIMPICONRC = gimprc.o
@@ -87,7 +90,7 @@
 	$(PANGOFT2_CFLAGS)	\
 	-I$(includedir)
 
-gimp_2_3_LDFLAGS = $(mwindows)
+gimp_2_3_LDFLAGS = $(mwindows) $(munix)
 
 gimp_2_3_LDADD = \
 	gui/libappgui.a			\
Index: m4macros/binreloc.m4
===================================================================
--- m4macros/binreloc.m4	(revision 0)
+++ m4macros/binreloc.m4	(revision 0)
@@ -0,0 +1,77 @@
+# Check for binary relocation support.
+# Written by Hongli Lai
+# http://autopackage.org/
+
+AC_DEFUN([AM_BINRELOC],
+[
+	AC_ARG_ENABLE(binreloc,
+		[  --enable-binreloc       compile with binary relocation support
+                          (default=enable when available)],
+		enable_binreloc=$enableval,enable_binreloc=auto)
+
+	AC_ARG_ENABLE(binreloc-threads,
+		[  --enable-binreloc-threads      compile binary relocation with threads support
+	                         (default=yes)],
+		enable_binreloc_threads=$enableval,enable_binreloc_threads=yes)
+
+	BINRELOC_CFLAGS=
+	BINRELOC_LIBS=
+	if test "x$enable_binreloc" = "xauto"; then
+		AC_CHECK_FILE([/proc/self/maps])
+		AC_CACHE_CHECK([whether everything is installed to the same prefix],
+			       [br_cv_valid_prefixes], [
+				if test "$bindir" = '${exec_prefix}/bin' -a "$sbindir" = '${exec_prefix}/sbin' -a \
+					"$datadir" = '${prefix}/share' -a "$libdir" = '${exec_prefix}/lib' -a \
+					"$libexecdir" = '${exec_prefix}/libexec' -a "$sysconfdir" = '${prefix}/etc'
+				then
+					br_cv_valid_prefixes=yes
+				else
+					br_cv_valid_prefixes=no
+				fi
+				])
+	fi
+	AC_CACHE_CHECK([whether binary relocation support should be enabled],
+		       [br_cv_binreloc],
+		       [if test "x$enable_binreloc" = "xyes"; then
+		       	       br_cv_binreloc=yes
+		       elif test "x$enable_binreloc" = "xauto"; then
+			       if test "x$br_cv_valid_prefixes" = "xyes" -a \
+			       	       "x$ac_cv_file__proc_self_maps" = "xyes"; then
+				       br_cv_binreloc=yes
+			       else
+				       br_cv_binreloc=no
+			       fi
+		       else
+			       br_cv_binreloc=no
+		       fi])
+
+	if test "x$br_cv_binreloc" = "xyes"; then
+		BINRELOC_CFLAGS="-DENABLE_BINRELOC"
+		AC_DEFINE(ENABLE_BINRELOC,,[Use binary relocation?])
+		if test "x$enable_binreloc_threads" = "xyes"; then
+			AC_CHECK_LIB([pthread], [pthread_getspecific])
+		fi
+
+		AC_CACHE_CHECK([whether binary relocation should use threads],
+			       [br_cv_binreloc_threads],
+			       [if test "x$enable_binreloc_threads" = "xyes"; then
+					if test "x$ac_cv_lib_pthread_pthread_getspecific" = "xyes"; then
+						br_cv_binreloc_threads=yes
+					else
+						br_cv_binreloc_threads=no
+					fi
+			        else
+					br_cv_binreloc_threads=no
+				fi])
+
+		if test "x$br_cv_binreloc_threads" = "xyes"; then
+			BINRELOC_LIBS="-lpthread"
+			AC_DEFINE(BR_PTHREAD,1,[Include pthread support for binary relocation?])
+		else
+			BINRELOC_CFLAGS="$BINRELOC_CFLAGS -DBR_PTHREADS=0"
+			AC_DEFINE(BR_PTHREAD,0,[Include pthread support for binary relocation?])
+		fi
+	fi
+	AC_SUBST(BINRELOC_CFLAGS)
+	AC_SUBST(BINRELOC_LIBS)
+])
Index: configure.in
===================================================================
--- configure.in	(revision 6)
+++ configure.in	(working copy)
@@ -369,7 +369,9 @@
 dnl check some more funcs
 AC_CHECK_FUNCS(difftime putenv mmap)
 
+AM_BINRELOC
 
+
 # _NL_MEASUREMENT_MEASUREMENT is an enum and not a define
 AC_MSG_CHECKING([for _NL_MEASUREMENT_MEASUREMENT])
 AC_TRY_LINK([#include <langinfo.h>], [
Index: acinclude.m4
===================================================================
--- acinclude.m4	(revision 6)
+++ acinclude.m4	(working copy)
@@ -3,3 +3,4 @@
 m4_include([m4macros/gimpprint.m4])
 m4_include([m4macros/alsa.m4])
 m4_include([m4macros/gtk-doc.m4])
+m4_include([m4macros/binreloc.m4])
Index: libgimpbase/gimpenv.c
===================================================================
--- libgimpbase/gimpenv.c	(revision 6)
+++ libgimpbase/gimpenv.c	(working copy)
@@ -34,6 +34,7 @@
 
 #include "gimpenv.h"
 #include "gimpversion.h"
+#include "gimpreloc.h"
 
 
 #ifdef G_OS_WIN32
@@ -58,10 +59,34 @@
 #define getegid() 0
 #endif
 
+static void    gimp_env_init_binreloc (void);
 static gchar * gimp_env_get_dir (const gchar *gimp_env_name,
                                  const gchar *env_dir);
 
 
+/* Initializes BinReloc if necessary. */
+static void
+gimp_env_init_binreloc (void)
+{
+#ifdef G_OS_WIN32
+  static gboolean tried_init = FALSE;
+
+  /* We don't check for gimp_binreloc_initialized() in this if-statement
+   * because initialization could fail. We only want to try once.
+   */
+  if (!tried_init)
+    {
+      tried_init = TRUE;
+      /* We do call gimp_binreloc_initialized() here because the main
+       * Gimp executable calls gimp_binreloc_init().
+       */
+      if (!_gimp_binreloc_initialized ())
+          _gimp_binreloc_init_lib (NULL);
+    }
+#endif
+}
+
+
 /**
  * gimp_directory:
  *
@@ -182,10 +207,10 @@
   return g_build_filename (gimp_directory (), basename, NULL);
 }
 
-#ifdef G_OS_WIN32
 gchar *
 gimp_toplevel_directory (void)
 {
+#ifdef G_OS_WIN32
   /* Figure it out from the executable name */
   static gchar *toplevel = NULL;
 
@@ -253,8 +278,11 @@
   toplevel = filename;
 
   return toplevel;
+#else
+  gimp_env_init_binreloc ();
+  return _gimp_binreloc_find_prefix (PREFIX);
+#endif
 }
-#endif
 
 /**
  * gimp_data_directory:
@@ -277,8 +305,16 @@
   static gchar *gimp_data_dir = NULL;
 
   if (! gimp_data_dir)
-    gimp_data_dir = gimp_env_get_dir ("GIMP2_DATADIR", DATADIR);
+    {
+      gchar *tmp;
 
+      gimp_env_init_binreloc ();
+      tmp = _gimp_binreloc_find_data_dir (DATADIR);
+      gimp_data_dir = gimp_env_get_dir ("GIMP2_DATADIR",
+					tmp);
+      g_free (tmp);
+    }
+
   return gimp_data_dir;
 }
 
@@ -303,8 +339,16 @@
   static gchar *gimp_locale_dir = NULL;
 
   if (! gimp_locale_dir)
-    gimp_locale_dir = gimp_env_get_dir ("GIMP2_LOCALEDIR", LOCALEDIR);
+    {
+      gchar *tmp;
 
+      gimp_env_init_binreloc ();
+      tmp = _gimp_binreloc_find_locale_dir (LOCALEDIR);
+      gimp_locale_dir = gimp_env_get_dir ("GIMP2_LOCALEDIR",
+					  tmp);
+      g_free (tmp);
+    }
+
   return gimp_locale_dir;
 }
 
@@ -329,8 +373,16 @@
   static gchar *gimp_sysconf_dir = NULL;
 
   if (! gimp_sysconf_dir)
-    gimp_sysconf_dir = gimp_env_get_dir ("GIMP2_SYSCONFDIR", SYSCONFDIR);
+    {
+      gchar *tmp;
 
+      gimp_env_init_binreloc ();
+      tmp = _gimp_binreloc_find_etc_dir (SYSCONFDIR);
+      gimp_sysconf_dir = gimp_env_get_dir ("GIMP2_SYSCONFDIR",
+					   tmp);
+      g_free (tmp);
+    }
+
   return gimp_sysconf_dir;
 }
 
@@ -355,8 +407,16 @@
   static gchar *gimp_plug_in_dir = NULL;
 
   if (! gimp_plug_in_dir)
-    gimp_plug_in_dir = gimp_env_get_dir ("GIMP2_PLUGINDIR", PLUGINDIR);
+    {
+      gchar *tmp;
 
+      gimp_env_init_binreloc ();
+      tmp = _gimp_binreloc_find_plugin_dir (PLUGINDIR);
+      gimp_plug_in_dir = gimp_env_get_dir ("GIMP2_PLUGINDIR",
+					   tmp);
+      g_free (tmp);
+    }
+
   return gimp_plug_in_dir;
 }
 
@@ -397,7 +457,9 @@
  * and *@path is replaced with a pointer to a new string with the
  * run-time prefix spliced in.
  *
- * On Unix, does nothing.
+ * On Linux, it does the same thing, but only if BinReloc support is enabled.
+ * On other Unices, it does nothing because those platforms don't have a
+ * way to find out where our binary is.
  */
 static void
 gimp_path_runtime_fix (gchar **path)
@@ -435,6 +497,20 @@
                                 *path, NULL);
       g_free (p);
     }
+#else
+  gchar *p;
+
+  if (strncmp (*path, PREFIX G_DIR_SEPARATOR_S, strlen (PREFIX G_DIR_SEPARATOR_S)) == 0)
+    {
+      /* This is a compile-time entry. Replace the path with the
+       * real one on this machine.
+       */
+      p = *path;
+      *path = g_build_filename (gimp_toplevel_directory (),
+				*path + strlen (PREFIX G_DIR_SEPARATOR_S),
+				NULL);
+      g_free (p);
+    }
 #endif
 }
 
Index: libgimpbase/gimpreloc.c
===================================================================
--- libgimpbase/gimpreloc.c	(revision 0)
+++ libgimpbase/gimpreloc.c	(revision 0)
@@ -0,0 +1,712 @@
+/*
+ * BinReloc - a library for creating relocatable executables
+ * Written by: Hongli Lai <h.lai@chello.nl>
+ * http://autopackage.org/
+ *
+ * This source code is public domain. You can relicense this code
+ * under whatever license you want.
+ *
+ * See http://autopackage.org/docs/binreloc/ for
+ * more information and how to use this.
+ */
+
+#ifndef _GIMPRELOC_C_
+#define _GIMPRELOC_C_
+
+#ifdef ENABLE_BINRELOC
+	#include <sys/types.h>
+	#include <sys/stat.h>
+	#include <unistd.h>
+#endif /* ENABLE_BINRELOC */
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+#include "gimpreloc.h"
+
+G_BEGIN_DECLS
+
+
+/** @internal
+ * Find the canonical filename of the executable. Returns the filename
+ * (which must be freed) or NULL on error. If the parameter 'error' is
+ * not NULL, the error code will be stored there, if an error occured.
+ */
+static char *
+_br_find_exe (GimpBinrelocInitError *error)
+{
+#ifndef ENABLE_BINRELOC
+	if (error)
+		*error = GIMP_BINRELOC_INIT_ERROR_DISABLED;
+	return NULL;
+#else
+	char *path, *path2, *line, *result;
+	size_t buf_size;
+	ssize_t size;
+	struct stat stat_buf;
+	FILE *f;
+
+	/* Read from /proc/self/exe (symlink) */
+	if (sizeof (path) > SSIZE_MAX)
+		buf_size = SSIZE_MAX - 1;
+	else
+		buf_size = PATH_MAX - 1;
+	path = (char *) g_try_malloc (buf_size);
+	if (path == NULL) {
+		/* Cannot allocate memory. */
+		if (error)
+			*error = GIMP_BINRELOC_INIT_ERROR_NOMEM;
+		return NULL;
+	}
+	path2 = (char *) g_try_malloc (buf_size);
+	if (path2 == NULL) {
+		/* Cannot allocate memory. */
+		if (error)
+			*error = GIMP_BINRELOC_INIT_ERROR_NOMEM;
+		g_free (path);
+		return NULL;
+	}
+
+	strncpy (path2, "/proc/self/exe", buf_size - 1);
+
+	while (1) {
+		int i;
+
+		size = readlink (path2, path, buf_size - 1);
+		if (size == -1) {
+			/* Error. */
+			g_free (path2);
+			break;
+		}
+
+		/* readlink() success. */
+		path[size] = '\0';
+
+		/* Check whether the symlink's target is also a symlink.
+		 * We want to get the final target. */
+		i = stat (path, &stat_buf);
+		if (i == -1) {
+			/* Error. */
+			g_free (path2);
+			break;
+		}
+
+		/* stat() success. */
+		if (!S_ISLNK (stat_buf.st_mode)) {
+			/* path is not a symlink. Done. */
+			g_free (path2);
+			return path;
+		}
+
+		/* path is a symlink. Continue loop and resolve this. */
+		strncpy (path, path2, buf_size - 1);
+	}
+
+
+	/* readlink() or stat() failed; this can happen when the program is
+	 * running in Valgrind 2.2. Read from /proc/self/maps as fallback. */
+
+	buf_size = PATH_MAX + 128;
+	line = (char *) g_try_realloc (path, buf_size);
+	if (line == NULL) {
+		/* Cannot allocate memory. */
+		g_free (path);
+		if (error)
+			*error = GIMP_BINRELOC_INIT_ERROR_NOMEM;
+		return NULL;
+	}
+
+	f = fopen ("/proc/self/maps", "r");
+	if (f == NULL) {
+		g_free (line);
+		if (error)
+			*error = GIMP_BINRELOC_INIT_ERROR_OPEN_MAPS;
+		return NULL;
+	}
+
+	/* The first entry should be the executable name. */
+	result = fgets (line, (int) buf_size, f);
+	if (result == NULL) {
+		fclose (f);
+		g_free (line);
+		if (error)
+			*error = GIMP_BINRELOC_INIT_ERROR_READ_MAPS;
+		return NULL;
+	}
+
+	/* Get rid of newline character. */
+	buf_size = strlen (line);
+	if (buf_size <= 0) {
+		/* Huh? An empty string? */
+		fclose (f);
+		g_free (line);
+		if (error)
+			*error = GIMP_BINRELOC_INIT_ERROR_INVALID_MAPS;
+		return NULL;
+	}
+	if (line[buf_size - 1] == 10)
+		line[buf_size - 1] = 0;
+
+	/* Extract the filename; it is always an absolute path. */
+	path = strchr (line, '/');
+
+	/* Sanity check. */
+	if (strstr (line, " r-xp ") == NULL || path == NULL) {
+		fclose (f);
+		g_free (line);
+		if (error)
+			*error = GIMP_BINRELOC_INIT_ERROR_INVALID_MAPS;
+		return NULL;
+	}
+
+	path = g_strdup (path);
+	g_free (line);
+	fclose (f);
+	return path;
+#endif /* ENABLE_BINRELOC */
+}
+
+
+/** @internal
+ * Find the canonical filename of the executable which owns symbol.
+ * Returns a filename which must be freed, or NULL on error.
+ */
+static char *
+_br_find_exe_for_symbol (const void *symbol, GimpBinrelocInitError *error)
+{
+#ifndef ENABLE_BINRELOC
+	if (error)
+		*error = GIMP_BINRELOC_INIT_ERROR_DISABLED;
+	return (char *) NULL;
+#else
+	#define SIZE PATH_MAX + 100
+	FILE *f;
+	size_t address_string_len;
+	char *address_string, line[SIZE], *found;
+
+	if (symbol == NULL)
+		return (char *) NULL;
+
+	f = fopen ("/proc/self/maps", "r");
+	if (f == NULL)
+		return (char *) NULL;
+
+	address_string_len = 4;
+	address_string = (char *) g_try_malloc (address_string_len);
+	found = (char *) NULL;
+
+	while (!feof (f)) {
+		char *start_addr, *end_addr, *end_addr_end, *file;
+		void *start_addr_p, *end_addr_p;
+		size_t len;
+
+		if (fgets (line, SIZE, f) == NULL)
+			break;
+
+		/* Sanity check. */
+		if (strstr (line, " r-xp ") == NULL || strchr (line, '/') == NULL)
+			continue;
+
+		/* Parse line. */
+		start_addr = line;
+		end_addr = strchr (line, '-');
+		file = strchr (line, '/');
+
+		/* More sanity check. */
+		if (!(file > end_addr && end_addr != NULL && end_addr[0] == '-'))
+			continue;
+
+		end_addr[0] = '\0';
+		end_addr++;
+		end_addr_end = strchr (end_addr, ' ');
+		if (end_addr_end == NULL)
+			continue;
+
+		end_addr_end[0] = '\0';
+		len = strlen (file);
+		if (len == 0)
+			continue;
+		if (file[len - 1] == '\n')
+			file[len - 1] = '\0';
+
+		/* Get rid of "(deleted)" from the filename. */
+		len = strlen (file);
+		if (len > 10 && strcmp (file + len - 10, " (deleted)") == 0)
+			file[len - 10] = '\0';
+
+		/* I don't know whether this can happen but better safe than sorry. */
+		len = strlen (start_addr);
+		if (len != strlen (end_addr))
+			continue;
+
+
+		/* Transform the addresses into a string in the form of 0xdeadbeef,
+		 * then transform that into a pointer. */
+		if (address_string_len < len + 3) {
+			address_string_len = len + 3;
+			address_string = (char *) g_try_realloc (address_string, address_string_len);
+		}
+
+		memcpy (address_string, "0x", 2);
+		memcpy (address_string + 2, start_addr, len);
+		address_string[2 + len] = '\0';
+		sscanf (address_string, "%p", &start_addr_p);
+
+		memcpy (address_string, "0x", 2);
+		memcpy (address_string + 2, end_addr, len);
+		address_string[2 + len] = '\0';
+		sscanf (address_string, "%p", &end_addr_p);
+
+
+		if (symbol >= start_addr_p && symbol < end_addr_p) {
+			found = file;
+			break;
+		}
+	}
+
+	g_free (address_string);
+	fclose (f);
+
+	if (found == NULL)
+		return (char *) NULL;
+	else
+		return g_strdup (found);
+#endif /* ENABLE_BINRELOC */
+}
+
+
+static gchar *exe = NULL;
+
+static void set_gerror (GError **error, GimpBinrelocInitError errcode);
+
+
+/** Initialize the BinReloc library (for applications).
+ *
+ * This function must be called before using any other BinReloc functions.
+ * It attempts to locate the application's canonical filename.
+ *
+ * @note If you want to use BinReloc for a library, then you should call
+ *       _gimp_binreloc_init_lib() instead.
+ * @note Initialization failure is not fatal. BinReloc functions will just
+ *       fallback to the supplied default path.
+ *
+ * @param error  If BinReloc failed to initialize, then the error report will
+ *               be stored in this variable. Set to NULL if you don't want an
+ *               error report. See the #GimpBinrelocInitError for a list of error
+ *               codes.
+ *
+ * @returns TRUE on success, FALSE if BinReloc failed to initialize.
+ */
+gboolean
+_gimp_binreloc_init (GError **error)
+{
+	GimpBinrelocInitError errcode;
+
+	/* Shut up compiler warning about uninitialized variable. */
+	errcode = GIMP_BINRELOC_INIT_ERROR_NOMEM;
+
+	/* Locate the application's filename. */
+	exe = _br_find_exe (&errcode);
+	if (exe != NULL)
+		/* Success! */
+		return TRUE;
+	else {
+		/* Failed :-( */
+		set_gerror (error, errcode);
+		return FALSE;
+	}
+}
+
+
+/** Initialize the BinReloc library (for libraries).
+ *
+ * This function must be called before using any other BinReloc functions.
+ * It attempts to locate the calling library's canonical filename.
+ *
+ * @note The BinReloc source code MUST be included in your library, or this
+ *       function won't work correctly.
+ * @note Initialization failure is not fatal. BinReloc functions will just
+ *       fallback to the supplied default path.
+ *
+ * @returns TRUE on success, FALSE if a filename cannot be found.
+ */
+G_GNUC_INTERNAL gboolean
+_gimp_binreloc_init_lib (GError **error)
+{
+	GimpBinrelocInitError errcode;
+
+	/* Shut up compiler warning about uninitialized variable. */
+	errcode = GIMP_BINRELOC_INIT_ERROR_NOMEM;
+
+	exe = _br_find_exe_for_symbol ((const void *) "", &errcode);
+	if (exe != NULL)
+		/* Success! */
+		return TRUE;
+	else {
+		/* Failed :-( */
+		set_gerror (error, errcode);
+		return exe != NULL;
+	}
+}
+
+
+/** Checks whether BinReloc is initialized.
+ *
+ * @returns TRUE or FALSE.
+ */
+G_GNUC_INTERNAL gboolean
+_gimp_binreloc_is_initialized   (void)
+{
+	return exe != NULL;
+}
+
+
+static void
+set_gerror (GError **error, GimpBinrelocInitError errcode)
+{
+	gchar *error_message;
+
+	if (error == NULL)
+		return;
+
+	switch (errcode) {
+	case GIMP_BINRELOC_INIT_ERROR_NOMEM:
+		error_message = "Cannot allocate memory.";
+		break;
+	case GIMP_BINRELOC_INIT_ERROR_OPEN_MAPS:
+		error_message = "Unable to open /proc/self/maps for reading.";
+		break;
+	case GIMP_BINRELOC_INIT_ERROR_READ_MAPS:
+		error_message = "Unable to read from /proc/self/maps.";
+		break;
+	case GIMP_BINRELOC_INIT_ERROR_INVALID_MAPS:
+		error_message = "The file format of /proc/self/maps is invalid.";
+		break;
+	case GIMP_BINRELOC_INIT_ERROR_DISABLED:
+		error_message = "Binary relocation support is disabled.";
+		break;
+	default:
+		error_message = "Unknown error.";
+		break;
+	};
+	g_set_error (error, g_quark_from_static_string ("GBinReloc"),
+		     errcode, "%s", error_message);
+}
+
+
+/** Find the canonical filename of the current application.
+ *
+ * @param default_exe  A default filename which will be used as fallback.
+ * @returns A string containing the application's canonical filename,
+ *          which must be freed when no longer necessary. If BinReloc is
+ *          not initialized, or if the initialization function failed,
+ *          then a copy of default_exe will be returned. If default_exe
+ *          is NULL, then NULL will be returned.
+ */
+G_GNUC_INTERNAL gchar *
+_gimp_binreloc_find_exe (const gchar *default_exe)
+{
+	if (exe == NULL) {
+		/* BinReloc is not initialized. */
+		if (default_exe != NULL)
+			return g_strdup (default_exe);
+		else
+			return NULL;
+	}
+	return g_strdup (exe);
+}
+
+
+/** Locate the directory in which the current application is installed.
+ *
+ * The prefix is generated by the following pseudo-code evaluation:
+ * \code
+ * dirname(exename)
+ * \endcode
+ *
+ * @param default_dir  A default directory which will used as fallback.
+ * @return A string containing the directory, which must be freed when no
+ *         longer necessary. If BinReloc is not initialized, or if the
+ *         initialization function failed, then a copy of default_dir
+ *         will be returned. If default_dir is NULL, then NULL will be
+ *         returned.
+ */
+G_GNUC_INTERNAL gchar *
+_gimp_binreloc_find_exe_dir (const gchar *default_dir)
+{
+	if (exe == NULL) {
+		/* BinReloc not initialized. */
+		if (default_dir != NULL)
+			return g_strdup (default_dir);
+		else
+			return NULL;
+	}
+
+	return g_path_get_dirname (exe);
+}
+
+
+/** Locate the prefix in which the current application is installed.
+ *
+ * The prefix is generated by the following pseudo-code evaluation:
+ * \code
+ * dirname(dirname(exename))
+ * \endcode
+ *
+ * @param default_prefix  A default prefix which will used as fallback.
+ * @return A string containing the prefix, which must be freed when no
+ *         longer necessary. If BinReloc is not initialized, or if the
+ *         initialization function failed, then a copy of default_prefix
+ *         will be returned. If default_prefix is NULL, then NULL will be
+ *         returned.
+ */
+G_GNUC_INTERNAL gchar *
+_gimp_binreloc_find_prefix (const gchar *default_prefix)
+{
+	gchar *dir1, *dir2;
+
+	if (exe == NULL) {
+		/* BinReloc not initialized. */
+		if (default_prefix != NULL)
+			return g_strdup (default_prefix);
+		else
+			return NULL;
+	}
+
+	dir1 = g_path_get_dirname (exe);
+	dir2 = g_path_get_dirname (dir1);
+	g_free (dir1);
+	return dir2;
+}
+
+
+/** Locate the application's binary folder.
+ *
+ * The path is generated by the following pseudo-code evaluation:
+ * \code
+ * prefix + "/bin"
+ * \endcode
+ *
+ * @param default_bin_dir  A default path which will used as fallback.
+ * @return A string containing the bin folder's path, which must be freed when
+ *         no longer necessary. If BinReloc is not initialized, or if the
+ *         initialization function failed, then a copy of default_bin_dir will
+ *         be returned. If default_bin_dir is NULL, then NULL will be returned.
+ */
+G_GNUC_INTERNAL gchar *
+_gimp_binreloc_find_bin_dir (const gchar *default_bin_dir)
+{
+	gchar *prefix, *dir;
+
+	prefix = _gimp_binreloc_find_prefix (NULL);
+	if (prefix == NULL) {
+		/* BinReloc not initialized. */
+		if (default_bin_dir != NULL)
+			return g_strdup (default_bin_dir);
+		else
+			return NULL;
+	}
+
+	dir = g_build_filename (prefix, "bin", NULL);
+	g_free (prefix);
+	return dir;
+}
+
+
+/** Locate the application's data folder.
+ *
+ * The path is generated by the following pseudo-code evaluation:
+ * \code
+ * prefix + "/share/" + GIMP_PACKAGE + "/" + GIMP_DATA_VERSION
+ * \endcode
+ *
+ * @param default_data_dir  A default path which will used as fallback.
+ * @return A string containing the data folder's path, which must be freed when
+ *         no longer necessary. If BinReloc is not initialized, or if the
+ *         initialization function failed, then a copy of default_data_dir
+ *         will be returned. If default_data_dir is NULL, then NULL will be
+ *         returned.
+ */
+G_GNUC_INTERNAL gchar *
+_gimp_binreloc_find_data_dir (const gchar *default_data_dir)
+{
+	gchar *prefix, *dir;
+
+	prefix = _gimp_binreloc_find_prefix (NULL);
+	if (prefix == NULL) {
+		/* BinReloc not initialized. */
+		if (default_data_dir != NULL)
+			return g_strdup (default_data_dir);
+		else
+			return NULL;
+	}
+
+	dir = g_build_filename (prefix, "share",
+				GIMP_PACKAGE,
+				GIMP_DATA_VERSION,
+				NULL);
+	g_free (prefix);
+	return dir;
+}
+
+G_GNUC_INTERNAL gchar *
+_gimp_binreloc_find_plugin_dir (const gchar *default_plugin_dir)
+{
+	gchar *libdir, *dir;
+
+	libdir = _gimp_binreloc_find_lib_dir (NULL);
+	if (libdir == NULL) {
+		/* BinReloc not initialized. */
+		if (default_plugin_dir != NULL)
+			return g_strdup (default_plugin_dir);
+		else
+			return NULL;
+	}
+
+	dir = g_build_filename (libdir,
+				GIMP_PACKAGE,
+				GIMP_PLUGIN_VERSION,
+				NULL);
+	g_free (libdir);
+	return dir;
+}
+
+
+/** Locate the application's localization folder.
+ *
+ * The path is generated by the following pseudo-code evaluation:
+ * \code
+ * prefix + "/share/locale"
+ * \endcode
+ *
+ * @param default_locale_dir  A default path which will used as fallback.
+ * @return A string containing the localization folder's path, which must be freed when
+ *         no longer necessary. If BinReloc is not initialized, or if the
+ *         initialization function failed, then a copy of default_locale_dir will be returned.
+ *         If default_locale_dir is NULL, then NULL will be returned.
+ */
+G_GNUC_INTERNAL gchar *
+_gimp_binreloc_find_locale_dir (const gchar *default_locale_dir)
+{
+	gchar *data_dir, *dir;
+
+	data_dir = _gimp_binreloc_find_data_dir (NULL);
+	if (data_dir == NULL) {
+		/* BinReloc not initialized. */
+		if (default_locale_dir != NULL)
+			return g_strdup (default_locale_dir);
+		else
+			return NULL;
+	}
+
+	dir = g_build_filename (data_dir, "locale", NULL);
+	g_free (data_dir);
+	return dir;
+}
+
+
+/** Locate the application's library folder.
+ *
+ * The path is generated by the following pseudo-code evaluation:
+ * \code
+ * prefix + "/lib"
+ * \endcode
+ *
+ * @param default_lib_dir  A default path which will used as fallback.
+ * @return A string containing the library folder's path, which must be freed when
+ *         no longer necessary. If BinReloc is not initialized, or if the
+ *         initialization function failed, then a copy of default_lib_dir will be returned.
+ *         If default_lib_dir is NULL, then NULL will be returned.
+ */
+gchar *
+_gimp_binreloc_find_lib_dir (const gchar *default_lib_dir)
+{
+	gchar *prefix, *dir;
+
+	prefix = _gimp_binreloc_find_prefix (NULL);
+	if (prefix == NULL) {
+		/* BinReloc not initialized. */
+		if (default_lib_dir != NULL)
+			return g_strdup (default_lib_dir);
+		else
+			return NULL;
+	}
+
+	dir = g_build_filename (prefix, "lib", NULL);
+	g_free (prefix);
+	return dir;
+}
+
+
+/** Locate the application's libexec folder.
+ *
+ * The path is generated by the following pseudo-code evaluation:
+ * \code
+ * prefix + "/libexec"
+ * \endcode
+ *
+ * @param default_libexec_dir  A default path which will used as fallback.
+ * @return A string containing the libexec folder's path, which must be freed when
+ *         no longer necessary. If BinReloc is not initialized, or if the initialization
+ *         function failed, then a copy of default_libexec_dir will be returned.
+ *         If default_libexec_dir is NULL, then NULL will be returned.
+ */
+G_GNUC_INTERNAL gchar *
+_gimp_binreloc_find_libexec_dir (const gchar *default_libexec_dir)
+{
+	gchar *prefix, *dir;
+
+	prefix = _gimp_binreloc_find_prefix (NULL);
+	if (prefix == NULL) {
+		/* BinReloc not initialized. */
+		if (default_libexec_dir != NULL)
+			return g_strdup (default_libexec_dir);
+		else
+			return NULL;
+	}
+
+	dir = g_build_filename (prefix, "libexec", NULL);
+	g_free (prefix);
+	return dir;
+}
+
+
+/** Locate the application's configuration files folder.
+ *
+ * The path is generated by the following pseudo-code evaluation:
+ * \code
+ * prefix + "/etc/" + GIMP_PACKAGE + "/" + GIMP_SYSCONF_VERSION
+ * \endcode
+ *
+ * @param default_etc_dir  A default path which will used as fallback.
+ * @return A string containing the etc folder's path, which must be freed when
+ *         no longer necessary. If BinReloc is not initialized, or if the initialization
+ *         function failed, then a copy of default_etc_dir will be returned.
+ *         If default_etc_dir is NULL, then NULL will be returned.
+ */
+G_GNUC_INTERNAL gchar *
+_gimp_binreloc_find_etc_dir (const gchar *default_etc_dir)
+{
+	gchar *prefix, *dir;
+
+	prefix = _gimp_binreloc_find_prefix (NULL);
+	if (prefix == NULL) {
+		/* BinReloc not initialized. */
+		if (default_etc_dir != NULL)
+			return g_strdup (default_etc_dir);
+		else
+			return NULL;
+	}
+
+	dir = g_build_filename (prefix, "etc",
+				GIMP_PACKAGE,
+				GIMP_SYSCONF_VERSION,
+				NULL);
+	g_free (prefix);
+	return dir;
+}
+
+
+G_END_DECLS
+
+#endif /* _GIMPRELOC_C_ */
Index: libgimpbase/gimpreloc.h
===================================================================
--- libgimpbase/gimpreloc.h	(revision 0)
+++ libgimpbase/gimpreloc.h	(revision 0)
@@ -0,0 +1,55 @@
+/*
+ * BinReloc - a library for creating relocatable executables
+ * Written by: Hongli Lai <h.lai@chello.nl>
+ * http://autopackage.org/
+ *
+ * This source code is public domain. You can relicense this code
+ * under whatever license you want.
+ *
+ * See http://autopackage.org/docs/binreloc/ for
+ * more information and how to use this.
+ */
+
+#ifndef _GIMPRELOC_H_
+#define _GIMPRELOC_H_
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+
+/** These error codes can be returned _gimp_binreloc_init() or _gimp_binreloc_init_lib(). */
+typedef enum {
+	/** Cannot allocate memory. */
+	GIMP_BINRELOC_INIT_ERROR_NOMEM,
+	/** Unable to open /proc/self/maps; see errno for details. */
+	GIMP_BINRELOC_INIT_ERROR_OPEN_MAPS,
+	/** Unable to read from /proc/self/maps; see errno for details. */
+	GIMP_BINRELOC_INIT_ERROR_READ_MAPS,
+	/** The file format of /proc/self/maps is invalid; kernel bug? */
+	GIMP_BINRELOC_INIT_ERROR_INVALID_MAPS,
+	/** BinReloc is disabled (the ENABLE_BINRELOC macro is not defined). */
+	GIMP_BINRELOC_INIT_ERROR_DISABLED
+} GimpBinrelocInitError;
+
+
+gboolean _gimp_binreloc_init            (GError **error);
+gboolean _gimp_binreloc_init_lib        (GError **error) G_GNUC_INTERNAL;
+gboolean _gimp_binreloc_is_initialized  (void)           G_GNUC_INTERNAL;
+
+gchar * _gimp_binreloc_find_exe         (const gchar *default_exe)         G_GNUC_INTERNAL;
+gchar * _gimp_binreloc_find_exe_dir     (const gchar *default_dir)         G_GNUC_INTERNAL;
+gchar * _gimp_binreloc_find_prefix      (const gchar *default_prefix)      G_GNUC_INTERNAL;
+gchar * _gimp_binreloc_find_bin_dir     (const gchar *default_bin_dir)     G_GNUC_INTERNAL;
+gchar * _gimp_binreloc_find_sbin_dir    (const gchar *default_sbin_dir)    G_GNUC_INTERNAL;
+gchar * _gimp_binreloc_find_data_dir    (const gchar *default_data_dir)    G_GNUC_INTERNAL;
+gchar * _gimp_binreloc_find_plugin_dir  (const gchar *default_plugin_dir)  G_GNUC_INTERNAL;
+gchar * _gimp_binreloc_find_locale_dir  (const gchar *default_locale_dir)  G_GNUC_INTERNAL;
+gchar * _gimp_binreloc_find_lib_dir     (const gchar *default_lib_dir);
+gchar * _gimp_binreloc_find_libexec_dir (const gchar *default_libexec_dir) G_GNUC_INTERNAL;
+gchar * _gimp_binreloc_find_etc_dir     (const gchar *default_etc_dir)     G_GNUC_INTERNAL;
+
+
+G_END_DECLS
+
+#endif /* _GIMPRELOC_H_ */
Index: libgimpbase/Makefile.am
===================================================================
--- libgimpbase/Makefile.am	(revision 6)
+++ libgimpbase/Makefile.am	(working copy)
@@ -46,7 +46,12 @@
 	-DLOCALEDIR=\""$(gimplocaledir)"\"	\
 	-DPLUGINDIR=\""$(gimpplugindir)"\"	\
 	-DSYSCONFDIR=\""$(gimpsysconfdir)"\"	\
+	-DGIMP_PACKAGE=\""@PACKAGE@"\"		\
+	-DGIMP_DATA_VERSION=\"$(GIMP_DATA_VERSION)\"		\
+	-DGIMP_SYSCONF_VERSION=\"$(GIMP_SYSCONF_VERSION)\"	\
+	-DGIMP_PLUGIN_VERSION=\"$(GIMP_PLUGIN_VERSION)\"	\
 	-DG_LOG_DOMAIN=\"LibGimpBase\"		\
+	$(BINRELOC_CFLAGS)			\
 	@GTHREAD_CFLAGS@
 
 INCLUDES = \
@@ -90,6 +95,8 @@
 	gimpparasiteio.h	\
 	gimpprotocol.c		\
 	gimpprotocol.h		\
+	gimpreloc.c		\
+	gimpreloc.h		\
 	gimpsignal.c            \
 	gimpsignal.h            \
 	gimpunit.c		\
