Revert "Add macro to browse reloc and sym entries"

This reverts commit 3cbc7a2dccf13b96c572623582d6c54394f98c36.

Thomas Preud'homme committed 12 years ago

Commit 2eb844f1 parent e5a706a1 file · +77 −37Browse files

Unified · Split

     put_stabs(NULL, type, other, desc, 0);
 }
-/* Browse each elem of type <type> in section <sec> starting at elem <startoff>
-   using variable <elem> */
-#define for_each_elem(sec, startoff, elem, type) \
-    for (elem = (type *) sec->data + startoff; \
-         elem < (type *) (sec->data + sec->data_offset); elem++)
 /* In an ELF file symbol table, the local symbols must appear below
    the global and weak ones. Since TCC cannot sort it while generating
    the code, we must do it after. All the relocation tables are also
     ElfW(Sym) *new_syms;
     int nb_syms, i;
     ElfW(Sym) *p, *q;
-    ElfW_Rel *rel;
+    ElfW_Rel *rel, *rel_end;
     Section *sr;
     int type, sym_index;
     for(i = 1; i < s1->nb_sections; i++) {
         sr = s1->sections[i];
         if (sr->sh_type == SHT_RELX && sr->link == s) {
-            for_each_elem(sr, 0, rel, ElfW_Rel) {
+            rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
+            for(rel = (ElfW_Rel *)sr->data;
+                rel < rel_end;
+                rel++) {
                 sym_index = ELFW(R_SYM)(rel->r_info);
                 type = ELFW(R_TYPE)(rel->r_info);
                 sym_index = old_to_new_syms[sym_index];
 /* relocate common symbols in the .bss section */
 ST_FUNC void relocate_common_syms(void)
 {
-    ElfW(Sym) *sym;
+    ElfW(Sym) *sym, *sym_end;
     unsigned long offset, align;
-    for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
+    sym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);
+    for(sym = (ElfW(Sym) *)symtab_section->data + 1;
+        sym < sym_end;
+        sym++) {
         if (sym->st_shndx == SHN_COMMON) {
             /* align symbol */
             align = sym->st_value;
    true and output error if undefined symbol. */
 ST_FUNC void relocate_syms(TCCState *s1, int do_resolve)
 {
-    ElfW(Sym) *sym, *esym;
+    ElfW(Sym) *sym, *esym, *sym_end;
     int sym_bind, sh_num, sym_index;
     const char *name;
-    for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
+    sym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);
+    for(sym = (ElfW(Sym) *)symtab_section->data + 1;
+        sym < sym_end;
+        sym++) {
         sh_num = sym->st_shndx;
         if (sh_num == SHN_UNDEF) {
             name = strtab_section->data + sym->st_name;
 ST_FUNC void relocate_section(TCCState *s1, Section *s)
 {
     Section *sr;
-    ElfW_Rel *rel;
+    ElfW_Rel *rel, *rel_end, *qrel;
     ElfW(Sym) *sym;
     int type, sym_index;
     unsigned char *ptr;
 #endif
     sr = s->reloc;
-    for_each_elem(sr, 0, rel, ElfW_Rel) {
+    rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
+    qrel = (ElfW_Rel *)sr->data;
+    for(rel = qrel;
+        rel < rel_end;
+        rel++) {
         ptr = s->data + rel->r_offset;
         sym_index = ELFW(R_SYM)(rel->r_info);
 static void relocate_rel(TCCState *s1, Section *sr)
 {
     Section *s;
-    ElfW_Rel *rel;
+    ElfW_Rel *rel, *rel_end;
     s = s1->sections[sr->sh_info];
-    for_each_elem(sr, 0, rel, ElfW_Rel)
+    rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
+    for(rel = (ElfW_Rel *)sr->data;
+        rel < rel_end;
+        rel++) {
         rel->r_offset += s->sh_addr;
+    }
 }
 /* count the number of dynamic relocations so that we can reserve
    their space */
 static int prepare_dynamic_rel(TCCState *s1, Section *sr)
 {
-    ElfW_Rel *rel;
+    ElfW_Rel *rel, *rel_end;
     int sym_index, esym_index, type, count;
     count = 0;
-    for_each_elem(sr, 0, rel, ElfW_Rel) {
+    rel_end = (ElfW_Rel *)(sr->data + sr->data_offset);
+    for(rel = (ElfW_Rel *)sr->data; rel < rel_end; rel++) {
         sym_index = ELFW(R_SYM)(rel->r_info);
         type = ELFW(R_TYPE)(rel->r_info);
         switch(type) {
 ST_FUNC void build_got_entries(TCCState *s1)
 {
     Section *s;
-    ElfW_Rel *rel;
+    ElfW_Rel *rel, *rel_end;
     ElfW(Sym) *sym;
     int i, type, reloc_type, sym_index;
         /* no need to handle got relocations */
         if (s->link != symtab_section)
             continue;
-        for_each_elem(s, 0, rel, ElfW_Rel) {
+        rel_end = (ElfW_Rel *)(s->data + s->data_offset);
+        for(rel = (ElfW_Rel *)s->data;
+            rel < rel_end;
+            rel++) {
             type = ELFW(R_TYPE)(rel->r_info);
             switch(type) {
 #if defined(TCC_TARGET_I386)
 void patch_dynsym_undef(TCCState *s1, Section *s)
 {
     uint32_t *gotd = (void *)s1->got->data;
-    ElfW(Sym) *sym;
+    ElfW(Sym) *sym, *sym_end;
     gotd += 3; /* dummy entries in .got */
     /* relocate symbols in .dynsym */
-    for_each_elem(s, 1, sym, ElfW(Sym)) {
+    sym_end = (ElfW(Sym) *)(s->data + s->data_offset);
+    for (sym = (ElfW(Sym) *)s->data + 1; sym < sym_end; sym++) {
         if (sym->st_shndx == SHN_UNDEF) {
             *gotd++ = sym->st_value + 6; /* XXX 6 is magic ? */
             sym->st_value = 0;
 /* zero plt offsets of weak symbols in .dynsym */
 void patch_dynsym_undef(TCCState *s1, Section *s)
 {
-    ElfW(Sym) *sym;
+    ElfW(Sym) *sym, *sym_end;
-    for_each_elem(s, 1, sym, ElfW(Sym))
+    sym_end = (ElfW(Sym) *)(s->data + s->data_offset);
+    for (sym = (ElfW(Sym) *)s->data + 1; sym < sym_end; sym++)
         if (sym->st_shndx == SHN_UNDEF && ELFW(ST_BIND)(sym->st_info) == STB_WEAK)
             sym->st_value = 0;
 }
 ST_FUNC void fill_got(TCCState *s1)
 {
     Section *s;
-    ElfW_Rel *rel;
+    ElfW_Rel *rel, *rel_end;
     int i;
     for(i = 1; i < s1->nb_sections; i++) {
         /* no need to handle got relocations */
         if (s->link != symtab_section)
             continue;
-        for_each_elem(s, 0, rel, ElfW_Rel) {
+        rel_end = (ElfW_Rel *) (s->data + s->data_offset);
+        for(rel = (ElfW_Rel *) s->data; rel < rel_end; rel++) {
             switch (ELFW(R_TYPE) (rel->r_info)) {
                 case R_X86_64_GOT32:
                 case R_X86_64_GOTPCREL:
         if (!s1->static_link) {
             const char *name;
             int sym_index, index;
-            ElfW(Sym) *esym;
+            ElfW(Sym) *esym, *sym_end;
             if (file_type == TCC_OUTPUT_EXE) {
                 char *ptr;
                is found, then we add it in the PLT. If a symbol
                STT_OBJECT is found, we add it in the .bss section with
                a suitable relocation */
+            sym_end = (ElfW(Sym) *)(symtab_section->data +
+                                    symtab_section->data_offset);
             if (file_type == TCC_OUTPUT_EXE) {
-                for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
+                for(sym = (ElfW(Sym) *)symtab_section->data + 1;
+                    sym < sym_end;
+                    sym++) {
                     if (sym->st_shndx == SHN_UNDEF) {
                         name = symtab_section->link->data + sym->st_name;
                         sym_index = find_elf_sym(s1->dynsymtab_section, name);
                                               sym - (ElfW(Sym) *)symtab_section->data);
                             } else if (type == STT_OBJECT) {
                                 unsigned long offset;
-                                ElfW(Sym) *dynsym;
+                                ElfW(Sym) *dynsym, *dynsym_end;
                                 offset = bss_section->data_offset;
                                 /* XXX: which alignment ? */
                                 offset = (offset + 16 - 1) & -16;
                                                     bss_section->sh_num, name);
                                 /* Ensure R_COPY works for weak symbol aliases */
                                 if (ELFW(ST_BIND)(esym->st_info) == STB_WEAK) {
-                                    for_each_elem(s1->dynsymtab_section, 1, dynsym, ElfW(Sym)) {
+                                    dynsym_end = (ElfW(Sym) *)
+                                                 (s1->dynsymtab_section->data +
+                                                  s1->dynsymtab_section->data_offset);
+                                    for(dynsym = (ElfW(Sym) *)s1->dynsymtab_section->data + 1;
+                                        dynsym < dynsym_end; dynsym++) {
                                         if ((dynsym->st_value == esym->st_value)
                                            && (ELFW(ST_BIND)(dynsym->st_info) == STB_GLOBAL)) {
                                             char *dynname;
                 /* now look at unresolved dynamic symbols and export
                    corresponding symbol */
-                for_each_elem(s1->dynsymtab_section, 1, esym, ElfW(Sym)) {
+                sym_end = (ElfW(Sym) *)(s1->dynsymtab_section->data +
+                                        s1->dynsymtab_section->data_offset);
+                for(esym = (ElfW(Sym) *)s1->dynsymtab_section->data + 1;
+                    esym < sym_end;
+                    esym++) {
                     if (esym->st_shndx == SHN_UNDEF) {
                         name = s1->dynsymtab_section->link->data + esym->st_name;
                         sym_index = find_elf_sym(symtab_section, name);
                 /* shared library case : we simply export all the global symbols */
                 nb_syms = symtab_section->data_offset / sizeof(ElfW(Sym));
                 s1->symtab_to_dynsym = tcc_mallocz(sizeof(int) * nb_syms);
-                for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
+                for(sym = (ElfW(Sym) *)symtab_section->data + 1;
+                    sym < sym_end;
+                    sym++) {
                     if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
 #if defined(TCC_OUTPUT_DLL_WITH_PLT)
                         if ((ELFW(ST_TYPE)(sym->st_info) == STT_FUNC ||
         /* if dynamic section, then add corresponing program header */
         if (dynamic) {
+            ElfW(Sym) *sym_end;
             ph = &phdr[phnum - 1];
             ph->p_type = PT_DYNAMIC;
             }
             /* relocate symbols in .dynsym */
-            for_each_elem(s1->dynsym, 1, sym, ElfW(Sym)) {
+            sym_end = (ElfW(Sym) *)(s1->dynsym->data + s1->dynsym->data_offset);
+            for(sym = (ElfW(Sym) *)s1->dynsym->data + 1;
+                sym < sym_end;
+                sym++) {
                 if (sym->st_shndx == SHN_UNDEF) {
                     /* relocate to the PLT if the symbol corresponds
                        to a PLT entry */
     char *sh_name, *name;
     SectionMergeInfo *sm_table, *sm;
     ElfW(Sym) *sym, *symtab;
-    ElfW_Rel *rel;
+    ElfW_Rel *rel, *rel_end;
     Section *s;
     int stab_index;
         case SHT_RELX:
             /* take relocation offset information */
             offseti = sm_table[sh->sh_info].offset;
-            for_each_elem(s, (offset / sizeof(*rel)), rel, ElfW_Rel) {
+            rel_end = (ElfW_Rel *)(s->data + s->data_offset);
+            for(rel = (ElfW_Rel *)(s->data + offset);
+                rel < rel_end;
+                rel++) {
                 int type;
                 unsigned sym_index;
                 /* convert symbol index */

Revert "Add macro to browse reloc and sym entries"

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code