static void clear(ElfCreator *ctor, int do_unlink)
{
if (do_unlink) {
if (ctor->elf)
elf_end(ctor->elf);
if (ctor->fd >= 0)
close(ctor->fd);
if (ctor->path)
unlink(ctor->path);
} else {
if (ctor->elf) {
elf_update(ctor->elf, ELF_C_WRITE_MMAP);
elf_end(ctor->elf);
}
if (ctor->fd >= 0)
close(ctor->fd);
}
memset(ctor, '\0', sizeof(*ctor));
}
int
main (int argc __attribute__ ((unused)), char *argv[])
{
int fd = open (argv[1], O_RDWR);
if (fd < 0)
error (2, errno, "open: %s", argv[1]);
if (elf_version (EV_CURRENT) == EV_NONE)
error (1, 0, "libelf version mismatch");
Elf *elf = elf_begin (fd, ELF_C_RDWR_MMAP, NULL);
if (elf == NULL)
error (1, 0, "elf_begin: %s", elf_errmsg (-1));
if (elf_update (elf, ELF_C_WRITE) < 0)
error (1, 0, "elf_update: %s", elf_errmsg (-1));
elf_end (elf);
close (fd);
return 0;
}
int main(int argc, char *argv[])
{
vita_elf_t *ve;
vita_imports_t **imports;
sce_module_info_t *module_info;
sce_section_sizes_t section_sizes;
void *encoded_modinfo;
vita_elf_rela_table_t rtable = {};
int imports_count;
int status = EXIT_SUCCESS;
if (argc < 3)
errx(EXIT_FAILURE,"Usage: vita-elf-create input-elf output-elf [extra.json ...]");
if ((ve = vita_elf_load(argv[1])) == NULL)
return EXIT_FAILURE;
if (!(imports = load_imports(argc, argv, &imports_count)))
return EXIT_FAILURE;
if (!vita_elf_lookup_imports(ve, imports, imports_count))
status = EXIT_FAILURE;
if (ve->fstubs_ndx) {
printf("Function stubs in section %d:\n", ve->fstubs_ndx);
print_stubs(ve->fstubs, ve->num_fstubs);
}
if (ve->vstubs_ndx) {
printf("Variable stubs in section %d:\n", ve->vstubs_ndx);
print_stubs(ve->vstubs, ve->num_vstubs);
}
printf("Relocations:\n");
list_rels(ve);
printf("Segments:\n");
list_segments(ve);
module_info = sce_elf_module_info_create(ve);
int total_size = sce_elf_module_info_get_size(module_info, §ion_sizes);
int curpos = 0;
printf("Total SCE data size: %d / %x\n", total_size, total_size);
#define PRINTSEC(name) printf(" .%.*s.%s: %d (%x @ %x)\n", (int)strcspn(#name,"_"), #name, strchr(#name,'_')+1, section_sizes.name, section_sizes.name, curpos+ve->segments[0].vaddr+ve->segments[0].memsz); curpos += section_sizes.name
PRINTSEC(sceModuleInfo_rodata);
PRINTSEC(sceLib_ent);
PRINTSEC(sceExport_rodata);
PRINTSEC(sceLib_stubs);
PRINTSEC(sceImport_rodata);
PRINTSEC(sceFNID_rodata);
PRINTSEC(sceFStub_rodata);
PRINTSEC(sceVNID_rodata);
PRINTSEC(sceVStub_rodata);
strncpy(module_info->name, argv[1], sizeof(module_info->name) - 1);
encoded_modinfo = sce_elf_module_info_encode(
module_info, ve, §ion_sizes, &rtable);
printf("Relocations from encoded modinfo:\n");
print_rtable(&rtable);
FILE *outfile;
Elf *dest;
ASSERT(dest = elf_utils_copy_to_file(argv[2], ve->elf, &outfile));
ASSERT(elf_utils_duplicate_shstrtab(dest));
ASSERT(sce_elf_discard_invalid_relocs(ve, ve->rela_tables));
ASSERT(sce_elf_write_module_info(dest, ve, §ion_sizes, encoded_modinfo));
rtable.next = ve->rela_tables;
ASSERT(sce_elf_write_rela_sections(dest, ve, &rtable));
ASSERT(sce_elf_rewrite_stubs(dest, ve));
ELF_ASSERT(elf_update(dest, ELF_C_WRITE) >= 0);
elf_end(dest);
ASSERT(sce_elf_set_headers(outfile, ve));
fclose(outfile);
sce_elf_module_info_free(module_info);
vita_elf_free(ve);
int i;
for (i = 0; i < imports_count; i++) {
vita_imports_free(imports[i]);
}
free(imports);
return status;
failure:
return EXIT_FAILURE;
}
bool saveSharedLibrary::readNewLib(){
Elf32_Shdr *newsh, *shdr;
Elf_Scn *scn, *newScn;
Elf32_Ehdr *ehdr;
Elf32_Phdr *oldPhdr;
Elf_Data *strdata, *newdata, *olddata;
if ((ehdr = elf32_getehdr(newElf)) == NULL){
fprintf(stderr," FAILED obtaining ehdr readNewLib\n");
return false;
}
if((scn = elf_getscn(newElf, ehdr->e_shstrndx)) != NULL){
if((strdata = elf_getdata(scn, NULL)) == NULL){
fprintf(stderr," Failed obtaining .shstrtab data buffer \n");
return false;
}
}else{
fprintf(stderr," FAILED obtaining .shstrtab scn\n");
}
unsigned int newScnName =0;
scn = NULL;
Elf_Data shstrtabData;
#if defined(i386_unknown_linux2_0) \
|| defined(x86_64_unknown_linux2_4)
/* save the PHDR from the library */
oldPhdr = elf32_getphdr(newElf);
Elf32_Phdr phdrBuffer[ehdr->e_phnum];
/* copy it over to a buffer because, on linux, we will close newElf and reopen it.
This closing of newElf should dealloc the data pointed to by oldPhdr
*/
memcpy(phdrBuffer, oldPhdr, ehdr->e_phnum * ehdr->e_phentsize);
#endif
for (int cnt = 1; (scn = elf_nextscn(newElf, scn)); cnt++) {
//copy sections from newElf to newElf.
shdr = elf32_getshdr(scn);
olddata = elf_getdata(scn,NULL);
if(!strcmp( (char *)strdata->d_buf + shdr->sh_name, ".text")){
textAddr = shdr->sh_addr;
textData = olddata;
textSize = shdr->sh_size;
}
if(!strcmp( (char*) strdata->d_buf + shdr->sh_name, ".shstrtab")){
const char *secname =".dyninst_mutated\0";
shstrtabData.d_size = olddata->d_size+strlen(secname)+1;
newShstrtabData_d_buf = new char[shstrtabData.d_size];
shstrtabData.d_buf = newShstrtabData_d_buf;
memcpy( shstrtabData.d_buf, olddata->d_buf, olddata->d_size);
memcpy(&(((char*) shstrtabData.d_buf)[olddata->d_size]), secname,
strlen(secname)+1);
newScnName = olddata->d_size;
olddata->d_buf = shstrtabData.d_buf;
olddata->d_size = shstrtabData.d_size;
shdr->sh_size +=strlen(secname)+1;
/* if the section header table is past this section in the
ELF file, calculate the new offset*/
if(ehdr ->e_shoff > shdr->sh_offset){
ehdr->e_shoff += strlen(secname)+1;
}
elf_flagscn(scn,ELF_C_SET,ELF_F_DIRTY);
}
}
ehdr-> e_shnum++;
newScn = elf_newscn(newElf);
newsh = elf32_getshdr(newScn);
newsh->sh_name = newScnName;
newsh->sh_type = SHT_NOBITS; // SHT_NOTE;
newsh->sh_flags=0;
newsh->sh_addr = 0x0;
newsh->sh_offset = shdr->sh_offset;
newsh->sh_size=0;
newsh->sh_link=0;
newsh->sh_info=0;
newsh->sh_addralign = 0x1; //Values 0 and 1 mean the section has no alignment constraints.
newsh->sh_entsize = 0;
newdata = elf_newdata(newScn);
newdata->d_size =0;
newdata->d_buf=0;
elf_update(newElf, ELF_C_NULL);
/* elfutils on linux does not write data back to an ELF file you
have opened correctly. Specifically, if you add a section the
section's section header has space allocated for it in the file
but no data is written to it. lovely, eh?
to combat this, we reopen the file we just closed, and find the
empty section header and fill it with data.
*/
#if defined(i386_unknown_linux2_0) \
|| defined(x86_64_unknown_linux2_4)
elf_update(newElf, ELF_C_WRITE);
elf_end(newElf);
P_close(newfd);
if((newfd = (open(newpathname, O_RDWR)))==-1){
fprintf(stderr,"%s[%d]: cannot open new SO : %s\n",FILE__, __LINE__, newpathname);
perror(" FAIL ");
return false;;
}
if((newElf = elf_begin(newfd, ELF_C_RDWR, NULL)) ==NULL){
fprintf(stderr,"cannot open ELF %s \n", newpathname);
return false;;
}
if ((ehdr = elf32_getehdr(newElf)) == NULL){
fprintf(stderr," FAILED obtaining ehdr readNewLib\n");
return false;
}
if((scn = elf_getscn(newElf, ehdr->e_shstrndx)) != NULL){
if((strdata = elf_getdata(scn, NULL)) == NULL){
fprintf(stderr," Failed obtaining .shstrtab data buffer \n");
return false;
}
}else{
fprintf(stderr," FAILED obtaining .shstrtab scn\n");
}
scn = NULL;
bool foundText=false;
for (int cnt = 1; (scn = elf_nextscn(newElf, scn)); cnt++) {
//copy sections from newElf to newElf.
shdr = elf32_getshdr(scn);
olddata = elf_getdata(scn,NULL);
if(!foundText && !strcmp( (char *)strdata->d_buf + shdr->sh_name, ".text")){
textAddr = shdr->sh_addr;
textData = olddata;
textSize = shdr->sh_size;
elf_flagscn(scn,ELF_C_SET,ELF_F_DIRTY);
foundText = true;
}
}
/**UPDATE THE LAST SHDR **/
memset(shdr,'\0', sizeof(Elf32_Shdr));
shdr->sh_name = newScnName;
shdr->sh_addr = 0x0;
shdr->sh_type = 7;
/* update the PHDR, well just make sure it is reset to
what was in the original library */
Elf32_Phdr *newPhdr = elf32_getphdr(newElf);
memcpy(newPhdr,phdrBuffer, ehdr->e_phnum * ehdr->e_phentsize);
/* be extra sure, set the DIRTY flag */
elf_flagphdr(newElf, ELF_C_SET,ELF_F_DIRTY);
elf_flagscn(scn,ELF_C_SET,ELF_F_DIRTY);
elf_update(newElf, ELF_C_NULL);
#endif
return true;
}
static int
build_file(Elf *src_elf, GElf_Ehdr *src_ehdr, Cmd_Info *cmd_info)
{
Elf_Scn *src_scn;
Elf_Scn *dst_scn;
int new_sh_name = 0; /* to hold the offset for the new */
/* section's name */
Elf *dst_elf = 0;
Elf_Data *elf_data;
Elf_Data *data;
int64_t scn_no, x;
size_t no_of_symbols = 0;
section_info_table *info;
unsigned int c = 0;
int fdtmp;
GElf_Shdr src_shdr;
GElf_Shdr dst_shdr;
GElf_Ehdr dst_ehdr;
GElf_Off new_offset = 0, r;
size_t shnum, shstrndx;
if (elf_getshnum(src_elf, &shnum) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if (elf_getshstrndx(src_elf, &shstrndx) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if ((fdtmp = open(elftmpfile, O_RDWR |
O_TRUNC | O_CREAT, (mode_t)0666)) == -1) {
error_message(OPEN_TEMP_ERROR,
SYSTEM_ERROR, strerror(errno),
prog, elftmpfile);
return (FAILURE);
}
if ((dst_elf = elf_begin(fdtmp, ELF_C_WRITE, (Elf *) 0)) == NULL) {
error_message(READ_ERROR,
LIBelf_ERROR, elf_errmsg(-1),
prog, elftmpfile);
(void) close(fdtmp);
return (FAILURE);
}
if (gelf_newehdr(dst_elf, gelf_getclass(src_elf)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
/* initialize dst_ehdr */
(void) gelf_getehdr(dst_elf, &dst_ehdr);
dst_ehdr = *src_ehdr;
/*
* flush the changes to the ehdr so the
* ident array is filled in.
*/
(void) gelf_update_ehdr(dst_elf, &dst_ehdr);
if (src_ehdr->e_phnum != 0) {
(void) elf_flagelf(dst_elf, ELF_C_SET, ELF_F_LAYOUT);
if (gelf_newphdr(dst_elf, src_ehdr->e_phnum) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
for (x = 0; x < src_ehdr->e_phnum; ++x) {
GElf_Phdr dst;
GElf_Phdr src;
/* LINTED */
(void) gelf_getphdr(src_elf, (int)x, &src);
/* LINTED */
(void) gelf_getphdr(dst_elf, (int)x, &dst);
(void) memcpy(&dst, &src, sizeof (GElf_Phdr));
/* LINTED */
(void) gelf_update_phdr(dst_elf, (int)x, &dst);
}
x = location(dst_ehdr.e_phoff, 0, src_elf);
if (x == AFTER)
new_offset = (GElf_Off)src_ehdr->e_ehsize;
}
scn_no = 1;
while ((src_scn = sec_table[scn_no].scn) != (Elf_Scn *) -1) {
info = &sec_table[scn_no];
/* If section should be copied to new file NOW */
if ((info->secno != (GElf_Word)DELETED) &&
info->secno <= scn_no) {
if ((dst_scn = elf_newscn(dst_elf)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
(void) gelf_getshdr(dst_scn, &dst_shdr);
(void) gelf_getshdr(info->scn, &src_shdr);
(void) memcpy(&dst_shdr, &src_shdr, sizeof (GElf_Shdr));
/*
* Update link and info fields
* The sh_link field may have special values so
* check them first.
*/
if ((src_shdr.sh_link >= shnum) ||
(src_shdr.sh_link == 0))
dst_shdr.sh_link = src_shdr.sh_link;
else if ((int)sec_table[src_shdr.sh_link].secno < 0)
dst_shdr.sh_link = 0;
else
dst_shdr.sh_link =
sec_table[src_shdr.sh_link].secno;
if ((src_shdr.sh_type == SHT_REL) ||
(src_shdr.sh_type == SHT_RELA)) {
if ((src_shdr.sh_info >= shnum) ||
((int)sec_table[src_shdr.
sh_info].secno < 0))
dst_shdr.sh_info = 0;
else
dst_shdr.sh_info =
sec_table[src_shdr.sh_info].secno;
}
data = sec_table[scn_no].data;
if ((elf_data = elf_newdata(dst_scn)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
*elf_data = *data;
/* SHT_{DYNSYM, SYMTAB} might need some change */
if (((src_shdr.sh_type == SHT_SYMTAB) ||
(src_shdr.sh_type == SHT_DYNSYM)) &&
src_shdr.sh_entsize != 0 &&
(cmd_info->no_of_delete != 0 ||
cmd_info->no_of_nulled != 0)) {
char *new_sym;
no_of_symbols = src_shdr.sh_size /
src_shdr.sh_entsize;
new_sym = malloc(no_of_symbols *
src_shdr.sh_entsize);
if (new_sym == NULL) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0, prog);
mcs_exit(FAILURE);
}
/* CSTYLED */
elf_data->d_buf = (void *) new_sym;
for (c = 0; c < no_of_symbols; c++) {
GElf_Sym csym;
(void) gelf_getsym(data, c, &csym);
if ((csym.st_shndx < SHN_LORESERVE) &&
(csym.st_shndx != SHN_UNDEF)) {
section_info_table *i;
i = &sec_table[csym.st_shndx];
if (((int)i->secno !=
DELETED) &&
((int)i->secno != NULLED))
csym.st_shndx =
i->secno;
else {
if (src_shdr.sh_type ==
SHT_SYMTAB)
/*
* The section which
* this * symbol relates
* to is removed.
* There is no way to
* specify this fact,
* just change the shndx
* to 1.
*/
csym.st_shndx = 1;
else {
/*
* If this is in a
* .dynsym, NULL it out.
*/
csym.st_shndx = 0;
csym.st_name = 0;
csym.st_value = 0;
csym.st_size = 0;
csym.st_info = 0;
csym.st_other = 0;
csym.st_shndx = 0;
}
}
}
(void) gelf_update_sym(elf_data, c,
&csym);
}
}
/* update SHT_SYMTAB_SHNDX */
if ((src_shdr.sh_type == SHT_SYMTAB_SHNDX) &&
(src_shdr.sh_entsize != 0) &&
((cmd_info->no_of_delete != 0) ||
(cmd_info->no_of_nulled != 0))) {
GElf_Word *oldshndx;
GElf_Word *newshndx;
uint_t entcnt;
entcnt = src_shdr.sh_size /
src_shdr.sh_entsize;
oldshndx = data->d_buf;
newshndx = malloc(entcnt *
src_shdr.sh_entsize);
if (newshndx == NULL) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0, prog);
mcs_exit(FAILURE);
}
elf_data->d_buf = (void *)newshndx;
for (c = 0; c < entcnt; c++) {
if (oldshndx[c] != SHN_UNDEF) {
section_info_table *i;
i = &sec_table[oldshndx[c]];
if (((int)i->secno !=
DELETED) &&
((int)i->secno != NULLED))
newshndx[c] = i->secno;
else
newshndx[c] =
oldshndx[c];
} else
newshndx[c] =
oldshndx[c];
}
}
/*
* If the section is to be updated,
* do so.
*/
if (ISCANDIDATE(info->flags)) {
if ((GET_LOC(info->flags) == PRIOR) &&
(((int)info->secno == NULLED) ||
((int)info->secno == EXPANDED) ||
((int)info->secno == SHRUNK))) {
/*
* The section is updated,
* but the position is not too
* good. Need to NULL this out.
*/
dst_shdr.sh_name = 0;
dst_shdr.sh_type = SHT_PROGBITS;
if ((int)info->secno != NULLED) {
(cmd_info->no_of_moved)++;
SET_MOVING(info->flags);
}
} else {
/*
* The section is positioned AFTER,
* or there are no segments.
* It is safe to update this section.
*/
data = sec_table[scn_no].mdata;
*elf_data = *data;
dst_shdr.sh_size = elf_data->d_size;
}
}
/* add new section name to shstrtab? */
else if (!Sect_exists &&
(new_sec_string != NULL) &&
(scn_no == shstrndx) &&
(dst_shdr.sh_type == SHT_STRTAB) &&
((src_ehdr->e_phnum == 0) ||
((x = scn_location(dst_scn, dst_elf)) != IN) ||
(x != PRIOR))) {
size_t sect_len;
sect_len = strlen(SECT_NAME);
if ((elf_data->d_buf =
malloc((dst_shdr.sh_size +
sect_len + 1))) == NULL) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0, prog);
mcs_exit(FAILURE);
}
/* put original data plus new data in section */
(void) memcpy(elf_data->d_buf,
data->d_buf, data->d_size);
(void) memcpy(&((char *)elf_data->d_buf)
[data->d_size],
SECT_NAME,
sect_len + 1);
/* LINTED */
new_sh_name = (int)dst_shdr.sh_size;
dst_shdr.sh_size += sect_len + 1;
elf_data->d_size += sect_len + 1;
}
/*
* Compute offsets.
*/
if (src_ehdr->e_phnum != 0) {
/*
* Compute section offset.
*/
if (off_table[scn_no] == 0) {
if (dst_shdr.sh_addralign != 0) {
r = new_offset %
dst_shdr.sh_addralign;
if (r)
new_offset +=
dst_shdr.sh_addralign - r;
}
dst_shdr.sh_offset = new_offset;
elf_data->d_off = 0;
} else {
if (nobits_table[scn_no] == 0)
new_offset = off_table[scn_no];
}
if (nobits_table[scn_no] == 0)
new_offset += dst_shdr.sh_size;
}
}
(void) gelf_update_shdr(dst_scn, &dst_shdr); /* flush changes */
scn_no++;
}
/*
* This is the real new section.
*/
if (!Sect_exists && new_sec_string != NULL) {
size_t string_size;
string_size = strlen(new_sec_string) + 1;
if ((dst_scn = elf_newscn(dst_elf)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
(void) gelf_getshdr(dst_scn, &dst_shdr);
dst_shdr.sh_name = new_sh_name;
dst_shdr.sh_type = SHT_PROGBITS;
dst_shdr.sh_flags = 0;
dst_shdr.sh_addr = 0;
if (src_ehdr->e_phnum != NULL)
dst_shdr.sh_offset = new_offset;
else
dst_shdr.sh_offset = 0;
dst_shdr.sh_size = string_size + 1;
dst_shdr.sh_link = 0;
dst_shdr.sh_info = 0;
dst_shdr.sh_addralign = 1;
dst_shdr.sh_entsize = 0;
(void) gelf_update_shdr(dst_scn, &dst_shdr); /* flush changes */
if ((elf_data = elf_newdata(dst_scn)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
elf_data->d_size = string_size + 1;
if ((elf_data->d_buf = (char *)
calloc(1, string_size + 1)) == NULL) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0,
prog);
mcs_exit(FAILURE);
}
(void) memcpy(&((char *)elf_data->d_buf)[1],
new_sec_string, string_size);
elf_data->d_align = 1;
new_offset += string_size + 1;
}
/*
* If there are sections which needed to be moved,
* then do it here.
*/
if (cmd_info->no_of_moved != 0) {
int cnt;
info = &sec_table[0];
for (cnt = 0; cnt < shnum; cnt++, info++) {
if ((GET_MOVING(info->flags)) == 0)
continue;
if ((src_scn = elf_getscn(src_elf, info->osecno)) ==
NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if (gelf_getshdr(src_scn, &src_shdr) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if ((dst_scn = elf_newscn(dst_elf)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if (gelf_getshdr(dst_scn, &dst_shdr) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
dst_shdr = src_shdr;
data = info->mdata;
dst_shdr.sh_offset = new_offset; /* UPDATE fields */
dst_shdr.sh_size = data->d_size;
if ((shnum >= src_shdr.sh_link) ||
(src_shdr.sh_link == 0))
dst_shdr.sh_link = src_shdr.sh_link;
else
dst_shdr.sh_link =
sec_table[src_shdr.sh_link].osecno;
if ((shnum >= src_shdr.sh_info) ||
(src_shdr.sh_info == 0))
dst_shdr.sh_info = src_shdr.sh_info;
else
dst_shdr.sh_info =
sec_table[src_shdr.sh_info].osecno;
(void) gelf_update_shdr(dst_scn, &dst_shdr);
if ((elf_data = elf_newdata(dst_scn)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
(void) memcpy(elf_data, data, sizeof (Elf_Data));
new_offset += data->d_size;
}
}
/*
* In the event that the position of the sting table has changed,
* as a result of deleted sections, update the ehdr->e_shstrndx.
*/
if ((shstrndx > 0) && (shnum > 0) &&
(sec_table[shstrndx].secno < shnum)) {
if (sec_table[shstrndx].secno < SHN_LORESERVE) {
dst_ehdr.e_shstrndx =
sec_table[dst_ehdr.e_shstrndx].secno;
} else {
Elf_Scn *_scn;
GElf_Shdr shdr0;
/*
* If shstrndx requires 'Extended ELF Sections'
* then it is stored in shdr[0].sh_link
*/
dst_ehdr.e_shstrndx = SHN_XINDEX;
if ((_scn = elf_getscn(dst_elf, 0)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
(void) gelf_getshdr(_scn, &shdr0);
shdr0.sh_link = sec_table[shstrndx].secno;
(void) gelf_update_shdr(_scn, &shdr0);
}
}
if (src_ehdr->e_phnum != 0) {
size_t align = gelf_fsize(dst_elf, ELF_T_ADDR, 1, EV_CURRENT);
/* UPDATE location of program header table */
if (location(dst_ehdr.e_phoff, 0, dst_elf) == AFTER) {
r = new_offset % align;
if (r)
new_offset += align - r;
dst_ehdr.e_phoff = new_offset;
new_offset += dst_ehdr.e_phnum
* dst_ehdr.e_phentsize;
}
/* UPDATE location of section header table */
if ((location(dst_ehdr.e_shoff, 0, src_elf) == AFTER) ||
((location(dst_ehdr.e_shoff, 0, src_elf) == PRIOR) &&
(!Sect_exists && new_sec_string != NULL))) {
r = new_offset % align;
if (r)
new_offset += align - r;
dst_ehdr.e_shoff = new_offset;
}
free(b_e_seg_table);
/*
* The NOTE segment is the one segment whos
* sections might get moved by mcs processing.
* Make sure that the NOTE segments offset points
* to the .note section.
*/
if ((notesegndx != -1) && (notesctndx != -1) &&
(sec_table[notesctndx].secno)) {
Elf_Scn * notescn;
GElf_Shdr nshdr;
notescn = elf_getscn(dst_elf,
sec_table[notesctndx].secno);
(void) gelf_getshdr(notescn, &nshdr);
if (gelf_getclass(dst_elf) == ELFCLASS32) {
Elf32_Phdr * ph = elf32_getphdr(dst_elf) +
notesegndx;
/* LINTED */
ph->p_offset = (Elf32_Off)nshdr.sh_offset;
} else {
Elf64_Phdr * ph = elf64_getphdr(dst_elf) +
notesegndx;
ph->p_offset = (Elf64_Off)nshdr.sh_offset;
}
}
}
/* copy ehdr changes back into real ehdr */
(void) gelf_update_ehdr(dst_elf, &dst_ehdr);
if (elf_update(dst_elf, ELF_C_WRITE) < 0) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
(void) elf_end(dst_elf);
(void) close(fdtmp);
return (SUCCESS);
}
static int
ctf_write_elf(ctf_file_t *fp, Elf *src, Elf *dst, int flags)
{
GElf_Ehdr sehdr, dehdr;
Elf_Scn *sscn, *dscn;
Elf_Data *sdata, *ddata;
GElf_Shdr shdr;
int symtab_idx = -1;
off_t new_offset = 0;
off_t ctfnameoff = 0;
int compress = (flags & CTF_ELFWRITE_F_COMPRESS);
int *secxlate = NULL;
int srcidx, dstidx, pad, i;
int curnmoff = 0;
int changing = 0;
int ret;
size_t nshdr, nphdr, strndx;
void *strdatabuf = NULL, *symdatabuf = NULL;
size_t strdatasz = 0, symdatasz = 0;
void *cdata = NULL;
size_t elfsize, asize;
if ((flags & ~(CTF_ELFWRITE_F_COMPRESS)) != 0) {
ret = ctf_set_errno(fp, EINVAL);
goto out;
}
if (gelf_newehdr(dst, gelf_getclass(src)) == 0) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
if (gelf_getehdr(src, &sehdr) == NULL) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
(void) memcpy(&dehdr, &sehdr, sizeof (GElf_Ehdr));
if (gelf_update_ehdr(dst, &dehdr) == 0) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
/*
* Use libelf to get the number of sections and the string section to
* deal with ELF files that may have a large number of sections. We just
* always use this to make our live easier.
*/
if (elf_getphdrnum(src, &nphdr) != 0) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
if (elf_getshdrnum(src, &nshdr) != 0) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
if (elf_getshdrstrndx(src, &strndx) != 0) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
/*
* Neither the existing debug sections nor the SUNW_ctf sections (new or
* existing) are SHF_ALLOC'd, so they won't be in areas referenced by
* program headers. As such, we can just blindly copy the program
* headers from the existing file to the new file.
*/
if (nphdr != 0) {
(void) elf_flagelf(dst, ELF_C_SET, ELF_F_LAYOUT);
if (gelf_newphdr(dst, nphdr) == 0) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
for (i = 0; i < nphdr; i++) {
GElf_Phdr phdr;
if (gelf_getphdr(src, i, &phdr) == NULL) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
if (gelf_update_phdr(dst, i, &phdr) == 0) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
}
}
secxlate = ctf_alloc(sizeof (int) * nshdr);
for (srcidx = dstidx = 0; srcidx < nshdr; srcidx++) {
Elf_Scn *scn = elf_getscn(src, srcidx);
GElf_Shdr shdr;
char *sname;
if (gelf_getshdr(scn, &shdr) == NULL) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
sname = elf_strptr(src, strndx, shdr.sh_name);
if (sname == NULL) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
if (strcmp(sname, CTF_ELF_SCN_NAME) == 0) {
secxlate[srcidx] = -1;
} else {
secxlate[srcidx] = dstidx++;
curnmoff += strlen(sname) + 1;
}
new_offset = (off_t)dehdr.e_phoff;
}
for (srcidx = 1; srcidx < nshdr; srcidx++) {
char *sname;
sscn = elf_getscn(src, srcidx);
if (gelf_getshdr(sscn, &shdr) == NULL) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
if (secxlate[srcidx] == -1) {
changing = 1;
continue;
}
dscn = elf_newscn(dst);
if (dscn == NULL) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
/*
* If this file has program headers, we need to explicitly lay
* out sections. If none of the sections prior to this one have
* been removed, then we can just use the existing location. If
* one or more sections have been changed, then we need to
* adjust this one to avoid holes.
*/
if (changing && nphdr != 0) {
pad = new_offset % shdr.sh_addralign;
if (pad != 0)
new_offset += shdr.sh_addralign - pad;
shdr.sh_offset = new_offset;
}
shdr.sh_link = secxlate[shdr.sh_link];
if (shdr.sh_type == SHT_REL || shdr.sh_type == SHT_RELA)
shdr.sh_info = secxlate[shdr.sh_info];
sname = elf_strptr(src, strndx, shdr.sh_name);
if (sname == NULL) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
if ((sdata = elf_getdata(sscn, NULL)) == NULL) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
if ((ddata = elf_newdata(dscn)) == NULL) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
bcopy(sdata, ddata, sizeof (Elf_Data));
if (srcidx == strndx) {
char seclen = strlen(CTF_ELF_SCN_NAME);
strdatasz = ddata->d_size + shdr.sh_size +
seclen + 1;
ddata->d_buf = strdatabuf = ctf_alloc(strdatasz);
if (ddata->d_buf == NULL) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
bcopy(sdata->d_buf, ddata->d_buf, shdr.sh_size);
(void) strcpy((caddr_t)ddata->d_buf + shdr.sh_size,
CTF_ELF_SCN_NAME);
ctfnameoff = (off_t)shdr.sh_size;
shdr.sh_size += seclen + 1;
ddata->d_size += seclen + 1;
if (nphdr != 0)
changing = 1;
}
if (shdr.sh_type == SHT_SYMTAB && shdr.sh_entsize != 0) {
int nsym = shdr.sh_size / shdr.sh_entsize;
symtab_idx = secxlate[srcidx];
symdatasz = shdr.sh_size;
ddata->d_buf = symdatabuf = ctf_alloc(symdatasz);
if (ddata->d_buf == NULL) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
(void) bcopy(sdata->d_buf, ddata->d_buf, shdr.sh_size);
for (i = 0; i < nsym; i++) {
GElf_Sym sym;
short newscn;
(void) gelf_getsym(ddata, i, &sym);
if (sym.st_shndx >= SHN_LORESERVE)
continue;
if ((newscn = secxlate[sym.st_shndx]) !=
sym.st_shndx) {
sym.st_shndx =
(newscn == -1 ? 1 : newscn);
if (gelf_update_sym(ddata, i, &sym) ==
0) {
ret = ctf_set_errno(fp,
ECTF_ELF);
goto out;
}
}
}
}
if (gelf_update_shdr(dscn, &shdr) == 0) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
new_offset = (off_t)shdr.sh_offset;
if (shdr.sh_type != SHT_NOBITS)
new_offset += shdr.sh_size;
}
if (symtab_idx == -1) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
/* Add the ctf section */
if ((dscn = elf_newscn(dst)) == NULL) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
if (gelf_getshdr(dscn, &shdr) == NULL) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
shdr.sh_name = ctfnameoff;
shdr.sh_type = SHT_PROGBITS;
shdr.sh_size = fp->ctf_size;
shdr.sh_link = symtab_idx;
shdr.sh_addralign = 4;
if (changing && nphdr != 0) {
pad = new_offset % shdr.sh_addralign;
if (pad)
new_offset += shdr.sh_addralign - pad;
shdr.sh_offset = new_offset;
new_offset += shdr.sh_size;
}
if ((ddata = elf_newdata(dscn)) == NULL) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
if (compress != 0) {
int err;
if (ctf_zopen(&err) == NULL) {
ret = ctf_set_errno(fp, err);
goto out;
}
if ((err = ctf_compress(fp, &cdata, &asize, &elfsize)) != 0) {
ret = ctf_set_errno(fp, err);
goto out;
}
ddata->d_buf = cdata;
ddata->d_size = elfsize;
} else {
ddata->d_buf = (void *)fp->ctf_base;
ddata->d_size = fp->ctf_size;
}
ddata->d_align = shdr.sh_addralign;
if (gelf_update_shdr(dscn, &shdr) == 0) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
/* update the section header location */
if (nphdr != 0) {
size_t align = gelf_fsize(dst, ELF_T_ADDR, 1, EV_CURRENT);
size_t r = new_offset % align;
if (r)
new_offset += align - r;
dehdr.e_shoff = new_offset;
}
/* commit to disk */
if (sehdr.e_shstrndx == SHN_XINDEX)
dehdr.e_shstrndx = SHN_XINDEX;
else
dehdr.e_shstrndx = secxlate[sehdr.e_shstrndx];
if (gelf_update_ehdr(dst, &dehdr) == 0) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
if (elf_update(dst, ELF_C_WRITE) < 0) {
ret = ctf_set_errno(fp, ECTF_ELF);
goto out;
}
ret = 0;
out:
if (strdatabuf != NULL)
ctf_free(strdatabuf, strdatasz);
if (symdatabuf != NULL)
ctf_free(symdatabuf, symdatasz);
if (cdata != NULL)
ctf_data_free(cdata, fp->ctf_size);
if (secxlate != NULL)
ctf_free(secxlate, sizeof (int) * nshdr);
return (ret);
}
int
main (int argc, char *argv[])
{
if (argc < 3)
error (EXIT_FAILURE, 0, "usage: %s FROMNAME TONAME", argv[0]);
elf_version (EV_CURRENT);
int infd = open (argv[1], O_RDONLY);
if (infd == -1)
error (EXIT_FAILURE, errno, "cannot open input file '%s'", argv[1]);
Elf *inelf = elf_begin (infd, ELF_C_READ, NULL);
if (inelf == NULL)
error (EXIT_FAILURE, 0, "problems opening '%s' as ELF file: %s",
argv[1], elf_errmsg (-1));
int outfd = creat (argv[2], 0666);
if (outfd == -1)
error (EXIT_FAILURE, errno, "cannot open output file '%s'", argv[2]);
Elf *outelf = elf_begin (outfd, ELF_C_WRITE, NULL);
if (outelf == NULL)
error (EXIT_FAILURE, 0, "problems opening '%s' as ELF file: %s",
argv[2], elf_errmsg (-1));
gelf_newehdr (outelf, gelf_getclass (inelf));
GElf_Ehdr ehdr_mem;
GElf_Ehdr *ehdr;
gelf_update_ehdr (outelf, (ehdr = gelf_getehdr (inelf, &ehdr_mem)));
if (ehdr->e_phnum > 0)
{
int cnt;
if (gelf_newphdr (outelf, ehdr->e_phnum) == 0)
error (EXIT_FAILURE, 0, "cannot create program header: %s",
elf_errmsg (-1));
for (cnt = 0; cnt < ehdr->e_phnum; ++cnt)
{
GElf_Phdr phdr_mem;
gelf_update_phdr (outelf, cnt, gelf_getphdr (inelf, cnt, &phdr_mem));
}
}
Elf_Scn *scn = NULL;
while ((scn = elf_nextscn (inelf, scn)) != NULL)
{
Elf_Scn *newscn = elf_newscn (outelf);
GElf_Shdr shdr_mem;
gelf_update_shdr (newscn, gelf_getshdr (scn, &shdr_mem));
*elf_newdata (newscn) = *elf_getdata (scn, NULL);
}
elf_flagelf (outelf, ELF_C_SET, ELF_F_LAYOUT);
if (elf_update (outelf, ELF_C_WRITE) == -1)
error (EXIT_FAILURE, 0, "elf_update failed: %s", elf_errmsg (-1));
close (outfd);
return 0;
}
void clone_elf(Elf *elf, Elf *newelf,
const char *elf_name,
const char *newelf_name,
bool *sym_filter, int num_symbols,
int shady
#ifdef SUPPORT_ANDROID_PRELINK_TAGS
, int *prelinked,
int *elf_little,
long *prelink_addr
#endif
, bool rebuild_shstrtab,
bool strip_debug,
bool dry_run)
{
GElf_Ehdr ehdr_mem, *ehdr; /* store ELF header of original library */
size_t shstrndx; /* section-strings-section index */
size_t shnum; /* number of sections in the original file */
/* string table for section headers in new file */
struct Ebl_Strtab *shst = NULL;
int dynamic_idx = -1; /* index in shdr_info[] of .dynamic section */
int dynsym_idx = -1; /* index in shdr_info[] of dynamic symbol table
section */
unsigned int cnt; /* general-purpose counter */
/* This flag is true when at least one section is dropped or when the
relative order of sections has changed, so that section indices in
the resulting file will be different from those in the original. */
bool sections_dropped_or_rearranged;
Elf_Scn *scn; /* general-purpose section */
size_t idx; /* general-purporse section index */
shdr_info_t *shdr_info = NULL;
unsigned int shdr_info_len = 0;
GElf_Phdr *phdr_info = NULL;
/* Get the information from the old file. */
ehdr = gelf_getehdr (elf, &ehdr_mem);
FAILIF_LIBELF(NULL == ehdr, gelf_getehdr);
/* Create new program header for the elf file */
FAILIF(gelf_newehdr (newelf, gelf_getclass (elf)) == 0 ||
(ehdr->e_type != ET_REL && gelf_newphdr (newelf,
ehdr->e_phnum) == 0),
"Cannot create new file: %s", elf_errmsg (-1));
#ifdef SUPPORT_ANDROID_PRELINK_TAGS
ASSERT(prelinked);
ASSERT(prelink_addr);
ASSERT(elf_little);
*elf_little = (ehdr->e_ident[EI_DATA] == ELFDATA2LSB);
*prelinked = check_prelinked(elf_name, *elf_little, prelink_addr);
#endif
INFO("\n\nCALCULATING MODIFICATIONS\n\n");
/* Copy out the old program header: notice that if the ELF file does not
have a program header, this loop won't execute.
*/
INFO("Copying ELF program header...\n");
phdr_info = (GElf_Phdr *)CALLOC(ehdr->e_phnum, sizeof(GElf_Phdr));
for (cnt = 0; cnt < ehdr->e_phnum; ++cnt) {
INFO("\tRetrieving entry %d\n", cnt);
FAILIF_LIBELF(NULL == gelf_getphdr(elf, cnt, phdr_info + cnt),
gelf_getphdr);
/* -- we update the header at the end
FAILIF_LIBELF(gelf_update_phdr (newelf, cnt, phdr_info + cnt) == 0,
gelf_update_phdr);
*/
}
/* Get the section-header strings section. This section contains the
strings used to name the other sections. */
FAILIF_LIBELF(elf_getshstrndx(elf, &shstrndx) < 0, elf_getshstrndx);
/* Get the number of sections. */
FAILIF_LIBELF(elf_getshnum (elf, &shnum) < 0, elf_getshnum);
INFO("Original ELF file has %zd sections.\n", shnum);
/* Allocate the section-header-info buffer. We allocate one more entry
for the section-strings section because we regenerate that one and
place it at the very end of the file. Note that just because we create
an extra entry in the shdr_info array, it does not mean that we create
one more section the header. We just mark the old section for removal
and create one as the last section.
*/
INFO("Allocating section-header info structure (%zd) bytes...\n",
shnum*sizeof (shdr_info_t));
shdr_info_len = rebuild_shstrtab ? shnum + 1 : shnum;
shdr_info = (shdr_info_t *)CALLOC(shdr_info_len, sizeof (shdr_info_t));
/* Iterate over all the sections and initialize the internal section-info
array...
*/
INFO("Initializing section-header info structure...\n");
/* Gather information about the sections in this file. */
scn = NULL;
cnt = 1;
while ((scn = elf_nextscn (elf, scn)) != NULL) {
ASSERT(elf_ndxscn(scn) == cnt);
shdr_info[cnt].scn = scn;
FAILIF_LIBELF(NULL == gelf_getshdr(scn, &shdr_info[cnt].shdr),
gelf_getshdr);
/* Get the name of the section. */
shdr_info[cnt].name = elf_strptr (elf, shstrndx,
shdr_info[cnt].shdr.sh_name);
INFO("\tname: %s\n", shdr_info[cnt].name);
FAILIF(shdr_info[cnt].name == NULL,
"Malformed file: section %d name is null\n",
cnt);
/* Mark them as present but not yet investigated. By "investigating"
sections, we mean that we check to see if by stripping other
sections, the sections under investigation will be compromised. For
example, if we are removing a section of code, then we want to make
sure that the symbol table does not contain symbols that refer to
this code, so we investigate the symbol table. If we do find such
symbols, we will not strip the code section.
*/
shdr_info[cnt].idx = 1;
/* Remember the shdr.sh_link value. We need to remember this value
for those sections that refer to other sections. For example,
we need to remember it for relocation-entry sections, because if
we modify the symbol table that a relocation-entry section is
relative to, then we need to patch the relocation section. By the
time we get to deciding whether we need to patch the relocation
section, we will have overwritten its header's sh_link field with
a new value.
*/
shdr_info[cnt].old_shdr = shdr_info[cnt].shdr;
INFO("\t\toriginal sh_link: %08d\n", shdr_info[cnt].old_shdr.sh_link);
INFO("\t\toriginal sh_addr: %lld\n", shdr_info[cnt].old_shdr.sh_addr);
INFO("\t\toriginal sh_offset: %lld\n",
shdr_info[cnt].old_shdr.sh_offset);
INFO("\t\toriginal sh_size: %lld\n", shdr_info[cnt].old_shdr.sh_size);
if (shdr_info[cnt].shdr.sh_type == SHT_DYNAMIC) {
INFO("\t\tthis is the SHT_DYNAMIC section [%s] at index %d\n",
shdr_info[cnt].name,
cnt);
dynamic_idx = cnt;
}
else if (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM) {
INFO("\t\tthis is the SHT_DYNSYM section [%s] at index %d\n",
shdr_info[cnt].name,
cnt);
dynsym_idx = cnt;
}
FAILIF(shdr_info[cnt].shdr.sh_type == SHT_SYMTAB_SHNDX,
"Cannot handle sh_type SHT_SYMTAB_SHNDX!\n");
FAILIF(shdr_info[cnt].shdr.sh_type == SHT_GROUP,
"Cannot handle sh_type SHT_GROUP!\n");
FAILIF(shdr_info[cnt].shdr.sh_type == SHT_GNU_versym,
"Cannot handle sh_type SHT_GNU_versym!\n");
/* Increment the counter. */
++cnt;
} /* while */
/* Get the EBL handling. */
Ebl *ebl = ebl_openbackend (elf);
FAILIF_LIBELF(NULL == ebl, ebl_openbackend);
FAILIF_LIBELF(0 != arm_init(elf, ehdr->e_machine, ebl, sizeof(Ebl)),
arm_init);
if (strip_debug) {
/* This will actually strip more than just sections. It will strip
anything not essential to running the image.
*/
INFO("Finding debug sections to strip.\n");
/* Now determine which sections can go away. The general rule is that
all sections which are not used at runtime are stripped out. But
there are a few exceptions:
- special sections named ".comment" and ".note" are kept
- OS or architecture specific sections are kept since we might not
know how to handle them
- if a section is referred to from a section which is not removed
in the sh_link or sh_info element it cannot be removed either
*/
for (cnt = 1; cnt < shnum; ++cnt) {
/* Check whether the section can be removed. */
if (SECTION_STRIP_P (ebl, elf, ehdr, &shdr_info[cnt].shdr,
shdr_info[cnt].name,
1, /* remove .comment sections */
1 /* remove all debug sections */) ||
/* The macro above is broken--check for .comment explicitly */
!strcmp(".comment", shdr_info[cnt].name)
#ifdef ARM_SPECIFIC_HACKS
||
/* We ignore this section, that's why we can remove it. */
!strcmp(".stack", shdr_info[cnt].name)
#endif
)
{
/* For now assume this section will be removed. */
INFO("Section [%s] will be stripped from image.\n",
shdr_info[cnt].name);
shdr_info[cnt].idx = 0;
}
#ifdef STRIP_STATIC_SYMBOLS
else if (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB) {
/* Mark the static symbol table for removal */
INFO("Section [%s] (static symbol table) will be stripped from image.\n",
shdr_info[cnt].name);
shdr_info[cnt].idx = 0;
if (shdr_info[shdr_info[cnt].shdr.sh_link].shdr.sh_type ==
SHT_STRTAB)
{
/* Mark the symbol table's string table for removal. */
INFO("Section [%s] (static symbol-string table) will be stripped from image.\n",
shdr_info[shdr_info[cnt].shdr.sh_link].name);
shdr_info[shdr_info[cnt].shdr.sh_link].idx = 0;
}
else {
ERROR("Expecting the sh_link field of a symbol table to point to"
" associated symbol-strings table! This is not mandated by"
" the standard, but is a common practice and the only way "
" to know for sure which strings table corresponds to which"
" symbol table!\n");
}
}
#endif
}
/* Mark the SHT_NULL section as handled. */
shdr_info[0].idx = 2;
/* Handle exceptions: section groups and cross-references. We might have
to repeat this a few times since the resetting of the flag might
propagate.
*/
int exceptions_pass = 0;
bool changes;
do {
changes = false;
INFO("\nHandling exceptions, pass %d\n\n", exceptions_pass++);
for (cnt = 1; cnt < shnum; ++cnt) {
if (shdr_info[cnt].idx == 0) {
/* If a relocation section is marked as being removed but the
section it is relocating is not, then do not remove the
relocation section.
*/
if ((shdr_info[cnt].shdr.sh_type == SHT_REL
|| shdr_info[cnt].shdr.sh_type == SHT_RELA)
&& shdr_info[shdr_info[cnt].shdr.sh_info].idx != 0) {
PRINT("\tSection [%s] will not be removed because the "
"section it is relocating (%s) stays.\n",
shdr_info[cnt].name,
shdr_info[shdr_info[cnt].shdr.sh_info].name);
}
}
if (shdr_info[cnt].idx == 1) {
INFO("Processing section [%s]...\n", shdr_info[cnt].name);
/* The content of symbol tables we don't remove must not
reference any section which we do remove. Otherwise
we cannot remove the referred section.
*/
if (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM ||
shdr_info[cnt].shdr.sh_type == SHT_SYMTAB)
{
Elf_Data *symdata;
size_t elsize;
INFO("\tSection [%s] is a symbol table that's not being"
" removed.\n\tChecking to make sure that no symbols"
" refer to sections that are being removed.\n",
shdr_info[cnt].name);
/* Make sure the data is loaded. */
symdata = elf_getdata (shdr_info[cnt].scn, NULL);
FAILIF_LIBELF(NULL == symdata, elf_getdata);
/* Go through all symbols and make sure the section they
reference is not removed. */
elsize = gelf_fsize (elf, ELF_T_SYM, 1, ehdr->e_version);
/* Check the length of the dynamic-symbol filter. */
FAILIF(sym_filter != NULL &&
(size_t)num_symbols != symdata->d_size / elsize,
"Length of dynsym filter (%d) must equal the number"
" of dynamic symbols (%zd)!\n",
num_symbols,
symdata->d_size / elsize);
size_t inner;
for (inner = 0;
inner < symdata->d_size / elsize;
++inner)
{
GElf_Sym sym_mem;
GElf_Sym *sym;
size_t scnidx;
sym = gelf_getsymshndx (symdata, NULL,
inner, &sym_mem, NULL);
FAILIF_LIBELF(sym == NULL, gelf_getsymshndx);
scnidx = sym->st_shndx;
FAILIF(scnidx == SHN_XINDEX,
"Can't handle SHN_XINDEX!\n");
if (scnidx == SHN_UNDEF ||
scnidx >= shnum ||
(scnidx >= SHN_LORESERVE &&
scnidx <= SHN_HIRESERVE) ||
GELF_ST_TYPE (sym->st_info) == STT_SECTION)
{
continue;
}
/* If the symbol is going to be thrown and it is a
global or weak symbol that is defined (not imported),
then continue. Since the symbol is going away, we
do not care whether it refers to a section that is
also going away.
*/
if (sym_filter && !sym_filter[inner])
{
bool global_or_weak =
ELF32_ST_BIND(sym->st_info) == STB_GLOBAL ||
ELF32_ST_BIND(sym->st_info) == STB_WEAK;
if (!global_or_weak && sym->st_shndx != SHN_UNDEF)
continue;
}
/* -- far too much output
INFO("\t\t\tSymbol [%s] (%d)\n",
elf_strptr(elf,
shdr_info[cnt].shdr.sh_link,
sym->st_name),
shdr_info[cnt].shdr.sh_info);
*/
if (shdr_info[scnidx].idx == 0)
{
PRINT("\t\t\tSymbol [%s] refers to section [%s], "
"which is being removed. Will keep that "
"section.\n",
elf_strptr(elf,
shdr_info[cnt].shdr.sh_link,
sym->st_name),
shdr_info[scnidx].name);
/* Mark this section as used. */
shdr_info[scnidx].idx = 1;
changes |= scnidx < cnt;
}
} /* for each symbol */
} /* section type is SHT_DYNSYM or SHT_SYMTAB */
/* Cross referencing happens:
- for the cases the ELF specification says. That are
+ SHT_DYNAMIC in sh_link to string table
+ SHT_HASH in sh_link to symbol table
+ SHT_REL and SHT_RELA in sh_link to symbol table
+ SHT_SYMTAB and SHT_DYNSYM in sh_link to string table
+ SHT_GROUP in sh_link to symbol table
+ SHT_SYMTAB_SHNDX in sh_link to symbol table
Other (OS or architecture-specific) sections might as
well use this field so we process it unconditionally.
- references inside section groups
- specially marked references in sh_info if the SHF_INFO_LINK
flag is set
*/
if (shdr_info[shdr_info[cnt].shdr.sh_link].idx == 0) {
shdr_info[shdr_info[cnt].shdr.sh_link].idx = 1;
changes |= shdr_info[cnt].shdr.sh_link < cnt;
}
/* Handle references through sh_info. */
if (SH_INFO_LINK_P (&shdr_info[cnt].shdr) &&
shdr_info[shdr_info[cnt].shdr.sh_info].idx == 0) {
PRINT("\tSection [%s] links to section [%s], which was "
"marked for removal--it will not be removed.\n",
shdr_info[cnt].name,
shdr_info[shdr_info[cnt].shdr.sh_info].name);
shdr_info[shdr_info[cnt].shdr.sh_info].idx = 1;
changes |= shdr_info[cnt].shdr.sh_info < cnt;
}
/* Mark the section as investigated. */
shdr_info[cnt].idx = 2;
} /* if (shdr_info[cnt].idx == 1) */
} /* for (cnt = 1; cnt < shnum; ++cnt) */
} while (changes);
}
else {
INFO("Not stripping sections.\n");
/* Mark the SHT_NULL section as handled. */
shdr_info[0].idx = 2;
}
/* Mark the section header string table as unused, we will create
a new one as the very last section in the new ELF file.
*/
shdr_info[shstrndx].idx = rebuild_shstrtab ? 0 : 2;
/* We need a string table for the section headers. */
FAILIF_LIBELF((shst = ebl_strtabinit (1 /* null-terminated */)) == NULL,
ebl_strtabinit);
/* Assign new section numbers. */
INFO("Creating new sections...\n");
//shdr_info[0].idx = 0;
for (cnt = idx = 1; cnt < shnum; ++cnt) {
if (shdr_info[cnt].idx > 0) {
shdr_info[cnt].idx = idx++;
/* Create a new section. */
FAILIF_LIBELF((shdr_info[cnt].newscn =
elf_newscn(newelf)) == NULL, elf_newscn);
ASSERT(elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx);
/* Add this name to the section header string table. */
shdr_info[cnt].se = ebl_strtabadd (shst, shdr_info[cnt].name, 0);
INFO("\tsection [%s] (old offset %lld, old size %lld) will have index %d "
"(was %zd).\n",
shdr_info[cnt].name,
shdr_info[cnt].old_shdr.sh_offset,
shdr_info[cnt].old_shdr.sh_size,
shdr_info[cnt].idx,
elf_ndxscn(shdr_info[cnt].scn));
} else {
INFO("\tIgnoring section [%s] (offset %lld, size %lld, index %zd), "
"it will be discarded.\n",
shdr_info[cnt].name,
shdr_info[cnt].shdr.sh_offset,
shdr_info[cnt].shdr.sh_size,
elf_ndxscn(shdr_info[cnt].scn));
}
} /* for */
sections_dropped_or_rearranged = idx != cnt;
Elf_Data *shstrtab_data = NULL;
#if 0
/* Fail if sections are being dropped or rearranged (except for moving shstrtab) or the
symbol filter is not empty, AND the file is an executable.
*/
FAILIF(((idx != cnt && !(cnt - idx == 1 && rebuild_shstrtab)) || sym_filter != NULL) &&
ehdr->e_type != ET_DYN,
"You may not rearrange sections or strip symbols on an executable file!\n");
#endif
INFO("\n\nADJUSTING ELF FILE\n\n");
adjust_elf(elf, elf_name,
newelf, newelf_name,
ebl,
ehdr, /* store ELF header of original library */
sym_filter, num_symbols,
shdr_info, shdr_info_len,
phdr_info,
idx, /* highest_scn_num */
shnum,
shstrndx,
shst,
sections_dropped_or_rearranged,
dynamic_idx, /* index in shdr_info[] of .dynamic section */
dynsym_idx, /* index in shdr_info[] of dynamic symbol table */
shady,
&shstrtab_data,
ehdr->e_type == ET_DYN, /* adjust section ofsets only when the file is a shared library */
rebuild_shstrtab);
/* We have everything from the old file. */
FAILIF_LIBELF(elf_cntl(elf, ELF_C_FDDONE) != 0, elf_cntl);
/* The ELF library better follows our layout when this is not a
relocatable object file. */
elf_flagelf (newelf,
ELF_C_SET,
(ehdr->e_type != ET_REL ? ELF_F_LAYOUT : 0));
/* Finally write the file. */
FAILIF_LIBELF(!dry_run && elf_update(newelf, ELF_C_WRITE) == -1, elf_update);
if (shdr_info != NULL) {
/* For some sections we might have created an table to map symbol
table indices. */
for (cnt = 1; cnt < shdr_info_len; ++cnt) {
FREEIF(shdr_info[cnt].newsymidx);
FREEIF(shdr_info[cnt].symse);
if(shdr_info[cnt].dynsymst != NULL)
ebl_strtabfree (shdr_info[cnt].dynsymst);
}
/* Free the memory. */
FREE (shdr_info);
}
FREEIF(phdr_info);
ebl_closebackend(ebl);
/* Free other resources. */
if (shst != NULL) ebl_strtabfree (shst);
if (shstrtab_data != NULL)
FREEIF(shstrtab_data->d_buf);
}
int main(int argc, const char *argv[]) {
ssize_t bytes_written; // only used to silence compiler warnings
if (argc < 2)
errx(EX_USAGE, "Usage: PatchEntry <binary>");
if (elf_version(EV_CURRENT) == EV_NONE)
errx(EX_SOFTWARE, "Invalid ELF version: %s", elf_errmsg(-1));
int fd = open(argv[1], O_RDWR);
if (fd == -1)
err(EX_NOINPUT, "open() failed");
Elf *e;
e = elf_begin(fd, ELF_C_RDWR, NULL);
if (e == nullptr)
errx(EX_SOFTWARE, "Failed to read from ELF file: %s", elf_errmsg(-1));
if (elf_kind(e) != ELF_K_ELF)
errx(EX_SOFTWARE, "File is not an ELF object");
// Read the ELF header to find the entry point
// FIXME: check the class/architecture, make sure it's the same as ours
GElf_Ehdr elf_hdr;
if (gelf_getehdr(e, &elf_hdr) == NULL)
errx(EX_SOFTWARE, "Failed to read ELF header: %s", elf_errmsg(-1));
auto dt_init = FindDynamicInit(e);
auto dt_init_ofs = 0;
if (dt_init) {
dt_init_ofs = dt_init->info.second.sh_offset +
dt_init->data->d_off +
dt_init->index * sizeof(Elf_Dyn) +
offsetof(Elf_Dyn, d_un);
}
auto pit_sym = FindSymbol(e, kProgramInfoTableName);
auto pit_info = FindSectionDataByAddr(e, pit_sym.st_value);
auto pit_ofs = std::get<0>(pit_info).second.sh_offset + // Section file offset
std::get<1>(pit_info)->d_off + // Elf_Data offset
std::get<2>(pit_info); // Offset relative to Elf_Data
#if 1
if (dt_init)
printf("Old ELF entry:%p DT_INIT:%p@%x PIT:%p@%lx\n",
(void*) elf_hdr.e_entry,
(void*) dt_init->dyn_section.d_un.d_ptr,
dt_init_ofs,
(void*) pit_sym.st_value,
pit_ofs);
else
printf("Old ELF entry:%p DT_INIT:NULL PIT:%p@%lx\n",
(void*) elf_hdr.e_entry,
(void*) pit_sym.st_value,
pit_ofs);
#endif
// Replace the ProgramInfoTable values
auto pit_data = std::get<1>(pit_info);
auto orig_pit = reinterpret_cast<TrapProgramInfoTable*>(
reinterpret_cast<uint8_t*>(pit_data->d_buf) + std::get<2>(pit_info));
TrapProgramInfoTable pit = *orig_pit; // Need to copy it here, since elf_end releases it
if (pit.num_sections != 0)
errx(EX_USAGE, "Binary already contains full ProgramInfoTable structure");
if (dt_init)
pit.orig_dt_init = dt_init->dyn_section.d_un.d_ptr;
else
pit.orig_dt_init = 0;
pit.orig_entry = elf_hdr.e_entry;
// Find executable sections in the binary (.text/.plt/others)
// then copy them over to the PIT
pit.num_sections = TRAP_NUM_SECTIONS;
for (size_t i = 0; i < TRAP_NUM_SECTIONS; i++) {
auto sec_info = FindSectionByName(e, kExecSections[i][0]);
if (sec_info.first != nullptr) {
pit.sections[i].start = sec_info.second.sh_addr;
pit.sections[i].size = sec_info.second.sh_size;
}
auto trap_sec_info = FindSectionByName(e, kExecSections[i][1]);
if (trap_sec_info.first != nullptr) {
pit.sections[i].trap = trap_sec_info.second.sh_addr;
pit.sections[i].trap_size = trap_sec_info.second.sh_size;
}
}
// Set the new entry point addresses
auto entry_trampoline_sym = FindSymbol(e, kEntryTrampolineName);
auto init_trampoline_sym = FindSymbol(e, kInitTrampolineName);
elf_hdr.e_entry = entry_trampoline_sym.st_value;
auto new_dt_init = static_cast<ArchPointer>(init_trampoline_sym.st_value);
// Find export trampolines
auto xptramp_info = FindSectionByName(e, ".xptramp");
DynamicSymbolMap dyn_sym_map;
ExportTrampolineVector xptramp_vec;
size_t xptramp_shndx = 0;
if (xptramp_info.first != nullptr) {
pit.xptramp_start = xptramp_info.second.sh_addr;
pit.xptramp_size = xptramp_info.second.sh_size;
dyn_sym_map = FindDynamicSymbols(e);
xptramp_vec = FindExportTrampolines(e, xptramp_info);
xptramp_shndx = elf_ndxscn(xptramp_info.first);
}
// Update the ELF header, then write it out
// There's some pretty ugly behavior from libelf here:
// if we let it handle the layout, it mis-aligns the data sections
// It also doesn't seem to update the contents correctly,
// so we do that manually
elf_flagelf(e, ELF_C_SET, ELF_F_LAYOUT);
gelf_update_ehdr(e, &elf_hdr);
if (elf_update(e, ELF_C_WRITE) <= 0)
errx(EX_SOFTWARE, "Couldn't update ELF file: %s", elf_errmsg(-1));
elf_end(e);
// FIXME: libelf shenanigans force us to
// write data out to the file manually
// 1) DT_INIT inside .dynamic
if (dt_init) {
printf("writing new DT_INIT: 0x%lu\n", new_dt_init);
lseek(fd, dt_init_ofs, SEEK_SET);
bytes_written = write(fd, &new_dt_init, sizeof(new_dt_init));
}
// 2) The ProgramInfoTable
lseek(fd, pit_ofs, SEEK_SET);
bytes_written = write(fd, &pit, sizeof(pit));
// 3) Exported symbols
WriteExportSymbols(fd, xptramp_info, xptramp_vec, xptramp_shndx, dyn_sym_map);
close(fd);
return 0;
}
int
main(int argc, char **argv)
{
GElf_Ehdr ehdr;
Elf *elf;
Elf_Kind kind;
int type = ELFOSABI_NONE;
int retval = 0;
int ch, change = 0, verbose = 0, force = 0, listed = 0;
if (elf_version(EV_CURRENT) == EV_NONE)
errx(EXIT_FAILURE, "elf_version error");
while ((ch = getopt_long(argc, argv, "Vf:hlt:v", brandelf_longopts,
NULL)) != -1)
switch (ch) {
case 'f':
if (change)
errx(EXIT_FAILURE, "ERROR: the -f option is "
"incompatible with the -t option.");
force = 1;
type = atoi(optarg);
if (errno == ERANGE || type < 0 || type > 255) {
warnx("ERROR: invalid argument to option "
"-f: %s", optarg);
usage();
}
break;
case 'h':
usage();
break;
case 'l':
printelftypes();
listed = 1;
break;
case 'v':
verbose = 1;
break;
case 't':
if (force)
errx(EXIT_FAILURE, "the -t option is "
"incompatible with the -f option.");
if ((type = elftype(optarg)) == -1) {
warnx("ERROR: invalid ELF type '%s'", optarg);
usage();
}
change = 1;
break;
case 'V':
printversion();
break;
default:
usage();
}
argc -= optind;
argv += optind;
if (!argc) {
if (listed)
exit(0);
else {
warnx("no file(s) specified");
usage();
}
}
while (argc) {
int fd;
elf = NULL;
if ((fd = open(argv[0], (change || force) ? O_RDWR :
O_RDONLY, 0)) < 0) {
warn("error opening file %s", argv[0]);
retval = 1;
goto fail;
}
if ((elf = elf_begin(fd, (change || force) ? ELF_C_RDWR :
ELF_C_READ, NULL)) == NULL) {
warnx("elf_begin failed: %s", elf_errmsg(-1));
retval = 1;
goto fail;
}
if ((kind = elf_kind(elf)) != ELF_K_ELF) {
if (kind == ELF_K_AR)
warnx("file '%s' is an archive.", argv[0]);
else
warnx("file '%s' is not an ELF file.",
argv[0]);
retval = 1;
goto fail;
}
if (gelf_getehdr(elf, &ehdr) == NULL) {
warnx("gelf_getehdr: %s", elf_errmsg(-1));
retval = 1;
goto fail;
}
if (!change && !force) {
fprintf(stdout,
"File '%s' is of brand '%s' (%u).\n",
argv[0], iselftype(ehdr.e_ident[EI_OSABI]),
ehdr.e_ident[EI_OSABI]);
if (!iselftype(type)) {
warnx("ELF ABI Brand '%u' is unknown",
type);
printelftypes();
}
} else {
/*
* Keep the existing layout of the ELF object.
*/
if (elf_flagelf(elf, ELF_C_SET, ELF_F_LAYOUT) == 0) {
warnx("elf_flagelf failed: %s",
elf_errmsg(-1));
retval = 1;
goto fail;
}
/*
* Update the ABI type.
*/
ehdr.e_ident[EI_OSABI] = type;
if (gelf_update_ehdr(elf, &ehdr) == 0) {
warnx("gelf_update_ehdr error: %s",
elf_errmsg(-1));
retval = 1;
goto fail;
}
/*
* Write back changes.
*/
if (elf_update(elf, ELF_C_WRITE) == -1) {
warnx("elf_update error: %s", elf_errmsg(-1));
retval = 1;
goto fail;
}
}
fail:
if (elf)
elf_end(elf);
if (fd >= 0 && close(fd) == -1) {
warnx("%s: close error", argv[0]);
retval = 1;
}
argc--;
argv++;
}
return (retval);
}
int
main(int argc, char **argv)
{
int c, ndx;
int readonly;
int fd;
const char *file;
const char *runpath;
Elf *elf;
GElf_Ehdr ehdr;
size_t shstrndx, shnum;
Elf_Scn *scn;
Elf_Data *data;
char *shnames = NULL;
Cache *cache, *_cache;
Cache *dynsec, *strsec;
GElf_Word numdyn;
dyn_elt_t rpath_elt;
dyn_elt_t runpath_elt;
dyn_elt_t strpad_elt;
dyn_elt_t flags_1_elt;
dyn_elt_t null_elt;
int changed = 0;
opterr = 0;
while ((c = getopt(argc, argv, "dr")) != EOF) {
switch (c) {
case 'd':
d_flg = 1;
break;
case 'r':
r_flg = 1;
break;
case '?':
msg_usage();
}
}
/*
* The first plain argument is the file name, and is required.
* The second plain argument is the runpath, and is optional.
* If no runpath is given, we print the current runpath to stdout
* and exit. If it is present, we modify the ELF file to use it.
*/
argc = argc - optind;
argv += optind;
if ((argc < 1) || (argc > 2))
msg_usage();
if ((argc == 2) && r_flg)
msg_usage();
readonly = (argc == 1) && !r_flg;
file = argv[0];
if (!readonly)
runpath = argv[1];
if ((fd = open(file, readonly ? O_RDONLY : O_RDWR)) == -1)
msg_fatal("unable to open file: %s: %s\n",
file, strerror(errno));
(void) elf_version(EV_CURRENT);
elf = elf_begin(fd, readonly ? ELF_C_READ : ELF_C_RDWR, NULL);
if (elf == NULL)
msg_elf("elf_begin");
/* We only handle standalone ELF files */
switch (elf_kind(elf)) {
case ELF_K_AR:
msg_fatal("unable to edit ELF archive: %s\n", file);
break;
case ELF_K_ELF:
break;
default:
msg_fatal("unable to edit non-ELF file: %s\n", file);
break;
}
if (gelf_getehdr(elf, &ehdr) == NULL)
msg_elf("gelf_getehdr");
if (elf_getshnum(elf, &shnum) == 0)
msg_elf("elf_getshnum");
if (elf_getshstrndx(elf, &shstrndx) == 0)
msg_elf("elf_getshstrndx");
/*
* Obtain the .shstrtab data buffer to provide the required section
* name strings.
*/
if ((scn = elf_getscn(elf, shstrndx)) == NULL)
msg_elf("elf_getscn");
if ((data = elf_getdata(scn, NULL)) == NULL)
msg_elf("elf_getdata");
shnames = data->d_buf;
/*
* Allocate a cache to maintain a descriptor for each section.
*/
if ((cache = malloc(shnum * sizeof (Cache))) == NULL)
msg_fatal("unable to allocate section cache: %s\n",
strerror(errno));
bzero(cache, sizeof (cache[0]));
cache->c_name = "";
_cache = cache + 1;
/*
* Fill in cache with information for each section, and
* locate the dynamic section.
*/
dynsec = strsec = NULL;
for (ndx = 1, scn = NULL; scn = elf_nextscn(elf, scn);
ndx++, _cache++) {
_cache->c_ndx = ndx;
if (gelf_getshdr(scn, &_cache->c_shdr) == NULL)
msg_elf("gelf_getshdr");
_cache->c_data = elf_getdata(scn, NULL);
_cache->c_name = shnames + _cache->c_shdr.sh_name;
if (_cache->c_shdr.sh_type == SHT_DYNAMIC) {
dynsec = _cache;
numdyn = dynsec->c_shdr.sh_size /
dynsec->c_shdr.sh_entsize;
msg_debug("[%d]%s: dynamic section\n",
ndx, _cache->c_name);
}
}
/*
* If we got a dynamic section, locate the string table.
* If not, we can't continue.
*/
if (dynsec == NULL)
msg_fatal("file lacks a dynamic section: %s\n", file);
strsec = &cache[dynsec->c_shdr.sh_link];
msg_debug("[%d]%s: dynamic string table section\n",
strsec->c_ndx, strsec->c_name);
/*
* History Lesson And Strategy:
*
* This routine handles both DT_RPATH and DT_RUNPATH entries, altering
* either or both if they are present.
*
* The original SYSV ABI only had DT_RPATH, and the runtime loader used
* it to search for things in the following order:
*
* DT_RPATH, LD_LIBRARY_PATH, defaults
*
* Solaris did not follow this rule. Environment variables should
* supersede everything else, so we have always deviated from the
* ABI and and instead search in the order
*
* LD_LIBRARY_PATH, DT_RPATH, defaults
*
* Other Unix variants initially followed the ABI, but in recent years
* realized that it was a mistake. Hence, DT_RUNPATH was invented,
* with the search order:
*
* LD_LIBRARY_PATH, DT_RUNPATH, defaults
*
* So for Solaris, DT_RPATH and DT_RUNPATH mean the same thing. If both
* are present (which does happen), we set them both to the new
* value. If either one is present, we set that one. If neither is
* present, and we have a spare DT_NULL slot, we create a DT_RUNPATH.
*/
/*
* Examine the dynamic section to determine the index for
* - DT_RPATH
* - DT_RUNPATH
* - DT_SUNW_STRPAD
* - DT_NULL, and whether there are any extra DT_NULL slots
*/
dyn_elt_init(&rpath_elt);
dyn_elt_init(&runpath_elt);
dyn_elt_init(&strpad_elt);
dyn_elt_init(&flags_1_elt);
dyn_elt_init(&null_elt);
for (ndx = 0; ndx < numdyn; ndx++) {
GElf_Dyn dyn;
if (gelf_getdyn(dynsec->c_data, ndx, &dyn) == NULL)
msg_elf("gelf_getdyn");
switch (dyn.d_tag) {
case DT_NULL:
/*
* Remember the state of the first DT_NULL. If there
* are more than one (i.e. the first one is not
* in the final spot), and there is no runpath, then
* we will turn the first one into a DT_RUNPATH.
*/
if (!null_elt.seen) {
dyn_elt_save(&null_elt, ndx, &dyn);
msg_debug("[%d]%s[%d]: DT_NULL\n",
dynsec->c_ndx, dynsec->c_name, ndx);
}
break;
case DT_RPATH:
dyn_elt_save(&rpath_elt, ndx, &dyn);
msg_debug("[%d]%s[%d]: DT_RPATH: %s\n",
dynsec->c_ndx, dynsec->c_name, ndx,
DYN_ELT_STRING(&rpath_elt, strsec));
break;
case DT_RUNPATH:
dyn_elt_save(&runpath_elt, ndx, &dyn);
msg_debug("[%d]%s[%d]: DT_RUNPATH: %s\n",
dynsec->c_ndx, dynsec->c_name, ndx,
DYN_ELT_STRING(&runpath_elt, strsec));
break;
case DT_SUNW_STRPAD:
dyn_elt_save(&strpad_elt, ndx, &dyn);
msg_debug("[%d]%s[%d]: DT_STRPAD: %d\n",
dynsec->c_ndx, dynsec->c_name, ndx,
(int)strpad_elt.dyn.d_un.d_val);
break;
case DT_FLAGS_1:
dyn_elt_save(&flags_1_elt, ndx, &dyn);
break;
}
}
/*
* If this is a readonly session, then print the existing
* runpath and exit. DT_RPATH and DT_RUNPATH should have
* the same value, so we arbitrarily favor DT_RUNPATH.
*/
if (readonly) {
if (runpath_elt.seen)
(void) printf("%s\n",
DYN_ELT_STRING(&runpath_elt, strsec));
else if (rpath_elt.seen)
(void) printf("%s\n",
DYN_ELT_STRING(&rpath_elt, strsec));
else
msg_debug("ELF file does not have a runpath: %s\n",
file);
return (0);
}
/* Edit the file, either to remove the runpath or to add/modify it */
if (r_flg) {
if (!(runpath_elt.seen || rpath_elt.seen))
msg_debug("[%d]%s: no runpath found\n",
dynsec->c_ndx, dynsec->c_name);
else
changed = remove_runpath(dynsec, numdyn);
} else {
changed = new_runpath(runpath, dynsec, numdyn, strsec,
&rpath_elt, &runpath_elt, &strpad_elt, &null_elt);
}
if (changed) {
/*
* If possible, set the DF_1_EDITED flag, indicating that
* this file has been edited after the fact.
*/
if (flags_1_elt.seen) {
flags_1_elt.dyn.d_un.d_val |= DF_1_EDITED;
} else if (null_elt.seen && (null_elt.ndx < (numdyn - 1))) {
msg_debug("[%d]%s: No existing flags_1 entry to "
"modify. Will use extra DT_NULL in slot [%d] \n",
dynsec->c_ndx, dynsec->c_name, null_elt.ndx);
flags_1_elt.seen = 1;
flags_1_elt.ndx = null_elt.ndx;
flags_1_elt.dyn.d_tag = DT_FLAGS_1;
flags_1_elt.dyn.d_un.d_val = DF_1_EDITED;
}
if (flags_1_elt.seen) {
msg_debug("[%d]%s[%d]: Set DF_1_EDITED flag\n",
dynsec->c_ndx, dynsec->c_name, flags_1_elt.ndx);
if (gelf_update_dyn(dynsec->c_data, flags_1_elt.ndx,
&flags_1_elt.dyn) == 0)
msg_elf("gelf_update_dyn");
}
/*
* Mark the data area as dirty so libelf will flush our
* changes to the dynamic section data.
*/
(void) elf_flagdata(dynsec->c_data, ELF_C_SET, ELF_F_DIRTY);
/* Flush the file to disk */
if (elf_update(elf, ELF_C_WRITE) == -1)
msg_elf("elf_update");
(void) close(fd);
(void) elf_end(elf);
}
return (0);
}
int main()
{
Dwarf_Error error = 0;
Dwarf_P_Debug dw = dwarf_producer_init_c(DW_DLC_WRITE | DW_DLC_SIZE_64,
createSectionCallback,
/* error handler */0,
/* error arg */0,
/* user data */0,
&error);
if (error != 0)
die("dwarf_producer_init_c failed");
Dwarf_Unsigned cie = dwarf_add_frame_cie(dw,
"",
/* code alignment factor */QT_POINTER_SIZE,
/* data alignment factor */-QT_POINTER_SIZE,
/* return address reg*/InstructionPointerRegister,
cie_init_instructions,
sizeof(cie_init_instructions),
&error);
if (error != 0)
die("dwarf_add_frame_cie failed");
Dwarf_P_Fde fde = dwarf_new_fde(dw, &error);
if (error != 0)
die("dwarf_new_fde failed");
/* New entry in state machine for code offset 1 after push rbp instruction */
dwarf_add_fde_inst(fde,
DW_CFA_advance_loc,
/*offset in code alignment units*/ 1,
/* unused*/ 0,
&error);
/* After "push rbp" the offset to the CFA is now 2 instead of 1 */
dwarf_add_fde_inst(fde,
DW_CFA_def_cfa_offset_sf,
/*offset in code alignment units*/ -2,
/* unused*/ 0,
&error);
/* After "push rbp" the value of rbp is now stored at offset 1 from CFA */
dwarf_add_fde_inst(fde,
DW_CFA_offset,
StackFrameRegister,
2,
&error);
/* New entry in state machine for code offset 3 for mov rbp, rsp instruction */
dwarf_add_fde_inst(fde,
DW_CFA_advance_loc,
/*offset in code alignment units*/ 3,
/* unused */ 0,
&error);
/* After "mov rbp, rsp" the cfa is reachable via rbp */
dwarf_add_fde_inst(fde,
DW_CFA_def_cfa_register,
StackFrameRegister,
/* unused */0,
&error);
/* Callee saved registers */
for (int i = 0; i < calleeSavedRegisterCount; ++i) {
dwarf_add_fde_inst(fde,
DW_CFA_offset,
calleeSavedRegisters[i],
i + 3,
&error);
}
dwarf_add_frame_fde(dw, fde,
/* die */0,
cie,
/*virt addr */0,
/* length of code */0,
/* symbol index */0,
&error);
if (error != 0)
die("dwarf_add_frame_fde failed");
dwarf_transform_to_disk_form(dw, &error);
if (error != 0)
die("dwarf_transform_to_disk_form failed");
Dwarf_Unsigned len = 0;
Dwarf_Signed elfIdx = 0;
unsigned char *bytes = (unsigned char *)dwarf_get_section_bytes(dw, /* section */1,
&elfIdx, &len, &error);
if (error != 0)
die("dwarf_get_section_bytes failed");
// libdwarf doesn't add a terminating FDE with zero length, so let's add one
// ourselves.
unsigned char *newBytes = (unsigned char *)alloca(len + 4);
memcpy(newBytes, bytes, len);
newBytes[len] = 0;
newBytes[len + 1] = 0;
newBytes[len + 2] = 0;
newBytes[len + 3] = 0;
newBytes[len + 4] = 0;
bytes = newBytes;
len += 4;
// Reset CIE-ID back to 0 as expected for .eh_frames
bytes[4] = 0;
bytes[5] = 0;
bytes[6] = 0;
bytes[7] = 0;
unsigned fde_offset = bytes[0] + 4;
bytes[fde_offset + 4] = fde_offset + 4;
printf("static const unsigned char cie_fde_data[] = {\n");
int i = 0;
while (i < len) {
printf(" ");
for (int j = 0; i < len && j < 8; ++j, ++i)
printf("0x%x, ", bytes[i]);
printf("\n");
}
printf("};\n");
printf("static const int fde_offset = %d;\n", fde_offset);
printf("static const int initial_location_offset = %d;\n", fde_offset + 8);
printf("static const int address_range_offset = %d;\n", fde_offset + 8 + QT_POINTER_SIZE);
#ifdef DEBUG
{
if (elf_version(EV_CURRENT) == EV_NONE)
die("wrong elf version");
int fd = open("debug.o", O_WRONLY | O_CREAT, 0777);
if (fd < 0)
die("cannot create debug.o");
Elf *e = elf_begin(fd, ELF_C_WRITE, 0);
if (!e)
die("elf_begin failed");
Elf_Ehdr *ehdr = elf_newehdr(e);
if (!ehdr)
die(elf_errmsg(-1));
ehdr->e_ident[EI_DATA] = ELFDATA2LSB;
#if defined(Q_PROCESSOR_X86_64)
ehdr->e_machine = EM_X86_64;
#elif defined(Q_PROCESSOR_X86)
ehdr->e_machine = EM_386;
#else
#error port me :)
#endif
ehdr->e_type = ET_EXEC;
ehdr->e_version = EV_CURRENT;
Elf_Scn *section = elf_newscn(e);
if (!section)
die("elf_newscn failed");
Elf_Data *data = elf_newdata(section);
if (!data)
die(elf_errmsg(-1));
data->d_align = 4;
data->d_off = 0;
data->d_buf = bytes;
data->d_size = len;
data->d_type = ELF_T_BYTE;
data->d_version = EV_CURRENT;
Elf_Shdr *shdr = elf_getshdr(section);
if (!shdr)
die(elf_errmsg(-1));
shdr->sh_name = 1;
shdr->sh_type = SHT_PROGBITS;
shdr->sh_entsize = 0;
char stringTable[] = {
0,
'.', 'e', 'h', '_', 'f', 'r', 'a', 'm', 'e', 0,
'.', 's', 'h', 's', 't', 'r', 't', 'a', 'b', 0
};
section = elf_newscn(e);
if (!section)
die("elf_newscn failed");
data = elf_newdata(section);
if (!data)
die(elf_errmsg(-1));
data->d_align = 1;
data->d_off = 0;
data->d_buf = stringTable;
data->d_size = sizeof(stringTable);
data->d_type = ELF_T_BYTE;
data->d_version = EV_CURRENT;
shdr = elf_getshdr(section);
if (!shdr)
die(elf_errmsg(-1));
shdr->sh_name = 11;
shdr->sh_type = SHT_STRTAB;
shdr->sh_flags = SHF_STRINGS | SHF_ALLOC;
shdr->sh_entsize = 0;
ehdr->e_shstrndx = elf_ndxscn(section);
if (elf_update(e, ELF_C_WRITE) < 0)
die(elf_errmsg(-1));
elf_end(e);
close(fd);
}
#endif
dwarf_producer_finish(dw, &error);
if (error != 0)
die("dwarf_producer_finish failed");
return 0;
}
int main(int argc, char **argv)
{
ELFHandles hIn = { 0 };
int exitval = EXIT_SUCCESS;
char *progname = argv[0];
int c;
int option_index = 0;
ElfuElf *me = NULL;
static struct option long_options[] = {
{"help", 0, 0, 'h'},
{"check", 0, 0, 'c'},
{"dump", 0, 0, 'd'},
{"input", 1, 0, 'i'},
{"output", 1, 0, 'o'},
{"reladd", 1, 0, 10001},
{"detour", 1, 0, 10002},
{NULL, 0, NULL, 0}
};
if (argc < 3) {
printUsage(progname);
goto EXIT;
}
/* Is libelf alive and well? */
if (elf_version(EV_CURRENT) == EV_NONE) {
fprintf(stderr, "libelf init error: %s\n", elf_errmsg(-1));
}
/* Parse and and execute user commands */
while ((c = getopt_long(argc, argv, "hcdi:o:",
long_options, &option_index)) != -1) {
switch (c) {
case 'h':
printUsage(progname);
goto EXIT;
case 'c':
if (!me) {
goto ERR_NO_INPUT;
} else {
printf("Checking model validity...\n");
elfu_mCheck(me);
}
break;
case 'd':
if (!me) {
goto ERR_NO_INPUT;
} else {
elfu_mDumpElf(me);
}
break;
case 'i':
if (me) {
elfu_mElfDestroy(me);
}
printf("Opening input file %s.\n", optarg);
openElf(&hIn, optarg, ELF_C_READ);
if (!hIn.e) {
printf("Error: Failed to open input file. Aborting.\n");
exitval = EXIT_FAILURE;
goto EXIT;
}
me = elfu_mFromElf(hIn.e);
closeElf(&hIn);
if (!me) {
printf("Error: Failed to load model, aborting.\n");
goto EXIT;
}
break;
case 'o':
if (!me) {
goto ERR_NO_INPUT;
} else {
ELFHandles hOut = { 0 };
printf("Writing modified file to %s.\n", optarg);
openElf(&hOut, optarg, ELF_C_WRITE);
if (!hOut.e) {
printf("Failed to open output file. Aborting.\n");
closeElf(&hOut);
exitval = EXIT_FAILURE;
goto EXIT;
}
elfu_mToElf(me, hOut.e);
if (elf_update(hOut.e, ELF_C_WRITE) < 0) {
fprintf(stderr, "elf_update() failed: %s\n", elf_errmsg(-1));
}
closeElf(&hOut);
}
break;
case 10001:
if (!me) {
goto ERR_NO_INPUT;
} else {
ELFHandles hRel = { 0 };
ElfuElf *mrel = NULL;
openElf(&hRel, optarg, ELF_C_READ);
if (!hRel.e) {
printf("--reladd: Failed to open file for --reladd, aborting.\n");
closeElf(&hRel);
goto ERR;
}
mrel = elfu_mFromElf(hRel.e);
closeElf(&hRel);
if (!mrel) {
printf("--reladd: Failed to load model for --reladd, aborting.\n");
goto ERR;
} else {
printf("--reladd: Injecting %s...\n", optarg);
if (elfu_mCheck(mrel)) {
printf("--reladd: Check for input file failed.\n");
elfu_mElfDestroy(mrel);
goto ERR;
}
if (elfu_mReladd(me, mrel)) {
printf("--reladd: Failed.\n");
elfu_mElfDestroy(mrel);
goto ERR;
}
printf("--reladd: Injected %s.\n", optarg);
elfu_mElfDestroy(mrel);
}
}
break;
case 10002:
if (!me) {
goto ERR_NO_INPUT;
} else {
GElf_Addr from;
GElf_Addr to;
char *second;
strtok_r(optarg, ",", &second);
printf("--detour: From '%s' to '%s'\n", optarg, second);
from = strtoul(optarg, NULL, 0);
if (from == 0) {
from = elfu_mSymtabLookupAddrByName(me, me->symtab, optarg);
}
if (from == 0) {
printf("--detour: Cannot parse argument 1, aborting.\n");
goto ERR;
}
printf("--detour: From %x\n", (unsigned)from);
to = strtoul(second, NULL, 0);
if (to == 0) {
to = elfu_mSymtabLookupAddrByName(me, me->symtab, second);
}
if (to == 0) {
printf("--detour: Cannot parse argument 2, aborting.\n");
goto ERR;
}
printf("--detour: To %x\n", (unsigned)to);
elfu_mDetour(me, from, to);
}
break;
case '?':
default:
printUsage(progname);
goto EXIT;
}
}
while (optind < argc) {
optind++;
}
EXIT:
if (me) {
elfu_mElfDestroy(me);
}
if (hIn.e) {
closeElf(&hIn);
}
return (exitval);
ERR_NO_INPUT:
printf("Error: No input file opened. Aborting.\n");
ERR:
exitval = EXIT_FAILURE;
goto EXIT;
}
static int replaceAMDILSection(Elf* e, int nStream, MWCALtargetEnum target)
{
Elf_Scn* scn = NULL;
size_t shstrndx = 0;
static const int verbose = 0;
static const int verboseDebug = 0;
/* Get section index of section containing the string table of section names */
if (elf_getshdrstrndx(e, &shstrndx) != 0)
{
mw_printf("elf_getshdrstrndx failed: %s\n", elf_errmsg(-1));
return 1;
}
/* Iterate through all the sections */
while ((scn = elf_nextscn(e, scn)))
{
Elf32_Shdr* shdr;
const char* name;
/* Get the header for this section */
shdr = elf32_getshdr(scn);
if (!shdr)
{
mw_printf("elf32_getshdr() failed: %s\n", elf_errmsg(-1));
return 1;
}
/* Look up the name of the section in the string table */
name = elf_strptr(e, shstrndx, shdr->sh_name);
if (!name)
{
mw_printf("elf_strptr() failed: %s\n", elf_errmsg(-1));
return 1;
}
/*
if (strstr(name, ".rodata") != NULL)
{
Elf_Data* data = elf_getdata(scn, NULL);
FILE* f = fopen("rodata_section.bin", "wb");
if (f)
{
fwrite(data->d_buf, 1, data->d_size, f);
fclose(f);
}
else
{
perror("Failed to open file");
}
size_t roSize;
char* r770RO = mwReadFileWithSize("rodata_section_RV770.bin", &roSize);
assert(r770RO);
data->d_buf = r770RO;
data->d_size = roSize;
if (!elf_flagdata(data, ELF_C_SET, ELF_F_DIRTY))
{
mw_printf("elf_flagdata() failed: %s\n", elf_errmsg(-1));
return 1;
}
if (!elf_flagscn(scn, ELF_C_SET, ELF_F_DIRTY))
{
mw_printf("elf_flagscn() failed: %s\n", elf_errmsg(-1));
return 1;
}
if (elf_update(e, ELF_C_NULL) < 0)
{
mw_printf("elf_update(NULL) failed: %s\n", elf_errmsg(-1));
return 1;
}
}
*/
if (strstr(name, ".amdil") != NULL)
{
int uavId;
const char* uavComment;
Elf_Data* data;
data = elf_getdata(scn, NULL);
if (!data)
{
mw_printf("Failed to get data for .amdil section: %s\n", elf_errmsg(-1));
return 1;
}
if (verbose)
{
mw_printf("Replacing section data of type %d, off %d align "ZU"\n",
data->d_type,
(int) data->d_off,
data->d_align);
}
/* Before we overwrite it, there is information we would like to extract */
uavComment = strstr((const char*) data->d_buf, ";uavid:");
if (!uavComment || (sscanf(uavComment, ";uavid:%d\n", &uavId) != 1))
{
mw_printf("Error reading uavid from IL comment\n");
uavId = -1;
}
ilSrc = getILSrc(nStream, target, uavId, &ilSrcLen);
if (!ilSrc || (ilSrcLen == 0))
{
mw_printf("Failed to get IL source\n");
return 1;
}
data->d_buf = (void*) ilSrc;
data->d_size = ilSrcLen;
if (!elf_flagdata(data, ELF_C_SET, ELF_F_DIRTY))
{
mw_printf("elf_flagdata() failed: %s\n", elf_errmsg(-1));
return 1;
}
if (!elf_flagscn(scn, ELF_C_SET, ELF_F_DIRTY))
{
mw_printf("elf_flagscn() failed: %s\n", elf_errmsg(-1));
return 1;
}
/* Don't let libelf rearrange the sections when writing.
clBuildProgram() crashes on Windows if you don't do
this with some(?) Catalyst versions
*/
if (!elf_flagelf(e, ELF_C_SET, ELF_F_LAYOUT))
{
mw_printf("elf_flagelf() failed: %s\n", elf_errmsg(-1));
return 1;
}
if (elf_update(e, ELF_C_NULL) < 0)
{
mw_printf("elf_update(NULL) failed: %s\n", elf_errmsg(-1));
return 1;
}
}
if (verboseDebug)
{
printf("Section %u %s\n", (unsigned int) elf_ndxscn(scn), name);
}
}
if (elf_update(e, ELF_C_WRITE) < 0)
{
mw_printf("elf_update(ELF_C_WRITE) failed: %s\n", elf_errmsg(-1));
return 1;
}
return 0;
}
main(int argc, char **argv)
{
int fd;
Elf *elf;
Elf32_Ehdr *ehdr;
Elf_Scn *scn;
Elf_Data *data;
Elf32_Half ndx;
Elf32_Shdr *shdr;
unsigned int *textdata;
if (argc != 2)
exit(2);
assert(!nlist(argv[1], nl));
assert(nl[0].n_value && !(nl[0].n_value & 0x3));
assert(nl[1].n_value && !(nl[1].n_value & 0x3));
assert(nl[2].n_value && !(nl[2].n_value & 0x3));
if (elf_version(EV_CURRENT) == EV_NONE) {
fprintf(stderr, "ELF punted! Recompile %s\n", argv[0]);
exit(1);
}
fd = open(argv[1], O_RDWR);
if (fd < 0) {
perror("open");
exit(1);
}
elf = elf_begin(fd, ELF_C_RDWR, NULL);
ehdr = elf32_getehdr(elf);
assert(ehdr);
/* want SHT_PROGBITS section named .text */
ndx = ehdr->e_shstrndx;
scn = NULL;
while ((scn = elf_nextscn(elf, scn))) {
char *name = NULL;
if ((shdr = elf32_getshdr(scn)))
name = elf_strptr(elf, ndx, (size_t) shdr->sh_name);
if (!strcmp(name, ".text"))
break;
}
data = elf_getdata(scn, NULL);
assert(data && data->d_size && !data->d_off);
textdata = (unsigned int *) data->d_buf;
/* process */
assert(textdata[nl[0].n_value / 4] == 0x000B000D);
textdata[nl[0].n_value / 4] = type_ReturnPcHeader;
assert(textdata[nl[1].n_value / 4] == 0x000A000D);
assert(textdata[nl[1].n_value / 4 + 1] == 0x000B000D);
assert(textdata[nl[1].n_value / 4 + 2] == 0x000B000D);
textdata[nl[1].n_value / 4 + 1] = 0x0417FECC;
textdata[nl[1].n_value / 4 + 2] = 0x01000000;
assert(textdata[nl[2].n_value / 4] == 0x000B000D);
textdata[nl[2].n_value / 4] = type_ReturnPcHeader;
elf_flagdata(data, ELF_C_SET, ELF_F_DIRTY);
elf_update(elf, ELF_C_WRITE);
elf_end(elf);
}
//-------------------------------------------------------------------
void avr_write_elffile(bblklist_t* blist, char* outFileName, file_desc_t* fdesc, uint32_t startaddr)
{
int fd;
Elf *elf, *nelf;
Elf32_Ehdr *ehdr, *nehdr;
Elf_Scn *scn, *nscn;
Elf32_Shdr *shdr, *nshdr;
Elf_Data *edata, *nedata;
DEBUG("=========== ELF File Write ===========\n");
elf = fdesc->elf;
fd = open(outFileName, O_RDWR|O_TRUNC|O_CREAT, 0666);
if ((nelf = elf_begin(fd, ELF_C_WRITE, (Elf *)NULL)) == 0){
fprintf(stderr, "avr_write_elffile: Error creating output ELF archive.\n");
exit(EXIT_FAILURE);
}
if ((nehdr = elf32_newehdr(nelf)) == NULL){
fprintf(stderr, "avr_write_elffile: Error creating new ELF header.\n");
exit(EXIT_FAILURE);
}
if ((ehdr = elf32_getehdr(elf)) == NULL){
fprintf(stderr, "avr_write_elfffile: Error reading ELF header.\n");
exit(EXIT_FAILURE);
}
avr_create_new_elf_header(ehdr, nehdr);
scn = NULL;
while ((scn = elf_nextscn(fdesc->elf, scn)) != NULL){
nscn = elf_newscn(nelf);
nshdr = elf32_getshdr(nscn);
shdr = elf32_getshdr(scn);
avr_create_new_section_header(shdr, nshdr);
edata = NULL;
edata = elf_getdata(scn, edata);
nedata = elf_newdata(nscn);
// Get name of current section
char* CurrSecName = NULL;
CurrSecName = elf_strptr(elf, ehdr->e_shstrndx, shdr->sh_name);
// Compare with .text section
if (strcmp(CurrSecName, ".text") == 0)
avr_create_new_text_data(edata, nedata, fdesc, blist, startaddr);
// Comare with .rela.text section
else if (strcmp(CurrSecName, ".rela.text") == 0){
avr_create_new_data(edata, nedata);
avr_create_new_rela_text_data(nedata, elf, nshdr, startaddr, blist);
}
else if (strcmp(CurrSecName, ".symtab") == 0){
avr_create_new_data(edata, nedata);
avr_create_new_symbol_table(nedata, elf, nelf, nshdr, startaddr, blist);
}
else
avr_create_new_data(edata, nedata);
elf_update(nelf, ELF_C_WRITE);
}
elf_end(nelf);
}
