lazy = (*(getenv ("LD_WARN") ?: "") == '\0' ? -1 : (*(getenv ("LD_BIND_NOW") ?: "") == '\0' ? 1 : 0));
lazy = (_dl_verbose ? (*(getenv ("LD_BIND_NOW") ?: "") == '\0' ? 1 : 0) : -1);
dl_main (const ElfW(Phdr) *phdr,	 ElfW(Half) phent,	 ElfW(Addr) *user_entry){  const ElfW(Phdr) *ph;  struct link_map *main_map;  int lazy;  enum { normal, list, verify, trace } mode;  struct link_map **preloads;  unsigned int npreloads;  const char *preloadlist;  size_t file_size;  char *file;  int has_interp = 0;  mode = getenv ("LD_TRACE_LOADED_OBJECTS") != NULL ? trace : normal;  /* LAZY is determined by the parameters --datadeps and --function-deps     if we trace the binary.  */  if (mode == trace)    lazy = (*(getenv ("LD_WARN") ?: "") == '\0' ? -1	    : (*(getenv ("LD_BIND_NOW") ?: "") == '\0' ? 1 : 0));  else    lazy = !__libc_enable_secure && *(getenv ("LD_BIND_NOW") ?: "") == '\0';  /* Set up a flag which tells we are just starting.  */  _dl_starting_up = 1;  if (*user_entry == (ElfW(Addr)) &_start)    {      /* Ho ho.  We are not the program interpreter!  We are the program	 itself!  This means someone ran ld.so as a command.  Well, that	 might be convenient to do sometimes.  We support it by	 interpreting the args like this:	 ld.so PROGRAM ARGS...	 The first argument is the name of a file containing an ELF	 executable we will load and run with the following arguments.	 To simplify life here, PROGRAM is searched for using the	 normal rules for shared objects, rather than $PATH or anything	 like that.  We just load it and use its entry point; we don't	 pay attention to its PT_INTERP command (we are the interpreter	 ourselves).  This is an easy way to test a new ld.so before	 installing it.  */      if (_dl_argc < 2)	_dl_sysdep_fatal ("\Usage: ld.so [--list|--verify] EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n\You have invoked `ld.so', the helper program for shared library executables.\n\This program usually lives in the file `/lib/ld.so', and special directives\n\in executable files using ELF shared libraries tell the system's program\n\loader to load the helper program from this file.  This helper program loads\n\the shared libraries needed by the program executable, prepares the program\n\to run, and runs it.  You may invoke this helper program directly from the\n\command line to load and run an ELF executable file; this is like executing\n\that file itself, but always uses this helper program from the file you\n\specified, instead of the helper program file specified in the executable\n\file you run.  This is mostly of use for maintainers to test new versions\n\of this helper program; chances are you did not intend to run this program.\n",			  NULL);      /* Note the place where the dynamic linker actually came from.  */      _dl_rtld_map.l_name = _dl_argv[0];      while (_dl_argc > 1)	if (! strcmp (_dl_argv[1], "--list"))	  {	    mode = list;	    lazy = -1;	/* This means do no dependency analysis.  */	    ++_dl_skip_args;	    --_dl_argc;	    ++_dl_argv;	  }	else if (! strcmp (_dl_argv[1], "--verify"))	  {	    mode = verify;	    ++_dl_skip_args;	    --_dl_argc;	    ++_dl_argv;	  }	else	  break;      ++_dl_skip_args;      --_dl_argc;      ++_dl_argv;      if (mode == verify)	{	  char *err_str = NULL;	  const char *obj_name __attribute__ ((unused));	  struct map_args args;	  args.str = _dl_argv[0];	  (void) _dl_catch_error (&err_str, &obj_name, map_doit, &args);	  main_map = args.main_map;	  if (err_str != NULL)	    {	      free (err_str);	      _exit (EXIT_FAILURE);	    }	}      else	main_map = _dl_map_object (NULL, _dl_argv[0], lt_library, 0);      phdr = main_map->l_phdr;      phent = main_map->l_phnum;      main_map->l_name = (char *) "";      *user_entry = main_map->l_entry;    }