Unified · Split
| @@ -76,8 +76,6 @@ · 75 unmodified lines | ||
| 76 | 76 | #define TOK_HASH_SIZE 2048 /* must be a power of two */ |
| 77 | 77 | #define TOK_ALLOC_INCR 512 /* must be a power of two */ |
| 78 | 78 | #define SYM_HASH_SIZE 1031 |
| 79 | −#define ELF_SYM_HASH_SIZE 2048 | |
| 80 | −#define ELF_DYNSYM_HASH_SIZE 32 | |
| 81 | 79 | |
| 82 | 80 | /* token symbol management */ |
| 83 | 81 | typedef struct TokenSym { |
| @@ -147,6 +145,7 @@ typedef struct Section { · 63 unmodified lines | ||
| 147 | 145 | unsigned long sh_size; /* section size (only used during output) */ |
| 148 | 146 | unsigned long sh_addr; /* address at which the section is relocated */ |
| 149 | 147 | unsigned long sh_offset; /* address at which the section is relocated */ |
| 148 | + int nb_hashed_syms; /* used to resize the hash table */ | |
| 150 | 149 | struct Section *link; /* link to another section */ |
| 151 | 150 | struct Section *reloc; /* corresponding section for relocation, if any */ |
| 152 | 151 | struct Section *hash; /* hash table for symbols */ |
| @@ -238,7 +237,7 @@ Section *lbounds_section; /* contains local data bound description */ · 85 unmodified lines | ||
| 238 | 237 | /* symbol sections */ |
| 239 | 238 | Section *symtab_section, *strtab_section; |
| 240 | 239 | /* temporary dynamic symbol sections (for dll loading) */ |
| 241 | −Section *dynsymtab_section, *dynstrtab_section; | |
| 240 | +Section *dynsymtab_section; | |
| 242 | 241 | /* exported dynamic symbol section */ |
| 243 | 242 | Section *dynsym; |
| 244 | 243 | /* got handling */ |
| @@ -246,7 +245,8 @@ Section *got; · 1 unmodified line | ||
| 246 | 245 | unsigned long *got_offsets; |
| 247 | 246 | int nb_got_offsets; |
| 248 | 247 | int nb_plt_entries; |
| 249 | − | |
| 248 | +/* give the correspondance from symtab indexes to dynsym indexes */ | |
| 249 | +int *symtab_to_dynsym; | |
| 250 | 250 | |
| 251 | 251 | /* array of all loaded dlls (including those referenced by loaded |
| 252 | 252 | dlls) */ |
| @@ -596,8 +596,9 @@ static Sym *get_sym_ref(int t, Section *sec, · 343 unmodified lines | ||
| 596 | 596 | /* section generation */ |
| 597 | 597 | static void *section_ptr(Section *sec, unsigned long size); |
| 598 | 598 | static void *section_ptr_add(Section *sec, unsigned long size); |
| 599 | −void put_extern_sym(Sym *sym, Section *section, unsigned long value); | |
| 600 | −void greloc(Section *s, Sym *sym, unsigned long addr, int type); | |
| 599 | +static void put_extern_sym(Sym *sym, Section *section, | |
| 600 | + unsigned long value, unsigned long size); | |
| 601 | +static void greloc(Section *s, Sym *sym, unsigned long addr, int type); | |
| 601 | 602 | static int put_elf_str(Section *s, const char *sym); |
| 602 | 603 | static int put_elf_sym(Section *s, |
| 603 | 604 | unsigned long value, unsigned long size, |
| @@ -822,10 +823,10 @@ Section *find_section(const char *name) · 218 unmodified lines | ||
| 822 | 823 | } |
| 823 | 824 | |
| 824 | 825 | /* add a new relocation entry to symbol 'sym' in section 's' */ |
| 825 | −void greloc(Section *s, Sym *sym, unsigned long offset, int type) | |
| 826 | +static void greloc(Section *s, Sym *sym, unsigned long offset, int type) | |
| 826 | 827 | { |
| 827 | 828 | if (!sym->c) |
| 828 | − put_extern_sym(sym, NULL, 0); | |
| 829 | + put_extern_sym(sym, NULL, 0, 0); | |
| 829 | 830 | /* now we can add ELF relocation info */ |
| 830 | 831 | put_elf_reloc(symtab_section, s, offset, type, sym->c); |
| 831 | 832 | } |
| @@ -2536,17 +2537,16 @@ static Sym *get_sym_ref(int t, Section *sec, · 1704 unmodified lines | ||
| 2536 | 2537 | v = anon_sym++; |
| 2537 | 2538 | sym = sym_push1(&global_stack, v, t | VT_STATIC, 0); |
| 2538 | 2539 | sym->r = VT_CONST | VT_SYM; |
| 2539 | − put_extern_sym(sym, sec, offset); | |
| 2540 | + put_extern_sym(sym, sec, offset, size); | |
| 2540 | 2541 | return sym; |
| 2541 | 2542 | } |
| 2542 | 2543 | |
| 2543 | 2544 | /* push a reference to a section offset by adding a dummy symbol */ |
| 2544 | −/* XXX: add size */ | |
| 2545 | −void vpush_ref(int t, Section *sec, unsigned long offset) | |
| 2545 | +void vpush_ref(int t, Section *sec, unsigned long offset, unsigned long size) | |
| 2546 | 2546 | { |
| 2547 | 2547 | CValue cval; |
| 2548 | 2548 | |
| 2549 | − cval.sym = get_sym_ref(t, sec, offset, 0); | |
| 2549 | + cval.sym = get_sym_ref(t, sec, offset, size); | |
| 2550 | 2550 | vsetc(t, VT_CONST | VT_SYM, &cval); |
| 2551 | 2551 | } |
| 2552 | 2552 | |
| @@ -2760,30 +2760,24 @@ int gv(int rc) · 207 unmodified lines | ||
| 2760 | 2760 | } else { |
| 2761 | 2761 | if (is_float(vtop->t) && |
| 2762 | 2762 | (vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) { |
| 2763 | − int v; | |
| 2764 | 2763 | Sym *sym; |
| 2765 | 2764 | int *ptr; |
| 2766 | − | |
| 2765 | + unsigned long offset; | |
| 2766 | + | |
| 2767 | 2767 | /* XXX: unify with initializers handling ? */ |
| 2768 | 2768 | /* CPUs usually cannot use float constants, so we store them |
| 2769 | 2769 | generically in data segment */ |
| 2770 | 2770 | size = type_size(vtop->t, &align); |
| 2771 | − data_section->data_offset = (data_section->data_offset + | |
| 2772 | − align - 1) & -align; | |
| 2771 | + offset = (data_section->data_offset + align - 1) & -align; | |
| 2772 | + data_section->data_offset = offset; | |
| 2773 | 2773 | /* XXX: not portable yet */ |
| 2774 | − ptr = section_ptr(data_section, size); | |
| 2774 | + ptr = section_ptr_add(data_section, size); | |
| 2775 | 2775 | size = size >> 2; |
| 2776 | 2776 | for(i=0;i<size;i++) |
| 2777 | 2777 | ptr[i] = vtop->c.tab[i]; |
| 2778 | − | |
| 2779 | − v = anon_sym++; | |
| 2780 | − sym = sym_push1(&global_stack, v, vtop->t | VT_STATIC, 0); | |
| 2781 | − sym->r = VT_CONST | VT_SYM; | |
| 2782 | − put_extern_sym(sym, data_section, data_section->data_offset); | |
| 2783 | − | |
| 2778 | + sym = get_sym_ref(vtop->t, data_section, offset, size << 2); | |
| 2784 | 2779 | vtop->r |= VT_LVAL | VT_SYM; |
| 2785 | 2780 | vtop->c.sym = sym; |
| 2786 | − data_section->data_offset += size << 2; | |
| 2787 | 2781 | } |
| 2788 | 2782 | #ifdef CONFIG_TCC_BCHECK |
| 2789 | 2783 | if (vtop->r & VT_MUSTBOUND) |
| @@ -4706,7 +4700,7 @@ void unary(void) · 1916 unmodified lines | ||
| 4706 | 4700 | t = VT_ARRAY | mk_pointer(VT_BYTE); |
| 4707 | 4701 | s = sym_find(((unsigned)t >> VT_STRUCT_SHIFT)); |
| 4708 | 4702 | s->c = len; |
| 4709 | − vpush_ref(t, data_section, data_section->data_offset); | |
| 4703 | + vpush_ref(t, data_section, data_section->data_offset, len); | |
| 4710 | 4704 | ptr = section_ptr_add(data_section, len); |
| 4711 | 4705 | memcpy(ptr, funcname, len); |
| 4712 | 4706 | next(); |
| @@ -4724,9 +4718,9 @@ void unary(void) · 11 unmodified lines | ||
| 4724 | 4718 | /* we must declare it as an array first to use initializer parser */ |
| 4725 | 4719 | t = VT_ARRAY | mk_pointer(t); |
| 4726 | 4720 | decl_initializer(t, data_section, data_offset, 1, 0); |
| 4727 | − data_offset += type_size(t, &align); | |
| 4728 | − /* XXX: is it correct to put it exactly as an array ? */ | |
| 4729 | − vpush_ref(t, data_section, fc); | |
| 4721 | + size = type_size(t, &align); | |
| 4722 | + data_offset += size; | |
| 4723 | + vpush_ref(t, data_section, fc, size); | |
| 4730 | 4724 | data_section->data_offset = data_offset; |
| 4731 | 4725 | } else { |
| 4732 | 4726 | t = tok; |
| @@ -5900,12 +5894,12 @@ void decl_initializer_alloc(int t, AttributeDef *ad, int r, int has_init, · 1167 unmodified lines | ||
| 5900 | 5894 | do_def: |
| 5901 | 5895 | sym = sym_push(v, t, r | VT_SYM, 0); |
| 5902 | 5896 | } |
| 5903 | − put_extern_sym(sym, sec, addr); | |
| 5897 | + put_extern_sym(sym, sec, addr, size); | |
| 5904 | 5898 | } else { |
| 5905 | 5899 | CValue cval; |
| 5906 | 5900 | |
| 5907 | 5901 | /* push global reference */ |
| 5908 | − sym = get_sym_ref(t, sec, addr, 0); | |
| 5902 | + sym = get_sym_ref(t, sec, addr, size); | |
| 5909 | 5903 | cval.sym = sym; |
| 5910 | 5904 | vsetc(t, VT_CONST | VT_SYM, &cval); |
| 5911 | 5905 | } |
| @@ -5942,7 +5936,6 @@ void put_func_debug(Sym *sym) · 30 unmodified lines | ||
| 5942 | 5936 | funcname, sym->t & VT_STATIC ? 'f' : 'F'); |
| 5943 | 5937 | put_stabs_r(buf, N_FUN, 0, file->line_num, 0, |
| 5944 | 5938 | cur_text_section, sym->c); |
| 5945 | − func_ind = ind; | |
| 5946 | 5939 | last_ind = 0; |
| 5947 | 5940 | last_line_num = 0; |
| 5948 | 5941 | } |
| @@ -6100,7 +6093,9 @@ void decl(int l) · 151 unmodified lines | ||
| 6100 | 6093 | /* put function symbol */ |
| 6101 | 6094 | sym = sym_push1(&global_stack, v, t, 0); |
| 6102 | 6095 | } |
| 6103 | − put_extern_sym(sym, cur_text_section, ind); | |
| 6096 | + /* NOTE: we patch the symbol size later */ | |
| 6097 | + put_extern_sym(sym, cur_text_section, ind, 0); | |
| 6098 | + func_ind = ind; | |
| 6104 | 6099 | sym->r = VT_SYM | VT_CONST; |
| 6105 | 6100 | /* put debug symbol */ |
| 6106 | 6101 | if (do_debug) |
| @@ -6121,6 +6116,9 @@ void decl(int l) · 14 unmodified lines | ||
| 6121 | 6116 | sym_pop(&label_stack, NULL); /* reset label stack */ |
| 6122 | 6117 | sym_pop(&local_stack, NULL); /* reset local stack */ |
| 6123 | 6118 | /* end of function */ |
| 6119 | + /* patch symbol size */ | |
| 6120 | + ((Elf32_Sym *)symtab_section->data)[sym->c].st_size = | |
| 6121 | + ind - func_ind; | |
| 6124 | 6122 | if (do_debug) { |
| 6125 | 6123 | put_stabn(N_FUN, 0, 0, ind - func_ind); |
| 6126 | 6124 | } |
| @@ -6322,6 +6320,40 @@ static unsigned long elf_hash(const unsigned char *name) · 195 unmodified lines | ||
| 6322 | 6320 | return h; |
| 6323 | 6321 | } |
| 6324 | 6322 | |
| 6323 | +/* rebuild hash table of section s */ | |
| 6324 | +/* NOTE: we do factorize the hash table code to go faster */ | |
| 6325 | +static void rebuild_hash(Section *s, unsigned int nb_buckets) | |
| 6326 | +{ | |
| 6327 | + Elf32_Sym *sym; | |
| 6328 | + int *ptr, *hash, nb_syms, sym_index, h; | |
| 6329 | + char *strtab; | |
| 6330 | + | |
| 6331 | + strtab = s->link->data; | |
| 6332 | + nb_syms = s->data_offset / sizeof(Elf32_Sym); | |
| 6333 | + | |
| 6334 | + s->hash->data_offset = 0; | |
| 6335 | + ptr = section_ptr_add(s->hash, (2 + nb_buckets + nb_syms) * sizeof(int)); | |
| 6336 | + ptr[0] = nb_buckets; | |
| 6337 | + ptr[1] = nb_syms; | |
| 6338 | + ptr += 2; | |
| 6339 | + hash = ptr; | |
| 6340 | + memset(hash, 0, (nb_buckets + 1) * sizeof(int)); | |
| 6341 | + ptr += nb_buckets + 1; | |
| 6342 | + | |
| 6343 | + sym = (Elf32_Sym *)s->data + 1; | |
| 6344 | + for(sym_index = 1; sym_index < nb_syms; sym_index++) { | |
| 6345 | + if (ELF32_ST_BIND(sym->st_info) != STB_LOCAL) { | |
| 6346 | + h = elf_hash(strtab + sym->st_name) % nb_buckets; | |
| 6347 | + *ptr = hash[h]; | |
| 6348 | + hash[h] = sym_index; | |
| 6349 | + } else { | |
| 6350 | + *ptr = 0; | |
| 6351 | + } | |
| 6352 | + ptr++; | |
| 6353 | + sym++; | |
| 6354 | + } | |
| 6355 | +} | |
| 6356 | + | |
| 6325 | 6357 | /* return the symbol number */ |
| 6326 | 6358 | static int put_elf_sym(Section *s, |
| 6327 | 6359 | unsigned long value, unsigned long size, |
| @@ -6347,20 +6379,26 @@ static int put_elf_sym(Section *s, · 19 unmodified lines | ||
| 6347 | 6379 | sym_index = sym - (Elf32_Sym *)s->data; |
| 6348 | 6380 | hs = s->hash; |
| 6349 | 6381 | if (hs) { |
| 6350 | − int *ptr; | |
| 6382 | + int *ptr, *base; | |
| 6351 | 6383 | ptr = section_ptr_add(hs, sizeof(int)); |
| 6384 | + base = (int *)hs->data; | |
| 6352 | 6385 | /* only add global or weak symbols */ |
| 6353 | 6386 | if (ELF32_ST_BIND(info) != STB_LOCAL) { |
| 6354 | 6387 | /* add another hashing entry */ |
| 6355 | − nbuckets = ((int *)hs->data)[0]; | |
| 6388 | + nbuckets = base[0]; | |
| 6356 | 6389 | h = elf_hash(name) % nbuckets; |
| 6357 | − *ptr = ((int *)hs->data)[2 + h]; | |
| 6358 | − ((int *)hs->data)[2 + h] = sym_index; | |
| 6390 | + *ptr = base[2 + h]; | |
| 6391 | + base[2 + h] = sym_index; | |
| 6392 | + base[1]++; | |
| 6393 | + /* we resize the hash table */ | |
| 6394 | + hs->nb_hashed_syms++; | |
| 6395 | + if (hs->nb_hashed_syms > 2 * nbuckets) { | |
| 6396 | + rebuild_hash(s, 2 * nbuckets); | |
| 6397 | + } | |
| 6359 | 6398 | } else { |
| 6360 | 6399 | *ptr = 0; |
| 6400 | + base[1]++; | |
| 6361 | 6401 | } |
| 6362 | − /* but still add room for all symbols */ | |
| 6363 | − ((int *)hs->data)[1]++; | |
| 6364 | 6402 | } |
| 6365 | 6403 | return sym_index; |
| 6366 | 6404 | } |
| @@ -6457,7 +6495,8 @@ static int add_elf_sym(Section *s, unsigned long value, unsigned long size, · 90 unmodified lines | ||
| 6457 | 6495 | |
| 6458 | 6496 | /* update sym->c so that it points to an external symbol in section |
| 6459 | 6497 | 'section' with value 'value' */ |
| 6460 | −void put_extern_sym(Sym *sym, Section *section, unsigned long value) | |
| 6498 | +static void put_extern_sym(Sym *sym, Section *section, | |
| 6499 | + unsigned long value, unsigned long size) | |
| 6461 | 6500 | { |
| 6462 | 6501 | int sym_type, sym_bind, sh_num, info; |
| 6463 | 6502 | Elf32_Sym *esym; |
| @@ -6502,10 +6541,11 @@ void put_extern_sym(Sym *sym, Section *section, unsigned long value) · 38 unmodified lines | ||
| 6502 | 6541 | } |
| 6503 | 6542 | #endif |
| 6504 | 6543 | info = ELF32_ST_INFO(sym_bind, sym_type); |
| 6505 | − sym->c = add_elf_sym(symtab_section, value, 0, info, sh_num, name); | |
| 6544 | + sym->c = add_elf_sym(symtab_section, value, size, info, sh_num, name); | |
| 6506 | 6545 | } else { |
| 6507 | 6546 | esym = &((Elf32_Sym *)symtab_section->data)[sym->c]; |
| 6508 | 6547 | esym->st_value = value; |
| 6548 | + esym->st_size = size; | |
| 6509 | 6549 | esym->st_shndx = sh_num; |
| 6510 | 6550 | } |
| 6511 | 6551 | } |
| @@ -6728,50 +6768,20 @@ static void relocate_syms(int do_resolve) · 216 unmodified lines | ||
| 6728 | 6768 | } |
| 6729 | 6769 | } |
| 6730 | 6770 | |
| 6731 | −/* elf relocation, CPU dependant */ | |
| 6732 | −static void elf_reloc(unsigned char *ptr, | |
| 6733 | − unsigned long addr, unsigned long val, int type, | |
| 6734 | − int sym_index) | |
| 6735 | −{ | |
| 6736 | − switch(type) { | |
| 6737 | − case R_386_32: | |
| 6738 | − *(int *)ptr += val; | |
| 6739 | − break; | |
| 6740 | − case R_386_PLT32: | |
| 6741 | − case R_386_PC32: | |
| 6742 | − *(int *)ptr += val - addr; | |
| 6743 | − break; | |
| 6744 | − case R_386_GLOB_DAT: | |
| 6745 | − case R_386_JMP_SLOT: | |
| 6746 | − *(int *)ptr = val; | |
| 6747 | − break; | |
| 6748 | − case R_386_GOTPC: | |
| 6749 | − *(int *)ptr += got->sh_addr - addr; | |
| 6750 | − break; | |
| 6751 | − case R_386_GOTOFF: | |
| 6752 | − *(int *)ptr += val - got->sh_addr; | |
| 6753 | − break; | |
| 6754 | − case R_386_GOT32: | |
| 6755 | − /* we load the got offset */ | |
| 6756 | − *(int *)ptr += got_offsets[sym_index]; | |
| 6757 | − break; | |
| 6758 | − } | |
| 6759 | −} | |
| 6760 | − | |
| 6761 | − | |
| 6762 | −/* relocate a given section */ | |
| 6763 | −static void relocate_section(Section *s) | |
| 6771 | +/* relocate a given section (CPU dependant) */ | |
| 6772 | +static void relocate_section(TCCState *s1, Section *s) | |
| 6764 | 6773 | { |
| 6765 | 6774 | Section *sr; |
| 6766 | − Elf32_Rel *rel, *rel_end; | |
| 6775 | + Elf32_Rel *rel, *rel_end, *qrel; | |
| 6767 | 6776 | Elf32_Sym *sym; |
| 6768 | − int type, sym_index; | |
| 6777 | + int type, sym_index, esym_index; | |
| 6769 | 6778 | unsigned char *ptr; |
| 6770 | − unsigned long val; | |
| 6779 | + unsigned long val, addr; | |
| 6771 | 6780 | |
| 6772 | 6781 | sr = s->reloc; |
| 6773 | 6782 | rel_end = (Elf32_Rel *)(sr->data + sr->data_offset); |
| 6774 | − for(rel = (Elf32_Rel *)sr->data; | |
| 6783 | + qrel = (Elf32_Rel *)sr->data; | |
| 6784 | + for(rel = qrel; | |
| 6775 | 6785 | rel < rel_end; |
| 6776 | 6786 | rel++) { |
| 6777 | 6787 | ptr = s->data + rel->r_offset; |
| @@ -6780,8 +6790,60 @@ static void relocate_section(Section *s) · 2 unmodified lines | ||
| 6780 | 6790 | sym = &((Elf32_Sym *)symtab_section->data)[sym_index]; |
| 6781 | 6791 | val = sym->st_value; |
| 6782 | 6792 | type = ELF32_R_TYPE(rel->r_info); |
| 6783 | − elf_reloc(ptr, s->sh_addr + rel->r_offset, val, type, sym_index); | |
| 6793 | + addr = s->sh_addr + rel->r_offset; | |
| 6794 | + | |
| 6795 | + /* CPU specific */ | |
| 6796 | + switch(type) { | |
| 6797 | + case R_386_32: | |
| 6798 | + if (s1->output_type == TCC_OUTPUT_DLL) { | |
| 6799 | + esym_index = symtab_to_dynsym[sym_index]; | |
| 6800 | + qrel->r_offset = rel->r_offset; | |
| 6801 | + if (esym_index) { | |
| 6802 | + qrel->r_info = ELF32_R_INFO(esym_index, R_386_32); | |
| 6803 | + qrel++; | |
| 6804 | + break; | |
| 6805 | + } else { | |
| 6806 | + qrel->r_info = ELF32_R_INFO(0, R_386_RELATIVE); | |
| 6807 | + qrel++; | |
| 6808 | + } | |
| 6809 | + } | |
| 6810 | + *(int *)ptr += val; | |
| 6811 | + break; | |
| 6812 | + case R_386_PC32: | |
| 6813 | + if (s1->output_type == TCC_OUTPUT_DLL) { | |
| 6814 | + /* DLL relocation */ | |
| 6815 | + esym_index = symtab_to_dynsym[sym_index]; | |
| 6816 | + if (esym_index) { | |
| 6817 | + qrel->r_offset = rel->r_offset; | |
| 6818 | + qrel->r_info = ELF32_R_INFO(esym_index, R_386_PC32); | |
| 6819 | + qrel++; | |
| 6820 | + break; | |
| 6821 | + } | |
| 6822 | + } | |
| 6823 | + *(int *)ptr += val - addr; | |
| 6824 | + break; | |
| 6825 | + case R_386_PLT32: | |
| 6826 | + *(int *)ptr += val - addr; | |
| 6827 | + break; | |
| 6828 | + case R_386_GLOB_DAT: | |
| 6829 | + case R_386_JMP_SLOT: | |
| 6830 | + *(int *)ptr = val; | |
| 6831 | + break; | |
| 6832 | + case R_386_GOTPC: | |
| 6833 | + *(int *)ptr += got->sh_addr - addr; | |
| 6834 | + break; | |
| 6835 | + case R_386_GOTOFF: | |
| 6836 | + *(int *)ptr += val - got->sh_addr; | |
| 6837 | + break; | |
| 6838 | + case R_386_GOT32: | |
| 6839 | + /* we load the got offset */ | |
| 6840 | + *(int *)ptr += got_offsets[sym_index]; | |
| 6841 | + break; | |
| 6842 | + } | |
| 6784 | 6843 | } |
| 6844 | + /* if the relocation is allocated, we change its symbol table */ | |
| 6845 | + if (sr->sh_flags & SHF_ALLOC) | |
| 6846 | + sr->link = dynsym; | |
| 6785 | 6847 | } |
| 6786 | 6848 | |
| 6787 | 6849 | /* relocate relocation table in 'sr' */ |
| @@ -6799,6 +6861,39 @@ static void relocate_rel(Section *sr) · 11 unmodified lines | ||
| 6799 | 6861 | } |
| 6800 | 6862 | } |
| 6801 | 6863 | |
| 6864 | +/* count the number of dynamic relocations so that we can reserve | |
| 6865 | + their space */ | |
| 6866 | +static int prepare_dynamic_rel(Section *sr) | |
| 6867 | +{ | |
| 6868 | + Elf32_Rel *rel, *rel_end; | |
| 6869 | + int sym_index, esym_index, type, count; | |
| 6870 | + | |
| 6871 | + count = 0; | |
| 6872 | + rel_end = (Elf32_Rel *)(sr->data + sr->data_offset); | |
| 6873 | + for(rel = (Elf32_Rel *)sr->data; rel < rel_end; rel++) { | |
| 6874 | + sym_index = ELF32_R_SYM(rel->r_info); | |
| 6875 | + type = ELF32_R_TYPE(rel->r_info); | |
| 6876 | + switch(type) { | |
| 6877 | + case R_386_32: | |
| 6878 | + count++; | |
| 6879 | + break; | |
| 6880 | + case R_386_PC32: | |
| 6881 | + esym_index = symtab_to_dynsym[sym_index]; | |
| 6882 | + if (esym_index) | |
| 6883 | + count++; | |
| 6884 | + break; | |
| 6885 | + default: | |
| 6886 | + break; | |
| 6887 | + } | |
| 6888 | + } | |
| 6889 | + if (count) { | |
| 6890 | + /* allocate the section */ | |
| 6891 | + sr->sh_flags |= SHF_ALLOC; | |
| 6892 | + sr->sh_size = count * sizeof(Elf32_Rel); | |
| 6893 | + } | |
| 6894 | + return count; | |
| 6895 | +} | |
| 6896 | + | |
| 6802 | 6897 | static void put_got_offset(int index, unsigned long val) |
| 6803 | 6898 | { |
| 6804 | 6899 | int n; |
| @@ -6934,18 +7029,32 @@ static void build_got_entries(void) · 129 unmodified lines | ||
| 6934 | 7029 | } |
| 6935 | 7030 | } |
| 6936 | 7031 | |
| 6937 | −static Section *new_section_hash(const char *name, int sh_flags, | |
| 6938 | − int nb_buckets, Section *symtab) | |
| 7032 | +static Section *new_symtab(const char *symtab_name, int sh_type, int sh_flags, | |
| 7033 | + const char *strtab_name, | |
| 7034 | + const char *hash_name, int hash_sh_flags) | |
| 6939 | 7035 | { |
| 6940 | − Section *hash; | |
| 6941 | − hash = new_section(name, SHT_HASH, sh_flags); | |
| 6942 | − ((int *)hash->data)[0] = nb_buckets; | |
| 6943 | − ((int *)hash->data)[1] = 1; | |
| 7036 | + Section *symtab, *strtab, *hash; | |
| 7037 | + int *ptr, nb_buckets; | |
| 7038 | + | |
| 7039 | + symtab = new_section(symtab_name, sh_type, sh_flags); | |
| 7040 | + symtab->sh_entsize = sizeof(Elf32_Sym); | |
| 7041 | + strtab = new_section(strtab_name, SHT_STRTAB, sh_flags); | |
| 7042 | + put_elf_str(strtab, ""); | |
| 7043 | + symtab->link = strtab; | |
| 7044 | + put_elf_sym(symtab, 0, 0, 0, 0, 0, NULL); | |
| 7045 | + | |
| 7046 | + nb_buckets = 1; | |
| 7047 | + | |
| 7048 | + hash = new_section(hash_name, SHT_HASH, hash_sh_flags); | |
| 6944 | 7049 | hash->sh_entsize = sizeof(int); |
| 6945 | − section_ptr_add(hash, (2 + nb_buckets + 1) * sizeof(int)); | |
| 6946 | 7050 | symtab->hash = hash; |
| 6947 | 7051 | hash->link = symtab; |
| 6948 | − return hash; | |
| 7052 | + | |
| 7053 | + ptr = section_ptr_add(hash, (2 + nb_buckets + 1) * sizeof(int)); | |
| 7054 | + ptr[0] = nb_buckets; | |
| 7055 | + ptr[1] = 1; | |
| 7056 | + memset(ptr + 2, 0, (nb_buckets + 1) * sizeof(int)); | |
| 7057 | + return symtab; | |
| 6949 | 7058 | } |
| 6950 | 7059 | |
| 6951 | 7060 | /* put dynamic tag */ |
| @@ -7055,7 +7164,7 @@ int tcc_output_file(TCCState *s1, const char *filename) · 103 unmodified lines | ||
| 7055 | 7164 | Section *strsec, *s; |
| 7056 | 7165 | Elf32_Shdr shdr, *sh; |
| 7057 | 7166 | Elf32_Phdr *phdr, *ph; |
| 7058 | − Section *interp, *plt, *dynamic, *dynstr, *hash; | |
| 7167 | + Section *interp, *plt, *dynamic, *dynstr; | |
| 7059 | 7168 | unsigned long saved_dynamic_data_offset; |
| 7060 | 7169 | Elf32_Sym *sym; |
| 7061 | 7170 | int type, file_type; |
| @@ -7072,7 +7181,6 @@ int tcc_output_file(TCCState *s1, const char *filename) · 10 unmodified lines | ||
| 7072 | 7181 | got = NULL; |
| 7073 | 7182 | nb_plt_entries = 0; |
| 7074 | 7183 | plt = NULL; /* avoid warning */ |
| 7075 | − hash = NULL; /* avoid warning */ | |
| 7076 | 7184 | dynstr = NULL; /* avoid warning */ |
| 7077 | 7185 | saved_dynamic_data_offset = 0; /* avoid warning */ |
| 7078 | 7186 | |
| @@ -7095,17 +7203,11 @@ int tcc_output_file(TCCState *s1, const char *filename) · 16 unmodified lines | ||
| 7095 | 7203 | } |
| 7096 | 7204 | |
| 7097 | 7205 | /* add dynamic symbol table */ |
| 7098 | − dynsym = new_section(".dynsym", SHT_DYNSYM, SHF_ALLOC); | |
| 7099 | − dynsym->sh_entsize = sizeof(Elf32_Sym); | |
| 7100 | − dynstr = new_section(".dynstr", SHT_STRTAB, SHF_ALLOC); | |
| 7101 | − put_elf_str(dynstr, ""); | |
| 7102 | − dynsym->link = dynstr; | |
| 7103 | − put_elf_sym(dynsym, 0, 0, 0, 0, 0, NULL); | |
| 7104 | − | |
| 7105 | − /* hash table */ | |
| 7106 | − hash = new_section_hash(".hash", SHF_ALLOC, | |
| 7107 | − ELF_DYNSYM_HASH_SIZE, dynsym); | |
| 7108 | − | |
| 7206 | + dynsym = new_symtab(".dynsym", SHT_DYNSYM, SHF_ALLOC, | |
| 7207 | + ".dynstr", | |
| 7208 | + ".hash", SHF_ALLOC); | |
| 7209 | + dynstr = dynsym->link; | |
| 7210 | + | |
| 7109 | 7211 | /* add dynamic section */ |
| 7110 | 7212 | dynamic = new_section(".dynamic", SHT_DYNAMIC, |
| 7111 | 7213 | SHF_ALLOC | SHF_WRITE); |
| @@ -7116,72 +7218,98 @@ int tcc_output_file(TCCState *s1, const char *filename) · 4 unmodified lines | ||
| 7116 | 7218 | plt = new_section(".plt", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR); |
| 7117 | 7219 | plt->sh_entsize = 4; |
| 7118 | 7220 | |
| 7221 | + build_got(); | |
| 7222 | + | |
| 7119 | 7223 | /* scan for undefined symbols and see if they are in the |
| 7120 | 7224 | dynamic symbols. If a symbol STT_FUNC is found, then we |
| 7121 | 7225 | add it in the PLT. If a symbol STT_OBJECT is found, we |
| 7122 | 7226 | add it in the .bss section with a suitable relocation */ |
| 7123 | 7227 | sym_end = (Elf32_Sym *)(symtab_section->data + |
| 7124 | 7228 | symtab_section->data_offset); |
| 7125 | − for(sym = (Elf32_Sym *)symtab_section->data + 1; | |
| 7126 | − sym < sym_end; | |
| 7127 | − sym++) { | |
| 7128 | − if (sym->st_shndx == SHN_UNDEF) { | |
| 7129 | − name = symtab_section->link->data + sym->st_name; | |
| 7130 | − sym_index = find_elf_sym(dynsymtab_section, name); | |
| 7131 | − if (sym_index) { | |
| 7132 | − esym = &((Elf32_Sym *)dynsymtab_section->data)[sym_index]; | |
| 7133 | − type = ELF32_ST_TYPE(esym->st_info); | |
| 7134 | − if (type == STT_FUNC) { | |
| 7135 | − put_got_entry(R_386_JMP_SLOT, esym->st_size, | |
| 7136 | − esym->st_info, | |
| 7137 | − sym - (Elf32_Sym *)symtab_section->data); | |
| 7138 | − } else if (type == STT_OBJECT) { | |
| 7139 | − unsigned long offset; | |
| 7140 | − offset = bss_section->data_offset; | |
| 7141 | − /* XXX: which alignment ? */ | |
| 7142 | − offset = (offset + 8 - 1) & -8; | |
| 7143 | − index = put_elf_sym(dynsym, offset, esym->st_size, | |
| 7144 | − esym->st_info, 0, | |
| 7145 | − bss_section->sh_num, name); | |
| 7146 | − put_elf_reloc(dynsym, bss_section, | |
| 7147 | − offset, R_386_COPY, index); | |
| 7148 | − offset += esym->st_size; | |
| 7149 | − bss_section->data_offset = offset; | |
| 7150 | − } | |
| 7151 | − } else { | |
| 7152 | − /* STB_WEAK undefined symbols are accepted */ | |
| 7153 | − /* XXX: _fp_hw seems to be part of the ABI, so we ignore | |
| 7154 | − it */ | |
| 7155 | − if (ELF32_ST_BIND(sym->st_info) == STB_WEAK || | |
| 7156 | − !strcmp(name, "_fp_hw")) { | |
| 7229 | + if (file_type == TCC_OUTPUT_EXE) { | |
| 7230 | + for(sym = (Elf32_Sym *)symtab_section->data + 1; | |
| 7231 | + sym < sym_end; | |
| 7232 | + sym++) { | |
| 7233 | + if (sym->st_shndx == SHN_UNDEF) { | |
| 7234 | + name = symtab_section->link->data + sym->st_name; | |
| 7235 | + sym_index = find_elf_sym(dynsymtab_section, name); | |
| 7236 | + if (sym_index) { | |
| 7237 | + esym = &((Elf32_Sym *)dynsymtab_section->data)[sym_index]; | |
| 7238 | + type = ELF32_ST_TYPE(esym->st_info); | |
| 7239 | + if (type == STT_FUNC) { | |
| 7240 | + put_got_entry(R_386_JMP_SLOT, esym->st_size, | |
| 7241 | + esym->st_info, | |
| 7242 | + sym - (Elf32_Sym *)symtab_section->data); | |
| 7243 | + } else if (type == STT_OBJECT) { | |
| 7244 | + unsigned long offset; | |
| 7245 | + offset = bss_section->data_offset; | |
| 7246 | + /* XXX: which alignment ? */ | |
| 7247 | + offset = (offset + 8 - 1) & -8; | |
| 7248 | + index = put_elf_sym(dynsym, offset, esym->st_size, | |
| 7249 | + esym->st_info, 0, | |
| 7250 | + bss_section->sh_num, name); | |
| 7251 | + put_elf_reloc(dynsym, bss_section, | |
| 7252 | + offset, R_386_COPY, index); | |
| 7253 | + offset += esym->st_size; | |
| 7254 | + bss_section->data_offset = offset; | |
| 7255 | + } | |
| 7157 | 7256 | } else { |
| 7158 | − error("undefined symbol '%s'", name); | |
| 7257 | + /* STB_WEAK undefined symbols are accepted */ | |
| 7258 | + /* XXX: _fp_hw seems to be part of the ABI, so we ignore | |
| 7259 | + it */ | |
| 7260 | + if (ELF32_ST_BIND(sym->st_info) == STB_WEAK || | |
| 7261 | + !strcmp(name, "_fp_hw")) { | |
| 7262 | + } else { | |
| 7263 | + error("undefined symbol '%s'", name); | |
| 7264 | + } | |
| 7159 | 7265 | } |
| 7160 | 7266 | } |
| 7161 | 7267 | } |
| 7162 | − } | |
| 7163 | 7268 | |
| 7164 | − /* now look at unresolved dynamic symbols and export | |
| 7165 | − corresponding symbol */ | |
| 7166 | − sym_end = (Elf32_Sym *)(dynsymtab_section->data + | |
| 7167 | − dynsymtab_section->data_offset); | |
| 7168 | − for(sym = (Elf32_Sym *)dynsymtab_section->data + 1; | |
| 7169 | − sym < sym_end; | |
| 7170 | − sym++) { | |
| 7171 | − if (sym->st_shndx == SHN_UNDEF) { | |
| 7172 | − name = dynsymtab_section->link->data + sym->st_name; | |
| 7173 | − sym_index = find_elf_sym(symtab_section, name); | |
| 7174 | − if (sym_index) { | |
| 7175 | − } else { | |
| 7176 | − if (ELF32_ST_BIND(sym->st_info) == STB_WEAK) { | |
| 7177 | − /* weak symbols can stay undefined */ | |
| 7269 | + /* now look at unresolved dynamic symbols and export | |
| 7270 | + corresponding symbol */ | |
| 7271 | + sym_end = (Elf32_Sym *)(dynsymtab_section->data + | |
| 7272 | + dynsymtab_section->data_offset); | |
| 7273 | + for(esym = (Elf32_Sym *)dynsymtab_section->data + 1; | |
| 7274 | + esym < sym_end; | |
| 7275 | + esym++) { | |
| 7276 | + if (esym->st_shndx == SHN_UNDEF) { | |
| 7277 | + name = dynsymtab_section->link->data + esym->st_name; | |
| 7278 | + sym_index = find_elf_sym(symtab_section, name); | |
| 7279 | + if (sym_index) { | |
| 7280 | + sym = &((Elf32_Sym *)symtab_section->data)[sym_index]; | |
| 7281 | + put_elf_sym(dynsym, sym->st_value, sym->st_size, | |
| 7282 | + sym->st_info, 0, | |
| 7283 | + sym->st_shndx, name); | |
| 7178 | 7284 | } else { |
| 7179 | − warning("undefined dynamic symbol '%s'", name); | |
| 7285 | + if (ELF32_ST_BIND(esym->st_info) == STB_WEAK) { | |
| 7286 | + /* weak symbols can stay undefined */ | |
| 7287 | + } else { | |
| 7288 | + warning("undefined dynamic symbol '%s'", name); | |
| 7289 | + } | |
| 7180 | 7290 | } |
| 7181 | 7291 | } |
| 7182 | 7292 | } |
| 7293 | + } else { | |
| 7294 | + int nb_syms; | |
| 7295 | + /* shared library case : we simply export all the global symbols */ | |
| 7296 | + nb_syms = symtab_section->data_offset / sizeof(Elf32_Sym); | |
| 7297 | + symtab_to_dynsym = malloc(sizeof(int) * nb_syms); | |
| 7298 | + memset(symtab_to_dynsym, 0, sizeof(int) * nb_syms); | |
| 7299 | + for(sym = (Elf32_Sym *)symtab_section->data + 1; | |
| 7300 | + sym < sym_end; | |
| 7301 | + sym++) { | |
| 7302 | + if (ELF32_ST_BIND(sym->st_info) != STB_LOCAL) { | |
| 7303 | + name = symtab_section->link->data + sym->st_name; | |
| 7304 | + index = put_elf_sym(dynsym, sym->st_value, sym->st_size, | |
| 7305 | + sym->st_info, 0, | |
| 7306 | + sym->st_shndx, name); | |
| 7307 | + symtab_to_dynsym[sym - (Elf32_Sym *)symtab_section->data] = | |
| 7308 | + index; | |
| 7309 | + } | |
| 7310 | + } | |
| 7183 | 7311 | } |
| 7184 | − | |
| 7312 | + | |
| 7185 | 7313 | build_got_entries(); |
| 7186 | 7314 | |
| 7187 | 7315 | /* update PLT/GOT sizes so that we can allocate their space */ |
| @@ -7193,6 +7321,10 @@ int tcc_output_file(TCCState *s1, const char *filename) · 5 unmodified lines | ||
| 7193 | 7321 | if (dllref->level == 0) |
| 7194 | 7322 | put_dt(dynamic, DT_NEEDED, put_elf_str(dynstr, dllref->name)); |
| 7195 | 7323 | } |
| 7324 | + /* XXX: currently, since we do not handle PIC code, we | |
| 7325 | + must relocate the readonly segments */ | |
| 7326 | + if (file_type == TCC_OUTPUT_DLL) | |
| 7327 | + put_dt(dynamic, DT_TEXTREL, 0); | |
| 7196 | 7328 | |
| 7197 | 7329 | /* add necessary space for other entries */ |
| 7198 | 7330 | saved_dynamic_data_offset = dynamic->data_offset; |
| @@ -7243,11 +7375,17 @@ int tcc_output_file(TCCState *s1, const char *filename) · 44 unmodified lines | ||
| 7243 | 7375 | for(i = 1; i < nb_sections; i++) { |
| 7244 | 7376 | s = sections[i]; |
| 7245 | 7377 | s->sh_name = put_elf_str(strsec, s->name); |
| 7246 | − /* we output all sections if debug or object file */ | |
| 7247 | − if (do_debug || | |
| 7378 | + /* when generating a DLL, we include relocations but we may | |
| 7379 | + patch them */ | |
| 7380 | + if (file_type == TCC_OUTPUT_DLL && | |
| 7381 | + s->sh_type == SHT_REL && | |
| 7382 | + !(s->sh_flags & SHF_ALLOC)) { | |
| 7383 | + prepare_dynamic_rel(s); | |
| 7384 | + } else if (do_debug || | |
| 7248 | 7385 | file_type == TCC_OUTPUT_OBJ || |
| 7249 | 7386 | (s->sh_flags & SHF_ALLOC) || |
| 7250 | 7387 | i == (nb_sections - 1)) { |
| 7388 | + /* we output all sections if debug or object file */ | |
| 7251 | 7389 | s->sh_size = s->data_offset; |
| 7252 | 7390 | } |
| 7253 | 7391 | } |
| @@ -7430,7 +7568,7 @@ int tcc_output_file(TCCState *s1, const char *filename) · 176 unmodified lines | ||
| 7430 | 7568 | /* put dynamic section entries */ |
| 7431 | 7569 | |
| 7432 | 7570 | dynamic->data_offset = saved_dynamic_data_offset; |
| 7433 | − put_dt(dynamic, DT_HASH, hash->sh_addr); | |
| 7571 | + put_dt(dynamic, DT_HASH, dynsym->hash->sh_addr); | |
| 7434 | 7572 | put_dt(dynamic, DT_STRTAB, dynstr->sh_addr); |
| 7435 | 7573 | put_dt(dynamic, DT_SYMTAB, dynsym->sh_addr); |
| 7436 | 7574 | put_dt(dynamic, DT_STRSZ, dynstr->data_offset); |
| @@ -7470,7 +7608,7 @@ int tcc_output_file(TCCState *s1, const char *filename) · 33 unmodified lines | ||
| 7470 | 7608 | for(i = 1; i < nb_sections; i++) { |
| 7471 | 7609 | s = sections[i]; |
| 7472 | 7610 | if (s->reloc && s != got) |
| 7473 | − relocate_section(s); | |
| 7611 | + relocate_section(s1, s); | |
| 7474 | 7612 | } |
| 7475 | 7613 | |
| 7476 | 7614 | /* relocate relocation entries if the relocation tables are |
| @@ -7484,7 +7622,10 @@ int tcc_output_file(TCCState *s1, const char *filename) · 7 unmodified lines | ||
| 7484 | 7622 | } |
| 7485 | 7623 | |
| 7486 | 7624 | /* get entry point address */ |
| 7487 | − ehdr.e_entry = get_elf_sym_val("_start"); | |
| 7625 | + if (file_type == TCC_OUTPUT_EXE) | |
| 7626 | + ehdr.e_entry = get_elf_sym_val("_start"); | |
| 7627 | + else | |
| 7628 | + ehdr.e_entry = text_section->sh_addr; /* XXX: is it correct ? */ | |
| 7488 | 7629 | } |
| 7489 | 7630 | |
| 7490 | 7631 | sort_syms(symtab_section); |
| @@ -8208,7 +8349,7 @@ int tcc_run(TCCState *s1, int argc, char **argv) · 717 unmodified lines | ||
| 8208 | 8349 | for(i = 1; i < nb_sections; i++) { |
| 8209 | 8350 | s = sections[i]; |
| 8210 | 8351 | if (s->reloc) |
| 8211 | − relocate_section(s); | |
| 8352 | + relocate_section(s1, s); | |
| 8212 | 8353 | } |
| 8213 | 8354 | |
| 8214 | 8355 | prog_main = (void *)get_elf_sym_val("main"); |
| @@ -8288,24 +8429,15 @@ TCCState *tcc_new(void) · 73 unmodified lines | ||
| 8288 | 8429 | bss_section = new_section(".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE); |
| 8289 | 8430 | |
| 8290 | 8431 | /* symbols are always generated for linking stage */ |
| 8291 | − symtab_section = new_section(".symtab", SHT_SYMTAB, 0); | |
| 8292 | − symtab_section->sh_entsize = sizeof(Elf32_Sym); | |
| 8293 | − strtab_section = new_section(".strtab", SHT_STRTAB, 0); | |
| 8294 | − put_elf_str(strtab_section, ""); | |
| 8295 | − symtab_section->link = strtab_section; | |
| 8296 | − put_elf_sym(symtab_section, 0, 0, 0, 0, 0, NULL); | |
| 8297 | − new_section_hash(".hashtab", SHF_PRIVATE, | |
| 8298 | − ELF_SYM_HASH_SIZE, symtab_section); | |
| 8432 | + symtab_section = new_symtab(".symtab", SHT_SYMTAB, 0, | |
| 8433 | + ".strtab", | |
| 8434 | + ".hashtab", SHF_PRIVATE); | |
| 8435 | + strtab_section = symtab_section->link; | |
| 8299 | 8436 | |
| 8300 | 8437 | /* private symbol table for dynamic symbols */ |
| 8301 | − dynsymtab_section = new_section(".dynsymtab", SHT_SYMTAB, SHF_PRIVATE); | |
| 8302 | − dynsymtab_section->sh_entsize = sizeof(Elf32_Sym); | |
| 8303 | − dynstrtab_section = new_section(".dynstrtab", SHT_STRTAB, SHF_PRIVATE); | |
| 8304 | − put_elf_str(dynstrtab_section, ""); | |
| 8305 | − dynsymtab_section->link = dynstrtab_section; | |
| 8306 | − put_elf_sym(dynsymtab_section, 0, 0, 0, 0, 0, NULL); | |
| 8307 | − new_section_hash(".dynhashtab", SHF_PRIVATE, | |
| 8308 | − ELF_SYM_HASH_SIZE, dynsymtab_section); | |
| 8438 | + dynsymtab_section = new_symtab(".dynsymtab", SHT_SYMTAB, SHF_PRIVATE, | |
| 8439 | + ".dynstrtab", | |
| 8440 | + ".dynhashtab", SHF_PRIVATE); | |
| 8309 | 8441 | return s; |
| 8310 | 8442 | } |
| 8311 | 8443 | |
| @@ -8504,7 +8636,7 @@ int tcc_set_output_type(TCCState *s, int output_type) · 192 unmodified lines | ||
| 8504 | 8636 | |
| 8505 | 8637 | void help(void) |
| 8506 | 8638 | { |
| 8507 | − printf("tcc version 0.9.8 - Tiny C Compiler - Copyright (C) 2001, 2002 Fabrice Bellard\n" | |
| 8639 | + printf("tcc version 0.9.9 - Tiny C Compiler - Copyright (C) 2001, 2002 Fabrice Bellard\n" | |
| 8508 | 8640 | "usage: tcc [-c] [-o outfile] [-Bdir] [-bench] [-Idir] [-Dsym[=val]] [-Usym]\n" |
| 8509 | 8641 | " [-g] [-b] [-Ldir] [-llib] [-shared] [-static]\n" |
| 8510 | 8642 | " [--] infile1 [infile2... --] [infile_args...]\n" |
| @@ -8528,7 +8660,7 @@ void help(void) · 17 unmodified lines | ||
| 8528 | 8660 | "Linker options:\n" |
| 8529 | 8661 | " -Ldir add library path 'dir'\n" |
| 8530 | 8662 | " -llib link with dynamic library 'lib'\n" |
| 8531 | − " -shared generate a shared library (NOT WORKING YET)\n" | |
| 8663 | + " -shared generate a shared library\n" | |
| 8532 | 8664 | " -static static linking\n" |
| 8533 | 8665 | ); |
| 8534 | 8666 | } |
| @@ -8619,8 +8751,6 @@ int main(int argc, char **argv) · 84 unmodified lines | ||
| 8619 | 8751 | output_type = TCC_OUTPUT_EXE; |
| 8620 | 8752 | |
| 8621 | 8753 | /* warning if not supported features */ |
| 8622 | − if (output_type == TCC_OUTPUT_DLL) | |
| 8623 | − warning("dll output is currently not supported"); | |
| 8624 | 8754 | #ifdef CONFIG_TCC_BCHECK |
| 8625 | 8755 | if (do_bounds_check && output_type != TCC_OUTPUT_MEMORY) |
| 8626 | 8756 | warning("bounds checking is currently only supported for in-memory execution"); |