if (_dl_addr (ptmalloc_init, &di, &l, NULL) != 0 && l->l_ns != LM_ID_BASE)
if (_dl_open_hook != NULL || (_dl_addr (ptmalloc_init, &di, &l, NULL) != 0 && l->l_ns != LM_ID_BASE))
ptmalloc_init (void){#if __STD_C  const char* s;#else  char* s;#endif  int secure = 0;  if(__malloc_initialized >= 0) return;  __malloc_initialized = 0;#ifdef _LIBC# if defined SHARED && defined USE_TLS && !USE___THREAD  /* ptmalloc_init_minimal may already have been called via     __libc_malloc_pthread_startup, above.  */  if (mp_.pagesize == 0)# endif#endif    ptmalloc_init_minimal();#ifndef NO_THREADS# if defined _LIBC && defined USE_TLS  /* We know __pthread_initialize_minimal has already been called,     and that is enough.  */#   define NO_STARTER# endif# ifndef NO_STARTER  /* With some threads implementations, creating thread-specific data     or initializing a mutex may call malloc() itself.  Provide a     simple starter version (realloc() won't work). */  save_malloc_hook = __malloc_hook;  save_memalign_hook = __memalign_hook;  save_free_hook = __free_hook;  __malloc_hook = malloc_starter;  __memalign_hook = memalign_starter;  __free_hook = free_starter;#  ifdef _LIBC  /* Initialize the pthreads interface. */  if (__pthread_initialize != NULL)    __pthread_initialize();#  endif /* !defined _LIBC */# endif	/* !defined NO_STARTER */#endif /* !defined NO_THREADS */  mutex_init(&main_arena.mutex);  main_arena.next = &main_arena;#if defined _LIBC && defined SHARED  /* In case this libc copy is in a non-default namespace, never use brk.  */  Dl_info di;  struct link_map *l;  if (_dl_addr (ptmalloc_init, &di, &l, NULL) != 0 && l->l_ns != LM_ID_BASE)    __morecore = __failing_morecore;#endif  mutex_init(&list_lock);  tsd_key_create(&arena_key, NULL);  tsd_setspecific(arena_key, (Void_t *)&main_arena);  thread_atfork(ptmalloc_lock_all, ptmalloc_unlock_all, ptmalloc_unlock_all2);#ifndef NO_THREADS# ifndef NO_STARTER  __malloc_hook = save_malloc_hook;  __memalign_hook = save_memalign_hook;  __free_hook = save_free_hook;# else#  undef NO_STARTER# endif#endif#ifdef _LIBC  secure = __libc_enable_secure;  s = NULL;  if (__builtin_expect (_environ != NULL, 1))    {      char **runp = _environ;      char *envline;      while (__builtin_expect ((envline = next_env_entry (&runp)) != NULL,			       0))	{	  size_t len = strcspn (envline, "=");	  if (envline[len] != '=')	    /* This is a "MALLOC_" variable at the end of the string	       without a '=' character.  Ignore it since otherwise we	       will access invalid memory below.  */	    continue;	  switch (len)	    {	    case 6:	      if (memcmp (envline, "CHECK_", 6) == 0)		s = &envline[7];	      break;	    case 8:	      if (! secure && memcmp (envline, "TOP_PAD_", 8) == 0)		mALLOPt(M_TOP_PAD, atoi(&envline[9]));	      break;	    case 9:	      if (! secure && memcmp (envline, "MMAP_MAX_", 9) == 0)		mALLOPt(M_MMAP_MAX, atoi(&envline[10]));	      break;	    case 15:	      if (! secure)		{		  if (memcmp (envline, "TRIM_THRESHOLD_", 15) == 0)		    mALLOPt(M_TRIM_THRESHOLD, atoi(&envline[16]));		  else if (memcmp (envline, "MMAP_THRESHOLD_", 15) == 0)		    mALLOPt(M_MMAP_THRESHOLD, atoi(&envline[16]));		}	      break;	    default:	      break;	    }	}    }#else  if (! secure)    {      if((s = getenv("MALLOC_TRIM_THRESHOLD_")))	mALLOPt(M_TRIM_THRESHOLD, atoi(s));      if((s = getenv("MALLOC_TOP_PAD_")))	mALLOPt(M_TOP_PAD, atoi(s));      if((s = getenv("MALLOC_MMAP_THRESHOLD_")))	mALLOPt(M_MMAP_THRESHOLD, atoi(s));      if((s = getenv("MALLOC_MMAP_MAX_")))	mALLOPt(M_MMAP_MAX, atoi(s));    }  s = getenv("MALLOC_CHECK_");#endif  if(s) {    if(s[0]) mALLOPt(M_CHECK_ACTION, (int)(s[0] - '0'));    if (check_action != 0)      __malloc_check_init();  }  if(__malloc_initialize_hook != NULL)    (*__malloc_initialize_hook)();  __malloc_initialized = 1;}