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 int
relocate_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;
}

int
pmelf_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_t
dt_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 better
int 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_t
elf_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;
}

static
int 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;
}