x86-64: Combine buffers of sections before we call tcc_run().

- Now we can run tcc -run tcc.c successfully, though there are some bugs. - Remove jmp_table and got_table and use text_section for got and plt entries. - Combine buffers in tcc_relocate(). - Use R_X86_64_64 instead of R_X86_64_32 for R_DATA_32 (now the name R_DATA_32 is inappropriate...).

Shinichiro Hamaji committed 17 years ago

Commit fcf2e591 parent 830b7533 files · +56 −47Browse files

Unified · Split

3 files

tcc.c +52 −19
tccelf.c +3 −27
x86_64-gen.c +1 −1

tcc.c+52−19

     /* output file for preprocessing */
     FILE *outfile;
-#ifdef TCC_TARGET_X86_64
-    /* buffer to store jump tables used when the output is memory */
-    char *jmp_table;
-    int jmp_table_num;
-    /* buffer to store got tables used when the output is memory */
-    void **got_table;
-    int got_table_num;
-#endif
 };
 /* The current value can be: */
 static void free_section(Section *s)
 {
-    tcc_free(s->data);
+#ifdef TCC_TARGET_X86_64
+    /* after tcc_relocate(), some sections share the data buffer.
+       let's check if the data is allocated not to free the shared buffers */
+    if (s->data_allocated)
+#endif
+        tcc_free(s->data);
 }
 /* realloc section and set its content to zero */
 #ifndef TCC_TARGET_PE
     build_got_entries(s1);
 #endif
+#ifdef TCC_TARGET_X86_64
+    {
+        /* If the distance of two sections are longer than 32bit, our
+           program will crash. Let's combine all sections which are
+           necessary to run the program into a single buffer in the
+           text section */
+        unsigned char *p;
+        int size;
+        /* calculate the size of buffers we need */
+        size = 0;
+        for(i = 1; i < s1->nb_sections; i++) {
+            s = s1->sections[i];
+            if (s->sh_flags & SHF_ALLOC) {
+                size += s->data_offset;
+            }
+        }
+        /* double the size of the buffer for got and plt entries
+           XXX: calculate exact size for them? */
+        section_realloc(text_section, size * 2);
+        p = text_section->data + text_section->data_offset;
+        /* we will put got and plt after this offset */
+        text_section->data_offset = size;
+        for(i = 1; i < s1->nb_sections; i++) {
+            s = s1->sections[i];
+            if (s->sh_flags & SHF_ALLOC) {
+                if (s != text_section && s->data_offset) {
+                    if (s->sh_type == SHT_NOBITS) {
+                        /* for bss section */
+                        memset(p, 0, s->data_offset);
+                    } else {
+                        memcpy(p, s->data, s->data_offset);
+                        tcc_free(s->data);
+                    }
+                    s->data = p;
+                    /* we won't free s->data for this section */
+                    s->data_allocated = 0;
+                    p += s->data_offset;
+                }
+                s->sh_addr = (unsigned long)s->data;
+            }
+        }
+    }
+#else
     /* compute relocation address : section are relocated in place. We
        also alloc the bss space */
     for(i = 1; i < s1->nb_sections; i++) {
             s->sh_addr = (unsigned long)s->data;
         }
     }
+#endif
     relocate_syms(s1, 1);
     /* XXX: currently the PE linker is not ready to support that */
     s->leading_underscore = 1;
 #endif
-#ifdef TCC_TARGET_X86_64
-    s->jmp_table = NULL;
-    s->got_table = NULL;
-#endif
     return s;
 }
     dynarray_reset(&s1->include_paths, &s1->nb_include_paths);
     dynarray_reset(&s1->sysinclude_paths, &s1->nb_sysinclude_paths);
-#ifdef TCC_TARGET_X86_64
-    tcc_free(s1->jmp_table);
-    tcc_free(s1->got_table);
-#endif
     tcc_free(s1);
 }

tccelf.c+3−27

@@ -479,22 +479,9 @@ static void relocate_syms(TCCState *s1, int do_resolve) · 478 unmodified lines
479		479
480	#ifdef TCC_TARGET_X86_64	480	#ifdef TCC_TARGET_X86_64
481	#define JMP_TABLE_ENTRY_SIZE 14	481	#define JMP_TABLE_ENTRY_SIZE 14
482	#define JMP_TABLE_ENTRY_MAX_NUM 4096
483	static unsigned long add_jmp_table(TCCState *s1, unsigned long val)	482	static unsigned long add_jmp_table(TCCState *s1, unsigned long val)
484	{	483	{
485	char *p;	484	char p = (char )section_ptr_add(text_section, JMP_TABLE_ENTRY_SIZE);
486	if (!s1->jmp_table) {
487	int size = JMP_TABLE_ENTRY_SIZE * JMP_TABLE_ENTRY_MAX_NUM;
488	s1->jmp_table_num = 0;
489	s1->jmp_table = (char *)tcc_malloc(size);
490	set_pages_executable(s1->jmp_table, size);
491	}
492	if (s1->jmp_table_num == JMP_TABLE_ENTRY_MAX_NUM) {
493	error("relocating >%d symbols are not supported",
494	JMP_TABLE_ENTRY_MAX_NUM);
495	}
496	p = s1->jmp_table + s1->jmp_table_num * JMP_TABLE_ENTRY_SIZE;
497	s1->jmp_table_num++;
498	/* jmp 0x0(%rip) /	485	/* jmp 0x0(%rip) /
499	p[0] = 0xff;	486	p[0] = 0xff;
500	p[1] = 0x25;	487	p[1] = 0x25;
@@ -503,21 +490,10 @@ static unsigned long add_jmp_table(TCCState *s1, unsigned long val) · 2 unmodified lines
503	return (unsigned long)p;	490	return (unsigned long)p;
504	}	491	}
505		492
506	#define GOT_TABLE_ENTRY_MAX_NUM 4096
507	static unsigned long add_got_table(TCCState *s1, unsigned long val)	493	static unsigned long add_got_table(TCCState *s1, unsigned long val)
508	{	494	{
509	unsigned long *p;	495	unsigned long *p =
510	if (!s1->got_table) {	496	(unsigned long )section_ptr_add(text_section, sizeof(void ));
511	int size = sizeof(void ) GOT_TABLE_ENTRY_MAX_NUM;
512	s1->got_table_num = 0;
513	s1->got_table = (char *)tcc_malloc(size);
514	}
515	if (s1->got_table_num == GOT_TABLE_ENTRY_MAX_NUM) {
516	error("relocating >%d symbols are not supported",
517	GOT_TABLE_ENTRY_MAX_NUM);
518	}
519	p = s1->got_table + s1->got_table_num;
520	s1->got_table_num++;
521	*p = val;	497	*p = val;
522	return (unsigned long)p;	498	return (unsigned long)p;
523	}	499	}

x86_64-gen.c+1−1

@@ -91,7 +91,7 @@ int reg_classes[NB_REGS] = { · 90 unmodified lines
91	#define EM_TCC_TARGET EM_X86_64	91	#define EM_TCC_TARGET EM_X86_64
92		92
93	/* relocation type for 32 bit data relocation */	93	/* relocation type for 32 bit data relocation */
94	#define R_DATA_32 R_X86_64_32	94	#define R_DATA_32 R_X86_64_64
95	#define R_JMP_SLOT R_X86_64_JUMP_SLOT	95	#define R_JMP_SLOT R_X86_64_JUMP_SLOT
96	#define R_COPY R_X86_64_COPY	96	#define R_COPY R_X86_64_COPY
97		97

x86-64: Combine buffers of sections before we call tcc_run().

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code