libltdl/loaders/dyld.c

/* loader-dyld.c -- dynamic linking on darwin and OS X

   Copyright (C) 1998-2000, 2004, 2006-2008, 2011-2015 Free Software
   Foundation, Inc.
   Written by Peter O'Gorman, 1998

   NOTE: The canonical source of this file is maintained with the
   GNU Libtool package.  Report bugs to bug-libtool@gnu.org.

GNU Libltdl is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.

As a special exception to the GNU Lesser General Public License,
if you distribute this file as part of a program or library that
is built using GNU Libtool, you may include this file under the
same distribution terms that you use for the rest of that program.

GNU Libltdl is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with GNU Libltdl; see the file COPYING.LIB.  If not, a
copy can be downloaded from  http://www.gnu.org/licenses/lgpl.html,
or obtained by writing to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/

#include "lt__private.h"
#include "lt_dlloader.h"

/* Use the preprocessor to rename non-static symbols to avoid namespace
   collisions when the loader code is statically linked into libltdl.
   Use the "<module_name>_LTX_" prefix so that the symbol addresses can
   be fetched from the preloaded symbol list by lt_dlsym():  */
#define get_vtable      dyld_LTX_get_vtable

LT_BEGIN_C_DECLS
LT_SCOPE lt_dlvtable *get_vtable (lt_user_data loader_data);
LT_END_C_DECLS


/* Boilerplate code to set up the vtable for hooking this loader into
   libltdl's loader list:  */
static int       vl_init  (lt_user_data loader_data);
static int       vl_exit  (lt_user_data loader_data);
static lt_module vm_open  (lt_user_data loader_data, const char *filename,
                           lt_dladvise advise);
static int       vm_close (lt_user_data loader_data, lt_module module);
static void *    vm_sym   (lt_user_data loader_data, lt_module module,
                          const char *symbolname);

static lt_dlvtable *vtable = 0;

/* Return the vtable for this loader, only the name and sym_prefix
   attributes (plus the virtual function implementations, obviously)
   change between loaders.  */
lt_dlvtable *
get_vtable (lt_user_data loader_data)
{
  if (!vtable)
    {
      vtable = lt__zalloc (sizeof *vtable);
    }

  if (vtable && !vtable->name)
    {
      vtable->name              = "lt_dyld";
      vtable->sym_prefix        = "_";
      vtable->dlloader_init     = vl_init;
      vtable->module_open       = vm_open;
      vtable->module_close      = vm_close;
      vtable->find_sym          = vm_sym;
      vtable->dlloader_exit     = vl_exit;
      vtable->dlloader_data     = loader_data;
      vtable->priority          = LT_DLLOADER_APPEND;
    }

  if (vtable && (vtable->dlloader_data != loader_data))
    {
      LT__SETERROR (INIT_LOADER);
      return 0;
    }

  return vtable;
}


/* --- IMPLEMENTATION --- */


#if defined HAVE_MACH_O_DYLD_H
#  if !defined __APPLE_CC__ && !defined __MWERKS__ && !defined __private_extern__
  /* Is this correct? Does it still function properly? */
#    define __private_extern__ extern
#  endif
#  include <mach-o/dyld.h>
#endif

#include <mach-o/getsect.h>

/* We have to put some stuff here that isn't in older dyld.h files */
#if !defined ENUM_DYLD_BOOL
# define ENUM_DYLD_BOOL
# undef FALSE
# undef TRUE
 enum DYLD_BOOL {
    FALSE,
    TRUE
 };
#endif
#if !defined LC_REQ_DYLD
# define LC_REQ_DYLD 0x80000000
#endif
#if !defined LC_LOAD_WEAK_DYLIB
# define LC_LOAD_WEAK_DYLIB (0x18 | LC_REQ_DYLD)
#endif

#if !defined NSADDIMAGE_OPTION_NONE
#  define NSADDIMAGE_OPTION_NONE                          0x0
#endif
#if !defined NSADDIMAGE_OPTION_RETURN_ON_ERROR
#  define NSADDIMAGE_OPTION_RETURN_ON_ERROR               0x1
#endif
#if !defined NSADDIMAGE_OPTION_WITH_SEARCHING
#  define NSADDIMAGE_OPTION_WITH_SEARCHING                0x2
#endif
#if !defined NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED
#  define NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED         0x4
#endif
#if !defined NSADDIMAGE_OPTION_MATCH_FILENAME_BY_INSTALLNAME
#  define NSADDIMAGE_OPTION_MATCH_FILENAME_BY_INSTALLNAME 0x8
#endif

#if !defined NSLOOKUPSYMBOLINIMAGE_OPTION_BIND
#  define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND               0x0
#endif
#if !defined NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW
#  define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW           0x1
#endif
#if !defined NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_FULLY
#  define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_FULLY         0x2
#endif
#if !defined NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR
#  define NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR    0x4
#endif

#define LT__SYMLOOKUP_OPTS      (NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW \
                                | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR)

#if defined __BIG_ENDIAN__
#  define LT__MAGIC     MH_MAGIC
#else
#  define LT__MAGIC     MH_CIGAM
#endif

#define DYLD__SETMYERROR(errmsg)    LT__SETERRORSTR (dylderror (errmsg))
#define DYLD__SETERROR(errcode)     DYLD__SETMYERROR (LT__STRERROR (errcode))

typedef struct mach_header mach_header;
typedef struct dylib_command dylib_command;

static const char *dylderror (const char *errmsg);
static const mach_header *lt__nsmodule_get_header (NSModule module);
static const char *lt__header_get_instnam (const mach_header *mh);
static const mach_header *lt__match_loadedlib (const char *name);
static NSSymbol lt__linkedlib_symbol (const char *symname, const mach_header *mh);

static const mach_header *(*lt__addimage)       (const char *image_name,
                                                 unsigned long options) = 0;
static NSSymbol (*lt__image_symbol)             (const mach_header *image,
                                                 const char *symbolName,
                                                 unsigned long options) = 0;
static enum DYLD_BOOL (*lt__image_symbol_p)     (const mach_header *image,
                                                 const char *symbolName) = 0;
static enum DYLD_BOOL (*lt__module_export)      (NSModule module) = 0;

static int dyld_cannot_close                              = 0;


/* A function called through the vtable when this loader is no
   longer needed by the application.  */
static int
vl_exit (lt_user_data loader_data LT__UNUSED)
{
  vtable = NULL;
  return 0;
}

/* A function called through the vtable to initialise this loader.  */
static int
vl_init (lt_user_data loader_data)
{
  int errors = 0;

  if (! dyld_cannot_close)
    {
      if (!_dyld_present ())
        {
          ++errors;
        }
      else
        {
          (void) _dyld_func_lookup ("__dyld_NSAddImage",
                                    (unsigned long*) &lt__addimage);
          (void) _dyld_func_lookup ("__dyld_NSLookupSymbolInImage",
                                    (unsigned long*)&lt__image_symbol);
          (void) _dyld_func_lookup ("__dyld_NSIsSymbolNameDefinedInImage",
                                    (unsigned long*) &lt__image_symbol_p);
          (void) _dyld_func_lookup ("__dyld_NSMakePrivateModulePublic",
                                    (unsigned long*) &lt__module_export);
          dyld_cannot_close = lt_dladderror ("can't close a dylib");
        }
    }

  return errors;
}


/* A function called through the vtable to open a module with this
   loader.  Returns an opaque representation of the newly opened
   module for processing with this loader's other vtable functions.  */
static lt_module
vm_open (lt_user_data loader_data, const char *filename,
         lt_dladvise advise LT__UNUSED)
{
  lt_module module = 0;
  NSObjectFileImage ofi = 0;

  if (!filename)
    {
      return (lt_module) -1;
    }

  switch (NSCreateObjectFileImageFromFile (filename, &ofi))
    {
    case NSObjectFileImageSuccess:
      module = NSLinkModule (ofi, filename, NSLINKMODULE_OPTION_RETURN_ON_ERROR
                                            | NSLINKMODULE_OPTION_PRIVATE
                                            | NSLINKMODULE_OPTION_BINDNOW);
      NSDestroyObjectFileImage (ofi);

      if (module)
        {
          lt__module_export (module);
        }
      break;

    case NSObjectFileImageInappropriateFile:
      if (lt__image_symbol_p && lt__image_symbol)
        {
          module = (lt_module) lt__addimage(filename,
                                            NSADDIMAGE_OPTION_RETURN_ON_ERROR);
        }
      break;

    case NSObjectFileImageFailure:
    case NSObjectFileImageArch:
    case NSObjectFileImageFormat:
    case NSObjectFileImageAccess:
      /*NOWORK*/
      break;
    }

  if (!module)
    {
      DYLD__SETERROR (CANNOT_OPEN);
    }

  return module;
}


/* A function called through the vtable when a particular module
   should be unloaded.  */
static int
vm_close (lt_user_data loader_data, lt_module module)
{
  int errors = 0;

  if (module != (lt_module) -1)
    {
      const mach_header *mh = (const mach_header *) module;
      int flags = 0;
      if (mh->magic == LT__MAGIC)
        {
          lt_dlseterror (dyld_cannot_close);
          ++errors;
        }
      else
        {
          /* Currently, if a module contains c++ static destructors and it
             is unloaded, we get a segfault in atexit(), due to compiler and
             dynamic loader differences of opinion, this works around that.  */
          if ((const struct section *) NULL !=
              getsectbynamefromheader (lt__nsmodule_get_header (module),
                                       "__DATA", "__mod_term_func"))
            {
              flags |= NSUNLINKMODULE_OPTION_KEEP_MEMORY_MAPPED;
            }
#if defined __ppc__
          flags |= NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES;
#endif
          if (!NSUnLinkModule (module, flags))
            {
              DYLD__SETERROR (CANNOT_CLOSE);
              ++errors;
            }
        }
    }

  return errors;
}

/* A function called through the vtable to get the address of
   a symbol loaded from a particular module.  */
static void *
vm_sym (lt_user_data loader_data, lt_module module, const char *name)
{
  NSSymbol *nssym = 0;
  const mach_header *mh = (const mach_header *) module;
  char saveError[256] = "Symbol not found";

  if (module == (lt_module) -1)
    {
      void *address, *unused;
      _dyld_lookup_and_bind (name, (unsigned long*) &address, &unused);
      return address;
    }

  if (mh->magic == LT__MAGIC)
    {
      if (lt__image_symbol_p && lt__image_symbol)
        {
          if (lt__image_symbol_p (mh, name))
            {
              nssym = lt__image_symbol (mh, name, LT__SYMLOOKUP_OPTS);
            }
        }

    }
  else
    {
      nssym = NSLookupSymbolInModule (module, name);
    }

  if (!nssym)
    {
      strlcpy (saveError, dylderror (LT__STRERROR (SYMBOL_NOT_FOUND)), 255);
      saveError[255] = 0;
      if (!mh)
        {
          mh = (mach_header *)lt__nsmodule_get_header (module);
        }
      nssym = lt__linkedlib_symbol (name, mh);
    }

  if (!nssym)
    {
      LT__SETERRORSTR (saveError);
    }

  return nssym ? NSAddressOfSymbol (nssym) : 0;
}


/* --- HELPER FUNCTIONS --- */


/* Return the dyld error string, or the passed in error string if none. */
static const char *
dylderror (const char *errmsg)
{
  NSLinkEditErrors ler;
  int lerno;
  const char *file;
  const char *errstr;

  NSLinkEditError (&ler, &lerno, &file, &errstr);

  if (! (errstr && *errstr))
    {
      errstr = errmsg;
    }

  return errstr;
}

/* There should probably be an apple dyld api for this. */
static const mach_header *
lt__nsmodule_get_header (NSModule module)
{
  int i = _dyld_image_count();
  const char *modname = NSNameOfModule (module);
  const mach_header *mh = 0;

  if (!modname)
    return NULL;

  while (i > 0)
    {
      --i;
      if (strneq (_dyld_get_image_name (i), modname))
        {
          mh = _dyld_get_image_header (i);
          break;
        }
    }

  return mh;
}

/* NSAddImage is also used to get the loaded image, but it only works if
   the lib is installed, for uninstalled libs we need to check the
   install_names against each other.  Note that this is still broken if
   DYLD_IMAGE_SUFFIX is set and a different lib was loaded as a result.  */
static const char *
lt__header_get_instnam (const mach_header *mh)
{
  unsigned long offset = sizeof(mach_header);
  const char* result   = 0;
  int j;

  for (j = 0; j < mh->ncmds; j++)
    {
      struct load_command *lc;

      lc = (struct load_command*) (((unsigned long) mh) + offset);
      if (LC_ID_DYLIB == lc->cmd)
        {
          result=(char*)(((dylib_command*) lc)->dylib.name.offset +
                         (unsigned long) lc);
        }
      offset += lc->cmdsize;
    }

  return result;
}

static const mach_header *
lt__match_loadedlib (const char *name)
{
  const mach_header *mh = 0;
  int i = _dyld_image_count();

  while (i > 0)
    {
      const char *id;

      --i;
      id = lt__header_get_instnam (_dyld_get_image_header (i));
      if (id && strneq (id, name))
        {
          mh = _dyld_get_image_header (i);
          break;
        }
    }

  return mh;
}

/* Safe to assume our mh is good. */
static NSSymbol
lt__linkedlib_symbol (const char *symname, const mach_header *mh)
{
  NSSymbol symbol = 0;

  if (lt__image_symbol && NSIsSymbolNameDefined (symname))
    {
      unsigned long offset = sizeof(mach_header);
      struct load_command *lc;
      int j;

      for (j = 0; j < mh->ncmds; j++)
        {
          lc = (struct load_command*) (((unsigned long) mh) + offset);
          if ((LC_LOAD_DYLIB == lc->cmd) || (LC_LOAD_WEAK_DYLIB == lc->cmd))
            {
              unsigned long base = ((dylib_command *) lc)->dylib.name.offset;
              char *name = (char *) (base + (unsigned long) lc);
              const mach_header *mh1 = lt__match_loadedlib (name);

              if (!mh1)
                {
                  /* Maybe NSAddImage can find it */
                  mh1 = lt__addimage (name,
                                      NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED
                                      | NSADDIMAGE_OPTION_WITH_SEARCHING
                                      | NSADDIMAGE_OPTION_RETURN_ON_ERROR);
                }

              if (mh1)
                {
                  symbol = lt__image_symbol (mh1, symname, LT__SYMLOOKUP_OPTS);
                  if (symbol)
                    break;
                }
            }

          offset += lc->cmdsize;
        }
    }

  return symbol;
}
Revision:	5394
Committed:	Tue Jan 20 14:03:09 2015 UTC (11 years, 6 months ago) by michael
Content type:	text/x-csrc
File size:	13617 byte(s)
Log Message:	- libtool 2.4.5, automake 1.15
#	Content
1	/* loader-dyld.c -- dynamic linking on darwin and OS X
2
3	Copyright (C) 1998-2000, 2004, 2006-2008, 2011-2015 Free Software
4	Foundation, Inc.
5	Written by Peter O'Gorman, 1998
6
7	NOTE: The canonical source of this file is maintained with the
8	GNU Libtool package. Report bugs to bug-libtool@gnu.org.
9
10	GNU Libltdl is free software; you can redistribute it and/or
11	modify it under the terms of the GNU Lesser General Public
12	License as published by the Free Software Foundation; either
13	version 2 of the License, or (at your option) any later version.
14
15	As a special exception to the GNU Lesser General Public License,
16	if you distribute this file as part of a program or library that
17	is built using GNU Libtool, you may include this file under the
18	same distribution terms that you use for the rest of that program.
19
20	GNU Libltdl is distributed in the hope that it will be useful,
21	but WITHOUT ANY WARRANTY; without even the implied warranty of
22	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23	GNU Lesser General Public License for more details.
24
25	You should have received a copy of the GNU Lesser General Public
26	License along with GNU Libltdl; see the file COPYING.LIB. If not, a
27	copy can be downloaded from http://www.gnu.org/licenses/lgpl.html,
28	or obtained by writing to the Free Software Foundation, Inc.,
29	51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
30	*/
31
32	#include "lt__private.h"
33	#include "lt_dlloader.h"
34
35	/* Use the preprocessor to rename non-static symbols to avoid namespace
36	collisions when the loader code is statically linked into libltdl.
37	Use the "<module_name>_LTX_" prefix so that the symbol addresses can
38	be fetched from the preloaded symbol list by lt_dlsym(): */
39	#define get_vtable dyld_LTX_get_vtable
40
41	LT_BEGIN_C_DECLS
42	LT_SCOPE lt_dlvtable *get_vtable (lt_user_data loader_data);
43	LT_END_C_DECLS
44
45
46	/* Boilerplate code to set up the vtable for hooking this loader into
47	libltdl's loader list: */
48	static int vl_init (lt_user_data loader_data);
49	static int vl_exit (lt_user_data loader_data);
50	static lt_module vm_open (lt_user_data loader_data, const char *filename,
51	lt_dladvise advise);
52	static int vm_close (lt_user_data loader_data, lt_module module);
53	static void * vm_sym (lt_user_data loader_data, lt_module module,
54	const char *symbolname);
55
56	static lt_dlvtable *vtable = 0;
57
58	/* Return the vtable for this loader, only the name and sym_prefix
59	attributes (plus the virtual function implementations, obviously)
60	change between loaders. */
61	lt_dlvtable *
62	get_vtable (lt_user_data loader_data)
63	{
64	if (!vtable)
65	{
66	vtable = lt__zalloc (sizeof *vtable);
67	}
68
69	if (vtable && !vtable->name)
70	{
71	vtable->name = "lt_dyld";
72	vtable->sym_prefix = "_";
73	vtable->dlloader_init = vl_init;
74	vtable->module_open = vm_open;
75	vtable->module_close = vm_close;
76	vtable->find_sym = vm_sym;
77	vtable->dlloader_exit = vl_exit;
78	vtable->dlloader_data = loader_data;
79	vtable->priority = LT_DLLOADER_APPEND;
80	}
81
82	if (vtable && (vtable->dlloader_data != loader_data))
83	{
84	LT__SETERROR (INIT_LOADER);
85	return 0;
86	}
87
88	return vtable;
89	}
90
91
92
93	/* --- IMPLEMENTATION --- */
94
95
96	#if defined HAVE_MACH_O_DYLD_H
97	# if !defined __APPLE_CC__ && !defined __MWERKS__ && !defined __private_extern__
98	/* Is this correct? Does it still function properly? */
99	# define __private_extern__ extern
100	# endif
101	# include <mach-o/dyld.h>
102	#endif
103
104	#include <mach-o/getsect.h>
105
106	/* We have to put some stuff here that isn't in older dyld.h files */
107	#if !defined ENUM_DYLD_BOOL
108	# define ENUM_DYLD_BOOL
109	# undef FALSE
110	# undef TRUE
111	enum DYLD_BOOL {
112	FALSE,
113	TRUE
114	};
115	#endif
116	#if !defined LC_REQ_DYLD
117	# define LC_REQ_DYLD 0x80000000
118	#endif
119	#if !defined LC_LOAD_WEAK_DYLIB
120	# define LC_LOAD_WEAK_DYLIB (0x18 \| LC_REQ_DYLD)
121	#endif
122
123	#if !defined NSADDIMAGE_OPTION_NONE
124	# define NSADDIMAGE_OPTION_NONE 0x0
125	#endif
126	#if !defined NSADDIMAGE_OPTION_RETURN_ON_ERROR
127	# define NSADDIMAGE_OPTION_RETURN_ON_ERROR 0x1
128	#endif
129	#if !defined NSADDIMAGE_OPTION_WITH_SEARCHING
130	# define NSADDIMAGE_OPTION_WITH_SEARCHING 0x2
131	#endif
132	#if !defined NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED
133	# define NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED 0x4
134	#endif
135	#if !defined NSADDIMAGE_OPTION_MATCH_FILENAME_BY_INSTALLNAME
136	# define NSADDIMAGE_OPTION_MATCH_FILENAME_BY_INSTALLNAME 0x8
137	#endif
138
139	#if !defined NSLOOKUPSYMBOLINIMAGE_OPTION_BIND
140	# define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND 0x0
141	#endif
142	#if !defined NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW
143	# define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW 0x1
144	#endif
145	#if !defined NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_FULLY
146	# define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_FULLY 0x2
147	#endif
148	#if !defined NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR
149	# define NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR 0x4
150	#endif
151
152	#define LT__SYMLOOKUP_OPTS (NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW \
153	\| NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR)
154
155	#if defined __BIG_ENDIAN__
156	# define LT__MAGIC MH_MAGIC
157	#else
158	# define LT__MAGIC MH_CIGAM
159	#endif
160
161	#define DYLD__SETMYERROR(errmsg) LT__SETERRORSTR (dylderror (errmsg))
162	#define DYLD__SETERROR(errcode) DYLD__SETMYERROR (LT__STRERROR (errcode))
163
164	typedef struct mach_header mach_header;
165	typedef struct dylib_command dylib_command;
166
167	static const char dylderror (const char errmsg);
168	static const mach_header *lt__nsmodule_get_header (NSModule module);
169	static const char lt__header_get_instnam (const mach_header mh);
170	static const mach_header lt__match_loadedlib (const char name);
171	static NSSymbol lt__linkedlib_symbol (const char symname, const mach_header mh);
172
173	static const mach_header (lt__addimage) (const char *image_name,
174	unsigned long options) = 0;
175	static NSSymbol (lt__image_symbol) (const mach_header image,
176	const char *symbolName,
177	unsigned long options) = 0;
178	static enum DYLD_BOOL (lt__image_symbol_p) (const mach_header image,
179	const char *symbolName) = 0;
180	static enum DYLD_BOOL (*lt__module_export) (NSModule module) = 0;
181
182	static int dyld_cannot_close = 0;
183
184
185	/* A function called through the vtable when this loader is no
186	longer needed by the application. */
187	static int
188	vl_exit (lt_user_data loader_data LT__UNUSED)
189	{
190	vtable = NULL;
191	return 0;
192	}
193
194	/* A function called through the vtable to initialise this loader. */
195	static int
196	vl_init (lt_user_data loader_data)
197	{
198	int errors = 0;
199
200	if (! dyld_cannot_close)
201	{
202	if (!_dyld_present ())
203	{
204	++errors;
205	}
206	else
207	{
208	(void) _dyld_func_lookup ("__dyld_NSAddImage",
209	(unsigned long*) &lt__addimage);
210	(void) _dyld_func_lookup ("__dyld_NSLookupSymbolInImage",
211	(unsigned long*)&lt__image_symbol);
212	(void) _dyld_func_lookup ("__dyld_NSIsSymbolNameDefinedInImage",
213	(unsigned long*) &lt__image_symbol_p);
214	(void) _dyld_func_lookup ("__dyld_NSMakePrivateModulePublic",
215	(unsigned long*) &lt__module_export);
216	dyld_cannot_close = lt_dladderror ("can't close a dylib");
217	}
218	}
219
220	return errors;
221	}
222
223
224	/* A function called through the vtable to open a module with this
225	loader. Returns an opaque representation of the newly opened
226	module for processing with this loader's other vtable functions. */
227	static lt_module
228	vm_open (lt_user_data loader_data, const char *filename,
229	lt_dladvise advise LT__UNUSED)
230	{
231	lt_module module = 0;
232	NSObjectFileImage ofi = 0;
233
234	if (!filename)
235	{
236	return (lt_module) -1;
237	}
238
239	switch (NSCreateObjectFileImageFromFile (filename, &ofi))
240	{
241	case NSObjectFileImageSuccess:
242	module = NSLinkModule (ofi, filename, NSLINKMODULE_OPTION_RETURN_ON_ERROR
243	\| NSLINKMODULE_OPTION_PRIVATE
244	\| NSLINKMODULE_OPTION_BINDNOW);
245	NSDestroyObjectFileImage (ofi);
246
247	if (module)
248	{
249	lt__module_export (module);
250	}
251	break;
252
253	case NSObjectFileImageInappropriateFile:
254	if (lt__image_symbol_p && lt__image_symbol)
255	{
256	module = (lt_module) lt__addimage(filename,
257	NSADDIMAGE_OPTION_RETURN_ON_ERROR);
258	}
259	break;
260
261	case NSObjectFileImageFailure:
262	case NSObjectFileImageArch:
263	case NSObjectFileImageFormat:
264	case NSObjectFileImageAccess:
265	/NOWORK/
266	break;
267	}
268
269	if (!module)
270	{
271	DYLD__SETERROR (CANNOT_OPEN);
272	}
273
274	return module;
275	}
276
277
278	/* A function called through the vtable when a particular module
279	should be unloaded. */
280	static int
281	vm_close (lt_user_data loader_data, lt_module module)
282	{
283	int errors = 0;
284
285	if (module != (lt_module) -1)
286	{
287	const mach_header mh = (const mach_header ) module;
288	int flags = 0;
289	if (mh->magic == LT__MAGIC)
290	{
291	lt_dlseterror (dyld_cannot_close);
292	++errors;
293	}
294	else
295	{
296	/* Currently, if a module contains c++ static destructors and it
297	is unloaded, we get a segfault in atexit(), due to compiler and
298	dynamic loader differences of opinion, this works around that. */
299	if ((const struct section *) NULL !=
300	getsectbynamefromheader (lt__nsmodule_get_header (module),
301	"__DATA", "__mod_term_func"))
302	{
303	flags \|= NSUNLINKMODULE_OPTION_KEEP_MEMORY_MAPPED;
304	}
305	#if defined __ppc__
306	flags \|= NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES;
307	#endif
308	if (!NSUnLinkModule (module, flags))
309	{
310	DYLD__SETERROR (CANNOT_CLOSE);
311	++errors;
312	}
313	}
314	}
315
316	return errors;
317	}
318
319	/* A function called through the vtable to get the address of
320	a symbol loaded from a particular module. */
321	static void *
322	vm_sym (lt_user_data loader_data, lt_module module, const char *name)
323	{
324	NSSymbol *nssym = 0;
325	const mach_header mh = (const mach_header ) module;
326	char saveError[256] = "Symbol not found";
327
328	if (module == (lt_module) -1)
329	{
330	void address, unused;
331	_dyld_lookup_and_bind (name, (unsigned long*) &address, &unused);
332	return address;
333	}
334
335	if (mh->magic == LT__MAGIC)
336	{
337	if (lt__image_symbol_p && lt__image_symbol)
338	{
339	if (lt__image_symbol_p (mh, name))
340	{
341	nssym = lt__image_symbol (mh, name, LT__SYMLOOKUP_OPTS);
342	}
343	}
344
345	}
346	else
347	{
348	nssym = NSLookupSymbolInModule (module, name);
349	}
350
351	if (!nssym)
352	{
353	strlcpy (saveError, dylderror (LT__STRERROR (SYMBOL_NOT_FOUND)), 255);
354	saveError[255] = 0;
355	if (!mh)
356	{
357	mh = (mach_header *)lt__nsmodule_get_header (module);
358	}
359	nssym = lt__linkedlib_symbol (name, mh);
360	}
361
362	if (!nssym)
363	{
364	LT__SETERRORSTR (saveError);
365	}
366
367	return nssym ? NSAddressOfSymbol (nssym) : 0;
368	}
369
370
371
372
373	/* --- HELPER FUNCTIONS --- */
374
375
376	/* Return the dyld error string, or the passed in error string if none. */
377	static const char *
378	dylderror (const char *errmsg)
379	{
380	NSLinkEditErrors ler;
381	int lerno;
382	const char *file;
383	const char *errstr;
384
385	NSLinkEditError (&ler, &lerno, &file, &errstr);
386
387	if (! (errstr && *errstr))
388	{
389	errstr = errmsg;
390	}
391
392	return errstr;
393	}
394
395	/* There should probably be an apple dyld api for this. */
396	static const mach_header *
397	lt__nsmodule_get_header (NSModule module)
398	{
399	int i = _dyld_image_count();
400	const char *modname = NSNameOfModule (module);
401	const mach_header *mh = 0;
402
403	if (!modname)
404	return NULL;
405
406	while (i > 0)
407	{
408	--i;
409	if (strneq (_dyld_get_image_name (i), modname))
410	{
411	mh = _dyld_get_image_header (i);
412	break;
413	}
414	}
415
416	return mh;
417	}
418
419	/* NSAddImage is also used to get the loaded image, but it only works if
420	the lib is installed, for uninstalled libs we need to check the
421	install_names against each other. Note that this is still broken if
422	DYLD_IMAGE_SUFFIX is set and a different lib was loaded as a result. */
423	static const char *
424	lt__header_get_instnam (const mach_header *mh)
425	{
426	unsigned long offset = sizeof(mach_header);
427	const char* result = 0;
428	int j;
429
430	for (j = 0; j < mh->ncmds; j++)
431	{
432	struct load_command *lc;
433
434	lc = (struct load_command*) (((unsigned long) mh) + offset);
435	if (LC_ID_DYLIB == lc->cmd)
436	{
437	result=(char)(((dylib_command) lc)->dylib.name.offset +
438	(unsigned long) lc);
439	}
440	offset += lc->cmdsize;
441	}
442
443	return result;
444	}
445
446	static const mach_header *
447	lt__match_loadedlib (const char *name)
448	{
449	const mach_header *mh = 0;
450	int i = _dyld_image_count();
451
452	while (i > 0)
453	{
454	const char *id;
455
456	--i;
457	id = lt__header_get_instnam (_dyld_get_image_header (i));
458	if (id && strneq (id, name))
459	{
460	mh = _dyld_get_image_header (i);
461	break;
462	}
463	}
464
465	return mh;
466	}
467
468	/* Safe to assume our mh is good. */
469	static NSSymbol
470	lt__linkedlib_symbol (const char symname, const mach_header mh)
471	{
472	NSSymbol symbol = 0;
473
474	if (lt__image_symbol && NSIsSymbolNameDefined (symname))
475	{
476	unsigned long offset = sizeof(mach_header);
477	struct load_command *lc;
478	int j;
479
480	for (j = 0; j < mh->ncmds; j++)
481	{
482	lc = (struct load_command*) (((unsigned long) mh) + offset);
483	if ((LC_LOAD_DYLIB == lc->cmd) \|\| (LC_LOAD_WEAK_DYLIB == lc->cmd))
484	{
485	unsigned long base = ((dylib_command *) lc)->dylib.name.offset;
486	char name = (char ) (base + (unsigned long) lc);
487	const mach_header *mh1 = lt__match_loadedlib (name);
488
489	if (!mh1)
490	{
491	/* Maybe NSAddImage can find it */
492	mh1 = lt__addimage (name,
493	NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED
494	\| NSADDIMAGE_OPTION_WITH_SEARCHING
495	\| NSADDIMAGE_OPTION_RETURN_ON_ERROR);
496	}
497
498	if (mh1)
499	{
500	symbol = lt__image_symbol (mh1, symname, LT__SYMLOOKUP_OPTS);
501	if (symbol)
502	break;
503	}
504	}
505
506	offset += lc->cmdsize;
507	}
508	}
509
510	return symbol;
511	}