List_t columns_in_common(Table_t *table1, Table_t *table2) {
List_t cols1 = column_list(table1),
cols2 = column_list(table2),
res;
ListNode_t *runner = cols1.front;
list_init(&res, NULL);
while (runner) {
Column_t *col = (Column_t *)runner->data;
/*printf("trying to find match for %s...\n", col->name); fflush(stdout);*/
Column_t *other_col = (Column_t *)list_findByString(&cols2,
get_colname,
col->name);
if (other_col) {
/*printf("Found matching column names: %s\n", col->name);*/
if (col->type == other_col->type) {
/*printf("Types match, adding to result\n");*/
list_addBack(&res, col);
}
else {
/*printf("Types don't match; ignoring match\n");*/
}
}
runner = runner->next;
}
return res;
}
List_t column_list(Table_t *table) {
List_t res;
Column_t *cols;
cols = table->columns;
/*printf("constructing column list for table %s\n", table_name);*/
list_init(&res, NULL);
list_setCompFunc(&res, Column_compareByName);
while (cols) {
/*printf("adding column '%s'\n", cols->name);*/
list_addBack(&res, cols);
cols = cols->next;
}
return res;
}
List_t column_list_str(const char *table_name) {
Table_t *table = list_findByString(&tables, toStringBuf, table_name);
List_t res;
Column_t *cols;
if (!table) {
fprintf(stderr, "Error: table %s was not found\n", table_name);
exit(1);
}
cols = table->columns;
/*printf("constructing column list for table %s\n", table_name);*/
list_init(&res, NULL);
while (cols) {
/*printf("adding column '%s'\n", cols->name);*/
list_addBack(&res, cols);
cols = cols->next;
}
return res;
}
void io_libraryDigestDynamic(io_library_t *library)
{
elf_dyn_t *dyn;
bool usePLTRel = false;
bool usePLTRela = false;
size_t relSize = 0;
size_t relaSize = 0;
elf32_address_t pltRel = 0;
size_t pltRelSize = 0;
for(dyn=library->dynamic; dyn->d_tag != DT_NULL; dyn ++)
{
switch(dyn->d_tag)
{
case DT_NEEDED:
{
struct io_dependency_s *dependency = list_addBack(library->dependencies);
dependency->name = dyn->d_un.d_val;
dependency->library = NULL;
break;
}
case DT_REL:
library->rel = (elf_rel_t *)(library->relocBase + dyn->d_un.d_ptr);
break;
case DT_RELSZ:
relSize = dyn->d_un.d_val;
break;
case DT_JMPREL:
pltRel = dyn->d_un.d_ptr;
break;
case DT_PLTRELSZ:
pltRelSize = dyn->d_un.d_val;
break;
case DT_RELENT:
assert(dyn->d_un.d_val == sizeof(elf_rel_t));
break;
case DT_RELA:
library->rela = (elf_rela_t *)(library->relocBase + dyn->d_un.d_ptr);
break;
case DT_RELASZ:
relaSize = dyn->d_un.d_val;
break;
case DT_STRTAB:
library->strtab = (const char *)(library->relocBase + dyn->d_un.d_ptr);
break;
case DT_STRSZ:
library->strtabSize = dyn->d_un.d_val;
break;
case DT_SYMTAB:
library->symtab = (elf_sym_t *)(library->relocBase + dyn->d_un.d_ptr);
break;
case DT_SYMENT:
assert(dyn->d_un.d_val == sizeof(elf_sym_t));
break;
case DT_HASH:
library->hashtab = (uint32_t *)(library->relocBase + dyn->d_un.d_ptr);
library->nbuckets = library->hashtab[0];
library->nchains = library->hashtab[1];
library->buckets = library->hashtab + 2;
library->chains = library->buckets + library->nbuckets;
break;
case DT_PLTREL:
usePLTRel = (dyn->d_un.d_val == DT_REL);
usePLTRela = (dyn->d_un.d_val == DT_RELA);
break;
case DT_INIT_ARRAY:
library->initArray = (uintptr_t *)(library->relocBase + dyn->d_un.d_ptr);
break;
case DT_INIT_ARRAYSZ:
library->initArrayCount = (dyn->d_un.d_val / sizeof(uintptr_t));
break;
default:
break;
}
}
// Relocation
library->rellimit = (elf_rel_t *)((uint8_t *)library->rel + relSize);
library->relalimit = (elf_rela_t *)((uint8_t *)library->rela + relaSize);
if(usePLTRel)
{
library->pltRel = (elf_rel_t *)(library->relocBase + pltRel);
library->pltRellimit = (elf_rel_t *)(library->relocBase + pltRel + pltRelSize);
}
else if(usePLTRela)
{
dbg("PLT RELA");
// TODO: Implement!
}
}
void add_table(Table_t *table) {
list_addBack(&tables, table);
}
