C++ elf_getdata函数代码示例

static ExportTrampolineVector FindExportTrampolines(Elf *e,
                                                    const ElfSectionInfo &xptramp_info) {
    auto sym_scn = FindSectionByType(e, SHT_DYNSYM);
    auto sym_data = elf_getdata(sym_scn.first, nullptr);
    auto syms = reinterpret_cast<Elf_Sym*>(sym_data->d_buf);

    ExportTrampolineVector res;
    // FIXME: this assumes that the whole section
    // is inside a single Elf_Data object
    auto xptramp_data = elf_getdata(xptramp_info.first, nullptr);
    auto xptramp_start = reinterpret_cast<uint8_t*>(xptramp_data->d_buf);
    auto xptramp_end = xptramp_start + xptramp_data->d_size;
    for (auto ptr = xptramp_start; ptr < xptramp_end;) {
        auto addr = xptramp_info.second.sh_addr   + xptramp_data->d_off + (ptr - xptramp_start);
        auto  ofs = xptramp_info.second.sh_offset + xptramp_data->d_off + (ptr - xptramp_start);
        auto arg = *reinterpret_cast<uint32_t*>(ptr + 1);
        switch(ptr[0]) {
        case 0x01:
            res.emplace_back(addr, ofs, syms[arg].st_value);
            break;
        case 0xE9:
            break;
        default:
            errx(EX_SOFTWARE, ".xptramp section has invalid byte: %hhd\n", ptr[0]);
        }
        ptr += 5;
    }
    return res;
}

unsigned char *
get_data_from_iterator (struct data_iterator *it, GElf_Addr size)
{
  unsigned char *ptr;

  /* If we're at the end of a data block, move onto the next.  */
  if (it->data && it->data->d_off + it->data->d_size == it->sec_offset)
    it->data = elf_getdata (it->dso->scn[it->sec], it->data);

  if (it->data == NULL)
    {
      /* Find out which section contains the next byte.  */
      it->sec = addr_to_sec (it->dso, it->addr);
      if (it->sec < 0)
	return NULL;

      /* Fast-forward to the block that contains ADDR, if any.  */
      it->sec_offset = it->addr - it->dso->shdr[it->sec].sh_addr;
      do
	it->data = elf_getdata (it->dso->scn[it->sec], it->data);
      while (it->data && it->data->d_off + it->data->d_size <= it->sec_offset);
    }

  /* Make sure that all the data we want is included in this block.  */
  if (it->data == NULL
      || it->data->d_off > it->sec_offset
      || it->data->d_off + it->data->d_size < it->sec_offset + size)
    return NULL;

  ptr = (unsigned char *) it->data->d_buf + (it->sec_offset - it->data->d_off);
  it->sec_offset += size;
  it->addr += size;
  return ptr;
}

static void handle_dynamic_section(elf_info_s *elf, Elf_Scn *scn, GElf_Shdr shdr)
{
    Elf_Data *data;
    GElf_Addr replt_addr;
    size_t replt_count;

    /* get data of .dynamic */
    data = elf_getdata(scn, NULL);

    /* iterate through .dynamic */
    for (size_t i = 0; i < shdr.sh_size / shdr.sh_entsize; ++i) {
        GElf_Dyn dyn;

        // get entries i
        gelf_getdyn(data, i, &dyn);
        // if replt
        if (dyn.d_tag == DT_JMPREL)
            replt_addr = dyn.d_un.d_ptr;
        // if replt_size
        if (dyn.d_tag == DT_PLTRELSZ)
            replt_count = dyn.d_un.d_val;
    }
    LOG(INFO, "Section relplt at 0x%lx (%zu)", replt_addr, replt_count);
    for (size_t i = 1; i < elf->hdr.e_shnum; ++i) {
        Elf_Scn *scn;
        GElf_Shdr shdr;
        scn = elf_getscn(elf->elf, i);
        gelf_getshdr(scn, &shdr);
        if (shdr.sh_addr == replt_addr && shdr.sh_size == replt_count) {
            elf->replt = elf_getdata(scn, NULL);
            elf->replt_count = shdr.sh_size / shdr.sh_entsize;
            break;
        }
    }
}

static void	resolve_relocations(sym_strtab **list)
{
  Elf_Scn	*scn;
  Elf64_Shdr	*shdr;

  scn = NULL;
  while ((scn = elf_nextscn(e, scn)))
    {
      if ((shdr = elf64_getshdr(scn)) == NULL)
      	exit_error("gelf_getshdr() fail");
      if (shdr->sh_type == SHT_DYNSYM)
	{
	  Elf_Data	*data;
	  data = elf_getdata(scn, NULL);
	  dynsym_tab = (Elf64_Sym*)data->d_buf;
	}
      if (shdr->sh_type == SHT_STRTAB && shdr->sh_flags == SHF_ALLOC)
	{
	  Elf_Data	*data;
	  data = elf_getdata(scn, NULL);
	  dynsym_strtab = (char*)data->d_buf;
	}
    }
  if (!dynsym_tab)
    return;
  scn = NULL;
  while ((scn = elf_nextscn(e, scn)))
    {
      if ((shdr = elf64_getshdr(scn)) == NULL)
      	exit_error("gelf_getshdr() fail");
      if (shdr->sh_type == SHT_RELA)
	reloc_treatment(scn, shdr, list);
    }
}

static Elf_Data *loaddata(Elf_Scn *scn, GElf_Shdr *shdr)
{
	Elf_Data *data = elf_getdata(scn, NULL);
	if (data == NULL || elf_getdata(scn, data) != NULL
	    || data->d_off || data->d_size != shdr->sh_size)
		return NULL;
	return data;
}

void radeon_elf_read(const char *elf_data, unsigned elf_size,
					struct radeon_shader_binary *binary,
					unsigned debug)
{
	char *elf_buffer;
	Elf *elf;
	Elf_Scn *section = NULL;
	size_t section_str_index;

	/* One of the libelf implementations
	 * (http://www.mr511.de/software/english.htm) requires calling
	 * elf_version() before elf_memory().
	 */
	elf_version(EV_CURRENT);
	elf_buffer = MALLOC(elf_size);
	memcpy(elf_buffer, elf_data, elf_size);

	elf = elf_memory(elf_buffer, elf_size);

	elf_getshdrstrndx(elf, &section_str_index);
	binary->disassembled = 0;

	while ((section = elf_nextscn(elf, section))) {
		const char *name;
		Elf_Data *section_data = NULL;
		GElf_Shdr section_header;
		if (gelf_getshdr(section, &section_header) != &section_header) {
			fprintf(stderr, "Failed to read ELF section header\n");
			return;
		}
		name = elf_strptr(elf, section_str_index, section_header.sh_name);
		if (!strcmp(name, ".text")) {
			section_data = elf_getdata(section, section_data);
			binary->code_size = section_data->d_size;
			binary->code = MALLOC(binary->code_size * sizeof(unsigned char));
			memcpy(binary->code, section_data->d_buf, binary->code_size);
		} else if (!strcmp(name, ".AMDGPU.config")) {
			section_data = elf_getdata(section, section_data);
			binary->config_size = section_data->d_size;
			binary->config = MALLOC(binary->config_size * sizeof(unsigned char));
			memcpy(binary->config, section_data->d_buf, binary->config_size);
		} else if (debug && !strcmp(name, ".AMDGPU.disasm")) {
			binary->disassembled = 1;
			section_data = elf_getdata(section, section_data);
			fprintf(stderr, "\nShader Disassembly:\n\n");
			fprintf(stderr, "%.*s\n", (int)section_data->d_size,
						  (char *)section_data->d_buf);
		}
	}

	if (elf){
		elf_end(elf);
	}
	FREE(elf_buffer);
}

struct trap_data_t read_trap_data(struct trap_file_t *file) {
    struct trap_data_t res = { TRAP_PLATFORM_UNKNOWN, 0, 0, NULL, 0 };
    Elf_Scn *txtrp_scn = find_section(file->elf, ".txtrp");
    if (txtrp_scn == NULL)
        return res;

    GElf_Shdr shdr;
    if (gelf_getshdr(txtrp_scn, &shdr) == NULL)
        errx(EXIT_FAILURE, "Cannot get section header");
    res.txtrp_address = shdr.sh_addr;

    // Get the platform
    GElf_Ehdr ehdr;
    if (gelf_getehdr(file->elf, &ehdr) == NULL)
        errx(EXIT_FAILURE, "Cannot get ELF header");
    switch (ehdr.e_machine) {
    case EM_386:
        res.trap_platform = TRAP_PLATFORM_POSIX_X86;
        break;

    case EM_X86_64:
        res.trap_platform = TRAP_PLATFORM_POSIX_X86_64;
        break;

    case EM_ARM:
        res.trap_platform = TRAP_PLATFORM_POSIX_ARM;
        break;

    case 183: // EM_AARCH64
        res.trap_platform = TRAP_PLATFORM_POSIX_ARM64;
        break;

    default:
        errx(EXIT_FAILURE, "Unknown ELF machine");
        break;
    }

    Elf_Data *data = elf_getdata(txtrp_scn, NULL);
    for (data = elf_getdata(txtrp_scn, NULL);
         data != NULL;
         data = elf_getdata(txtrp_scn, data))
        res.size += data->d_size;

    res.data = malloc(res.size);
    uint8_t *ptr = res.data;
    for (data = elf_getdata(txtrp_scn, NULL);
         data != NULL;
         data = elf_getdata(txtrp_scn, data)) {
        memcpy(ptr, data->d_buf, data->d_size);
        ptr += data->d_size;
    }
    return res;
}

static void handle_dynsym_section(elf_info_s *elf, Elf_Scn *scn, GElf_Shdr shdr)
{
    Elf_Data *data;
    /* get .dynsym data and size */
    elf->dynsym = elf_getdata(scn, NULL);
    elf->dynsym_count = shdr.sh_size / shdr.sh_entsize;

    /* retrieve the header table index link which point to .dynstr */
    scn = elf_getscn(elf->elf, shdr.sh_link);
    gelf_getshdr(scn, &shdr);
    /* get the data of .dynstr */
    data = elf_getdata(scn, NULL);
    elf->dynstr = data->d_buf;
}

/* Below code adapted from libelf tutorial example */
static u32 extract_functions_internal (const char *str, func_entry *func_list) {
    Elf *e;
    Elf_Kind ek;
    Elf_Scn *scn;
    Elf_Data *edata;
    u32 fd, i, symbol_count;
    GElf_Sym sym;
    GElf_Shdr shdr;
    u32 func_count = 0;

    if(elf_version(EV_CURRENT) == EV_NONE) {
        printf("Error initializing ELF: %s\n", elf_errmsg(-1));
        return -1;
    }

    if ((fd = open(str, O_RDONLY, 0)) < 0) {
        printf("Unable to open %s\n", str);
        return -1;
    }

    if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
        printf("elf_begin failed: %s\n", elf_errmsg(-1));
    }

    ek = elf_kind(e);
    if(ek != ELF_K_ELF) {
        printf("not an ELF object");
    } else {
        scn = NULL;
        edata = NULL;
        while((scn = elf_nextscn(e, scn)) != NULL) {
            gelf_getshdr(scn, &shdr);
            if(shdr.sh_type == SHT_SYMTAB) {
                edata = elf_getdata(scn, edata);
                symbol_count = shdr.sh_size / shdr.sh_entsize;
                for(i = 0; i < symbol_count; i++) {
                    gelf_getsym(edata, i, &sym);
                    if(ELF32_ST_TYPE(sym.st_info) != STT_FUNC) {
                        check_for_end_marker(elf_strptr(e, shdr.sh_link, sym.st_name), sym.st_value);
                        continue;
                    }
                    if(sym.st_size == 0) continue;

                    func_list[func_count].offset = sym.st_value;
                    func_list[func_count++].func_name = strdup(elf_strptr(e, shdr.sh_link, sym.st_name));

                    if(func_count >= MAXFNS) {
                        printf("Func limit (%"PRId32") reached, please increase MAXFNS & rebuild\n", MAXFNS);
                        raise(SIGABRT);
                    }
                    //                    printf("%08x %08x\t%s\n", sym.st_value, sym.st_size, elf_strptr(e, shdr.sh_link, sym.st_name));
                }
            }
        }
    }

    elf_end(e);
    close(fd);
    return func_count;
}

/* if this function encounters an error it never returns */
static Elf_Data *exec_getdata( Elf_Scn *scn, int line )
#define exec_getdata(a) \
    exec_getdata(a,__LINE__)
{
    Elf_Data *data;
    char *location;

    location = NULL;
    data = elf_getdata(scn, NULL);
    if ( data != NULL )
    {
        if ( data->d_buf != NULL )
        {
            return data;
        }
        else
        {
            location = "d_buf";
        }
    }
    else
    {
        location = "elf_data";
    }
    fprintf( stderr, "exec_getdata: %[email protected]%d - %s\n", location, line,
             elf_errmsg( -1 ) );
    exit( 1 );
}

int find_symbol(char *fn, struct lsym *lsym, unsigned long baseaddr)
{
	struct lsym *ls;
	int num = 0;
	for (ls = lsym; ls->name; ls++)
		num++;

	elf_version(EV_CURRENT);
	int fd = open(fn, O_RDONLY);
	if (fd < 0)
		return -1;

	long ret = -1;
	Elf *elf = elf_begin(fd, ELF_C_READ, NULL);
	if (elf == NULL)
		goto out;

	GElf_Ehdr header;
	if (!gelf_getehdr(elf, &header))
		goto out_elf;

	Elf_Scn *section = NULL;
	int found = 0;
	while (found < num && (section = elf_nextscn(elf, section)) != 0) {
		GElf_Shdr shdr, *sh;
		sh = gelf_getshdr(section, &shdr);

		if (sh->sh_type == SHT_SYMTAB || sh->sh_type == SHT_DYNSYM) {
			Elf_Data *data = elf_getdata(section, NULL);
			GElf_Sym *sym, symbol;
			int j;

			unsigned numsym = sh->sh_size / sh->sh_entsize;
			for (j = 0; j < numsym; j++) {
				sym = gelf_getsymshndx(data, NULL, j, &symbol, NULL);
				char *symname = elf_strptr(elf, shdr.sh_link, sym->st_name);
				for (ls = lsym; ls->name; ls++) {
					if (!strcmp(symname, ls->name)) {
						Elf_Scn *oscn = elf_getscn(elf, sym->st_shndx);
						GElf_Shdr oshdr, *osh;
						osh = gelf_getshdr(oscn, &oshdr);
						ls->addr = (sym->st_value - osh->sh_addr) + osh->sh_offset + baseaddr;
						found++;
						if (found == num)
							break;
					}
				}
			}
		}
	}
	if (found == num)
		ret = 0;

out_elf:
	elf_end(elf);

out:
	close(fd);
	return ret;
}

static int dump_dynamic(struct file_state *f, Elf_Scn *scn, GElf_Shdr *shdr)
{
	struct dyn_state d;
	GElf_Dyn needed_dyn;
	char *needed_name;
	int i;

	d.f = f;
	d.dyn_data = elf_getdata(scn, NULL);
	if (!d.dyn_data) {
		elf_err("elf_getdata failed");
		return -1;
	}
	d.count = shdr->sh_size / shdr->sh_entsize;

	for (i = 0; i < d.count; i++) {
		if (!gelf_getdyn(d.dyn_data, i, &needed_dyn))
			continue;

		if (needed_dyn.d_tag != DT_NEEDED)
			continue;

		needed_name = (char *)f->strtab_data->d_buf
			      + needed_dyn.d_un.d_val;

		dump_needed(f->t, needed_name);
	}

	return 0;
}

Elf_Scn *
get_scnbyname(Elf *elf, char *name, int *num)
{
	Elf32_Ehdr	* ehdr;
	Elf_Scn		* scn;
	Elf32_Shdr	* shdr;
	Elf_Data	* data;
	int		  cnt,
			  tmp;

	if (!num)
		num = &tmp;
	
	*num = 0;

	if ((ehdr = elf32_getehdr(elf))==NULL)
		return NULL;

	if (((scn = elf_getscn(elf, ehdr->e_shstrndx)) == NULL) ||
	    ((data = elf_getdata(scn, NULL)) == NULL))
		return NULL;

	for (cnt = 1, scn = NULL; (scn = elf_nextscn(elf, scn)); cnt++) {
		if ((shdr = elf32_getshdr(scn)) == NULL)
			return NULL;

		if (! strcmp(name, (char *)data->d_buf + shdr->sh_name)) {
			*num = cnt;
			return scn;
		}
	}
	return NULL;
}

/**
 * Read a script from it's elf section and store it
 * @param script In output, contains the lua script loaded
 * @param scn section containing the script
 * @param shdr section header
 * @param name name of the script
 */
static void load_script(struct lua_script *script, Elf_Scn *scn,
		GElf_Shdr *shdr, const char *name)
{
	unsigned i;
	Elf_Data *data;
	char *p;

	script->name = strdup(name + strlen(LUA_WRAPPER_SECTION_PREFIX));
	if (script->name == NULL)
	        exit(101);
	script->code = calloc(shdr->sh_size + 1, 1);
	if (script->name == NULL)
		exit(102);

	script->code[shdr->sh_size] = '\0';
	data = NULL;
	i = 0;
	while (i < shdr->sh_size && (data = elf_getdata(scn, data)) != NULL) {
		p = data->d_buf;
		while (p < (char *)data->d_buf + data->d_size) {
			script->code[i] = *p;
			i++;
			p++;
		}
	}
	remove_shebang(script->code);
}

Elf_Scn *elf_utils_new_scn_with_name(Elf *e, const char *scn_name)
{
	Elf_Scn *scn;
	GElf_Shdr shdr;
	size_t shstrndx, index, namelen;
	Elf_Data *shstrdata;
	void *ptr;

	ELF_ASSERT(elf_getshdrstrndx(e, &shstrndx) == 0);

	ELF_ASSERT(scn = elf_getscn(e, shstrndx));
	ELF_ASSERT(shstrdata = elf_getdata(scn, NULL));

	namelen = strlen(scn_name) + 1;
	ELF_ASSERT(gelf_getshdr(scn, &shdr));
	if (!elf_utils_shift_contents(e, shdr.sh_offset + shdr.sh_size, namelen))
		goto failure;
	ASSERT(ptr = realloc(shstrdata->d_buf, shstrdata->d_size + namelen));
	index = shstrdata->d_size;
	strcpy(ptr+index, scn_name);
	shstrdata->d_buf = ptr;
	shstrdata->d_size += namelen;
	shdr.sh_size += namelen;
	ELF_ASSERT(gelf_update_shdr(scn, &shdr));

	ELF_ASSERT(scn = elf_newscn(e));
	ELF_ASSERT(gelf_getshdr(scn, &shdr));
	shdr.sh_name = index;
	ELF_ASSERT(gelf_update_shdr(scn, &shdr));
	
	return scn;
failure:
	return NULL;
}