自学教程：C++ ELF32_ST_BIND函数代码示例

static BOOL DLSYM_lookup_symtab(const char *sym_name, struct Elf32_Sym *symtab,                                Elf32_Word symnum, Elf32_Addr *sym_value,                                BOOL require_local_binding){   Elf32_Addr sym_idx;   for (sym_idx = 0; sym_idx < symnum; sym_idx++)   {#if LOADER_DEBUG      if (debugging_on)         DLIF_trace("DLSYM_lookup_symtab %s/n",                    (char *)symtab[sym_idx].st_name);#endif      if ((symtab[sym_idx].st_shndx != SHN_UNDEF) &&          ((require_local_binding &&            (ELF32_ST_BIND(symtab[sym_idx].st_info) == STB_LOCAL)) ||	   (!require_local_binding &&	    (ELF32_ST_BIND(symtab[sym_idx].st_info) != STB_LOCAL))) &&          !strcmp(sym_name,(char*)(symtab[sym_idx].st_name)))      {         if (sym_value) *sym_value = symtab[sym_idx].st_value;         return TRUE;      }   }   if (sym_value) *sym_value = 0;   return FALSE;}

void dump_SHT_SYMTAB_section(void* data, size_t length, int i) {    Elf32_Ehdr* ehdr = (Elf32_Ehdr*)data;    Elf32_Shdr* shdrs = (Elf32_Shdr*)((char*)data + ehdr->e_shoff);    Elf32_Sym* symbols = (Elf32_Sym*)((char*)data + shdrs[i].sh_offset);    int shnum = ehdr->e_shnum;    int shentsize = ehdr->e_shentsize;    int entnum;    unsigned char st_info;    char info[3];   /* local/global/weak, data/function/section/file */    int j;    assert(sizeof(Elf32_Shdr) == ehdr->e_shentsize &&            sizeof(Elf32_Sym) == shdrs[i].sh_entsize);    entnum = shdrs[i].sh_size / shdrs[i].sh_entsize;    assert(entnum > 0);        info[2] = '/0';    printf("entnum=%d/n", entnum);    puts("    [ Nr]  value size  info  other   shndx   name");    for (j = 0; j < entnum; ++j) {        st_info = symbols[j].st_info;        if (ELF32_ST_BIND(st_info) == STB_LOCAL)            info[0] = 'l';        else if (ELF32_ST_BIND(st_info) == STB_GLOBAL)            info[0] = 'g';        else if (ELF32_ST_BIND(st_info) == STB_WEAK)            info[0] = 'w';        else            info[0] = '?';        if (ELF32_ST_TYPE(st_info) == STT_OBJECT)            info[1] = 'd';        else if (ELF32_ST_TYPE(st_info) == STT_FUNC)            info[1] = 'F';        else if (ELF32_ST_TYPE(st_info) == STT_SECTION)            info[1] = 's';        else if (ELF32_ST_TYPE(st_info) == STT_FILE)            info[1] = 'f';        else if (ELF32_ST_TYPE(st_info) == STT_NOTYPE)            info[1] = ' ';        else            info[1] = '?';        printf("    [%3d] %6d %4d  [%2s]    %2d   %6d  %-12s/n",                j,                symbols[j].st_value,                symbols[j].st_size,                info,                symbols[j].st_other,                symbols[j].st_shndx,                (symbols[j].st_name == 0) ? "<UNNAMED>" :                    get_str(data, shdrs[i].sh_link, symbols[j].st_name));    }}

/** * Get the binding of a symbol. * @param infos		Information about the symbol. * @return			Binding as a string. */const char *get_binding(const gel_sym_info_t *infos) {	static char buf[32];	switch(ELF32_ST_BIND(infos->info)) {	case STB_LOCAL: return "local";	case STB_GLOBAL: return "global";	case STB_WEAK: return "weak";	default:		sprintf(buf, "%d", ELF32_ST_BIND(infos->info));		return buf;	}}

int add_global( char *name, Elf32_Sym *sym, object *parent ){   DEBUG(( stderr, "add_global(%s, %p, %p): ", name, sym, parent ));   global *g = root_global;   while( g )   {      if( strcmp( name, g->name ) == 0 ) break;      g = g->next;   }   if( !g )   {      // such global does not yet exists, add to list      g = new global;      g->next = root_global;      root_global = g;      g->name = name;      g->sym = sym;      g->parent = parent;      DEBUG(( stderr, "created global definition of '%s' at %p [weak: %d, value: %d]/n", name, g, ELF32_ST_BIND(sym->st_info) == STB_WEAK, sym->st_value ));   }   else   {      if( ELF32_ST_BIND(g->sym->st_info) == ELF32_ST_BIND(sym->st_info) ) // equal binding      {         if( ELF32_ST_BIND(sym->st_info) == STB_WEAK )         {            DEBUG(( stderr, "duplicate weak symbol, discarding/n" ));            return 0;         }         if( g->sym->st_value == sym->st_value )         {            warning( "global symbol '%s' is redefined in '%s'", name, parent->filename );            return 0;         }         error( "global symbol '%s' defined in '%s' conflicts with global symbol already defined in '%s'", name, parent->filename, g->parent->filename );         return 1;      }      if( ELF32_ST_BIND(sym->st_info) == STB_GLOBAL )      {         g->sym = sym;         g->parent = parent;         DEBUG(( stderr, "replacing old weak definition of '%s' at %p/n", name, g ));      }   }   return 0;}

static intrelocate_section_rel(Elf32_Sym *sym_table, Elf32_Rel *rel,		     char *target_sect, int nr_reloc, char *strtab){	Elf32_Sym *sym;	Elf32_Addr sym_val;	int i;	for (i = 0; i < nr_reloc; i++) {		sym = &sym_table[ELF32_R_SYM(rel->r_info)];		ELFDBG(("%s/n", strtab + sym->st_name));		if (sym->st_shndx != STN_UNDEF) {			sym_val = (Elf32_Addr)sect_addr[sym->st_shndx]				+ sym->st_value;			if (relocate_rel(rel, sym_val, target_sect) != 0)				return -1;		} else if (ELF32_ST_BIND(sym->st_info) != STB_WEAK) {			DPRINTF(("Undefined symbol for rel[%x] sym=%lx/n",				 i, (long)sym));			return -1;		} else {			DPRINTF(("Undefined weak symbol for rel[%x]/n", i));		}		rel++;	}	return 0;}

intpmelf_getsym32(Elf_Stream s, Elf32_Sym *psym){	if ( 1 != SREAD(psym, sizeof(*psym), 1, s) ) {		return -1;	}	if ( s->needswap ) {#ifdef PMELF_CONFIG_NO_SWAPSUPPORT		return -2;#else		elf_swap32( &psym->st_name);		elf_swap32( &psym->st_value);		elf_swap32( &psym->st_size);		elf_swap16( &psym->st_shndx);#endif	}#ifdef PARANOIA_ON	{	int x;	if ( (x = ELF32_ST_TYPE( psym->st_info )) > STT_MAXSUP ) {		PMELF_PRINTF( pmelf_err, PMELF_PRE"pmelf_getsym - paranoia: unsupported type %i/n", x);		return -1;	}	if ( (x = ELF32_ST_BIND( psym->st_info )) > STB_MAXSUP ) {		PMELF_PRINTF( pmelf_err, PMELF_PRE"pmelf_getsym - paranoia: unsupported binding %i/n", x);		return -1;	}	}#endif	return 0;}

/** * Get information about a symbol. * @param loader	Current loader. * @param sym		Symbol index. * @param data		Dat structure to store information in. */void gliss_loader_sym(gliss_loader_t *loader, int sym, gliss_loader_sym_t *data) {	assert(sym < gliss_loader_count_syms(loader));	Elf32_Sym *s;	/* get the descriptor */	assert(sym < gliss_loader_count_syms(loader));	s = &loader->Tables.sym_tbl[sym];	/* get name */	data->name = loader->Tables.symstr_tbl + loader->Tables.sym_tbl[sym].st_name;	/* get value and section */	data->value = s->st_value;	data->sect = s->st_shndx;	data->size = s->st_size;	/* get the binding */	switch(ELF32_ST_BIND(s->st_info)) {	case STB_LOCAL: data->bind = GLISS_LOADER_LOCAL; break;	case STB_GLOBAL: data->bind = GLISS_LOADER_GLOBAL; break;	case STB_WEAK: data->bind = GLISS_LOADER_WEAK; break;	default: data->bind = GLISS_LOADER_NO_BINDING; break;	}	/* get the type */	switch(ELF32_ST_TYPE(s->st_info)) {	case STT_FUNC: data->type = GLISS_LOADER_SYM_CODE; break;	case STT_OBJECT: data->type = GLISS_LOADER_SYM_DATA; break;	default: data->type = GLISS_LOADER_SYM_NO_TYPE; break;	}}

GElf_Sym *gelf_getsym(Elf_Data *d, int ndx, GElf_Sym *dst){	int ec;	Elf *e;	Elf_Scn *scn;	Elf32_Sym *sym32;	Elf64_Sym *sym64;	size_t msz;	uint32_t sh_type;	if (d == NULL || ndx < 0 || dst == NULL ||	    (scn = d->d_scn) == NULL ||	    (e = scn->s_elf) == NULL) {		LIBELF_SET_ERROR(ARGUMENT, 0);		return (NULL);	}	ec = e->e_class;	assert(ec == ELFCLASS32 || ec == ELFCLASS64);	if (ec == ELFCLASS32)		sh_type = scn->s_shdr.s_shdr32.sh_type;	else		sh_type = scn->s_shdr.s_shdr64.sh_type;	if (_libelf_xlate_shtype(sh_type) != ELF_T_SYM) {		LIBELF_SET_ERROR(ARGUMENT, 0);		return (NULL);	}	msz = _libelf_msize(ELF_T_SYM, ec, e->e_version);	assert(msz > 0);	if (msz * ndx >= d->d_size) {		LIBELF_SET_ERROR(ARGUMENT, 0);		return (NULL);	}	if (ec == ELFCLASS32) {		sym32 = (Elf32_Sym *) d->d_buf + ndx;		dst->st_name  = sym32->st_name;		dst->st_value = (Elf64_Addr) sym32->st_value;		dst->st_size  = (Elf64_Xword) sym32->st_size;		dst->st_info  = ELF64_ST_INFO(ELF32_ST_BIND(sym32->st_info),		    ELF32_ST_TYPE(sym32->st_info));		dst->st_other = sym32->st_other;		dst->st_shndx = sym32->st_shndx;	} else {		sym64 = (Elf64_Sym *) d->d_buf + ndx;		*dst = *sym64;	}	return (dst);}

static uint_tdt_module_syminit32(dt_module_t *dmp){	const Elf32_Sym *sym = dmp->dm_symtab.cts_data;	const char *base = dmp->dm_strtab.cts_data;	size_t ss_size = dmp->dm_strtab.cts_size;	uint_t i, n = dmp->dm_nsymelems;	uint_t asrsv = 0;	for (i = 0; i < n; i++, sym++) {		const char *name = base + sym->st_name;		uchar_t type = ELF32_ST_TYPE(sym->st_info);		if (type >= STT_NUM || type == STT_SECTION)			continue; /* skip sections and unknown types */		if (sym->st_name == 0 || sym->st_name >= ss_size)			continue; /* skip null or invalid names */		if (sym->st_value != 0 &&		    (ELF32_ST_BIND(sym->st_info) != STB_LOCAL || sym->st_size))			asrsv++; /* reserve space in the address map */		dt_module_symhash_insert(dmp, name, i);	}	return (asrsv);}

static int _dl_do_reloc(struct elf_resolve *tpnt, struct dyn_elf *scope,			Elf32_Rela *rpnt, Elf32_Sym *symtab, char *strtab){	int reloc_type;	int symtab_index;	char *symname;	unsigned long *reloc_addr;	unsigned long symbol_addr;#if defined(__SUPPORT_LD_DEBUG__)	unsigned long old_val;#endif	reloc_addr = (unsigned long *)(tpnt->loadaddr + rpnt->r_offset);	reloc_type = ELF32_R_TYPE(rpnt->r_info);	symtab_index = ELF32_R_SYM(rpnt->r_info);	symbol_addr = 0;	symname = strtab + symtab[symtab_index].st_name;	if (symtab_index) {		symbol_addr = (unsigned long)			_dl_find_hash(strtab + symtab[symtab_index].st_name,				      tpnt->symbol_scope, tpnt,				      elf_machine_type_class(reloc_type));		/* Allow undefined references to weak symbols */		if (!symbol_addr &&		    ELF32_ST_BIND(symtab[symtab_index].st_info) != STB_WEAK) {			_dl_dprintf(2, "%s: can't resolve symbol '%s'/n",				    _dl_progname, symname);			return 0;		}	}#if defined(__SUPPORT_LD_DEBUG__)	old_val = *reloc_addr;#endif	switch (reloc_type) {	case R_AVR32_NONE:		break;	case R_AVR32_GLOB_DAT:	case R_AVR32_JMP_SLOT:		*reloc_addr = symbol_addr + rpnt->r_addend;		break;	case R_AVR32_RELATIVE:		*reloc_addr = (unsigned long)tpnt->loadaddr			+ rpnt->r_addend;		break;	default:		return -1;	}#if defined(__SUPPORT_LD_DEBUG__)	if (_dl_debug_reloc && _dl_debug_detail)		_dl_dprintf(_dl_debug_file, "/tpatched: %x ==> %x @ %x/n",			    old_val, *reloc_addr);#endif	return 0;}

/* *  ======== print_symbol_info ======== */static void print_symbol_info(struct Elf32_Sym *sym){    DEBUG_PRINT("Name-Offset = 0x%.8x Value = 0x%.8x Size = 0x%.8x "                "Bind = %d Type = %d Visibility = %d Index = %d/n",                sym->st_name, sym->st_value, sym->st_size,                ELF32_ST_BIND(sym->st_info), ELF32_ST_TYPE(sym->st_info),                sym->st_other, sym->st_shndx);}

// this function first tries to see if the first image and it's already resolved symbol is okay, otherwise// it tries to link against the shared_image// XXX gross hack and needs to be done betterint elf_resolve_symbol(struct elf_image_info *image, struct Elf32_Sym *sym, struct elf_image_info *shared_image, const char *sym_prepend,addr_t *sym_addr){	struct Elf32_Sym *sym2;	char new_symname[512];	switch(sym->st_shndx) {		case SHN_UNDEF:			// patch the symbol name			strlcpy(new_symname, sym_prepend, sizeof(new_symname));			strlcat(new_symname, SYMNAME(image, sym), sizeof(new_symname));			// it's undefined, must be outside this image, try the other image			sym2 = elf_find_symbol(shared_image, new_symname);			if(!sym2) {				dprintf("elf_resolve_symbol: could not resolve symbol '%s'/n", new_symname);				return ERR_ELF_RESOLVING_SYMBOL;			}			// make sure they're the same type			if(ELF32_ST_TYPE(sym->st_info) != ELF32_ST_TYPE(sym2->st_info)) {				dprintf("elf_resolve_symbol: found symbol '%s' in shared image but wrong type/n", new_symname);				return ERR_ELF_RESOLVING_SYMBOL;			}			if(ELF32_ST_BIND(sym2->st_info) != STB_GLOBAL && ELF32_ST_BIND(sym2->st_info) != STB_WEAK) {				dprintf("elf_resolve_symbol: found symbol '%s' but not exported/n", new_symname);				return ERR_ELF_RESOLVING_SYMBOL;			}			*sym_addr = sym2->st_value + shared_image->regions[0].delta;			return NO_ERROR;		case SHN_ABS:			*sym_addr = sym->st_value;			return NO_ERROR;		case SHN_COMMON:			// XXX finish this			dprintf("elf_resolve_symbol: COMMON symbol, finish me!/n");			return ERR_NOT_IMPLEMENTED;		default:			// standard symbol			*sym_addr = sym->st_value + image->regions[0].delta;			return NO_ERROR;	}}

BOOL DLSYM_canonical_lookup(DLOAD_HANDLE handle, int sym_index,                             DLIMP_Dynamic_Module *dyn_module,                             Elf32_Addr *sym_value){   /*------------------------------------------------------------------------*/   /* Lookup the symbol table to get the symbol characteristics.             */   /*------------------------------------------------------------------------*/   struct Elf32_Sym *sym = &dyn_module->symtab[sym_index];   int32_t           st_bind = ELF32_ST_BIND(sym->st_info);   int32_t           st_vis  = ELF32_ST_VISIBILITY(sym->st_other);   BOOL              is_def  = (sym->st_shndx != SHN_UNDEF &&                                (sym->st_shndx < SHN_LORESERVE ||                                 sym->st_shndx == SHN_ABS ||                                 sym->st_shndx == SHN_COMMON ||                                 sym->st_shndx == SHN_XINDEX));   const char *sym_name = (char *)sym->st_name; #if LOADER_DEBUG   if (debugging_on)      DLIF_trace("DLSYM_canonical_lookup: %d, %s/n", sym_index, sym_name);#endif   /*------------------------------------------------------------------------*/   /* Local symbols and symbol definitions that cannot be pre-empted         */   /* are resolved by the definition in the same module.                     */   /*------------------------------------------------------------------------*/   if (st_bind == STB_LOCAL || st_vis != STV_DEFAULT)   {      /*---------------------------------------------------------------------*/      /* If it is a local symbol or non-local that cannot be preempted,      */      /* the definition should be found in the same module. If we don't      */      /* find the definition it is an error.                                 */      /*---------------------------------------------------------------------*/      if (!is_def)      {         DLIF_error(DLET_SYMBOL,                     "Local/non-imported symbol %s definition is not found "                    "in module %s!/n", sym_name, dyn_module->name);         return FALSE;      }      else      {         if (sym_value) *sym_value = sym->st_value;         return TRUE;       }   }   /*------------------------------------------------------------------------*/   /* Else we have either pre-emptable defintion or undef symbol. We need    */   /* to do global look up.                                                  */   /*------------------------------------------------------------------------*/   else    {      return DLSYM_global_lookup(handle, sym_name, dyn_module->loaded_module,                                  sym_value);   }}

db_sym_telf_db_search_symbol (db_symtab_t *stab,		      db_addr_t off,		      db_strategy_t strategy,		      db_expr_t *diffp)	/* in/out */{  struct db_symtab_elf *self = (struct db_symtab_elf *) stab;  unsigned long	diff = *diffp;  Elf32_Sym *s, *symp = NULL;  for (s = self->start; s < self->end; s++) {    if (s->st_name == 0)      continue;    if (strategy == DB_STGY_XTRN && (ELF32_ST_BIND(s->st_info) != STB_GLOBAL))      continue;    if (off >= s->st_value) {      if (ELF32_ST_TYPE(s->st_info) == STT_FUNC)	continue;      if (off - s->st_value < diff) {	diff = off - s->st_value;	symp = s;	if (diff == 0 && (ELF32_ST_BIND(s->st_info) == STB_GLOBAL))	  break;      } else if (off - s->st_value == diff) {	if (symp == NULL)	  symp = s;	else if ((ELF32_ST_BIND(symp->st_info) != STB_GLOBAL)		 && (ELF32_ST_BIND(s->st_info) == STB_GLOBAL))	  symp = s;	/* pick the external symbol */      }    }  }  if (symp == NULL)    *diffp = off;  else    *diffp = diff;  return (db_sym_t) symp;}

staticint elf_search_section_sym(WadFrame *f, char *secname, char *strname) {  int         nsymtab;  int         nstrtab;  int         symtab_size;  Elf32_Sym  *sym;  int         nsym;  char       *str;  int         i;  unsigned long vaddr, base;  char        *name;  char        *localfile = 0;  vaddr = (unsigned long) f->pc;  base  = (unsigned long) f->segment->base;  nsymtab = wad_elf_section_byname(f->object,secname);  if (nsymtab < 0) return 0;  nstrtab = wad_elf_section_byname(f->object,strname);  if (nstrtab < 0) return 0;    symtab_size = wad_elf_section_size(f->object,nsymtab);  sym = (Elf32_Sym *) wad_elf_section_data(f->object,nsymtab);  str = (char *) wad_elf_section_data(f->object,nstrtab);  nsym = (symtab_size/sizeof(Elf32_Sym));  for (i = 0; i < nsym; i++) {    name = str + sym[i].st_name;    /* Look for filename in case the symbol maps to a local symbol */    if (ELF32_ST_TYPE(sym[i].st_info) == STT_FILE) {      localfile = name;    }    if (wad_debug_mode & DEBUG_SYMBOL_SEARCH) {      wad_printf("%x(%x): %s   %x + %x, %x, %x/n", base, vaddr, name, sym[i].st_value, sym[i].st_size, sym[i].st_info, sym[i].st_shndx);    }    if (((base + sym[i].st_value) <= vaddr) && (vaddr <= (base+sym[i].st_value + sym[i].st_size))) {#ifdef WAD_LINUX      /* If the section index is 0, the symbol is undefined */      if (sym[i].st_shndx == 0) continue;#endif      f->sym_name = name;      f->sym_nlen = strlen(name);      f->sym_base = base + sym[i].st_value;      f->sym_size = sym[i].st_size;      if (ELF32_ST_BIND(sym[i].st_info) == STB_LOCAL) {	f->sym_file = localfile;	f->sym_bind = SYM_LOCAL;      } else {	f->sym_bind = SYM_GLOBAL;      }      return 1;    }  }  return 0;}

void *__wrap_dlsym(void *handle, const char *symbol){    if (extractLibs)        return dlsym(handle, symbol);    soinfo *found;    Elf32_Sym *sym;    unsigned bind;    pthread_mutex_lock(&dl_lock);    if(unlikely(handle == 0)) {         set_dlerror(DL_ERR_INVALID_LIBRARY_HANDLE);        goto err;    }    if(unlikely(symbol == 0)) {        set_dlerror(DL_ERR_BAD_SYMBOL_NAME);        goto err;    }    if(handle == RTLD_DEFAULT) {        sym = lookup(symbol, &found, NULL);    } else if(handle == RTLD_NEXT) {        void *ret_addr = __builtin_return_address(0);        soinfo *si = find_containing_library(ret_addr);        sym = NULL;        if(si && si->next) {            sym = lookup(symbol, &found, si->next);        }    } else {        found = (soinfo*)handle;        sym = lookup_in_library(found, symbol);    }    if(likely(sym != 0)) {        bind = ELF32_ST_BIND(sym->st_info);        if(likely((bind == STB_GLOBAL) && (sym->st_shndx != 0))) {            unsigned ret = sym->st_value + found->base;            pthread_mutex_unlock(&dl_lock);            return (void*)ret;        }        set_dlerror(DL_ERR_SYMBOL_NOT_GLOBAL);    }    else        set_dlerror(DL_ERR_SYMBOL_NOT_FOUND);err:    pthread_mutex_unlock(&dl_lock);    return 0;}

/* Change all symbols so that sh_value encodes the pointer directly. */static int simplify_symbols(Elf32_Shdr *sechdrs,			    unsigned int symindex,			    const char *strtab){	Elf32_Sym *sym = (void *)sechdrs[symindex].sh_addr;	unsigned long secbase;	unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf32_Sym);	int ret = 0;	for (i = 1; i < n; i++) {		switch (sym[i].st_shndx) {		case SHN_COMMON:			/* We compiled with -fno-common.  These are not			   supposed to happen.  */			printf("Common symbol: %s/n", strtab + sym[i].st_name);			printf("please compile with -fno-common/n");			ret = -1;			break;		case SHN_ABS:			/* Don't need to do anything */			debug("Absolute symbol: 0x%08lx/n",			       (long)sym[i].st_value);			break;		case SHN_UNDEF:			sym[i].st_value			  = resolve_symbol(sechdrs,					   strtab + sym[i].st_name);			debug("undef  : %20s 0x%08x 0x%08lx/n", strtab + sym[i].st_name, sym[i].st_value);			/* Ok if resolved.  */			if (sym[i].st_value != 0)				break;			/* Ok if weak.  */			if (ELF32_ST_BIND(sym[i].st_info) == STB_WEAK)				break;			printf("Unknown symbol %s/n",			       strtab + sym[i].st_name);			ret = -1;			break;		default:			secbase = sechdrs[sym[i].st_shndx].sh_addr;			debug("default: %20s 0x%08x 0x%08lx/n", strtab + sym[i].st_name, sym[i].st_value, secbase);			sym[i].st_value += secbase;			break;		}	}	return ret;}

/* * Sort comparison function for 32-bit symbol address-to-name lookups.  We sort * symbols by value.  If values are equal, we prefer the symbol that is * non-zero sized, typed, not weak, or lexically first, in that order. */static intdt_module_symcomp32(const void *lp, const void *rp){	Elf32_Sym *lhs = *((Elf32_Sym **)lp);	Elf32_Sym *rhs = *((Elf32_Sym **)rp);	if (lhs->st_value != rhs->st_value)		return (lhs->st_value > rhs->st_value ? 1 : -1);	if ((lhs->st_size == 0) != (rhs->st_size == 0))		return (lhs->st_size == 0 ? 1 : -1);	if ((ELF32_ST_TYPE(lhs->st_info) == STT_NOTYPE) !=	    (ELF32_ST_TYPE(rhs->st_info) == STT_NOTYPE))		return (ELF32_ST_TYPE(lhs->st_info) == STT_NOTYPE ? 1 : -1);	if ((ELF32_ST_BIND(lhs->st_info) == STB_WEAK) !=	    (ELF32_ST_BIND(rhs->st_info) == STB_WEAK))		return (ELF32_ST_BIND(lhs->st_info) == STB_WEAK ? 1 : -1);	return (strcmp(dt_module_strtab + lhs->st_name,	    dt_module_strtab + rhs->st_name));}

int elf_rel_find_symbol(struct mem_ehdr *ehdr,	const char *name, struct mem_sym *ret_sym){	struct mem_shdr *shdr, *shdr_end;	if (!ehdr->e_shdr) {		/* "No section header? */		return  -1;	}	/* Walk through the sections and find the symbol table */	shdr_end = &ehdr->e_shdr[ehdr->e_shnum];	for (shdr = ehdr->e_shdr; shdr != shdr_end; shdr++) {		const char *strtab;		size_t sym_size;		const unsigned char *ptr, *sym_end;		if (shdr->sh_type != SHT_SYMTAB) {			continue;		}		if (shdr->sh_link > ehdr->e_shnum) {			/* Invalid strtab section number? */			continue;		}		strtab = (char *)ehdr->e_shdr[shdr->sh_link].sh_data;		/* Walk through the symbol table and find the symbol */		sym_size = elf_sym_size(ehdr);		sym_end = shdr->sh_data + shdr->sh_size;		for(ptr = shdr->sh_data; ptr < sym_end; ptr += sym_size) {			struct mem_sym sym;			sym = elf_sym(ehdr, ptr);			if (ELF32_ST_BIND(sym.st_info) != STB_GLOBAL) {				continue;			}			if (strcmp(strtab + sym.st_name, name) != 0) {				continue;			}			if ((sym.st_shndx == STN_UNDEF) ||				(sym.st_shndx > ehdr->e_shnum))			{				die("Symbol: %s has Bad section index %d/n",					name, sym.st_shndx);			}			*ret_sym = sym;			return 0;		}	}	/* I did not find it :( */	return -1;}

static uint_tdt_module_syminit32(dt_module_t *dmp){#if STT_NUM != (STT_TLS + 1)#error "STT_NUM has grown. update dt_module_syminit32()"#endif	Elf32_Sym *sym = dmp->dm_symtab.cts_data;	const char *base = dmp->dm_strtab.cts_data;	size_t ss_size = dmp->dm_strtab.cts_size;	uint_t i, n = dmp->dm_nsymelems;	uint_t asrsv = 0;#if defined(__FreeBSD__)	GElf_Ehdr ehdr;	int is_elf_obj;	gelf_getehdr(dmp->dm_elf, &ehdr);	is_elf_obj = (ehdr.e_type == ET_REL);#endif	for (i = 0; i < n; i++, sym++) {		const char *name = base + sym->st_name;		uchar_t type = ELF32_ST_TYPE(sym->st_info);		if (type >= STT_NUM || type == STT_SECTION)			continue; /* skip sections and unknown types */		if (sym->st_name == 0 || sym->st_name >= ss_size)			continue; /* skip null or invalid names */		if (sym->st_value != 0 &&		    (ELF32_ST_BIND(sym->st_info) != STB_LOCAL || sym->st_size)) {			asrsv++; /* reserve space in the address map */#if defined(__FreeBSD__)			sym->st_value += (Elf_Addr) dmp->dm_reloc_offset;			if (is_elf_obj && sym->st_shndx != SHN_UNDEF &&			    sym->st_shndx < ehdr.e_shnum)				sym->st_value +=				    dmp->dm_sec_offsets[sym->st_shndx];#endif		}		dt_module_symhash_insert(dmp, name, i);	}	return (asrsv);}

char * symbol_bind2str( Elf32_Sym * sym ){   char * ret;   if( ! sym )      error_ret("null arg",NULL);   switch( ELF32_ST_BIND( sym->st_info ) ) {     case STB_LOCAL  : ret = "STB_LOCAL "; break;     case STB_GLOBAL : ret = "STB_GLOBAL"; break;     case STB_WEAK   : ret = "STB_WEAK  "; break;     case STB_LOPROC : ret = "STB_LOPROC"; break;     case STB_HIPROC : ret = "STB_HIPROC"; break;     default         : ret = "unknown   "; break;   }   return( ret );}

Elf32_Sym elflink_getsym( const char *name, elfinfo_t *elf, int elfcount ) {	int n, has_weak = 0, weak_n, bind, weak_s;	Elf32_Sym *weak;	Elf32_Word sym;	Elf32_Sym *sym_p;	Elf32_Sym notfound;	for ( n = 0; n < elfcount; n++ ) {		sym = elf_findsym(	elf[n].hash_p, 					elf[n].symtab_p,					elf[n].strtab_p,					name );				if ( sym == STN_UNDEF )			continue;				sym_p = ( Elf32_Sym *) (((uintptr_t)elf[n].symtab_p) + 					( elf[n].syment * sym ));		if ( sym_p->st_shndx == SHN_UNDEF )			continue;		bind = ELF32_ST_BIND( sym_p->st_info );				if ( bind == STB_GLOBAL ) {			printf("Bound symbol %s to image %i symbol %i/n", 				name, n, sym );			return *sym_p;		} else if ( bind == STB_WEAK ) {			weak = sym_p;			weak_n = n;			weak_s = sym;			has_weak = 1;		}	}		if ( has_weak ) {		printf("Weakly bound symbol %s to image %i symbol %i/n",			name, weak_n, weak_s);		return *weak;	}	notfound.st_shndx = SHN_UNDEF;	printf("Unresolved symbol %s/n", name);	return notfound;}

static Elf32_Sym *elf_find_func(struct elf_obj *obj, unsigned int func){  int i, j;  Elf32_Sym *cur;  for(i = 0, j = 0, cur = obj->e_syms; i < obj->e_sym_num; i++, cur++) {    if(ELF32_ST_BIND(cur->st_info) != STB_GLOBAL)      continue;    if(ELF32_ST_TYPE(cur->st_info) != STT_FUNC)      continue;    if(j == func)      return cur;    j++;  }  return NULL;}

static voidassign32(void *symp, CexpSym cesp, void *closure){Elf32_Sym	*sp=symp;CexpType	t;int 		s=sp->st_size;	cesp->size = s;	t=TVoid;	switch (ELF32_ST_TYPE(sp->st_info)) {	case STT_OBJECT:		/* determine the type of variable */		t = cexpTypeGuessFromSize(s);	break;	case STT_FUNC:		t=TFuncP;	break;	case STT_NOTYPE:		t=TVoid;	break;	case STT_SECTION:		t=TVoid;		cesp->flags|=CEXP_SYMFLG_SECT;	break;	default:	break;	}	cesp->value.type = t;	switch(ELF32_ST_BIND(sp->st_info)) {		case STB_GLOBAL: cesp->flags|=CEXP_SYMFLG_GLBL; break;		case STB_WEAK  : cesp->flags|=CEXP_SYMFLG_WEAK; break;		default:			break;	}	cesp->value.ptv  = (CexpVal)(uintptr_t)sp->st_value;}

void StELFFile::dumpSymbolTable(){    const char *symbolTypes[5] = { "NOTYPE", "OBJECT", "FUNC", "SECTION", "FILE" };    const char *symbolBinding[3] = { "LOCAL", "GLOBAL", "WEAK" };    unsigned count = getSymbolCount();    unsigned i = 0;    for (; i < count; ++i)    {        const Elf32_Sym &symbol = getSymbolAtIndex(i);        std::string name = getSymbolName(symbol);        printf("'%s': %s, %s, 0x%08x, 0x%08x, %d. 0x%08x/n", name.c_str(), symbolTypes[ELF32_ST_TYPE(symbol.st_info)],               symbolBinding[ELF32_ST_BIND(symbol.st_info)], symbol.st_value, symbol.st_size, symbol.st_shndx,               symbol.st_other);    }}

  /* Finds a defined version of the symbol looking through      all loaded libraries. If exclude_root is true, skips     root file symbols when looking for the symbol.   */  Elf32_Sym * link_node::find_symbol(unsigned char *name, char *vername, Elf32_Word verhash,                                      bool exclude_root)  {    link_node *p = root;    unsigned int symhash = dyn_table.elf_hash(name);    Elf32_Sym *the_symbol = NULL, *weak_sym = NULL;    symbol_wrapper *symbol;    if (exclude_root == true)      p = p->get_next();        while (p != NULL)      {	the_symbol = p->lookup_local_symbol(symhash, name, vername, verhash);        if (the_symbol != NULL) {          symbol = new symbol_wrapper(the_symbol, match_endian);          if (ELF32_ST_BIND(symbol->read_info()) == STB_WEAK) {            if (weak_sym == NULL)              weak_sym = the_symbol;            the_symbol = NULL;          }          delete symbol;        }	if (the_symbol != NULL)	  break;	p = p->get_next();      }    /* Hook for special symbols */    if (the_symbol != NULL) {      symbol = new symbol_wrapper(the_symbol, match_endian);      if(strcmp("_rtld_global", (char*)name)==0) {        patch_rtld_global(symbol);      }      delete symbol;    }        if (the_symbol == NULL && weak_sym != NULL)      return weak_sym;    return the_symbol;  }

void *dlsym(void *handle, const char *symbol){    soinfo *found;    Elf32_Sym *sym;    unsigned bind;    pthread_mutex_lock(&dl_lock);    if(unlikely(handle == 0)) {         set_dlerror(DL_ERR_INVALID_LIBRARY_HANDLE);        goto err;    }    if(unlikely(symbol == 0)) {        set_dlerror(DL_ERR_BAD_SYMBOL_NAME);        goto err;    }    if(handle == RTLD_DEFAULT) {        sym = lookup(symbol, &found);    } else if(handle == RTLD_NEXT) {        sym = lookup(symbol, &found);    } else {        found = (soinfo*)handle;        sym = lookup_in_library(found, symbol);    }    if(likely(sym != 0)) {        bind = ELF32_ST_BIND(sym->st_info);        if(likely((bind == STB_GLOBAL) && (sym->st_shndx != 0))) {            unsigned ret = sym->st_value + found->base;            pthread_mutex_unlock(&dl_lock);            return (void*)ret;        }        set_dlerror(DL_ERR_SYMBOL_NOT_GLOBAL);    }    else        set_dlerror(DL_ERR_SYMBOL_NOT_FOUND);err:    pthread_mutex_unlock(&dl_lock);    return 0;}

void* dlsym(void* handle, const char* symbol) {  ScopedPthreadMutexLocker locker(&gDlMutex);  if (handle == NULL) {    __bionic_format_dlerror("dlsym library handle is null", NULL);    return NULL;  }  if (symbol == NULL) {    __bionic_format_dlerror("dlsym symbol name is null", NULL);    return NULL;  }  soinfo* found = NULL;  Elf32_Sym* sym = NULL;  if (handle == RTLD_DEFAULT) {    sym = lookup(symbol, &found, NULL);  } else if (handle == RTLD_NEXT) {    void* ret_addr = __builtin_return_address(0);    soinfo* si = find_containing_library(ret_addr);    sym = NULL;    if (si && si->next) {      sym = lookup(symbol, &found, si->next);    }  } else {    found = (soinfo*) handle;    sym = soinfo_lookup(found, symbol);  }  if (sym != NULL) {    unsigned bind = ELF32_ST_BIND(sym->st_info);    if (bind == STB_GLOBAL && sym->st_shndx != 0) {      unsigned ret = sym->st_value + found->load_bias;      return (void*) ret;    }    __bionic_format_dlerror("symbol found but not global", symbol);    return NULL;  } else {    __bionic_format_dlerror("undefined symbol", symbol);    return NULL;  }}

/* changesymbols() finds all symbols in a given symbol table that * appear in the namelist with the specified binding and alters their * binding strength. */static int changesymbols(Elf32_Sym *symtab, char const *strtab, int count){    Elf32_Sym  *sym;    char const *name;    int		touched;    int		i;    touched = FALSE;    for (i = 0, sym = symtab ; i < count ; ++i, ++sym) {	if (ELF32_ST_BIND(sym->st_info) != fromstrength)	    continue;	name = strtab + sym->st_name;	if (!bsearch(&name, namelist, namecount, sizeof *namelist, qstrcmp))	    continue;	sym->st_info = ELF32_ST_INFO(tostrength, ELF32_ST_TYPE(sym->st_info));	printf("%s /"%s/"./n", tostrengthtext, name);	touched = TRUE;    }    return touched;}

static SYM *readsyms(Elf32_Sym *data, size_t num, Elf *elf, Elf32_Word link){    SYM *s, *buf;    size_t i;    if((buf = (SYM *)calloc(num, sizeof(SYM)) ) == NULL) {	return NULL;    }    s = buf;	/* save pointer to head of array */    for(i=1; i<num; i++,data++,buf++) {	buf->indx = i;	buf->name = (char *)elf_strptr(elf, link, data->st_name);	buf->value = data->st_value;	buf->size = data->st_size;	buf->type = ELF32_ST_TYPE(data->st_info);	buf->bind = ELF32_ST_BIND(data->st_info);	buf->other = data->st_other;	buf->shndx = data->st_shndx;    }	/* end for loop */    return(s);}