History

Switch to newer tccpe.c (includes support for resources)

grischka committed 18 years ago

Commit 5342b321 parent adb14566 files · +1342 −987Browse files

Unified · Split

6 files
  1. Changelog +1 −0
  2. i386-gen.c +3 −3
  3. tcc.c +174 −135
  4. tccelf.c +79 −82
  5. tccpe.c +1007 −700
  6. win32/readme.txt +78 −67
Changelog+1−0
@@ -1,5 +1,6 @@
11 version 0.9.24:
22
3+- Switch to newer tccpe.c (includes support for resources)
34 - Handle backslashes within #include, #error, #warning
45 - Import changesets (part 4) 428,457,460,467: defines for openbsd etc.
56 - Use _WIN32 for a windows hosted tcc and define it for the PE target,
i386-gen.c+3−3
@@ -380,7 +380,7 @@ void gfunc_call(int nb_args) · 379 unmodified lines
380380 }
381381 save_regs(0); /* save used temporary registers */
382382 func_sym = vtop->type.ref;
383− func_call = func_sym->r;
383+ func_call = FUNC_CALL(func_sym->r);
384384 /* fast call case */
385385 if ((func_call >= FUNC_FASTCALL1 && func_call <= FUNC_FASTCALL3) ||
386386 func_call == FUNC_FASTCALLW) {
@@ -402,7 +402,7 @@ void gfunc_call(int nb_args) · 15 unmodified lines
402402 }
403403 }
404404 gcall_or_jmp(0);
405− if (args_size && func_sym->r != FUNC_STDCALL)
405+ if (args_size && func_call != FUNC_STDCALL)
406406 gadd_sp(args_size);
407407 vtop--;
408408 }
@@ -423,7 +423,7 @@ void gfunc_prolog(CType *func_type) · 14 unmodified lines
423423 CType *type;
424424
425425 sym = func_type->ref;
426− func_call = sym->r;
426+ func_call = FUNC_CALL(sym->r);
427427 addr = 8;
428428 loc = 0;
429429 if (func_call >= FUNC_FASTCALL1 && func_call <= FUNC_FASTCALL3) {
tcc.c+174−135
@@ -40,7 +40,7 @@ · 39 unmodified lines
4040 #include <time.h>
4141 #ifdef _WIN32
4242 #include <sys/timeb.h>
43−// #include <windows.h>
43+#include <windows.h>
4444 #endif
4545 #ifndef _WIN32
4646 #include <sys/time.h>
@@ -230,10 +230,24 @@ typedef struct AttributeDef { · 183 unmodified lines
230230 int aligned;
231231 int packed;
232232 Section *section;
233− unsigned char func_call; /* FUNC_CDECL, FUNC_STDCALL, FUNC_FASTCALLx */
234− unsigned char dllexport;
233+ int func_attr; /* calling convention, exports, ... */
235234 } AttributeDef;
236235
236+/* -------------------------------------------------- */
237+/* gr: wrappers for casting sym->r for other purposes */
238+typedef struct {
239+ unsigned
240+ func_call : 8,
241+ func_args : 8,
242+ func_export : 1;
243+} func_attr_t;
244+
245+#define FUNC_CALL(r) (((func_attr_t*)&(r))->func_call)
246+#define FUNC_EXPORT(r) (((func_attr_t*)&(r))->func_export)
247+#define FUNC_ARGS(r) (((func_attr_t*)&(r))->func_args)
248+#define INLINE_DEF(r) (*(int **)&(r))
249+/* -------------------------------------------------- */
250+
237251 #define SYM_STRUCT 0x40000000 /* struct/union/enum symbol space */
238252 #define SYM_FIELD 0x20000000 /* struct/union field symbol space */
239253 #define SYM_FIRST_ANOM 0x10000000 /* first anonymous sym */
@@ -383,6 +397,9 @@ static CType char_pointer_type, func_old_type, int_type; · 143 unmodified lines
383397 /* true if isid(c) || isnum(c) */
384398 static unsigned char isidnum_table[256];
385399
400+/* display some information during compilation */
401+static int verbose = 0;
402+
386403 /* compile with debug symbol (and use them if error during execution) */
387404 static int do_debug = 0;
388405
@@ -723,14 +740,6 @@ static const char tcc_keywords[] = · 334 unmodified lines
723740 #define TOK_UIDENT TOK_DEFINE
724741
725742 #ifdef _WIN32
726−int __stdcall GetModuleFileNameA(void *, char *, int);
727−void *__stdcall GetProcAddress(void *, const char *);
728−void *__stdcall GetModuleHandleA(const char *);
729−void *__stdcall LoadLibraryA(const char *);
730−int __stdcall FreeConsole(void);
731−int __stdcall VirtualProtect(void*,unsigned long,unsigned long,unsigned long*);
732−#define PAGE_EXECUTE_READWRITE 0x0040
733−
734743 #define snprintf _snprintf
735744 #define vsnprintf _vsnprintf
736745 #ifndef __GNUC__
@@ -758,6 +767,7 @@ extern long double strtold (const char *__nptr, char **__endptr); · 21 unmodified lines
758767 static char *pstrcpy(char *buf, int buf_size, const char *s);
759768 static char *pstrcat(char *buf, int buf_size, const char *s);
760769 static char *tcc_basename(const char *name);
770+static char *tcc_fileextension (const char *p);
761771
762772 static void next(void);
763773 static void next_nomacro(void);
@@ -858,10 +868,12 @@ int tcc_output_coff(TCCState *s1, FILE *f); · 94 unmodified lines
858868
859869 /* tccpe.c */
860870 void *resolve_sym(TCCState *s1, const char *sym, int type);
861−int pe_load_def_file(struct TCCState *s1, FILE *fp);
862−void pe_setup_paths(struct TCCState *s1, int *p_output_type, const char **p_outfile, char *first_file);
863−unsigned long pe_add_runtime(struct TCCState *s1);
864−int tcc_output_pe(struct TCCState *s1, const char *filename);
871+int pe_load_def_file(struct TCCState *s1, int fd);
872+int pe_test_res_file(void *v, int size);
873+int pe_load_res_file(struct TCCState *s1, int fd);
874+void pe_add_runtime(struct TCCState *s1);
875+void pe_guess_outfile(char *objfilename, int output_type);
876+int pe_output_file(struct TCCState *s1, const char *filename);
865877
866878 /* tccasm.c */
867879
@@ -1036,6 +1048,27 @@ static int strstart(const char *str, const char *val, const char **ptr) · 168 unmodified lines
10361048 return 1;
10371049 }
10381050
1051+/* extract the basename of a file */
1052+static char *tcc_basename(const char *name)
1053+{
1054+ char *p = strchr(name, 0);
1055+ while (p > name
1056+ && p[-1] != '/'
1057+#ifdef _WIN32
1058+ && p[-1] != '\\'
1059+#endif
1060+ )
1061+ --p;
1062+ return p;
1063+}
1064+
1065+static char *tcc_fileextension (const char *name)
1066+{
1067+ char *b = tcc_basename(name);
1068+ char *e = strrchr(b, '.');
1069+ return e ? e : strchr(b, 0);
1070+}
1071+
10391072 #ifdef _WIN32
10401073 char *normalize_slashes(char *path)
10411074 {
@@ -1162,6 +1195,16 @@ static void dynarray_add(void ***ptab, int *nb_ptr, void *data) · 120 unmodified lines
11621195 *nb_ptr = nb;
11631196 }
11641197
1198+static void dynarray_reset(void *pp, int *n)
1199+{
1200+ void **p;
1201+ for (p = *(void***)pp; *n; ++p, --*n)
1202+ if (*p)
1203+ tcc_free(*p);
1204+ tcc_free(*(void**)pp);
1205+ *(void**)pp = NULL;
1206+}
1207+
11651208 /* symbol allocator */
11661209 static Sym *__sym_malloc(void)
11671210 {
@@ -1291,7 +1334,7 @@ static void put_extern_sym2(Sym *sym, Section *section, · 123 unmodified lines
12911334 unsigned long value, unsigned long size,
12921335 int can_add_underscore)
12931336 {
1294− int sym_type, sym_bind, sh_num, info;
1337+ int sym_type, sym_bind, sh_num, info, other, attr;
12951338 Elf32_Sym *esym;
12961339 const char *name;
12971340 char buf1[256];
@@ -1302,16 +1345,29 @@ static void put_extern_sym2(Sym *sym, Section *section, · 4 unmodified lines
13021345 sh_num = SHN_ABS;
13031346 else
13041347 sh_num = section->sh_num;
1348+
1349+ other = attr = 0;
1350+
1351+ if ((sym->type.t & VT_BTYPE) == VT_FUNC) {
1352+ sym_type = STT_FUNC;
1353+#ifdef TCC_TARGET_PE
1354+ if (sym->type.ref)
1355+ attr = sym->type.ref->r;
1356+ if (FUNC_EXPORT(attr))
1357+ other |= 1;
1358+ if (FUNC_CALL(attr) == FUNC_STDCALL)
1359+ other |= 2;
1360+#endif
1361+ } else {
1362+ sym_type = STT_OBJECT;
1363+ }
1364+
1365+ if (sym->type.t & VT_STATIC)
1366+ sym_bind = STB_LOCAL;
1367+ else
1368+ sym_bind = STB_GLOBAL;
1369+
13051370 if (!sym->c) {
1306− if ((sym->type.t & VT_BTYPE) == VT_FUNC)
1307− sym_type = STT_FUNC;
1308− else
1309− sym_type = STT_OBJECT;
1310− if (sym->type.t & VT_STATIC)
1311− sym_bind = STB_LOCAL;
1312− else
1313− sym_bind = STB_GLOBAL;
1314−
13151371 name = get_tok_str(sym->v, NULL);
13161372 #ifdef CONFIG_TCC_BCHECK
13171373 if (do_bounds_check) {
@@ -1342,18 +1398,26 @@ static void put_extern_sym2(Sym *sym, Section *section, · 24 unmodified lines
13421398 }
13431399 }
13441400 #endif
1401+
1402+#ifdef TCC_TARGET_PE
1403+ if ((other & 2) && can_add_underscore) {
1404+ sprintf(buf1, "_%s@%d", name, FUNC_ARGS(attr));
1405+ name = buf1;
1406+ } else
1407+#endif
13451408 if (tcc_state->leading_underscore && can_add_underscore) {
13461409 buf1[0] = '_';
13471410 pstrcpy(buf1 + 1, sizeof(buf1) - 1, name);
13481411 name = buf1;
13491412 }
13501413 info = ELF32_ST_INFO(sym_bind, sym_type);
1351− sym->c = add_elf_sym(symtab_section, value, size, info, 0, sh_num, name);
1414+ sym->c = add_elf_sym(symtab_section, value, size, info, other, sh_num, name);
13521415 } else {
13531416 esym = &((Elf32_Sym *)symtab_section->data)[sym->c];
13541417 esym->st_value = value;
13551418 esym->st_size = size;
13561419 esym->st_shndx = sh_num;
1420+ esym->st_other |= other;
13571421 }
13581422 }
13591423
@@ -2868,7 +2932,7 @@ static void preprocess(int is_bof) · 1508 unmodified lines
28682932 {
28692933 TCCState *s1 = tcc_state;
28702934 int size, i, c, n, saved_parse_flags;
2871− char buf[1024], *q, *p;
2935+ char buf[1024], *q;
28722936 char buf1[1024];
28732937 BufferedFile *f;
28742938 Sym *s;
@@ -2962,10 +3026,7 @@ static void preprocess(int is_bof) · 87 unmodified lines
29623026 } else {
29633027 if (c == '\"') {
29643028 /* first search in current dir if "header.h" */
2965− size = 0;
2966− p = strrchr(file->filename, '/');
2967− if (p)
2968− size = p + 1 - file->filename;
3029+ size = tcc_basename(file->filename) - file->filename;
29693030 if (size > sizeof(buf1) - 1)
29703031 size = sizeof(buf1) - 1;
29713032 memcpy(buf1, file->filename, size);
@@ -4026,7 +4087,9 @@ static int *macro_arg_subst(Sym **nested_list, int *macro_str, Sym *args) · 1054 unmodified lines
40264087 cstr_ccat(&cstr, ' ');
40274088 TOK_GET(t, st, cval);
40284089 cstr_cat(&cstr, get_tok_str(t, &cval));
4090+#ifndef PP_NOSPACES
40294091 notfirst = 1;
4092+#endif
40304093 }
40314094 cstr_ccat(&cstr, '\0');
40324095 #ifdef PP_DEBUG
@@ -6112,7 +6175,7 @@ static int is_compatible_func(CType *type1, CType *type2) · 2079 unmodified lines
61126175 if (!is_compatible_types(&s1->type, &s2->type))
61136176 return 0;
61146177 /* check func_call */
6115− if (s1->r != s2->r)
6178+ if (FUNC_CALL(s1->r) != FUNC_CALL(s2->r))
61166179 return 0;
61176180 /* XXX: not complete */
61186181 if (s1->c == FUNC_OLD || s2->c == FUNC_OLD)
@@ -6569,12 +6632,12 @@ static void parse_attribute(AttributeDef *ad) · 450 unmodified lines
65696632 case TOK_CDECL1:
65706633 case TOK_CDECL2:
65716634 case TOK_CDECL3:
6572− ad->func_call = FUNC_CDECL;
6635+ FUNC_CALL(ad->func_attr) = FUNC_CDECL;
65736636 break;
65746637 case TOK_STDCALL1:
65756638 case TOK_STDCALL2:
65766639 case TOK_STDCALL3:
6577− ad->func_call = FUNC_STDCALL;
6640+ FUNC_CALL(ad->func_attr) = FUNC_STDCALL;
65786641 break;
65796642 #ifdef TCC_TARGET_I386
65806643 case TOK_REGPARM1:
@@ -6586,17 +6649,17 @@ static void parse_attribute(AttributeDef *ad) · 5 unmodified lines
65866649 else if (n < 0)
65876650 n = 0;
65886651 if (n > 0)
6589− ad->func_call = FUNC_FASTCALL1 + n - 1;
6652+ FUNC_CALL(ad->func_attr) = FUNC_FASTCALL1 + n - 1;
65906653 skip(')');
65916654 break;
65926655 case TOK_FASTCALL1:
65936656 case TOK_FASTCALL2:
65946657 case TOK_FASTCALL3:
6595− ad->func_call = FUNC_FASTCALLW;
6658+ FUNC_CALL(ad->func_attr) = FUNC_FASTCALLW;
65966659 break;
65976660 #endif
65986661 case TOK_DLLEXPORT:
6599− ad->dllexport = 1;
6662+ FUNC_EXPORT(ad->func_attr) = 1;
66006663 break;
66016664 default:
66026665 if (tcc_state->warn_unsupported)
@@ -6979,7 +7042,7 @@ static int parse_btype(CType *type, AttributeDef *ad) · 376 unmodified lines
69797042 }
69807043 the_end:
69817044 if ((t & (VT_SIGNED|VT_UNSIGNED)) == (VT_SIGNED|VT_UNSIGNED))
6982− error("signed and unsigned modifier");
7045+ error("signed and unsigned modifier");
69837046 if (tcc_state->char_is_unsigned) {
69847047 if ((t & (VT_SIGNED|VT_UNSIGNED|VT_BTYPE)) == VT_BYTE)
69857048 t |= VT_UNSIGNED;
@@ -7009,7 +7072,7 @@ static inline void convert_parameter_type(CType *pt) · 23 unmodified lines
70097072
70107073 static void post_type(CType *type, AttributeDef *ad)
70117074 {
7012− int n, l, t1;
7075+ int n, l, t1, arg_size, align;
70137076 Sym **plast, *s, *first;
70147077 AttributeDef ad1;
70157078 CType pt;
@@ -7020,6 +7083,7 @@ static void post_type(CType *type, AttributeDef *ad) · 4 unmodified lines
70207083 l = 0;
70217084 first = NULL;
70227085 plast = &first;
7086+ arg_size = 0;
70237087 if (tok != ')') {
70247088 for(;;) {
70257089 /* read param name and compute offset */
@@ -7038,6 +7102,7 @@ static void post_type(CType *type, AttributeDef *ad) · 12 unmodified lines
70387102 type_decl(&pt, &ad1, &n, TYPE_DIRECT | TYPE_ABSTRACT);
70397103 if ((pt.t & VT_BTYPE) == VT_VOID)
70407104 error("parameter declared as void");
7105+ arg_size += (type_size(&pt, &align) + 3) & ~3;
70417106 } else {
70427107 old_proto:
70437108 n = tok;
@@ -7070,7 +7135,8 @@ static void post_type(CType *type, AttributeDef *ad) · 26 unmodified lines
70707135 type->t &= ~(VT_STORAGE | VT_CONSTANT);
70717136 post_type(type, ad);
70727137 /* we push a anonymous symbol which will contain the function prototype */
7073− s = sym_push(SYM_FIELD, type, ad->func_call, l);
7138+ FUNC_ARGS(ad->func_attr) = arg_size;
7139+ s = sym_push(SYM_FIELD, type, ad->func_attr, l);
70747140 s->next = first;
70757141 type->t = t1 | VT_FUNC;
70767142 type->ref = s;
@@ -7629,6 +7695,7 @@ static void unary(void) · 552 unmodified lines
76297695 next();
76307696 sa = s->next; /* first parameter */
76317697 nb_args = 0;
7698+ ret.r2 = VT_CONST;
76327699 /* compute first implicit argument if a structure is returned */
76337700 if ((s->type.t & VT_BTYPE) == VT_STRUCT) {
76347701 /* get some space for the returned structure */
@@ -7643,7 +7710,6 @@ static void unary(void) · 8 unmodified lines
76437710 nb_args++;
76447711 } else {
76457712 ret.type = s->type;
7646− ret.r2 = VT_CONST;
76477713 /* return in register */
76487714 if (is_float(ret.type.t)) {
76497715 ret.r = REG_FRET;
@@ -8660,12 +8726,11 @@ static void decl_initializer(CType *type, Section *sec, unsigned long c, · 1010 unmodified lines
86608726 them as ((w)char *) expressions */
86618727 if ((tok == TOK_LSTR &&
86628728 #ifdef TCC_TARGET_PE
8663− (t1->t & VT_BTYPE) == VT_SHORT && (t1->t & VT_UNSIGNED)) ||
8729+ (t1->t & VT_BTYPE) == VT_SHORT && (t1->t & VT_UNSIGNED)
86648730 #else
8665− (t1->t & VT_BTYPE) == VT_INT) ||
8731+ (t1->t & VT_BTYPE) == VT_INT
86668732 #endif
8667− (tok == TOK_STR &&
8668− (t1->t & VT_BTYPE) == VT_BYTE)) {
8733+ ) || (tok == TOK_STR && (t1->t & VT_BTYPE) == VT_BYTE)) {
86698734 while (tok == TOK_STR || tok == TOK_LSTR) {
86708735 int cstr_len, ch;
86718736 CString *cstr;
@@ -9166,9 +9231,9 @@ static void gen_inline_functions(void) · 494 unmodified lines
91669231 sym->c != 0) {
91679232 /* the function was used: generate its code and
91689233 convert it to a normal function */
9169− str = (int *)sym->r;
9234+ str = INLINE_DEF(sym->r);
91709235 sym->r = VT_SYM | VT_CONST;
9171− type->t &= ~VT_INLINE;
9236+ sym->type.t &= ~VT_INLINE;
91729237
91739238 macro_ptr = str;
91749239 next();
@@ -9190,7 +9255,10 @@ static void gen_inline_functions(void) · 15 unmodified lines
91909255 if (((type->t & VT_BTYPE) == VT_FUNC) &&
91919256 (type->t & (VT_STATIC | VT_INLINE)) ==
91929257 (VT_STATIC | VT_INLINE)) {
9193− str = (int *)sym->r;
9258+ //gr printf("sym %d %s\n", sym->r, get_tok_str(sym->v, NULL));
9259+ if (sym->r == (VT_SYM | VT_CONST)) //gr beware!
9260+ continue;
9261+ str = INLINE_DEF(sym->r);
91949262 tok_str_free(str);
91959263 sym->r = 0; /* fail safe */
91969264 }
@@ -9273,9 +9341,13 @@ static void decl(int l) · 76 unmodified lines
92739341 /* specific case: if not func_call defined, we put
92749342 the one of the prototype */
92759343 /* XXX: should have default value */
9276− if (sym->type.ref->r != FUNC_CDECL &&
9277− type.ref->r == FUNC_CDECL)
9278− type.ref->r = sym->type.ref->r;
9344+ r = sym->type.ref->r;
9345+ if (FUNC_CALL(r) != FUNC_CDECL
9346+ && FUNC_CALL(type.ref->r) == FUNC_CDECL)
9347+ FUNC_CALL(type.ref->r) = FUNC_CALL(r);
9348+ if (FUNC_EXPORT(r))
9349+ FUNC_EXPORT(type.ref->r) = 1;
9350+
92799351 if (!is_compatible_types(&sym->type, &type)) {
92809352 func_error1:
92819353 error("incompatible types for redefinition of '%s'",
@@ -9317,7 +9389,7 @@ static void decl(int l) · 35 unmodified lines
93179389 }
93189390 tok_str_add(&func_str, -1);
93199391 tok_str_add(&func_str, 0);
9320− sym->r = (int)func_str.str;
9392+ INLINE_DEF(sym->r) = func_str.str;
93219393 } else {
93229394 /* compute text section */
93239395 cur_text_section = ad.section;
@@ -9325,11 +9397,6 @@ static void decl(int l) · 1 unmodified line
93259397 cur_text_section = text_section;
93269398 sym->r = VT_SYM | VT_CONST;
93279399 gen_function(sym);
9328−#ifdef TCC_TARGET_PE
9329− if (ad.dllexport) {
9330− ((Elf32_Sym *)symtab_section->data)[sym->c].st_other |= 1;
9331− }
9332−#endif
93339400 }
93349401 break;
93359402 } else {
@@ -9341,8 +9408,8 @@ static void decl(int l) · 5 unmodified lines
93419408 } else if ((type.t & VT_BTYPE) == VT_FUNC) {
93429409 /* external function definition */
93439410 /* specific case for func_call attribute */
9344− if (ad.func_call)
9345− type.ref->r = ad.func_call;
9411+ if (ad.func_attr)
9412+ type.ref->r = ad.func_attr;
93469413 external_sym(v, &type, 0);
93479414 } else {
93489415 /* not lvalue if array */
@@ -9891,9 +9958,9 @@ int tcc_relocate(TCCState *s1) · 542 unmodified lines
98919958 relocate_common_syms();
98929959
98939960 tcc_add_linker_symbols(s1);
9894−
9961+#ifndef TCC_TARGET_PE
98959962 build_got_entries(s1);
9896−
9963+#endif
98979964 /* compute relocation address : section are relocated in place. We
98989965 also alloc the bss space */
98999966 for(i = 1; i < s1->nb_sections; i++) {
@@ -10118,27 +10185,15 @@ void tcc_delete(TCCState *s1) · 218 unmodified lines
1011810185 tcc_free(s1->sections);
1011910186
1012010187 /* free loaded dlls array */
10121− for(i = 0; i < s1->nb_loaded_dlls; i++)
10122− tcc_free(s1->loaded_dlls[i]);
10123− tcc_free(s1->loaded_dlls);
10124−
10125− /* library paths */
10126− for(i = 0; i < s1->nb_library_paths; i++)
10127− tcc_free(s1->library_paths[i]);
10128− tcc_free(s1->library_paths);
10188+ dynarray_reset(&s1->loaded_dlls, &s1->nb_loaded_dlls);
1012910189
10130− /* cached includes */
10131− for(i = 0; i < s1->nb_cached_includes; i++)
10132− tcc_free(s1->cached_includes[i]);
10133− tcc_free(s1->cached_includes);
10190+ /* free library paths */
10191+ dynarray_reset(&s1->library_paths, &s1->nb_library_paths);
1013410192
10135− for(i = 0; i < s1->nb_include_paths; i++)
10136− tcc_free(s1->include_paths[i]);
10137− tcc_free(s1->include_paths);
10138−
10139− for(i = 0; i < s1->nb_sysinclude_paths; i++)
10140− tcc_free(s1->sysinclude_paths[i]);
10141− tcc_free(s1->sysinclude_paths);
10193+ /* free include paths */
10194+ dynarray_reset(&s1->cached_includes, &s1->nb_cached_includes);
10195+ dynarray_reset(&s1->include_paths, &s1->nb_include_paths);
10196+ dynarray_reset(&s1->sysinclude_paths, &s1->nb_sysinclude_paths);
1014210197
1014310198 tcc_free(s1);
1014410199 }
@@ -10163,19 +10218,14 @@ int tcc_add_sysinclude_path(TCCState *s1, const char *pathname) · 18 unmodified lines
1016310218
1016410219 static int tcc_add_file_internal(TCCState *s1, const char *filename, int flags)
1016510220 {
10166− const char *ext, *filename1;
10221+ const char *ext;
1016710222 Elf32_Ehdr ehdr;
1016810223 int fd, ret;
1016910224 BufferedFile *saved_file;
1017010225
1017110226 /* find source file type with extension */
10172− filename1 = strrchr(filename, '/');
10173− if (filename1)
10174− filename1++;
10175− else
10176− filename1 = filename;
10177− ext = strrchr(filename1, '.');
10178− if (ext)
10227+ ext = tcc_fileextension(filename);
10228+ if (ext[0])
1017910229 ext++;
1018010230
1018110231 /* open the file */
@@ -10191,7 +10241,7 @@ static int tcc_add_file_internal(TCCState *s1, const char *filename, int flags) · 9 unmodified lines
1019110241
1019210242 if (flags & AFF_PREPROCESS) {
1019310243 ret = tcc_preprocess(s1);
10194− } else if (!ext || !strcmp(ext, "c")) {
10244+ } else if (!ext[0] || !strcmp(ext, "c")) {
1019510245 /* C file assumed */
1019610246 ret = tcc_compile(s1);
1019710247 } else
@@ -10206,7 +10256,7 @@ static int tcc_add_file_internal(TCCState *s1, const char *filename, int flags) · 8 unmodified lines
1020610256 #endif
1020710257 #ifdef TCC_TARGET_PE
1020810258 if (!strcmp(ext, "def")) {
10209− ret = pe_load_def_file(s1, fdopen(file->fd, "rb"));
10259+ ret = pe_load_def_file(s1, file->fd);
1021010260 } else
1021110261 #endif
1021210262 {
@@ -10256,6 +10306,11 @@ static int tcc_add_file_internal(TCCState *s1, const char *filename, int flags) · 43 unmodified lines
1025610306 if (*(uint16_t *)(&ehdr) == COFF_C67_MAGIC) {
1025710307 ret = tcc_load_coff(s1, fd);
1025810308 } else
10309+#endif
10310+#ifdef TCC_TARGET_PE
10311+ if (pe_test_res_file(&ehdr, ret)) {
10312+ ret = pe_load_res_file(s1, fd);
10313+ } else
1025910314 #endif
1026010315 {
1026110316 /* as GNU ld, consider it is an ld script if not recognized */
@@ -10478,20 +10533,6 @@ int tcc_set_flag(TCCState *s, const char *flag_name, int value) · 216 unmodified lines
1047810533 flag_name, value);
1047910534 }
1048010535
10481−/* extract the basename of a file */
10482−static char *tcc_basename(const char *name)
10483−{
10484− char *p = strchr(name, 0);
10485− while (p > name
10486− && p[-1] != '/'
10487−#ifdef _WIN32
10488− && p[-1] != '\\'
10489−#endif
10490− )
10491− --p;
10492− return p;
10493−}
10494−
1049510536 #if !defined(LIBTCC)
1049610537
1049710538 static int64_t getclock_us(void)
@@ -10535,7 +10576,7 @@ void help(void) · 37 unmodified lines
1053510576 " -shared generate a shared library\n"
1053610577 " -static static linking\n"
1053710578 " -rdynamic export all global symbols to dynamic linker\n"
10538− " -r relocatable output\n"
10579+ " -r generate (relocatable) object file\n"
1053910580 "Debugger options:\n"
1054010581 " -g generate runtime debug info\n"
1054110582 #ifdef CONFIG_TCC_BCHECK
@@ -10885,6 +10926,7 @@ int main(int argc, char **argv) · 343 unmodified lines
1088510926 nb_libraries = 0;
1088610927 reloc_output = 0;
1088710928 print_search_dirs = 0;
10929+ ret = 0;
1088810930
1088910931 optind = parse_args(s, argc - 1, argv + 1) + 1;
1089010932
@@ -10915,30 +10957,28 @@ int main(int argc, char **argv) · 24 unmodified lines
1091510957 if (!outfile) {
1091610958 s->outfile = stdout;
1091710959 } else {
10918− s->outfile = fopen(outfile, "wb");
10960+ s->outfile = fopen(outfile, "w");
1091910961 if (!s->outfile)
1092010962 error("could not open '%s", outfile);
1092110963 }
1092210964 } else if (output_type != TCC_OUTPUT_MEMORY) {
1092310965 if (!outfile) {
1092410966 /* compute default outfile name */
10925− pstrcpy(objfilename, sizeof(objfilename) - 1,
10926− /* strip path */
10927− tcc_basename(files[0]));
10967+ char *ext;
10968+ pstrcpy(objfilename, sizeof(objfilename), tcc_basename(files[0]));
10969+ ext = tcc_fileextension(objfilename);
1092810970 #ifdef TCC_TARGET_PE
10929− pe_guess_outfile(objfilename, output_type);
10930−#else
10931− if (output_type == TCC_OUTPUT_OBJ && !reloc_output) {
10932− char *ext = strrchr(objfilename, '.');
10933− if (!ext)
10934− goto default_outfile;
10935− /* add .o extension */
10936− strcpy(ext + 1, "o");
10937− } else {
10938− default_outfile:
10939− pstrcpy(objfilename, sizeof(objfilename), "a.out");
10940− }
10971+ if (output_type == TCC_OUTPUT_DLL)
10972+ strcpy(ext, ".dll");
10973+ else
10974+ if (output_type == TCC_OUTPUT_EXE)
10975+ strcpy(ext, ".exe");
10976+ else
1094110977 #endif
10978+ if (output_type == TCC_OUTPUT_OBJ && !reloc_output && *ext)
10979+ strcpy(ext, ".o");
10980+ else
10981+ pstrcpy(objfilename, sizeof(objfilename), "a.out");
1094210982 outfile = objfilename;
1094310983 }
1094410984 }
@@ -10950,29 +10990,29 @@ int main(int argc, char **argv) · 5 unmodified lines
1095010990 tcc_set_output_type(s, output_type);
1095110991
1095210992 /* compile or add each files or library */
10953− for(i = 0;i < nb_files; i++) {
10993+ for(i = 0; i < nb_files && ret == 0; i++) {
1095410994 const char *filename;
1095510995
1095610996 filename = files[i];
1095710997 if (output_type == TCC_OUTPUT_PREPROCESS) {
10958− tcc_add_file_internal(s, filename,
10959− AFF_PRINT_ERROR | AFF_PREPROCESS);
10998+ if (tcc_add_file_internal(s, filename,
10999+ AFF_PRINT_ERROR | AFF_PREPROCESS) < 0)
11000+ ret = 1;
11001+ } else if (filename[0] == '-') {
11002+ if (tcc_add_library(s, filename + 2) < 0)
11003+ error("cannot find %s", filename);
1096011004 } else {
10961− if (filename[0] == '-') {
10962− if (tcc_add_library(s, filename + 2) < 0)
10963− error("cannot find %s", filename);
10964− } else {
10965− if (tcc_add_file(s, filename) < 0) {
10966− ret = 1;
10967− goto the_end;
10968− }
10969− }
11005+ if (tcc_add_file(s, filename) < 0)
11006+ ret = 1;
1097011007 }
1097111008 }
1097211009
1097311010 /* free all files */
1097411011 tcc_free(files);
1097511012
11013+ if (ret)
11014+ goto the_end;
11015+
1097611016 if (do_bench) {
1097711017 double total_time;
1097811018 total_time = (double)(getclock_us() - start_time) / 1000000.0;
@@ -10989,13 +11029,12 @@ int main(int argc, char **argv) · 10 unmodified lines
1098911029 if (s->output_type == TCC_OUTPUT_PREPROCESS) {
1099011030 if (outfile)
1099111031 fclose(s->outfile);
10992− ret = 0;
1099311032 } else if (s->output_type == TCC_OUTPUT_MEMORY) {
1099411033 ret = tcc_run(s, argc - optind, argv + optind);
1099511034 } else
1099611035 #ifdef TCC_TARGET_PE
1099711036 if (s->output_type != TCC_OUTPUT_OBJ) {
10998− ret = tcc_output_pe(s, outfile);
11037+ ret = pe_output_file(s, outfile);
1099911038 } else
1100011039 #endif
1100111040 {
tccelf.c+79−82
@@ -531,11 +531,11 @@ static void relocate_section(TCCState *s1, Section *s) · 530 unmodified lines
531531 *(int *)ptr += s1->got_offsets[sym_index];
532532 break;
533533 #elif defined(TCC_TARGET_ARM)
534− case R_ARM_PC24:
535− case R_ARM_CALL:
536− case R_ARM_JUMP24:
537− case R_ARM_PLT32:
538− {
534+ case R_ARM_PC24:
535+ case R_ARM_CALL:
536+ case R_ARM_JUMP24:
537+ case R_ARM_PLT32:
538+ {
539539 int x;
540540 x = (*(int *)ptr)&0xffffff;
541541 (*(int *)ptr) &= 0xff000000;
@@ -548,42 +548,42 @@ static void relocate_section(TCCState *s1, Section *s) · 6 unmodified lines
548548 x >>= 2;
549549 x &= 0xffffff;
550550 (*(int *)ptr) |= x;
551− }
552− break;
553− case R_ARM_PREL31:
554− {
555− int x;
556− x = (*(int *)ptr) & 0x7fffffff;
557− (*(int *)ptr) &= 0x80000000;
558− x = (x * 2) / 2;
559− x += val - addr;
560− if((x^(x>>1))&0x40000000)
561− error("can't relocate value at %x",addr);
562− (*(int *)ptr) |= x & 0x7fffffff;
563− }
564− case R_ARM_ABS32:
565− *(int *)ptr += val;
566− break;
567− case R_ARM_BASE_PREL:
568− *(int *)ptr += s1->got->sh_addr - addr;
569− break;
570− case R_ARM_GOTOFF32:
551+ }
552+ break;
553+ case R_ARM_PREL31:
554+ {
555+ int x;
556+ x = (*(int *)ptr) & 0x7fffffff;
557+ (*(int *)ptr) &= 0x80000000;
558+ x = (x * 2) / 2;
559+ x += val - addr;
560+ if((x^(x>>1))&0x40000000)
561+ error("can't relocate value at %x",addr);
562+ (*(int *)ptr) |= x & 0x7fffffff;
563+ }
564+ case R_ARM_ABS32:
565+ *(int *)ptr += val;
566+ break;
567+ case R_ARM_BASE_PREL:
568+ *(int *)ptr += s1->got->sh_addr - addr;
569+ break;
570+ case R_ARM_GOTOFF32:
571571 *(int *)ptr += val - s1->got->sh_addr;
572572 break;
573573 case R_ARM_GOT_BREL:
574574 /* we load the got offset */
575575 *(int *)ptr += s1->got_offsets[sym_index];
576576 break;
577− case R_ARM_COPY:
577+ case R_ARM_COPY:
578578 break;
579− default:
580− fprintf(stderr,"FIXME: handle reloc type %x at %lx [%.8x] to %lx\n",
579+ default:
580+ fprintf(stderr,"FIXME: handle reloc type %x at %lx [%.8x] to %lx\n",
581581 type,addr,(unsigned int )ptr,val);
582582 break;
583583 #elif defined(TCC_TARGET_C67)
584− case R_C60_32:
585− *(int *)ptr += val;
586− break;
584+ case R_C60_32:
585+ *(int *)ptr += val;
586+ break;
587587 case R_C60LO16:
588588 {
589589 uint32_t orig;
@@ -603,7 +603,7 @@ static void relocate_section(TCCState *s1, Section *s) · 13 unmodified lines
603603 case R_C60HI16:
604604 break;
605605 default:
606− fprintf(stderr,"FIXME: handle reloc type %x at %lx [%.8x] to %lx\n",
606+ fprintf(stderr,"FIXME: handle reloc type %x at %lx [%.8x] to %lx\n",
607607 type,addr,(unsigned int )ptr,val);
608608 break;
609609 #else
@@ -784,7 +784,7 @@ static void put_got_entry(TCCState *s1, · 174 unmodified lines
784784 offset = plt->data_offset - 16;
785785 }
786786 #elif defined(TCC_TARGET_ARM)
787− if (reloc_type == R_ARM_JUMP_SLOT) {
787+ if (reloc_type == R_ARM_JUMP_SLOT) {
788788 Section *plt;
789789 uint8_t *p;
790790
@@ -797,17 +797,17 @@ static void put_got_entry(TCCState *s1, · 6 unmodified lines
797797 if (plt->data_offset == 0) {
798798 /* first plt entry */
799799 p = section_ptr_add(plt, 16);
800− put32(p , 0xe52de004);
801− put32(p + 4, 0xe59fe010);
802− put32(p + 8, 0xe08fe00e);
803− put32(p + 12, 0xe5bef008);
800+ put32(p , 0xe52de004);
801+ put32(p + 4, 0xe59fe010);
802+ put32(p + 8, 0xe08fe00e);
803+ put32(p + 12, 0xe5bef008);
804804 }
805805
806806 p = section_ptr_add(plt, 16);
807− put32(p , 0xe59fc004);
808− put32(p+4, 0xe08fc00c);
809− put32(p+8, 0xe59cf000);
810− put32(p+12, s1->got->data_offset);
807+ put32(p , 0xe59fc004);
808+ put32(p+4, 0xe08fc00c);
809+ put32(p+8, 0xe59cf000);
810+ put32(p+12, s1->got->data_offset);
811811
812812 /* the symbol is modified so that it will be relocated to
813813 the PLT */
@@ -872,7 +872,7 @@ static void build_got_entries(TCCState *s1) · 58 unmodified lines
872872 }
873873 break;
874874 #elif defined(TCC_TARGET_ARM)
875− case R_ARM_GOT_BREL:
875+ case R_ARM_GOT_BREL:
876876 case R_ARM_GOTOFF32:
877877 case R_ARM_BASE_PREL:
878878 case R_ARM_PLT32:
@@ -891,7 +891,7 @@ static void build_got_entries(TCCState *s1) · 12 unmodified lines
891891 }
892892 break;
893893 #elif defined(TCC_TARGET_C67)
894− case R_C60_GOT32:
894+ case R_C60_GOT32:
895895 case R_C60_GOTOFF:
896896 case R_C60_GOTPC:
897897 case R_C60_PLT32:
@@ -1547,13 +1547,13 @@ int tcc_output_file(TCCState *s1, const char *filename) · 649 unmodified lines
15471547 p += 16;
15481548 }
15491549 #elif defined(TCC_TARGET_ARM)
1550− int x;
1551− x=s1->got->sh_addr - s1->plt->sh_addr - 12;
1552− p +=16;
1553− while (p < p_end) {
1554− put32(p + 12, x + get32(p + 12) + s1->plt->data - p);
1555− p += 16;
1556− }
1550+ int x;
1551+ x=s1->got->sh_addr - s1->plt->sh_addr - 12;
1552+ p +=16;
1553+ while (p < p_end) {
1554+ put32(p + 12, x + get32(p + 12) + s1->plt->data - p);
1555+ p += 16;
1556+ }
15571557 #elif defined(TCC_TARGET_C67)
15581558 /* XXX: TODO */
15591559 #else
@@ -1682,8 +1682,8 @@ int tcc_output_file(TCCState *s1, const char *filename) · 122 unmodified lines
16821682 #endif
16831683 #ifdef TCC_TARGET_ARM
16841684 #ifdef TCC_ARM_EABI
1685− ehdr.e_ident[EI_OSABI] = 0;
1686− ehdr.e_flags = 4 << 24;
1685+ ehdr.e_ident[EI_OSABI] = 0;
1686+ ehdr.e_flags = 4 << 24;
16871687 #else
16881688 ehdr.e_ident[EI_OSABI] = ELFOSABI_ARM;
16891689 #endif
@@ -1859,7 +1859,7 @@ static int tcc_load_object_file(TCCState *s1, · 169 unmodified lines
18591859 if (sh->sh_type != SHT_PROGBITS &&
18601860 sh->sh_type != SHT_REL &&
18611861 #ifdef TCC_ARM_EABI
1862− sh->sh_type != SHT_ARM_EXIDX &&
1862+ sh->sh_type != SHT_ARM_EXIDX &&
18631863 #endif
18641864 sh->sh_type != SHT_NOBITS)
18651865 continue;
@@ -2022,16 +2022,16 @@ static int tcc_load_object_file(TCCState *s1, · 156 unmodified lines
20222022 return ret;
20232023 }
20242024
2025−#define ARMAG "!<arch>\012" /* For COFF and a.out archives */
2025+#define ARMAG "!<arch>\012" /* For COFF and a.out archives */
20262026
20272027 typedef struct ArchiveHeader {
2028− char ar_name[16]; /* name of this member */
2029− char ar_date[12]; /* file mtime */
2030− char ar_uid[6]; /* owner uid; printed as decimal */
2031− char ar_gid[6]; /* owner gid; printed as decimal */
2032− char ar_mode[8]; /* file mode, printed as octal */
2033− char ar_size[10]; /* file size, printed as decimal */
2034− char ar_fmag[2]; /* should contain ARFMAG */
2028+ char ar_name[16]; /* name of this member */
2029+ char ar_date[12]; /* file mtime */
2030+ char ar_uid[6]; /* owner uid; printed as decimal */
2031+ char ar_gid[6]; /* owner gid; printed as decimal */
2032+ char ar_mode[8]; /* file mode, printed as octal */
2033+ char ar_size[10]; /* file size, printed as decimal */
2034+ char ar_fmag[2]; /* should contain ARFMAG */
20352035 } ArchiveHeader;
20362036
20372037 static int get_be32(const uint8_t *b)
@@ -2056,26 +2056,26 @@ static int tcc_load_alacarte(TCCState *s1, int fd, int size) · 18 unmodified lines
20562056 ar_names = ar_index + nsyms * 4;
20572057
20582058 do {
2059− bound = 0;
2060− for(p = ar_names, i = 0; i < nsyms; i++, p += strlen(p)+1) {
2061− sym_index = find_elf_sym(symtab_section, p);
2062− if(sym_index) {
2063− sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
2064− if(sym->st_shndx == SHN_UNDEF) {
2065− off = get_be32(ar_index + i * 4) + sizeof(ArchiveHeader);
2059+ bound = 0;
2060+ for(p = ar_names, i = 0; i < nsyms; i++, p += strlen(p)+1) {
2061+ sym_index = find_elf_sym(symtab_section, p);
2062+ if(sym_index) {
2063+ sym = &((Elf32_Sym *)symtab_section->data)[sym_index];
2064+ if(sym->st_shndx == SHN_UNDEF) {
2065+ off = get_be32(ar_index + i * 4) + sizeof(ArchiveHeader);
20662066 #if 0
2067− printf("%5d\t%s\t%08x\n", i, p, sym->st_shndx);
2067+ printf("%5d\t%s\t%08x\n", i, p, sym->st_shndx);
20682068 #endif
2069− ++bound;
2070− lseek(fd, off, SEEK_SET);
2071− if(tcc_load_object_file(s1, fd, off) < 0) {
2069+ ++bound;
2070+ lseek(fd, off, SEEK_SET);
2071+ if(tcc_load_object_file(s1, fd, off) < 0) {
20722072 fail:
20732073 ret = -1;
20742074 goto the_end;
20752075 }
2076− }
2077− }
2078− }
2076+ }
2077+ }
2078+ }
20792079 } while(bound);
20802080 ret = 0;
20812081 the_end:
@@ -2119,8 +2119,8 @@ static int tcc_load_archive(TCCState *s1, int fd) · 37 unmodified lines
21192119 size = (size + 1) & ~1;
21202120 if (!strcmp(ar_name, "/")) {
21212121 /* coff symbol table : we handle it */
2122− if(s1->alacarte_link)
2123− return tcc_load_alacarte(s1, fd, size);
2122+ if(s1->alacarte_link)
2123+ return tcc_load_alacarte(s1, fd, size);
21242124 } else if (!strcmp(ar_name, "//") ||
21252125 !strcmp(ar_name, "__.SYMDEF") ||
21262126 !strcmp(ar_name, "__.SYMDEF/") ||
@@ -2146,7 +2146,7 @@ static int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level) · 19 unmodified lines
21462146 Elf32_Sym *sym, *dynsym;
21472147 Elf32_Dyn *dt, *dynamic;
21482148 unsigned char *dynstr;
2149− const char *name, *soname, *p;
2149+ const char *name, *soname;
21502150 DLLReference *dllref;
21512151
21522152 read(fd, &ehdr, sizeof(ehdr));
@@ -2185,10 +2185,7 @@ static int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level) · 32 unmodified lines
21852185 }
21862186
21872187 /* compute the real library name */
2188− soname = filename;
2189− p = strrchr(soname, '/');
2190− if (p)
2191− soname = p + 1;
2188+ soname = tcc_basename(filename);
21922189
21932190 for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
21942191 if (dt->d_tag == DT_SONAME) {
tccpe.c+1007−700
@@ -1,7 +1,7 @@
11 /*
2− * TCCPE.C - PE file output for the TinyC Compiler
3− *
4− * Copyright (c) 2005 grischka
2+ * TCCPE.C - PE file output for the Tiny C Compiler
3+ *
4+ * Copyright (c) 2005-2007 grischka
55 *
66 * This library is free software; you can redistribute it and/or
77 * modify it under the terms of the GNU Lesser General Public
@@ -18,251 +18,189 @@ · 10 unmodified lines
1818 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1919 */
2020
21−typedef unsigned char BYTE;
22−typedef unsigned short WORD;
23−typedef unsigned long DWORD;
24−#define ST static
21+#ifdef TCC_TARGET_PE
2522
26−/* XXX: move that to TCC ? */
27−int verbose = 0;
23+#define ST_FN static
24+#define ST_DATA static
25+#define PUB_FN
2826
29−/* definitions below are from winnt.h */
27+#ifndef _WIN32
28+#define stricmp strcasecmp
29+#define strnicmp strncasecmp
30+#endif
31+
32+#ifndef MAX_PATH
33+#define MAX_PATH 260
34+#endif
3035
31−typedef struct _IMAGE_DOS_HEADER { /* DOS .EXE header */
32− WORD e_magic; /* Magic number */
33− WORD e_cblp; /* Bytes on last page of file */
34− WORD e_cp; /* Pages in file */
35− WORD e_crlc; /* Relocations */
36− WORD e_cparhdr; /* Size of header in paragraphs */
37− WORD e_minalloc; /* Minimum extra paragraphs needed */
38− WORD e_maxalloc; /* Maximum extra paragraphs needed */
39− WORD e_ss; /* Initial (relative) SS value */
40− WORD e_sp; /* Initial SP value */
41− WORD e_csum; /* Checksum */
42− WORD e_ip; /* Initial IP value */
43− WORD e_cs; /* Initial (relative) CS value */
44− WORD e_lfarlc; /* File address of relocation table */
45− WORD e_ovno; /* Overlay number */
46− WORD e_res[4]; /* Reserved words */
47− WORD e_oemid; /* OEM identifier (for e_oeminfo) */
48− WORD e_oeminfo; /* OEM information; e_oemid specific */
49− WORD e_res2[10]; /* Reserved words */
50− DWORD e_lfanew; /* File address of new exe header */
51− BYTE e_code[0x40];
36+#define PE_MERGE_DATA
37+// #define PE_PRINT_SECTIONS
5238
39+/* ----------------------------------------------------------- */
40+#ifndef IMAGE_NT_SIGNATURE
41+/* ----------------------------------------------------------- */
42+/* definitions below are from winnt.h */
43+
44+typedef unsigned char BYTE;
45+typedef unsigned short WORD;
46+typedef unsigned long DWORD;
47+#pragma pack(push, 1)
48+
49+typedef struct _IMAGE_DOS_HEADER { /* DOS .EXE header */
50+ WORD e_magic; /* Magic number */
51+ WORD e_cblp; /* Bytes on last page of file */
52+ WORD e_cp; /* Pages in file */
53+ WORD e_crlc; /* Relocations */
54+ WORD e_cparhdr; /* Size of header in paragraphs */
55+ WORD e_minalloc; /* Minimum extra paragraphs needed */
56+ WORD e_maxalloc; /* Maximum extra paragraphs needed */
57+ WORD e_ss; /* Initial (relative) SS value */
58+ WORD e_sp; /* Initial SP value */
59+ WORD e_csum; /* Checksum */
60+ WORD e_ip; /* Initial IP value */
61+ WORD e_cs; /* Initial (relative) CS value */
62+ WORD e_lfarlc; /* File address of relocation table */
63+ WORD e_ovno; /* Overlay number */
64+ WORD e_res[4]; /* Reserved words */
65+ WORD e_oemid; /* OEM identifier (for e_oeminfo) */
66+ WORD e_oeminfo; /* OEM information; e_oemid specific */
67+ WORD e_res2[10]; /* Reserved words */
68+ DWORD e_lfanew; /* File address of new exe header */
5369 } IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER;
5470
5571 #define IMAGE_NT_SIGNATURE 0x00004550 /* PE00 */
5672 #define SIZE_OF_NT_SIGNATURE 4
5773
5874 typedef struct _IMAGE_FILE_HEADER {
59− WORD Machine;
60− WORD NumberOfSections;
61− DWORD TimeDateStamp;
62− DWORD PointerToSymbolTable;
63− DWORD NumberOfSymbols;
64− WORD SizeOfOptionalHeader;
65− WORD Characteristics;
75+ WORD Machine;
76+ WORD NumberOfSections;
77+ DWORD TimeDateStamp;
78+ DWORD PointerToSymbolTable;
79+ DWORD NumberOfSymbols;
80+ WORD SizeOfOptionalHeader;
81+ WORD Characteristics;
6682 } IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;
6783
6884
6985 #define IMAGE_SIZEOF_FILE_HEADER 20
7086
7187 typedef struct _IMAGE_DATA_DIRECTORY {
72− DWORD VirtualAddress;
73− DWORD Size;
88+ DWORD VirtualAddress;
89+ DWORD Size;
7490 } IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;
7591
7692
7793 typedef struct _IMAGE_OPTIONAL_HEADER {
7894 /* Standard fields. */
79− WORD Magic;
80− BYTE MajorLinkerVersion;
81− BYTE MinorLinkerVersion;
82− DWORD SizeOfCode;
83− DWORD SizeOfInitializedData;
84− DWORD SizeOfUninitializedData;
85− DWORD AddressOfEntryPoint;
86− DWORD BaseOfCode;
87− DWORD BaseOfData;
95+ WORD Magic;
96+ BYTE MajorLinkerVersion;
97+ BYTE MinorLinkerVersion;
98+ DWORD SizeOfCode;
99+ DWORD SizeOfInitializedData;
100+ DWORD SizeOfUninitializedData;
101+ DWORD AddressOfEntryPoint;
102+ DWORD BaseOfCode;
103+ DWORD BaseOfData;
88104
89105 /* NT additional fields. */
90− DWORD ImageBase;
91− DWORD SectionAlignment;
92− DWORD FileAlignment;
93− WORD MajorOperatingSystemVersion;
94− WORD MinorOperatingSystemVersion;
95− WORD MajorImageVersion;
96− WORD MinorImageVersion;
97− WORD MajorSubsystemVersion;
98− WORD MinorSubsystemVersion;
99− DWORD Win32VersionValue;
100− DWORD SizeOfImage;
101− DWORD SizeOfHeaders;
102− DWORD CheckSum;
103− WORD Subsystem;
104− WORD DllCharacteristics;
105− DWORD SizeOfStackReserve;
106− DWORD SizeOfStackCommit;
107− DWORD SizeOfHeapReserve;
108− DWORD SizeOfHeapCommit;
109− DWORD LoaderFlags;
110− DWORD NumberOfRvaAndSizes;
106+ DWORD ImageBase;
107+ DWORD SectionAlignment;
108+ DWORD FileAlignment;
109+ WORD MajorOperatingSystemVersion;
110+ WORD MinorOperatingSystemVersion;
111+ WORD MajorImageVersion;
112+ WORD MinorImageVersion;
113+ WORD MajorSubsystemVersion;
114+ WORD MinorSubsystemVersion;
115+ DWORD Win32VersionValue;
116+ DWORD SizeOfImage;
117+ DWORD SizeOfHeaders;
118+ DWORD CheckSum;
119+ WORD Subsystem;
120+ WORD DllCharacteristics;
121+ DWORD SizeOfStackReserve;
122+ DWORD SizeOfStackCommit;
123+ DWORD SizeOfHeapReserve;
124+ DWORD SizeOfHeapCommit;
125+ DWORD LoaderFlags;
126+ DWORD NumberOfRvaAndSizes;
111127 IMAGE_DATA_DIRECTORY DataDirectory[16];
112128
113−} IMAGE_OPTIONAL_HEADER32, *PIMAGE_OPTIONAL_HEADER32;
129+} IMAGE_OPTIONAL_HEADER, *PIMAGE_OPTIONAL_HEADER;
114130
115131
116−#define IMAGE_DIRECTORY_ENTRY_EXPORT 0 /* Export Directory */
117−#define IMAGE_DIRECTORY_ENTRY_IMPORT 1 /* Import Directory */
118−#define IMAGE_DIRECTORY_ENTRY_RESOURCE 2 /* Resource Directory */
119−#define IMAGE_DIRECTORY_ENTRY_EXCEPTION 3 /* Exception Directory */
120−#define IMAGE_DIRECTORY_ENTRY_SECURITY 4 /* Security Directory */
121−#define IMAGE_DIRECTORY_ENTRY_BASERELOC 5 /* Base Relocation Table */
122−#define IMAGE_DIRECTORY_ENTRY_DEBUG 6 /* Debug Directory */
132+#define IMAGE_DIRECTORY_ENTRY_EXPORT 0 /* Export Directory */
133+#define IMAGE_DIRECTORY_ENTRY_IMPORT 1 /* Import Directory */
134+#define IMAGE_DIRECTORY_ENTRY_RESOURCE 2 /* Resource Directory */
135+#define IMAGE_DIRECTORY_ENTRY_EXCEPTION 3 /* Exception Directory */
136+#define IMAGE_DIRECTORY_ENTRY_SECURITY 4 /* Security Directory */
137+#define IMAGE_DIRECTORY_ENTRY_BASERELOC 5 /* Base Relocation Table */
138+#define IMAGE_DIRECTORY_ENTRY_DEBUG 6 /* Debug Directory */
123139 /* IMAGE_DIRECTORY_ENTRY_COPYRIGHT 7 (X86 usage) */
124−#define IMAGE_DIRECTORY_ENTRY_ARCHITECTURE 7 /* Architecture Specific Data */
125−#define IMAGE_DIRECTORY_ENTRY_GLOBALPTR 8 /* RVA of GP */
126−#define IMAGE_DIRECTORY_ENTRY_TLS 9 /* TLS Directory */
127−#define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG 10 /* Load Configuration Directory */
128−#define IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT 11 /* Bound Import Directory in headers */
129−#define IMAGE_DIRECTORY_ENTRY_IAT 12 /* Import Address Table */
130−#define IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT 13 /* Delay Load Import Descriptors */
131−#define IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR 14 /* COM Runtime descriptor */
140+#define IMAGE_DIRECTORY_ENTRY_ARCHITECTURE 7 /* Architecture Specific Data */
141+#define IMAGE_DIRECTORY_ENTRY_GLOBALPTR 8 /* RVA of GP */
142+#define IMAGE_DIRECTORY_ENTRY_TLS 9 /* TLS Directory */
143+#define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG 10 /* Load Configuration Directory */
144+#define IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT 11 /* Bound Import Directory in headers */
145+#define IMAGE_DIRECTORY_ENTRY_IAT 12 /* Import Address Table */
146+#define IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT 13 /* Delay Load Import Descriptors */
147+#define IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR 14 /* COM Runtime descriptor */
132148
133149 /* Section header format. */
134−#define IMAGE_SIZEOF_SHORT_NAME 8
150+#define IMAGE_SIZEOF_SHORT_NAME 8
135151
136152 typedef struct _IMAGE_SECTION_HEADER {
137− BYTE Name[IMAGE_SIZEOF_SHORT_NAME];
153+ BYTE Name[IMAGE_SIZEOF_SHORT_NAME];
138154 union {
139− DWORD PhysicalAddress;
140− DWORD VirtualSize;
155+ DWORD PhysicalAddress;
156+ DWORD VirtualSize;
141157 } Misc;
142− DWORD VirtualAddress;
143− DWORD SizeOfRawData;
144− DWORD PointerToRawData;
145− DWORD PointerToRelocations;
146− DWORD PointerToLinenumbers;
147− WORD NumberOfRelocations;
148− WORD NumberOfLinenumbers;
149− DWORD Characteristics;
158+ DWORD VirtualAddress;
159+ DWORD SizeOfRawData;
160+ DWORD PointerToRawData;
161+ DWORD PointerToRelocations;
162+ DWORD PointerToLinenumbers;
163+ WORD NumberOfRelocations;
164+ WORD NumberOfLinenumbers;
165+ DWORD Characteristics;
150166 } IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
151167
152−#define IMAGE_SIZEOF_SECTION_HEADER 40
168+#define IMAGE_SIZEOF_SECTION_HEADER 40
153169
154−/* ----------------------------------------------------------- */
155170 typedef struct _IMAGE_BASE_RELOCATION {
156− DWORD VirtualAddress;
157− DWORD SizeOfBlock;
171+ DWORD VirtualAddress;
172+ DWORD SizeOfBlock;
158173 // WORD TypeOffset[1];
159174 } IMAGE_BASE_RELOCATION;
160175
161−#define IMAGE_SIZEOF_BASE_RELOCATION 8
176+#define IMAGE_SIZEOF_BASE_RELOCATION 8
162177
163−#define IMAGE_REL_BASED_ABSOLUTE 0
164−#define IMAGE_REL_BASED_HIGH 1
165−#define IMAGE_REL_BASED_LOW 2
166−#define IMAGE_REL_BASED_HIGHLOW 3
167−#define IMAGE_REL_BASED_HIGHADJ 4
168−#define IMAGE_REL_BASED_MIPS_JMPADDR 5
169−#define IMAGE_REL_BASED_SECTION 6
170−#define IMAGE_REL_BASED_REL32 7
178+#define IMAGE_REL_BASED_ABSOLUTE 0
179+#define IMAGE_REL_BASED_HIGH 1
180+#define IMAGE_REL_BASED_LOW 2
181+#define IMAGE_REL_BASED_HIGHLOW 3
182+#define IMAGE_REL_BASED_HIGHADJ 4
183+#define IMAGE_REL_BASED_MIPS_JMPADDR 5
184+#define IMAGE_REL_BASED_SECTION 6
185+#define IMAGE_REL_BASED_REL32 7
171186
172−/* ----------------------------------------------------------- */
187+#pragma pack(pop)
173188
174189 /* ----------------------------------------------------------- */
175−IMAGE_DOS_HEADER pe_dos_hdr = {
176− 0x5A4D, /*WORD e_magic; Magic number */
177− 0x0090, /*WORD e_cblp; Bytes on last page of file */
178− 0x0003, /*WORD e_cp; Pages in file */
179− 0x0000, /*WORD e_crlc; Relocations */
180−
181− 0x0004, /*WORD e_cparhdr; Size of header in paragraphs */
182− 0x0000, /*WORD e_minalloc; Minimum extra paragraphs needed */
183− 0xFFFF, /*WORD e_maxalloc; Maximum extra paragraphs needed */
184− 0x0000, /*WORD e_ss; Initial (relative) SS value */
185−
186− 0x00B8, /*WORD e_sp; Initial SP value */
187− 0x0000, /*WORD e_csum; Checksum */
188− 0x0000, /*WORD e_ip; Initial IP value */
189− 0x0000, /*WORD e_cs; Initial (relative) CS value */
190− 0x0040, /*WORD e_lfarlc; File address of relocation table */
191− 0x0000, /*WORD e_ovno; Overlay number */
192− {0, 0, 0, 0}, /*WORD e_res[4]; Reserved words */
193− 0x0000, /*WORD e_oemid; OEM identifier (for e_oeminfo) */
194− 0x0000, /*WORD e_oeminfo; OEM information; e_oemid specific */
195− {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, /*WORD e_res2[10]; Reserved words */
196− 0x00000080, /*DWORD e_lfanew; File address of new exe header */
197− { /* 14 code bytes + "This program cannot be run in DOS mode.\r\r\n$" + 6 * 0x00 */
198− /*0040 */ 0x0e, 0x1f, 0xba, 0x0e, 0x00, 0xb4, 0x09, 0xcd, 0x21, 0xb8,
199− 0x01, 0x4c, 0xcd, 0x21, 0x54, 0x68,
200− /*0050 */ 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d,
201− 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f,
202− /*0060 */ 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x69,
203− 0x6e, 0x20, 0x44, 0x4f, 0x53, 0x20,
204− /*0070 */ 0x6d, 0x6f, 0x64, 0x65, 0x2e, 0x0d, 0x0d, 0x0a, 0x24, 0x00,
205− 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
206− /*0080 */
207− }
208−};
209−
210−DWORD pe_magic = IMAGE_NT_SIGNATURE;
211−
212−IMAGE_FILE_HEADER pe_file_hdr = {
213− 0x014C, /*WORD Machine; */
214− 0x0003, /*WORD NumberOfSections; */
215− 0x00000000, /*DWORD TimeDateStamp; */
216− 0x00000000, /*DWORD PointerToSymbolTable; */
217− 0x00000000, /*DWORD NumberOfSymbols; */
218− 0x00E0, /*WORD SizeOfOptionalHeader; */
219− 0x030F /*WORD Characteristics; */
220−};
190+#endif /* ndef IMAGE_NT_SIGNATURE */
191+/* ----------------------------------------------------------- */
221192
222−IMAGE_OPTIONAL_HEADER32 pe_opt_hdr = {
223− /* Standard fields. */
224− 0x010B, /*WORD Magic; */
225− 0x06, /*BYTE MajorLinkerVersion; */
226− 0x00, /*BYTE MinorLinkerVersion; */
227− 0x00000000, /*DWORD SizeOfCode; */
228− 0x00000000, /*DWORD SizeOfInitializedData; */
229− 0x00000000, /*DWORD SizeOfUninitializedData; */
230− 0x00000000, /*DWORD AddressOfEntryPoint; */
231− 0x00000000, /*DWORD BaseOfCode; */
232− 0x00000000, /*DWORD BaseOfData; */
193+#pragma pack(push, 1)
233194
234− /* NT additional fields. */
235− 0x00400000, /*DWORD ImageBase; */
236− 0x00001000, /*DWORD SectionAlignment; */
237− 0x00000200, /*DWORD FileAlignment; */
238− 0x0004, /*WORD MajorOperatingSystemVersion; */
239− 0x0000, /*WORD MinorOperatingSystemVersion; */
240− 0x0000, /*WORD MajorImageVersion; */
241− 0x0000, /*WORD MinorImageVersion; */
242− 0x0004, /*WORD MajorSubsystemVersion; */
243− 0x0000, /*WORD MinorSubsystemVersion; */
244− 0x00000000, /*DWORD Win32VersionValue; */
245− 0x00000000, /*DWORD SizeOfImage; */
246− 0x00000200, /*DWORD SizeOfHeaders; */
247− 0x00000000, /*DWORD CheckSum; */
248− 0x0002, /*WORD Subsystem; */
249− 0x0000, /*WORD DllCharacteristics; */
250− 0x00100000, /*DWORD SizeOfStackReserve; */
251− 0x00001000, /*DWORD SizeOfStackCommit; */
252− 0x00100000, /*DWORD SizeOfHeapReserve; */
253− 0x00001000, /*DWORD SizeOfHeapCommit; */
254− 0x00000000, /*DWORD LoaderFlags; */
255− 0x00000010, /*DWORD NumberOfRvaAndSizes; */
256−
257− /* IMAGE_DATA_DIRECTORY DataDirectory[16]; */
258− {{0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0},
259− {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}}
195+struct pe_header
196+{
197+ IMAGE_DOS_HEADER doshdr;
198+ BYTE dosstub[0x40];
199+ DWORD nt_sig;
200+ IMAGE_FILE_HEADER filehdr;
201+ IMAGE_OPTIONAL_HEADER opthdr;
260202 };
261203
262−/*----------------------------------------------------------------------------*/
263−
264−/*----------------------------------------------------------------------------*/
265−
266204 struct pe_import_header {
267205 DWORD first_entry;
268206 DWORD time_date;
@@ -289,52 +227,154 @@ struct pe_reloc_header { · 20 unmodified lines
289227 DWORD size;
290228 };
291229
230+struct pe_rsrc_header {
231+ struct _IMAGE_FILE_HEADER filehdr;
232+ struct _IMAGE_SECTION_HEADER sectionhdr;
233+};
234+
235+struct pe_rsrc_reloc {
236+ DWORD offset;
237+ DWORD size;
238+ WORD type;
239+};
240+
241+#pragma pack(pop)
242+
243+/* ----------------------------------------------------------- */
244+ST_DATA struct pe_header pe_header = {
245+{
246+ /* IMAGE_DOS_HEADER doshdr */
247+ 0x5A4D, /*WORD e_magic; Magic number */
248+ 0x0090, /*WORD e_cblp; Bytes on last page of file */
249+ 0x0003, /*WORD e_cp; Pages in file */
250+ 0x0000, /*WORD e_crlc; Relocations */
251+
252+ 0x0004, /*WORD e_cparhdr; Size of header in paragraphs */
253+ 0x0000, /*WORD e_minalloc; Minimum extra paragraphs needed */
254+ 0xFFFF, /*WORD e_maxalloc; Maximum extra paragraphs needed */
255+ 0x0000, /*WORD e_ss; Initial (relative) SS value */
256+
257+ 0x00B8, /*WORD e_sp; Initial SP value */
258+ 0x0000, /*WORD e_csum; Checksum */
259+ 0x0000, /*WORD e_ip; Initial IP value */
260+ 0x0000, /*WORD e_cs; Initial (relative) CS value */
261+ 0x0040, /*WORD e_lfarlc; File address of relocation table */
262+ 0x0000, /*WORD e_ovno; Overlay number */
263+ {0,0,0,0}, /*WORD e_res[4]; Reserved words */
264+ 0x0000, /*WORD e_oemid; OEM identifier (for e_oeminfo) */
265+ 0x0000, /*WORD e_oeminfo; OEM information; e_oemid specific */
266+ {0,0,0,0,0,0,0,0,0,0}, /*WORD e_res2[10]; Reserved words */
267+ 0x00000080 /*DWORD e_lfanew; File address of new exe header */
268+},{
269+ /* BYTE dosstub[0x40] */
270+ /* 14 code bytes + "This program cannot be run in DOS mode.\r\r\n$" + 6 * 0x00 */
271+ 0x0e,0x1f,0xba,0x0e,0x00,0xb4,0x09,0xcd,0x21,0xb8,0x01,0x4c,0xcd,0x21,0x54,0x68,
272+ 0x69,0x73,0x20,0x70,0x72,0x6f,0x67,0x72,0x61,0x6d,0x20,0x63,0x61,0x6e,0x6e,0x6f,
273+ 0x74,0x20,0x62,0x65,0x20,0x72,0x75,0x6e,0x20,0x69,0x6e,0x20,0x44,0x4f,0x53,0x20,
274+ 0x6d,0x6f,0x64,0x65,0x2e,0x0d,0x0d,0x0a,0x24,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
275+},
276+ 0x00004550, /* DWORD nt_sig = IMAGE_NT_SIGNATURE */
277+{
278+ /* IMAGE_FILE_HEADER filehdr */
279+ 0x014C, /*WORD Machine; */
280+ 0x0003, /*WORD NumberOfSections; */
281+ 0x00000000, /*DWORD TimeDateStamp; */
282+ 0x00000000, /*DWORD PointerToSymbolTable; */
283+ 0x00000000, /*DWORD NumberOfSymbols; */
284+ 0x00E0, /*WORD SizeOfOptionalHeader; */
285+ 0x030F /*WORD Characteristics; */
286+},{
287+ /* IMAGE_OPTIONAL_HEADER opthdr */
288+ /* Standard fields. */
289+ 0x010B, /*WORD Magic; */
290+ 0x06, /*BYTE MajorLinkerVersion; */
291+ 0x00, /*BYTE MinorLinkerVersion; */
292+ 0x00000000, /*DWORD SizeOfCode; */
293+ 0x00000000, /*DWORD SizeOfInitializedData; */
294+ 0x00000000, /*DWORD SizeOfUninitializedData; */
295+ 0x00000000, /*DWORD AddressOfEntryPoint; */
296+ 0x00000000, /*DWORD BaseOfCode; */
297+ 0x00000000, /*DWORD BaseOfData; */
298+
299+ /* NT additional fields. */
300+ 0x00400000, /*DWORD ImageBase; */
301+ 0x00001000, /*DWORD SectionAlignment; */
302+ 0x00000200, /*DWORD FileAlignment; */
303+ 0x0004, /*WORD MajorOperatingSystemVersion; */
304+ 0x0000, /*WORD MinorOperatingSystemVersion; */
305+ 0x0000, /*WORD MajorImageVersion; */
306+ 0x0000, /*WORD MinorImageVersion; */
307+ 0x0004, /*WORD MajorSubsystemVersion; */
308+ 0x0000, /*WORD MinorSubsystemVersion; */
309+ 0x00000000, /*DWORD Win32VersionValue; */
310+ 0x00000000, /*DWORD SizeOfImage; */
311+ 0x00000200, /*DWORD SizeOfHeaders; */
312+ 0x00000000, /*DWORD CheckSum; */
313+ 0x0002, /*WORD Subsystem; */
314+ 0x0000, /*WORD DllCharacteristics; */
315+ 0x00100000, /*DWORD SizeOfStackReserve; */
316+ 0x00001000, /*DWORD SizeOfStackCommit; */
317+ 0x00100000, /*DWORD SizeOfHeapReserve; */
318+ 0x00001000, /*DWORD SizeOfHeapCommit; */
319+ 0x00000000, /*DWORD LoaderFlags; */
320+ 0x00000010, /*DWORD NumberOfRvaAndSizes; */
321+
322+ /* IMAGE_DATA_DIRECTORY DataDirectory[16]; */
323+ {{0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0},
324+ {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}}
325+}};
326+
292327 /* ------------------------------------------------------------- */
293328 /* internal temporary structures */
294329
295−ST const char *pe_sec_names[] = {
296− ".text",
297− ".data",
298− ".bss",
299− ".rsrc",
300− ".reloc",
301− ".stab",
302− ".stabstr"
303−};
330+/*
331+#define IMAGE_SCN_CNT_CODE 0x00000020
332+#define IMAGE_SCN_CNT_INITIALIZED_DATA 0x00000040
333+#define IMAGE_SCN_CNT_UNINITIALIZED_DATA 0x00000080
334+#define IMAGE_SCN_MEM_DISCARDABLE 0x02000000
335+#define IMAGE_SCN_MEM_SHARED 0x10000000
336+#define IMAGE_SCN_MEM_EXECUTE 0x20000000
337+#define IMAGE_SCN_MEM_READ 0x40000000
338+#define IMAGE_SCN_MEM_WRITE 0x80000000
339+*/
304340
305341 enum {
306342 sec_text = 0,
307− sec_data,
308− sec_bss,
309− sec_rsrc,
310− sec_reloc,
311− sec_stab,
312− sec_stabstr,
313− pe_sec_number
343+ sec_data ,
344+ sec_bss ,
345+ sec_idata ,
346+ sec_rsrc ,
347+ sec_stab ,
348+ sec_reloc ,
349+
350+ sec_last
314351 };
315352
316−ST DWORD pe_flags[] = {
317− 0x60000020, /* ".text", */
318− 0xC0000040, /* ".data", */
319− 0xC0000080, /* ".bss", */
320− 0x40000040, /* ".rsrc", */
321− 0x42000040, /* ".reloc", */
322− 0x42000802, /* ".stab", */
323− 0x42000802 /* ".stabstr", */
353+ST_DATA DWORD pe_sec_flags[] = {
354+ 0x60000020, /* ".text" , */
355+ 0xC0000040, /* ".data" , */
356+ 0xC0000080, /* ".bss" , */
357+ 0x40000040, /* ".idata" , */
358+ 0x40000040, /* ".rsrc" , */
359+ 0x42000802, /* ".stab" , */
360+ 0x42000040, /* ".reloc" , */
324361 };
325362
326363 struct section_info {
327− struct section_info *next;
328− int id;
364+ int cls, ord;
365+ char name[32];
329366 DWORD sh_addr;
330367 DWORD sh_size;
368+ DWORD sh_flags;
331369 unsigned char *data;
332370 DWORD data_size;
371+ IMAGE_SECTION_HEADER ish;
333372 };
334373
335374 struct import_symbol {
336375 int sym_index;
337− int offset;
376+ int iat_index;
377+ int thk_offset;
338378 };
339379
340380 struct pe_import_info {
@@ -344,7 +384,11 @@ struct pe_import_info { · 3 unmodified lines
344384 };
345385
346386 struct pe_info {
387+ TCCState *s1;
388+ Section *reloc;
389+ Section *thunk;
347390 const char *filename;
391+ int type;
348392 DWORD sizeofheaders;
349393 DWORD imagebase;
350394 DWORD start_addr;
@@ -354,173 +398,172 @@ struct pe_info { · 3 unmodified lines
354398 DWORD iat_size;
355399 DWORD exp_offs;
356400 DWORD exp_size;
357− struct section_info sh_info[pe_sec_number];
401+ struct section_info *sec_info;
358402 int sec_count;
359403 struct pe_import_info **imp_info;
360404 int imp_count;
361− Section *reloc;
362− Section *thunk;
363− TCCState *s1;
364405 };
365406
366407 /* ------------------------------------------------------------- */
367−#define PE_MERGE_DATA
368−// #define PE_PRINT_SECTIONS
369−
370−#ifndef MAX_PATH
371−#define MAX_PATH 260
372−#endif
373−
374−void error_noabort(const char *, ...);
375−
376−ST char pe_type;
377408
378409 #define PE_NUL 0
379410 #define PE_DLL 1
380411 #define PE_GUI 2
381412 #define PE_EXE 3
382413
383−ST int pe_find_import(TCCState * s1, const char *symbol, char *ret)
414+void error_noabort(const char *, ...);
415+
416+#ifdef _WIN32
417+void dbg_printf (const char *fmt, ...)
384418 {
385− int sym_index = find_elf_sym(s1->dynsymtab_section, symbol);
386− if (0 == sym_index) {
387− /* Hm, maybe it's '_symbol' instead of 'symbol' or '__imp__symbol' */
388− char buffer[100];
389− if (0 == memcmp(symbol, "__imp__", 7))
390− symbol += 6;
391− else
392− buffer[0] = '_', strcpy(buffer + 1, symbol), symbol = buffer;
393− sym_index = find_elf_sym(s1->dynsymtab_section, symbol);
419+ char buffer[4000];
420+ va_list arg;
421+ int x;
422+ va_start(arg, fmt);
423+ x = vsprintf (buffer, fmt, arg);
424+ strcpy(buffer+x, "\n");
425+ OutputDebugString(buffer);
426+}
427+#endif
428+
429+/* --------------------------------------------*/
430+
431+ST_FN const char* get_alt_symbol(char *buffer, const char *symbol)
432+{
433+ const char *p;
434+ p = strrchr(symbol, '@');
435+ if (p && isnum(p[1]) && symbol[0] == '_') { /* stdcall decor */
436+ strcpy(buffer, symbol+1)[p-symbol-1] = 0;
437+ } else if (symbol[0] != '_') { /* try non-ansi function */
438+ buffer[0] = '_', strcpy(buffer + 1, symbol);
439+ } else if (0 == memcmp(symbol, "__imp__", 7)) { /* mingw 2.0 */
440+ strcpy(buffer, symbol + 6);
441+ } else if (0 == memcmp(symbol, "_imp___", 7)) { /* mingw 3.7 */
442+ strcpy(buffer, symbol + 6);
443+ } else {
444+ return symbol;
394445 }
395− if (ret)
396− strcpy(ret, symbol);
446+ return buffer;
447+}
448+
449+ST_FN int pe_find_import(TCCState * s1, const char *symbol)
450+{
451+ char buffer[200];
452+ const char *s;
453+ int sym_index, n = 0;
454+ do {
455+ s = n ? get_alt_symbol(buffer, symbol) : symbol;
456+ sym_index = find_elf_sym(s1->dynsymtab_section, s);
457+ // printf("find %d %s\n", sym_index, s);
458+ } while (0 == sym_index && ++n < 2);
397459 return sym_index;
398460 }
399461
400−#ifdef _WIN32
401−ST void **pe_imp;
402−ST int nb_pe_imp;
462+#if defined _WIN32 || defined __CYGWIN__
403463
464+#ifdef __CYGWIN__
465+# include <dlfcn.h>
466+# define LoadLibrary(s) dlopen(s, RTLD_NOW)
467+# define GetProcAddress(h,s) dlsym(h, s)
468+#endif
469+
470+/* for the -run option: dynamically load symbol from dll */
404471 void *resolve_sym(struct TCCState *s1, const char *symbol, int type)
405472 {
406− char buffer[100], *p = buffer;
407− void *a = NULL;
408− int sym_index = pe_find_import(s1, symbol, p);
409− int dll_index;
410− const char *dll_name;
411− void *hm;
412−
413− if (sym_index) {
414− dll_index = ((Elf32_Sym *) s1->dynsymtab_section->data)[sym_index].
415− st_other;
416− dll_name = s1->loaded_dlls[dll_index]->name;
417− hm = GetModuleHandleA(dll_name);
418− if (NULL == hm)
419− hm = LoadLibraryA(dll_name);
420− if (hm) {
421− a = GetProcAddress(hm, buffer);
422− if (a && STT_OBJECT == type) {
423− // need to return a pointer to the address for data objects
424− dynarray_add(&pe_imp, &nb_pe_imp, a);
425− a = &pe_imp[nb_pe_imp - 1];
426− }
427− }
473+ char buffer[100];
474+ int sym_index, dll_index;
475+ void *hModule, *addr, **m;
476+
477+ sym_index = pe_find_import(s1, symbol);
478+ if (0 == sym_index)
479+ return NULL;
480+ dll_index = ((Elf32_Sym *)s1->dynsymtab_section->data + sym_index)->st_value;
481+ hModule = LoadLibrary(s1->loaded_dlls[dll_index-1]->name);
482+ addr = GetProcAddress(hModule, symbol);
483+ if (NULL == addr)
484+ addr = GetProcAddress(hModule, get_alt_symbol(buffer, symbol));
485+
486+ if (addr && STT_OBJECT == type) {
487+ /* need to return a pointer to the address for data objects */
488+ m = (void**)tcc_malloc(sizeof addr), *m = addr, addr = m;
489+#ifdef MEM_DEBUG
490+ /* yep, we don't free it */
491+ mem_cur_size -= sizeof (void*);
492+#endif
428493 }
429− return a;
494+ return addr;
430495 }
431496 #endif
432497
433−#define for_sym_in_symtab(sym) \
434−for (sym = (Elf32_Sym *)symtab_section->data + 1; \
435− sym < (Elf32_Sym *)(symtab_section->data + \
436− symtab_section->data_offset); \
437− ++sym)
438−
439−#define pe_set_datadir(dir,addr,size) \
440− pe_opt_hdr.DataDirectory[dir].VirtualAddress = addr, \
441− pe_opt_hdr.DataDirectory[dir].Size = size
442−
443498 /*----------------------------------------------------------------------------*/
444−ST void dynarray_reset(void ***pp, int *n)
445−{
446− int i;
447− for (i = 0; i < *n; ++i)
448− tcc_free((*pp)[i]);
449− tcc_free(*pp);
450− *pp = NULL;
451− *n = 0;
452−}
453499
454−ST int dynarray_assoc(void **pp, int n, int key)
500+ST_FN int dynarray_assoc(void **pp, int n, int key)
455501 {
456502 int i;
457503 for (i = 0; i < n; ++i, ++pp)
458− if (key == **(int **) pp)
459− return i;
504+ if (key == **(int **) pp)
505+ return i;
460506 return -1;
461507 }
462508
463509 #if 0
464−ST DWORD umin(DWORD a, DWORD b)
510+ST_FN DWORD umin(DWORD a, DWORD b)
465511 {
466512 return a < b ? a : b;
467513 }
468514 #endif
469515
470−ST DWORD umax(DWORD a, DWORD b)
516+ST_FN DWORD umax(DWORD a, DWORD b)
471517 {
472518 return a < b ? b : a;
473519 }
474520
475−ST void pe_fpad(FILE * fp, DWORD new_pos)
521+ST_FN void pe_fpad(FILE *fp, DWORD new_pos)
476522 {
477523 DWORD pos = ftell(fp);
478524 while (++pos <= new_pos)
479525 fputc(0, fp);
480526 }
481527
482−ST DWORD pe_file_align(DWORD n)
528+ST_FN DWORD pe_file_align(DWORD n)
483529 {
484530 return (n + (0x200 - 1)) & ~(0x200 - 1);
485531 }
486532
487−ST DWORD pe_virtual_align(DWORD n)
533+ST_FN DWORD pe_virtual_align(DWORD n)
488534 {
489535 return (n + (0x1000 - 1)) & ~(0x1000 - 1);
490536 }
491537
492−ST void pe_align_section(Section * s, int a)
538+ST_FN void pe_align_section(Section *s, int a)
493539 {
494− int i = s->data_offset & (a - 1);
540+ int i = s->data_offset & (a-1);
495541 if (i)
496542 section_ptr_add(s, a - i);
497543 }
498544
545+ST_FN void pe_set_datadir(int dir, DWORD addr, DWORD size)
546+{
547+ pe_header.opthdr.DataDirectory[dir].VirtualAddress = addr;
548+ pe_header.opthdr.DataDirectory[dir].Size = size;
549+}
499550
500551 /*----------------------------------------------------------------------------*/
501−ST int pe_write_pe(struct pe_info *pe)
552+ST_FN int pe_write(struct pe_info *pe)
502553 {
503554 int i;
504555 FILE *op;
505− DWORD file_offset;
506− IMAGE_SECTION_HEADER ish[pe_sec_number], *psh;
507− int sec_index = 0;
556+ DWORD file_offset, r;
508557
509558 op = fopen(pe->filename, "wb");
510559 if (NULL == op) {
511− error_noabort("could not create file: %s", pe->filename);
560+ error_noabort("could not write '%s': %s", pe->filename, strerror(errno));
512561 return 1;
513562 }
514563
515− memset(&ish, 0, sizeof ish);
516−
517− pe->sizeofheaders = pe_file_align(sizeof pe_dos_hdr
518− + sizeof pe_magic
519− + sizeof pe_file_hdr
520− + sizeof pe_opt_hdr
521− +
522− pe->sec_count *
523− sizeof(IMAGE_SECTION_HEADER)
564+ pe->sizeofheaders = pe_file_align(
565+ sizeof pe_header
566+ + pe->sec_count * sizeof (IMAGE_SECTION_HEADER)
524567 );
525568
526569 file_offset = pe->sizeofheaders;
@@ -531,137 +574,132 @@ ST int pe_write_pe(struct pe_info *pe) · 4 unmodified lines
531574 "\n virt file size section" "\n");
532575
533576 for (i = 0; i < pe->sec_count; ++i) {
534− struct section_info *si = pe->sh_info + i;
535− const char *sh_name = pe_sec_names[si->id];
577+ struct section_info *si = pe->sec_info + i;
578+ const char *sh_name = si->name;
536579 unsigned long addr = si->sh_addr - pe->imagebase;
537580 unsigned long size = si->sh_size;
581+ IMAGE_SECTION_HEADER *psh = &si->ish;
538582
539583 if (2 == verbose)
540584 printf("%6lx %6lx %6lx %s\n",
541− addr, file_offset, size, sh_name);
585+ addr, file_offset, size, sh_name);
542586
543− switch (si->id) {
544− case sec_text:
545− pe_opt_hdr.BaseOfCode = addr;
546− pe_opt_hdr.AddressOfEntryPoint = addr + pe->start_addr;
547− break;
587+ switch (si->cls) {
588+ case sec_text:
589+ pe_header.opthdr.BaseOfCode = addr;
590+ pe_header.opthdr.AddressOfEntryPoint = addr + pe->start_addr;
591+ break;
592+
593+ case sec_data:
594+ pe_header.opthdr.BaseOfData = addr;
595+ break;
596+
597+ case sec_bss:
598+ break;
599+
600+ case sec_reloc:
601+ pe_set_datadir(IMAGE_DIRECTORY_ENTRY_BASERELOC, addr, size);
602+ break;
603+
604+ case sec_rsrc:
605+ pe_set_datadir(IMAGE_DIRECTORY_ENTRY_RESOURCE, addr, size);
606+ break;
607+
608+ case sec_stab:
609+ break;
610+ }
548611
549− case sec_data:
550− pe_opt_hdr.BaseOfData = addr;
612+ if (pe->thunk == pe->s1->sections[si->ord]) {
551613 if (pe->imp_size) {
552614 pe_set_datadir(IMAGE_DIRECTORY_ENTRY_IMPORT,
553− pe->imp_offs + addr, pe->imp_size);
615+ pe->imp_offs + addr, pe->imp_size);
554616 pe_set_datadir(IMAGE_DIRECTORY_ENTRY_IAT,
555− pe->iat_offs + addr, pe->iat_size);
617+ pe->iat_offs + addr, pe->iat_size);
556618 }
557619 if (pe->exp_size) {
558620 pe_set_datadir(IMAGE_DIRECTORY_ENTRY_EXPORT,
559− pe->exp_offs + addr, pe->exp_size);
621+ pe->exp_offs + addr, pe->exp_size);
560622 }
561− break;
562−
563− case sec_bss:
564− break;
565−
566− case sec_reloc:
567− pe_set_datadir(IMAGE_DIRECTORY_ENTRY_BASERELOC, addr, size);
568− break;
569−
570− case sec_rsrc:
571− pe_set_datadir(IMAGE_DIRECTORY_ENTRY_RESOURCE, addr, size);
572− break;
573−
574− case sec_stab:
575− break;
576−
577− case sec_stabstr:
578− break;
579623 }
580624
581− psh = &ish[sec_index++];
582− strcpy((char *) psh->Name, sh_name);
625+ strcpy((char*)psh->Name, sh_name);
583626
584− psh->Characteristics = pe_flags[si->id];
627+ psh->Characteristics = pe_sec_flags[si->cls];
585628 psh->VirtualAddress = addr;
586629 psh->Misc.VirtualSize = size;
587− pe_opt_hdr.SizeOfImage =
588− umax(psh->VirtualAddress + psh->Misc.VirtualSize,
589− pe_opt_hdr.SizeOfImage);
630+ pe_header.opthdr.SizeOfImage =
631+ umax(pe_virtual_align(size + addr), pe_header.opthdr.SizeOfImage);
590632
591633 if (si->data_size) {
592− psh->PointerToRawData = file_offset;
634+ psh->PointerToRawData = r = file_offset;
593635 fwrite(si->data, 1, si->data_size, op);
594636 file_offset = pe_file_align(file_offset + si->data_size);
595− psh->SizeOfRawData = file_offset - psh->PointerToRawData;
637+ psh->SizeOfRawData = file_offset - r;
596638 pe_fpad(op, file_offset);
597639 }
598640 }
599641
600− /*----------------------------------------------------- */
601−
602− pe_file_hdr.NumberOfSections = sec_index;
603− pe_opt_hdr.SizeOfHeaders = pe->sizeofheaders;
604− pe_opt_hdr.ImageBase = pe->imagebase;
605− if (PE_DLL == pe_type)
606− pe_file_hdr.Characteristics = 0x230E;
607− else if (PE_GUI != pe_type)
608− pe_opt_hdr.Subsystem = 3;
642+ // pe_header.filehdr.TimeDateStamp = time(NULL);
643+ pe_header.filehdr.NumberOfSections = pe->sec_count;
644+ pe_header.opthdr.SizeOfHeaders = pe->sizeofheaders;
645+ pe_header.opthdr.ImageBase = pe->imagebase;
646+ if (PE_DLL == pe->type)
647+ pe_header.filehdr.Characteristics = 0x230E;
648+ else if (PE_GUI != pe->type)
649+ pe_header.opthdr.Subsystem = 3;
609650
610651 fseek(op, SEEK_SET, 0);
611− fwrite(&pe_dos_hdr, 1, sizeof pe_dos_hdr, op);
612− fwrite(&pe_magic, 1, sizeof pe_magic, op);
613− fwrite(&pe_file_hdr, 1, sizeof pe_file_hdr, op);
614− fwrite(&pe_opt_hdr, 1, sizeof pe_opt_hdr, op);
615− for (i = 0; i < sec_index; ++i)
616− fwrite(&ish[i], 1, sizeof(IMAGE_SECTION_HEADER), op);
617− fclose(op);
652+ fwrite(&pe_header, 1, sizeof pe_header, op);
653+ for (i = 0; i < pe->sec_count; ++i)
654+ fwrite(&pe->sec_info[i].ish, 1, sizeof(IMAGE_SECTION_HEADER), op);
655+ fclose (op);
618656
619657 if (2 == verbose)
620658 printf("-------------------------------\n");
621659 if (verbose)
622− printf("<-- %s (%lu bytes)\n", pe->filename, file_offset);
660+ printf("<- %s (%lu bytes)\n", pe->filename, file_offset);
623661
624662 return 0;
625663 }
626664
627665 /*----------------------------------------------------------------------------*/
628−ST int pe_add_import(struct pe_info *pe, int sym_index, DWORD offset)
666+
667+ST_FN struct import_symbol *pe_add_import(struct pe_info *pe, int sym_index)
629668 {
630669 int i;
631670 int dll_index;
632671 struct pe_import_info *p;
633672 struct import_symbol *s;
634673
635− dll_index =
636− ((Elf32_Sym *) pe->s1->dynsymtab_section->data)[sym_index].
637− st_other;
638− i = dynarray_assoc((void **) pe->imp_info, pe->imp_count, dll_index);
674+ dll_index = ((Elf32_Sym *)pe->s1->dynsymtab_section->data + sym_index)->st_value;
675+ if (0 == dll_index)
676+ return NULL;
677+
678+ i = dynarray_assoc ((void**)pe->imp_info, pe->imp_count, dll_index);
639679 if (-1 != i) {
640680 p = pe->imp_info[i];
641681 goto found_dll;
642682 }
643683 p = tcc_mallocz(sizeof *p);
644684 p->dll_index = dll_index;
645− dynarray_add((void ***) &pe->imp_info, &pe->imp_count, p);
685+ dynarray_add((void***)&pe->imp_info, &pe->imp_count, p);
646686
647− found_dll:
648− i = dynarray_assoc((void **) p->symbols, p->sym_count, sym_index);
687+found_dll:
688+ i = dynarray_assoc ((void**)p->symbols, p->sym_count, sym_index);
649689 if (-1 != i)
650− goto found_sym;
690+ return p->symbols[i];
691+
651692 s = tcc_mallocz(sizeof *s);
693+ dynarray_add((void***)&p->symbols, &p->sym_count, s);
652694 s->sym_index = sym_index;
653− s->offset = offset;
654− dynarray_add((void ***) &p->symbols, &p->sym_count, s);
655−
656− found_sym:
657− return 1;
695+ return s;
658696 }
659697
660698 /*----------------------------------------------------------------------------*/
661−ST void pe_build_imports(struct pe_info *pe)
699+ST_FN void pe_build_imports(struct pe_info *pe)
662700 {
663701 int thk_ptr, ent_ptr, dll_ptr, sym_cnt, i;
664− DWORD voffset = pe->thunk->sh_addr - pe->imagebase;
702+ DWORD rva_base = pe->thunk->sh_addr - pe->imagebase;
665703 int ndlls = pe->imp_count;
666704
667705 for (sym_cnt = i = 0; i < ndlls; ++i)
@@ -676,293 +714,447 @@ ST void pe_build_imports(struct pe_info *pe) · 8 unmodified lines
676714 pe->imp_size = (ndlls + 1) * sizeof(struct pe_import_header);
677715 pe->iat_offs = dll_ptr + pe->imp_size;
678716 pe->iat_size = (sym_cnt + ndlls) * sizeof(DWORD);
679− section_ptr_add(pe->thunk, pe->imp_size + 2 * pe->iat_size);
717+ section_ptr_add(pe->thunk, pe->imp_size + 2*pe->iat_size);
680718
681719 thk_ptr = pe->iat_offs;
682720 ent_ptr = pe->iat_offs + pe->iat_size;
721+
683722 for (i = 0; i < pe->imp_count; ++i) {
684723 struct pe_import_header *hdr;
685724 int k, n, v;
686725 struct pe_import_info *p = pe->imp_info[i];
687− const char *name = pe->s1->loaded_dlls[p->dll_index]->name;
726+ const char *name = pe->s1->loaded_dlls[p->dll_index-1]->name;
688727
689728 /* put the dll name into the import header */
690− if (0 == strncmp(name, "lib", 3))
691− name += 3;
692729 v = put_elf_str(pe->thunk, name);
693730
694− hdr = (struct pe_import_header *) (pe->thunk->data + dll_ptr);
695− hdr->first_thunk = thk_ptr + voffset;
696− hdr->first_entry = ent_ptr + voffset;
697− hdr->lib_name_offset = v + voffset;
731+ hdr = (struct pe_import_header*)(pe->thunk->data + dll_ptr);
732+ hdr->first_thunk = thk_ptr + rva_base;
733+ hdr->first_entry = ent_ptr + rva_base;
734+ hdr->lib_name_offset = v + rva_base;
698735
699736 for (k = 0, n = p->sym_count; k <= n; ++k) {
700737 if (k < n) {
701− DWORD offset = p->symbols[k]->offset;
738+ DWORD iat_index = p->symbols[k]->iat_index;
702739 int sym_index = p->symbols[k]->sym_index;
703− Elf32_Sym *sym =
704− (Elf32_Sym *) pe->s1->dynsymtab_section->data +
705− sym_index;
706− const char *name =
707− pe->s1->dynsymtab_section->link->data + sym->st_name;
708−
709− if (offset & 0x80000000) { /* ref to data */
710− Elf32_Sym *sym =
711− &((Elf32_Sym *) symtab_section->
712− data)[offset & 0x7FFFFFFF];
713− sym->st_value = thk_ptr;
714− sym->st_shndx = pe->thunk->sh_num;
715− } else { /* ref to function */
716−
717− char buffer[100];
718− sprintf(buffer, "IAT.%s", name);
719− sym_index =
720− put_elf_sym(symtab_section, thk_ptr, sizeof(DWORD),
721− ELF32_ST_INFO(STB_GLOBAL, STT_OBJECT),
722− 0, pe->thunk->sh_num, buffer);
723−
724− put_elf_reloc(symtab_section, text_section, offset, R_386_32, /*R_JMP_SLOT, */
725− sym_index);
726− }
727− v = pe->thunk->data_offset + voffset;
728− section_ptr_add(pe->thunk, sizeof(WORD)); /* hint, not used */
740+ Elf32_Sym *imp_sym = (Elf32_Sym *)pe->s1->dynsymtab_section->data + sym_index;
741+ Elf32_Sym *org_sym = (Elf32_Sym *)symtab_section->data + iat_index;
742+ const char *name = pe->s1->dynsymtab_section->link->data + imp_sym->st_name;
743+
744+ org_sym->st_value = thk_ptr;
745+ org_sym->st_shndx = pe->thunk->sh_num;
746+ v = pe->thunk->data_offset + rva_base;
747+ section_ptr_add(pe->thunk, sizeof(WORD)); /* hint, not used */
729748 put_elf_str(pe->thunk, name);
749+
730750 } else {
731− v = 0; // last entry is zero
751+ v = 0; /* last entry is zero */
732752 }
733− *(DWORD *) (pe->thunk->data + thk_ptr) =
734− *(DWORD *) (pe->thunk->data + ent_ptr) = v;
735− thk_ptr += sizeof(DWORD);
736− ent_ptr += sizeof(DWORD);
753+ *(DWORD*)(pe->thunk->data+thk_ptr) =
754+ *(DWORD*)(pe->thunk->data+ent_ptr) = v;
755+ thk_ptr += sizeof (DWORD);
756+ ent_ptr += sizeof (DWORD);
737757 }
738758 dll_ptr += sizeof(struct pe_import_header);
739− dynarray_reset((void ***) &p->symbols, &p->sym_count);
759+ dynarray_reset(&p->symbols, &p->sym_count);
740760 }
741− dynarray_reset((void ***) &pe->imp_info, &pe->imp_count);
761+ dynarray_reset(&pe->imp_info, &pe->imp_count);
742762 }
743763
744764 /* ------------------------------------------------------------- */
745−ST int sym_cmp(const void *va, const void *vb)
765+/*
766+ For now only functions are exported. Export of data
767+ would work, but import requires compiler support to
768+ do an additional indirection.
769+
770+ For instance:
771+ __declspec(dllimport) extern int something;
772+
773+ needs to be translated to:
774+
775+ *(int*)something
776+*/
777+
778+ST_FN int sym_cmp(const void *va, const void *vb)
746779 {
747− Elf32_Sym *sa = (Elf32_Sym *)symtab_section->data + *(int*)va;
748− Elf32_Sym *sb = (Elf32_Sym *)symtab_section->data + *(int*)vb;
749− const char *ca = symtab_section->link->data + sa->st_name;
750− const char *cb = symtab_section->link->data + sb->st_name;
780+ const char *ca = ((const char **)va)[1];
781+ const char *cb = ((const char **)vb)[1];
751782 return strcmp(ca, cb);
752783 }
753784
754−ST void pe_build_exports(struct pe_info *pe)
785+ST_FN void pe_build_exports(struct pe_info *pe)
755786 {
756787 Elf32_Sym *sym;
757− DWORD func_offset, voffset;
788+ int sym_index, sym_end;
789+ DWORD rva_base, func_o, name_o, ord_o, str_o;
758790 struct pe_export_header *hdr;
759− int sym_count, n, ord, *sorted;
791+ int sym_count, n, ord, *sorted, *sp;
760792
761− voffset = pe->thunk->sh_addr - pe->imagebase;
762− sym_count = 0, n = 1, sorted = NULL;
793+ FILE *op;
794+ char buf[MAX_PATH];
795+ const char *dllname;
796+ const char *name;
763797
764− // for simplicity only functions are exported
765− for_sym_in_symtab(sym)
766− {
798+ rva_base = pe->thunk->sh_addr - pe->imagebase;
799+ sym_count = 0, n = 1, sorted = NULL, op = NULL;
800+
801+ sym_end = symtab_section->data_offset / sizeof(Elf32_Sym);
802+ for (sym_index = 1; sym_index < sym_end; ++sym_index) {
803+ sym = (Elf32_Sym*)symtab_section->data + sym_index;
804+ name = symtab_section->link->data + sym->st_name;
767805 if ((sym->st_other & 1)
768− && sym->st_shndx == text_section->sh_num)
806+ /* export only symbols from actually written sections */
807+ && pe->s1->sections[sym->st_shndx]->sh_addr) {
769808 dynarray_add((void***)&sorted, &sym_count, (void*)n);
809+ dynarray_add((void***)&sorted, &sym_count, (void*)name);
810+ }
770811 ++n;
812+#if 0
813+ if (sym->st_other & 1)
814+ printf("export: %s\n", name);
815+ if (sym->st_other & 2)
816+ printf("stdcall: %s\n", name);
817+#endif
771818 }
772819
773820 if (0 == sym_count)
774821 return;
822+ sym_count /= 2;
775823
776− qsort (sorted, sym_count, sizeof sorted[0], sym_cmp);
824+ qsort (sorted, sym_count, 2 * sizeof sorted[0], sym_cmp);
777825 pe_align_section(pe->thunk, 16);
826+ dllname = tcc_basename(pe->filename);
778827
779828 pe->exp_offs = pe->thunk->data_offset;
780− hdr = section_ptr_add(pe->thunk,
781− sizeof(struct pe_export_header) +
782− sym_count * (2 * sizeof(DWORD) + sizeof(WORD)));
783−
784− func_offset = pe->exp_offs + sizeof(struct pe_export_header);
785−
786− hdr->Characteristics = 0;
787− hdr->Base = 1;
788− hdr->NumberOfFunctions = sym_count;
789− hdr->NumberOfNames = sym_count;
790− hdr->AddressOfFunctions = func_offset + voffset;
791− hdr->AddressOfNames = hdr->AddressOfFunctions + sym_count * sizeof(DWORD);
792− hdr->AddressOfNameOrdinals = hdr->AddressOfNames + sym_count * sizeof(DWORD);
793− hdr->Name = pe->thunk->data_offset + voffset;
794− put_elf_str(pe->thunk, tcc_basename(pe->filename));
795−
796− for (ord = 0; ord < sym_count; ++ord)
829+ func_o = pe->exp_offs + sizeof(struct pe_export_header);
830+ name_o = func_o + sym_count * sizeof (DWORD);
831+ ord_o = name_o + sym_count * sizeof (DWORD);
832+ str_o = ord_o + sym_count * sizeof(WORD);
833+
834+ hdr = section_ptr_add(pe->thunk, str_o - pe->exp_offs);
835+ hdr->Characteristics = 0;
836+ hdr->Base = 1;
837+ hdr->NumberOfFunctions = sym_count;
838+ hdr->NumberOfNames = sym_count;
839+ hdr->AddressOfFunctions = func_o + rva_base;
840+ hdr->AddressOfNames = name_o + rva_base;
841+ hdr->AddressOfNameOrdinals = ord_o + rva_base;
842+ hdr->Name = str_o + rva_base;
843+ put_elf_str(pe->thunk, dllname);
844+
845+#if 1
846+ /* automatically write exports to <output-filename>.def */
847+ strcpy(buf, pe->filename);
848+ strcpy(tcc_fileextension(buf), ".def");
849+ op = fopen(buf, "w");
850+ if (NULL == op) {
851+ error_noabort("could not create '%s': %s", buf, strerror(errno));
852+ } else {
853+ fprintf(op, "LIBRARY %s\n\nEXPORTS\n", dllname);
854+ if (verbose)
855+ printf("<- %s (%d symbols)\n", buf, sym_count);
856+ }
857+#endif
858+
859+ for (sp = sorted, ord = 0; ord < sym_count; ++ord, sp += 2)
797860 {
798− char *name; DWORD *p, *pfunc, *pname; WORD *pord;
799− sym = (Elf32_Sym *)symtab_section->data + sorted[ord];
800− name = symtab_section->link->data + sym->st_name;
801− p = (DWORD*)(pe->thunk->data + func_offset);
802− pfunc = p + ord;
803− pname = p + sym_count + ord;
804− pord = (WORD *)(p + 2*sym_count) + ord;
805− *pfunc = sym->st_value + pe->s1->sections[sym->st_shndx]->sh_addr - pe->imagebase;
806− *pname = pe->thunk->data_offset + voffset;
807− *pord = ord;
861+ sym_index = sp[0], name = (const char *)sp[1];
862+ /* insert actual address later in pe_relocate_rva */
863+ put_elf_reloc(symtab_section, pe->thunk,
864+ func_o, R_386_RELATIVE, sym_index);
865+ *(DWORD*)(pe->thunk->data + name_o)
866+ = pe->thunk->data_offset + rva_base;
867+ *(WORD*)(pe->thunk->data + ord_o)
868+ = ord;
808869 put_elf_str(pe->thunk, name);
809− /* printf("export: %s\n", name); */
870+ func_o += sizeof (DWORD);
871+ name_o += sizeof (DWORD);
872+ ord_o += sizeof (WORD);
873+
874+ if (op)
875+ fprintf(op, "%s\n", name);
810876 }
811877 pe->exp_size = pe->thunk->data_offset - pe->exp_offs;
812878 tcc_free(sorted);
813879 }
814880
815881 /* ------------------------------------------------------------- */
816−ST void pe_build_reloc(struct pe_info *pe, int *section_order,
817− int section_count)
882+ST_FN void pe_build_reloc (struct pe_info *pe)
818883 {
819884 DWORD offset, block_ptr, addr;
820885 int count, i;
821886 Elf32_Rel *rel, *rel_end;
822887 Section *s = NULL, *sr;
888+
823889 offset = addr = block_ptr = count = i = 0;
824890 rel = rel_end = NULL;
825− for (;;) {
891+
892+ for(;;) {
826893 if (rel < rel_end) {
827894 int type = ELF32_R_TYPE(rel->r_info);
828895 addr = rel->r_offset + s->sh_addr;
829− ++rel;
896+ ++ rel;
830897 if (type != R_386_32)
831898 continue;
832− if (count == 0) { /* new block */
899+ if (count == 0) { /* new block */
833900 block_ptr = pe->reloc->data_offset;
834901 section_ptr_add(pe->reloc, sizeof(struct pe_reloc_header));
835− offset = addr & 0xFFFFFFFF << 12;
902+ offset = addr & 0xFFFFFFFF<<12;
836903 }
837− if ((addr -= offset) < (1 << 12)) { /* one block spans 4k addresses */
838− WORD *wp = section_ptr_add(pe->reloc, sizeof(WORD));
839− *wp = addr | IMAGE_REL_BASED_HIGHLOW << 12;
904+ if ((addr -= offset) < (1<<12)) { /* one block spans 4k addresses */
905+ WORD *wp = section_ptr_add(pe->reloc, sizeof (WORD));
906+ *wp = addr | IMAGE_REL_BASED_HIGHLOW<<12;
840907 ++count;
841908 continue;
842909 }
843− --rel;
844− } else if (i < section_count) {
845− sr = (s = pe->s1->sections[section_order[i++]])->reloc;
910+ -- rel;
911+
912+ } else if (i < pe->sec_count) {
913+ sr = (s = pe->s1->sections[pe->sec_info[i++].ord])->reloc;
846914 if (sr) {
847− rel = (Elf32_Rel *) sr->data;
848− rel_end = (Elf32_Rel *) (sr->data + sr->data_offset);
915+ rel = (Elf32_Rel *)sr->data;
916+ rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
849917 }
850918 continue;
851919 }
852920
853− if (count) { /* store the last block and ready for a new one */
921+ if (count) {
922+ /* store the last block and ready for a new one */
854923 struct pe_reloc_header *hdr;
855− if (count & 1)
856− section_ptr_add(pe->reloc, 2), ++count;
857− hdr = (struct pe_reloc_header *) (pe->reloc->data + block_ptr);
858− hdr->offset = offset - pe->imagebase;
859− hdr->size =
860− count * sizeof(WORD) + sizeof(struct pe_reloc_header);
924+ if (count & 1) /* align for DWORDS */
925+ section_ptr_add(pe->reloc, sizeof(WORD)), ++count;
926+ hdr = (struct pe_reloc_header *)(pe->reloc->data + block_ptr);
927+ hdr -> offset = offset - pe->imagebase;
928+ hdr -> size = count * sizeof(WORD) + sizeof(struct pe_reloc_header);
861929 count = 0;
862930 }
931+
863932 if (rel >= rel_end)
864933 break;
865934 }
866935 }
867936
868937 /* ------------------------------------------------------------- */
869−ST int pe_assign_addresses(struct pe_info *pe)
938+ST_FN int pe_section_class(Section *s)
870939 {
871− int i, k, n;
940+ int type, flags;
941+ const char *name;
942+
943+ type = s->sh_type;
944+ flags = s->sh_flags;
945+ name = s->name;
946+ if (flags & SHF_ALLOC) {
947+ if (type == SHT_PROGBITS) {
948+ if (flags & SHF_EXECINSTR)
949+ return sec_text;
950+ if (flags & SHF_WRITE)
951+ return sec_data;
952+ if (0 == strcmp(name, ".rsrc"))
953+ return sec_rsrc;
954+ if (0 == strcmp(name, ".iedat"))
955+ return sec_idata;
956+ } else if (type == SHT_NOBITS) {
957+ if (flags & SHF_WRITE)
958+ return sec_bss;
959+ }
960+ } else {
961+ if (0 == strcmp(name, ".reloc"))
962+ return sec_reloc;
963+ if (0 == strncmp(name, ".stab", 5)) /* .stab and .stabstr */
964+ return sec_stab;
965+ }
966+ return -1;
967+}
968+
969+ST_FN int pe_assign_addresses (struct pe_info *pe)
970+{
971+ int i, k, o, c;
872972 DWORD addr;
873− int section_order[pe_sec_number];
874− struct section_info *si_data = NULL;
973+ int *section_order;
974+ struct section_info *si;
975+ Section *s;
976+
977+ // pe->thunk = new_section(pe->s1, ".iedat", SHT_PROGBITS, SHF_ALLOC);
978+
979+ section_order = tcc_malloc(pe->s1->nb_sections * sizeof (int));
980+ for (o = k = 0 ; k < sec_last; ++k) {
981+ for (i = 1; i < pe->s1->nb_sections; ++i) {
982+ s = pe->s1->sections[i];
983+ if (k == pe_section_class(s)) {
984+ // printf("%s %d\n", s->name, k);
985+ s->sh_addr = pe->imagebase;
986+ section_order[o++] = i;
987+ }
988+ }
989+ }
875990
876− pe->imagebase = PE_DLL == pe_type ? 0x10000000 : 0x00400000;
991+ pe->sec_info = tcc_mallocz(o * sizeof (struct section_info));
877992 addr = pe->imagebase + 1;
878993
879− if (PE_DLL == pe_type)
880− pe->reloc = new_section(pe->s1, ".reloc", SHT_DYNAMIC, SHF_ALLOC);
994+ for (i = 0; i < o; ++i)
995+ {
996+ k = section_order[i];
997+ s = pe->s1->sections[k];
998+ c = pe_section_class(s);
999+ si = &pe->sec_info[pe->sec_count];
8811000
882− for (n = k = 0; n < pe_sec_number; ++n) {
883− for (i = 1; i < pe->s1->nb_sections; ++i) {
884− Section *s = pe->s1->sections[i];
885− if (0 == strcmp(s->name, pe_sec_names[n])) {
886− struct section_info *si = &pe->sh_info[pe->sec_count];
8871001 #ifdef PE_MERGE_DATA
888− if (n == sec_bss && si_data) {
889− /* append .bss to .data */
890− s->sh_addr = addr = ((addr - 1) | 15) + 1;
891− addr += s->data_offset;
892− si_data->sh_size = addr - si_data->sh_addr;
893− } else
1002+ if (c == sec_bss && pe->sec_count && si[-1].cls == sec_data) {
1003+ /* append .bss to .data */
1004+ s->sh_addr = addr = ((addr-1) | 15) + 1;
1005+ addr += s->data_offset;
1006+ si[-1].sh_size = addr - si[-1].sh_addr;
1007+ continue;
1008+ }
8941009 #endif
895− {
896− si->sh_addr = s->sh_addr = addr =
897− pe_virtual_align(addr);
898− si->id = n;
899−
900− if (n == sec_data) {
901− pe->thunk = s;
902− si_data = si;
903− pe_build_imports(pe);
904− pe_build_exports(pe);
905− } else if (n == sec_reloc) {
906− pe_build_reloc(pe, section_order, k);
907− }
908−
909− if (s->data_offset) {
910− if (n != sec_bss) {
911− si->data = s->data;
912− si->data_size = s->data_offset;
913− }
914−
915− addr += s->data_offset;
916− si->sh_size = s->data_offset;
917− ++pe->sec_count;
918− }
919− //printf("Section %08X %04X %s\n", si->sh_addr, si->data_size, s->name);
920− }
921− section_order[k] = i, ++k;
1010+ strcpy(si->name, s->name);
1011+ si->cls = c;
1012+ si->ord = k;
1013+ si->sh_addr = s->sh_addr = addr = pe_virtual_align(addr);
1014+ si->sh_flags = s->sh_flags;
1015+
1016+ if (c == sec_data && NULL == pe->thunk)
1017+ pe->thunk = s;
1018+
1019+ if (s == pe->thunk) {
1020+ pe_build_imports(pe);
1021+ pe_build_exports(pe);
1022+ }
1023+
1024+ if (c == sec_reloc)
1025+ pe_build_reloc (pe);
1026+
1027+ if (s->data_offset)
1028+ {
1029+ if (s->sh_type != SHT_NOBITS) {
1030+ si->data = s->data;
1031+ si->data_size = s->data_offset;
9221032 }
1033+
1034+ addr += s->data_offset;
1035+ si->sh_size = s->data_offset;
1036+ ++pe->sec_count;
9231037 }
1038+ // printf("%08x %05x %s\n", si->sh_addr, si->sh_size, si->name);
9241039 }
1040+
1041+#if 0
1042+ for (i = 1; i < pe->s1->nb_sections; ++i) {
1043+ Section *s = pe->s1->sections[i];
1044+ int type = s->sh_type;
1045+ int flags = s->sh_flags;
1046+ printf("section %-16s %-10s %5x %s,%s,%s\n",
1047+ s->name,
1048+ type == SHT_PROGBITS ? "progbits" :
1049+ type == SHT_NOBITS ? "nobits" :
1050+ type == SHT_SYMTAB ? "symtab" :
1051+ type == SHT_STRTAB ? "strtab" :
1052+ type == SHT_REL ? "rel" : "???",
1053+ s->data_offset,
1054+ flags & SHF_ALLOC ? "alloc" : "",
1055+ flags & SHF_WRITE ? "write" : "",
1056+ flags & SHF_EXECINSTR ? "exec" : ""
1057+ );
1058+ }
1059+ verbose = 2;
1060+#endif
1061+
1062+ tcc_free(section_order);
9251063 return 0;
9261064 }
9271065
1066+/* ------------------------------------------------------------- */
1067+ST_FN void pe_relocate_rva (struct pe_info *pe, Section *s)
1068+{
1069+ Section *sr = s->reloc;
1070+ Elf32_Rel *rel, *rel_end;
1071+ rel_end = (Elf32_Rel *)(sr->data + sr->data_offset);
1072+ for(rel = (Elf32_Rel *)sr->data; rel < rel_end; rel++)
1073+ if (ELF32_R_TYPE(rel->r_info) == R_386_RELATIVE) {
1074+ int sym_index = ELF32_R_SYM(rel->r_info);
1075+ DWORD addr = s->sh_addr;
1076+ if (sym_index) {
1077+ Elf32_Sym *sym = (Elf32_Sym *)symtab_section->data + sym_index;
1078+ addr = sym->st_value;
1079+ }
1080+ *(DWORD*)(s->data + rel->r_offset) += addr - pe->imagebase;
1081+ }
1082+}
1083+
9281084 /*----------------------------------------------------------------------------*/
929−ST int pe_check_symbols(struct pe_info *pe)
1085+ST_FN int pe_check_symbols(struct pe_info *pe)
9301086 {
9311087 Elf32_Sym *sym;
1088+ int sym_index, sym_end;
9321089 int ret = 0;
9331090
9341091 pe_align_section(text_section, 8);
9351092
936− for_sym_in_symtab(sym) {
1093+ sym_end = symtab_section->data_offset / sizeof(Elf32_Sym);
1094+ for (sym_index = 1; sym_index < sym_end; ++sym_index) {
1095+
1096+ sym = (Elf32_Sym*)symtab_section->data + sym_index;
9371097 if (sym->st_shndx == SHN_UNDEF) {
938− const char *symbol = symtab_section->link->data + sym->st_name;
1098+
1099+ const char *name = symtab_section->link->data + sym->st_name;
9391100 unsigned type = ELF32_ST_TYPE(sym->st_info);
940− int sym_index = pe_find_import(pe->s1, symbol, NULL);
941− if (sym_index) {
942− if (type == STT_FUNC) {
943− unsigned long offset = text_section->data_offset;
944− if (pe_add_import(pe, sym_index, offset + 2)) {
945− /* add the 'jmp IAT[x]' instruction */
946− *(WORD *) section_ptr_add(text_section, 8) =
947− 0x25FF;
948− /* patch the symbol */
949− sym->st_shndx = text_section->sh_num;
950− sym->st_value = offset;
951− continue;
952− }
953− } else if (type == STT_OBJECT) { /* data, ptr to that should be */
954− if (pe_add_import(pe, sym_index,
955− (sym -
956− (Elf32_Sym *) symtab_section->data) |
957− 0x80000000))
958− continue;
1101+ int imp_sym = pe_find_import(pe->s1, name);
1102+ struct import_symbol *is;
1103+
1104+ if (0 == imp_sym)
1105+ goto not_found;
1106+ is = pe_add_import(pe, imp_sym);
1107+ if (!is)
1108+ goto not_found;
1109+
1110+ if (type == STT_FUNC) {
1111+ unsigned long offset = is->thk_offset;
1112+ if (offset) {
1113+ /* got aliased symbol, like stricmp and _stricmp */
1114+
1115+ } else {
1116+ char buffer[100];
1117+
1118+ offset = text_section->data_offset;
1119+ /* add the 'jmp IAT[x]' instruction */
1120+ *(WORD*)section_ptr_add(text_section, 8) = 0x25FF;
1121+
1122+ /* add a helper symbol, will be patched later in
1123+ pe_build_imports */
1124+ sprintf(buffer, "IAT.%s", name);
1125+ is->iat_index = put_elf_sym(
1126+ symtab_section, 0, sizeof(DWORD),
1127+ ELF32_ST_INFO(STB_GLOBAL, STT_OBJECT),
1128+ 0, SHN_UNDEF, buffer);
1129+ put_elf_reloc(symtab_section, text_section,
1130+ offset + 2, R_386_32, is->iat_index);
1131+ is->thk_offset = offset;
9591132 }
1133+
1134+ /* tcc_realloc might have altered sym's address */
1135+ sym = (Elf32_Sym*)symtab_section->data + sym_index;
1136+
1137+ /* patch the original symbol */
1138+ sym->st_value = offset;
1139+ sym->st_shndx = text_section->sh_num;
1140+ sym->st_other &= ~1; /* do not export */
1141+ continue;
9601142 }
961− error_noabort("undefined symbol '%s'", symbol);
1143+
1144+ if (type == STT_OBJECT) { /* data, ptr to that should be */
1145+ if (0 == is->iat_index) {
1146+ /* original symbol will be patched later in pe_build_imports */
1147+ is->iat_index = sym_index;
1148+ continue;
1149+ }
1150+ }
1151+
1152+ not_found:
1153+ error_noabort("undefined symbol '%s'", name);
9621154 ret = 1;
963− } else
964− if (pe->s1->rdynamic
965− && ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {
1155+
1156+ } else if (pe->s1->rdynamic
1157+ && ELF32_ST_BIND(sym->st_info) != STB_LOCAL) {
9661158 /* if -rdynamic option, then export all non local symbols */
9671159 sym->st_other |= 1;
9681160 }
@@ -972,8 +1164,9 @@ ST int pe_check_symbols(struct pe_info *pe) · 3 unmodified lines
9721164
9731165 /*----------------------------------------------------------------------------*/
9741166 #ifdef PE_PRINT_SECTIONS
975−ST void pe_print_section(FILE * f, Section * s)
976−{ /* just if you'r curious */
1167+ST_FN void pe_print_section(FILE * f, Section * s)
1168+{
1169+ /* just if you'r curious */
9771170 BYTE *p, *e, b;
9781171 int i, n, l, m;
9791172 p = s->data;
@@ -992,6 +1185,9 @@ ST void pe_print_section(FILE * f, Section * s) · 12 unmodified lines
9921185 if (s->sh_type == SHT_NOBITS)
9931186 return;
9941187
1188+ if (0 == l)
1189+ return;
1190+
9951191 if (s->sh_type == SHT_SYMTAB)
9961192 m = sizeof(Elf32_Sym);
9971193 if (s->sh_type == SHT_REL)
@@ -999,7 +1195,49 @@ ST void pe_print_section(FILE * f, Section * s) · 1 unmodified line
9991195 else
10001196 m = 16;
10011197
1002− for (i = 0; i < l;) {
1198+ fprintf(f, "%-8s", "offset");
1199+ for (i = 0; i < m; ++i)
1200+ fprintf(f, " %02x", i);
1201+ n = 56;
1202+
1203+ if (s->sh_type == SHT_SYMTAB || s->sh_type == SHT_REL) {
1204+ const char *fields1[] = {
1205+ "name",
1206+ "value",
1207+ "size",
1208+ "bind",
1209+ "type",
1210+ "other",
1211+ "shndx",
1212+ NULL
1213+ };
1214+
1215+ const char *fields2[] = {
1216+ "offs",
1217+ "type",
1218+ "symb",
1219+ NULL
1220+ };
1221+
1222+ const char **p;
1223+
1224+ if (s->sh_type == SHT_SYMTAB)
1225+ p = fields1, n = 106;
1226+ else
1227+ p = fields2, n = 58;
1228+
1229+ for (i = 0; p[i]; ++i)
1230+ fprintf(f, "%6s", p[i]);
1231+ fprintf(f, " symbol");
1232+ }
1233+
1234+ fprintf(f, "\n");
1235+ for (i = 0; i < n; ++i)
1236+ fprintf(f, "-");
1237+ fprintf(f, "\n");
1238+
1239+ for (i = 0; i < l;)
1240+ {
10031241 fprintf(f, "%08X", i);
10041242 for (n = 0; n < m; ++n) {
10051243 if (n + i < l)
@@ -1011,31 +1249,20 @@ ST void pe_print_section(FILE * f, Section * s) · 5 unmodified lines
10111249 if (s->sh_type == SHT_SYMTAB) {
10121250 Elf32_Sym *sym = (Elf32_Sym *) (p + i);
10131251 const char *name = s->link->data + sym->st_name;
1014− fprintf(f,
1015− " name:%04X"
1016− " value:%04X"
1017− " size:%04X"
1018− " bind:%02X"
1019− " type:%02X"
1020− " other:%02X"
1021− " shndx:%04X"
1022− " \"%s\"",
1252+ fprintf(f, " %04X %04X %04X %02X %02X %02X %04X \"%s\"",
10231253 sym->st_name,
10241254 sym->st_value,
10251255 sym->st_size,
10261256 ELF32_ST_BIND(sym->st_info),
10271257 ELF32_ST_TYPE(sym->st_info),
10281258 sym->st_other, sym->st_shndx, name);
1259+
10291260 } else if (s->sh_type == SHT_REL) {
10301261 Elf32_Rel *rel = (Elf32_Rel *) (p + i);
10311262 Elf32_Sym *sym =
10321263 (Elf32_Sym *) s->link->data + ELF32_R_SYM(rel->r_info);
10331264 const char *name = s->link->link->data + sym->st_name;
1034− fprintf(f,
1035− " offset:%04X"
1036− " type:%02X"
1037− " symbol:%04X"
1038− " \"%s\"",
1265+ fprintf(f, " %04X %02X %04X \"%s\"",
10391266 rel->r_offset,
10401267 ELF32_R_TYPE(rel->r_info),
10411268 ELF32_R_SYM(rel->r_info), name);
@@ -1055,190 +1282,270 @@ ST void pe_print_section(FILE * f, Section * s) · 13 unmodified lines
10551282 }
10561283 fprintf(f, "\n\n");
10571284 }
1285+
1286+ST_FN void pe_print_sections(TCCState *s1, const char *fname)
1287+{
1288+ Section *s;
1289+ FILE *f;
1290+ int i;
1291+ f = fopen(fname, "wt");
1292+ for (i = 1; i < s1->nb_sections; ++i) {
1293+ s = s1->sections[i];
1294+ pe_print_section(f, s);
1295+ }
1296+ pe_print_section(f, s1->dynsymtab_section);
1297+ fclose(f);
1298+}
10581299 #endif
10591300
1060−static int pe_test_cmd(const char **pp, const char *cmd)
1301+/* -------------------------------------------------------------
1302+ * This is for compiled windows resources in 'coff' format
1303+ * as generated by 'windres.exe -O coff ...'.
1304+ */
1305+
1306+PUB_FN int pe_test_res_file(void *v, int size)
10611307 {
1062− const char *p;
1063− char *q, buf[16];
1064− int ret;
1308+ struct pe_rsrc_header *p = (struct pe_rsrc_header *)v;
1309+ return
1310+ size >= IMAGE_SIZEOF_FILE_HEADER + IMAGE_SIZEOF_SHORT_NAME /* = 28 */
1311+ && p->filehdr.Machine == 0x014C
1312+ && 1 == p->filehdr.NumberOfSections
1313+ && 0 == strcmp(p->sectionhdr.Name, ".rsrc")
1314+ ;
1315+}
10651316
1066− p = *pp;
1067− q = buf;
1068− while (*p != '\0' && !is_space(*p)) {
1069− if ((q - buf) < sizeof(buf) - 1)
1070− *q++ = toup(*p);
1071− p++;
1317+ST_FN int read_n(int fd, void *ptr, unsigned size)
1318+{
1319+ return size == read(fd, ptr, size);
1320+}
1321+
1322+PUB_FN int pe_load_res_file(TCCState *s1, int fd)
1323+{
1324+ struct pe_rsrc_header hdr;
1325+ Section *rsrc_section;
1326+ int i, ret = -1;
1327+ BYTE *ptr;
1328+
1329+ lseek (fd, 0, SEEK_SET);
1330+ if (!read_n(fd, &hdr, sizeof hdr))
1331+ goto quit;
1332+ if (!pe_test_res_file(&hdr, sizeof hdr))
1333+ goto quit;
1334+
1335+ rsrc_section = new_section(s1, ".rsrc", SHT_PROGBITS, SHF_ALLOC);
1336+ ptr = section_ptr_add(rsrc_section, hdr.sectionhdr.SizeOfRawData);
1337+ lseek (fd, hdr.sectionhdr.PointerToRawData, SEEK_SET);
1338+ if (!read_n(fd, ptr, hdr.sectionhdr.SizeOfRawData))
1339+ goto quit;
1340+
1341+ lseek (fd, hdr.sectionhdr.PointerToRelocations, SEEK_SET);
1342+ for (i = 0; i < hdr.sectionhdr.NumberOfRelocations; ++i)
1343+ {
1344+ struct pe_rsrc_reloc rel;
1345+ if (!read_n(fd, &rel, sizeof rel))
1346+ goto quit;
1347+ // printf("rsrc_reloc: %x %x %x\n", rel.offset, rel.size, rel.type);
1348+ if (rel.type != 7) /* DIR32NB */
1349+ goto quit;
1350+ put_elf_reloc(symtab_section, rsrc_section,
1351+ rel.offset, R_386_RELATIVE, 0);
10721352 }
1073− *q = '\0';
1074− ret = !strcmp(buf, cmd);
1075− *pp = p;
1353+ ret = 0;
1354+quit:
1355+ if (ret)
1356+ error_noabort("unrecognized resource file format");
10761357 return ret;
10771358 }
10781359
10791360 /* ------------------------------------------------------------- */
1080−int pe_load_def_file(TCCState * s1, FILE * fp)
1361+ST_FN char *trimfront(char *p)
10811362 {
1082− DLLReference *dllref;
1083− int f = 0, sym_index;
1084− char *p, line[120], dllname[40];
1085− while (fgets(line, sizeof line, fp)) {
1086− p = strchr(line, 0);
1087− while (p > line && p[-1] <= ' ')
1088− --p;
1089− *p = 0;
1090− p = line;
1091− while (*p && *p <= ' ')
1092− ++p;
1093−
1094− if (*p && ';' != *p)
1095− switch (f) {
1096− case 0:
1097− if (!pe_test_cmd((const char **)&p, "LIBRARY"))
1098− return -1;
1099− while (is_space(*p))
1100− p++;
1101− pstrcpy(dllname, sizeof(dllname), p);
1102− ++f;
1103− continue;
1363+ while (*p && (unsigned char)*p <= ' ')
1364+ ++p;
1365+ return p;
1366+}
11041367
1105− case 1:
1106− if (!pe_test_cmd((const char **)&p, "EXPORTS"))
1107− return -1;
1108− ++f;
1109− continue;
1368+ST_FN char *trimback(char *a, char *e)
1369+{
1370+ while (e > a && (unsigned char)e[-1] <= ' ')
1371+ --e;
1372+ *e = 0;;
1373+ return a;
1374+}
11101375
1111− case 2:
1112− dllref =
1113− tcc_malloc(sizeof(DLLReference) + strlen(dllname));
1114− strcpy(dllref->name, dllname);
1115− dllref->level = 0;
1116− dynarray_add((void ***) &s1->loaded_dlls,
1117− &s1->nb_loaded_dlls, dllref);
1118− ++f;
1119−
1120− default:
1121− /* tccpe needs to know from what dll it should import
1122− the sym */
1123− sym_index = add_elf_sym(s1->dynsymtab_section,
1124− 0, 0, ELF32_ST_INFO(STB_GLOBAL,
1125− STT_FUNC),
1126− s1->nb_loaded_dlls - 1,
1127− text_section->sh_num, p);
1128− continue;
1129− }
1130− }
1131− return 0;
1376+ST_FN char *get_line(char *line, int size, FILE *fp)
1377+{
1378+ if (NULL == fgets(line, size, fp))
1379+ return NULL;
1380+ trimback(line, strchr(line, 0));
1381+ return trimfront(line);
11321382 }
11331383
11341384 /* ------------------------------------------------------------- */
1135−void pe_guess_outfile(char *objfilename, int output_type)
1385+PUB_FN int pe_load_def_file(TCCState *s1, int fd)
11361386 {
1137− char *ext = strrchr(objfilename, '.');
1138− if (NULL == ext)
1139− ext = strchr(objfilename, 0);
1140− if (output_type == TCC_OUTPUT_DLL)
1141− strcpy(ext, ".dll");
1142− else
1143− if (output_type == TCC_OUTPUT_EXE)
1144− strcpy(ext, ".exe");
1145− else
1146− if (output_type == TCC_OUTPUT_OBJ && strcmp(ext, ".o"))
1147− strcpy(ext, ".o");
1148− else
1149− error("no outputfile given");
1387+ DLLReference *dllref;
1388+ int state = 0, ret = -1;
1389+ char line[400], dllname[80], *p;
1390+ FILE *fp = fdopen(dup(fd), "rb");
1391+
1392+ if (NULL == fp)
1393+ goto quit;
1394+
1395+ for (;;) {
1396+ p = get_line(line, sizeof line, fp);
1397+ if (NULL == p)
1398+ break;
1399+ if (0 == *p || ';' == *p)
1400+ continue;
1401+ switch (state) {
1402+ case 0:
1403+ if (0 != strnicmp(p, "LIBRARY", 7))
1404+ goto quit;
1405+ strcpy(dllname, trimfront(p+7));
1406+ ++state;
1407+ continue;
1408+
1409+ case 1:
1410+ if (0 != stricmp(p, "EXPORTS"))
1411+ goto quit;
1412+ ++state;
1413+ continue;
1414+
1415+ case 2:
1416+ dllref = tcc_malloc(sizeof(DLLReference) + strlen(dllname));
1417+ strcpy(dllref->name, dllname);
1418+ dllref->level = 0;
1419+ dynarray_add((void ***) &s1->loaded_dlls, &s1->nb_loaded_dlls, dllref);
1420+ ++state;
1421+
1422+ default:
1423+ add_elf_sym(s1->dynsymtab_section,
1424+ s1->nb_loaded_dlls, 0,
1425+ ELF32_ST_INFO(STB_GLOBAL, STT_FUNC), 0,
1426+ text_section->sh_num, p);
1427+ continue;
1428+ }
1429+ }
1430+ ret = 0;
1431+quit:
1432+ if (fp)
1433+ fclose(fp);
1434+ if (ret)
1435+ error_noabort("unrecognized export definition file format");
1436+ return ret;
11501437 }
11511438
11521439 /* ------------------------------------------------------------- */
1153−unsigned long pe_add_runtime(TCCState * s1)
1440+
1441+ST_FN void pe_add_runtime_ex(TCCState *s1, struct pe_info *pe)
11541442 {
11551443 const char *start_symbol;
1156− unsigned long addr;
1444+ unsigned long addr = 0;
1445+ int pe_type = 0;
11571446
1158− if (find_elf_sym(symtab_section, "WinMain"))
1447+ if (find_elf_sym(symtab_section, "_WinMain@16"))
11591448 pe_type = PE_GUI;
11601449 else
1161− if (TCC_OUTPUT_DLL == s1->output_type)
1162− {
1450+ if (TCC_OUTPUT_DLL == s1->output_type) {
11631451 pe_type = PE_DLL;
1164− // need this for 'tccelf.c:relocate_section()'
1452+ /* need this for 'tccelf.c:relocate_section()' */
11651453 s1->output_type = TCC_OUTPUT_EXE;
11661454 }
11671455
11681456 start_symbol =
11691457 TCC_OUTPUT_MEMORY == s1->output_type
11701458 ? PE_GUI == pe_type ? "_runwinmain" : NULL
1171− : PE_DLL == pe_type ? "_dllstart"
1172− : PE_GUI == pe_type ? "_winstart" : "_start";
1459+ : PE_DLL == pe_type ? "__dllstart@12"
1460+ : PE_GUI == pe_type ? "_winstart" : "_start"
1461+ ;
11731462
11741463 /* grab the startup code from libtcc1 */
11751464 if (start_symbol)
11761465 add_elf_sym(symtab_section,
1177− 0, 0,
1178− ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
1179− SHN_UNDEF, start_symbol);
1466+ 0, 0,
1467+ ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
1468+ SHN_UNDEF, start_symbol);
11801469
11811470 if (0 == s1->nostdlib) {
11821471 tcc_add_library(s1, "tcc1");
1472+#ifdef __CYGWIN__
1473+ tcc_add_library(s1, "cygwin1");
1474+#else
11831475 tcc_add_library(s1, "msvcrt");
1476+#endif
1477+ tcc_add_library(s1, "kernel32");
11841478 if (PE_DLL == pe_type || PE_GUI == pe_type) {
1185− tcc_add_library(s1, "kernel32");
11861479 tcc_add_library(s1, "user32");
11871480 tcc_add_library(s1, "gdi32");
11881481 }
11891482 }
11901483
1191− addr = start_symbol ?
1192− (unsigned long) tcc_get_symbol_err(s1, start_symbol) : 0;
1193−
1194− if (s1->output_type == TCC_OUTPUT_MEMORY && addr) {
1195− /* for -run GUI's, put '_runwinmain' instead of 'main' */
1196− add_elf_sym(symtab_section,
1484+ if (start_symbol) {
1485+ addr = (unsigned long)tcc_get_symbol_err(s1, start_symbol);
1486+ if (s1->output_type == TCC_OUTPUT_MEMORY && addr)
1487+ /* for -run GUI's, put '_runwinmain' instead of 'main' */
1488+ add_elf_sym(symtab_section,
11971489 addr, 0,
11981490 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE), 0,
11991491 text_section->sh_num, "main");
1492+ }
12001493
1201− /* FreeConsole(); */
1494+ if (pe) {
1495+ pe->type = pe_type;
1496+ pe->start_addr = addr;
12021497 }
1203− return addr;
12041498 }
12051499
1206−int tcc_output_pe(TCCState * s1, const char *filename)
1500+PUB_FN void pe_add_runtime(TCCState *s1)
1501+{
1502+ pe_add_runtime_ex(s1, NULL);
1503+}
1504+
1505+PUB_FN int pe_output_file(TCCState * s1, const char *filename)
12071506 {
12081507 int ret;
12091508 struct pe_info pe;
12101509 int i;
1510+
12111511 memset(&pe, 0, sizeof pe);
12121512 pe.filename = filename;
12131513 pe.s1 = s1;
1214− pe.start_addr = pe_add_runtime(s1);
12151514
1216− relocate_common_syms(); /* assign bss adresses */
1515+ pe_add_runtime_ex(s1, &pe);
1516+ relocate_common_syms(); /* assign bss adresses */
1517+ tcc_add_linker_symbols(s1);
1518+
12171519 ret = pe_check_symbols(&pe);
12181520 if (0 == ret) {
1521+ if (PE_DLL == pe.type) {
1522+ pe.reloc = new_section(pe.s1, ".reloc", SHT_PROGBITS, 0);
1523+ pe.imagebase = 0x10000000;
1524+ } else {
1525+ pe.imagebase = 0x00400000;
1526+ }
12191527 pe_assign_addresses(&pe);
12201528 relocate_syms(s1, 0);
12211529 for (i = 1; i < s1->nb_sections; ++i) {
12221530 Section *s = s1->sections[i];
1223− if (s->reloc)
1531+ if (s->reloc) {
12241532 relocate_section(s1, s);
1533+ pe_relocate_rva(&pe, s);
1534+ }
12251535 }
1226− ret = pe_write_pe(&pe);
1536+ if (s1->nb_errors)
1537+ ret = 1;
1538+ else
1539+ ret = pe_write(&pe);
1540+ tcc_free(pe.sec_info);
12271541 }
1542+
12281543 #ifdef PE_PRINT_SECTIONS
1229− {
1230− Section *s;
1231− FILE *f;
1232− f = fopen("tccpe.log", "wt");
1233− for (i = 1; i < s1->nb_sections; ++i) {
1234− s = s1->sections[i];
1235− pe_print_section(f, s);
1236− }
1237− pe_print_section(f, s1->dynsymtab_section);
1238− fclose(f);
1239− }
1544+ pe_print_sections(s1, "tcc.log");
12401545 #endif
12411546 return ret;
12421547 }
12431548
1244−/*----------------------------------------------------------------------------*/
1549+/* ------------------------------------------------------------- */
1550+#endif /* def TCC_TARGET_PE */
1551+/* ------------------------------------------------------------- */
win32/readme.txt+78−67
@@ -1,115 +1,126 @@
11
2− TinyCC-PE
3− ---------
2+ TinyCC-PE
3+ ---------
44
5− TinyCC (aka TCC) is a small but hyperfast C compiler,
6− written by Fabrice Bellard,
5+ TinyCC (aka TCC) is a small but hyperfast C compiler,
6+ written by Fabrice Bellard,
77
88
9− TinyCC-PE is the TinyCC compiler with an extension to
10− write PE executables for MS-Windows.
9+ TinyCC-PE is the TinyCC compiler with an extension to
10+ write PE executables for MS-Windows.
1111
1212
13− Features:
14− ---------
13+ Features:
14+ ---------
1515
16− TinyCC-PE can produce console applications, native windows
17− GUI programs and DLL's.
16+ TinyCC-PE can produce console applications, native windows
17+ GUI programs and DLL's.
1818
19− Most of the features pointed out by Fabrice Bellard for the
20− original version are still valid, i.e:
19+ Most of the features pointed out by Fabrice Bellard for the
20+ original version are still valid, i.e:
2121
22− - SMALL! The package with ~400kb includes a complete C-compiler
23− with header files for console and GUI applications.
22+ - SMALL! The package with ~400kb includes a complete C-compiler
23+ with header files for console and GUI applications.
2424
25− - With the -run switch you can run C-sources without any
26− linking directly from the command line.
25+ - With the -run switch you can run C-sources without any
26+ linking directly from the command line.
2727
28− - TCC can of course compile itself.
28+ - TCC can of course compile itself.
2929
3030
31− Compilation: (omit that if you use the binary ZIP package)
32− ------------
33−
34− You must use the MinGW and MSYS tools available at
35− http://www.mingw.org to compile TCC for Windows. Untar the TCC
36− archive and type in the MSYS shell:
37−
38− ./configure
39− make
40− make install
31+ Compilation: (omit that if you use the binary ZIP package)
32+ ------------
33+
34+ You must use the MinGW and MSYS tools available at
35+ http://www.mingw.org to compile TCC for Windows. Untar the TCC
36+ archive and type in the MSYS shell:
37+
38+ ./configure
39+ make
40+ make install
4141
42− TCC is installed in c:\Program Files\tcc
42+ TCC is installed in c:\Program Files\tcc
4343
44− Installation: (from the binary ZIP package)
45− -------------
44+ Alternatively you can use win32\build-tcc.bat to compile TCC
45+ with just gcc and ar from MINGW. To install, copy the entire
46+ contents of the win32 directory to where you want.
4647
47− Just unzip the package to a directory anywhere on your computer.
4848
49+ Installation: (from the binary ZIP package)
50+ -------------
4951
50− Examples:
51− ---------
52+ Just unzip the package to a directory anywhere on your computer.
5253
53− For the 'Fibonacci' console example type from the command line:
5454
55− tcc examples\fib.c
55+ Examples:
56+ ---------
5657
58+ For the 'Fibonacci' console example type from the command line:
5759
58− For the 'Hello Windows' GUI example:
60+ tcc examples\fib.c
5961
60− tcc examples\hello_win.c
62+ For the 'Hello Windows' GUI example:
6163
64+ tcc examples\hello_win.c
6265
63− For the 'Hello DLL' example:
66+ For the 'Hello DLL' example:
6467
65− tcc -shared examples\dll.c
66− tcc examples\hello_dll.c examples\dll.def
68+ tcc -shared examples\dll.c
69+ tcc examples\hello_dll.c examples\dll.def
6770
6871
69− Import Definitions:
70− -------------------
72+ Import Definitions:
73+ -------------------
7174
72− TinyCC-PE searches and reads import definition files similar
73− to libraries.
75+ TinyCC-PE searches and reads import definition files similar
76+ to libraries.
7477
75− The included 'tiny_impdef' program may be used to make .def files
76− for any DLL, e.g for an 'opengl32.def':
78+ The included 'tiny_impdef' program may be used to make .def files
79+ for any DLL, e.g for an 'opengl32.def':
7780
78− tiny_impdef.exe opengl32.dll
81+ tiny_impdef.exe opengl32.dll
7982
80− or to the same effect:
83+ or to the same effect:
8184
82− tcc -lkernel32 -run tiny_impdef.c opengl32.dll
85+ tcc -run tiny_impdef.c opengl32.dll
8386
8487
85− Header Files:
86− -------------
88+ Resource Files:
89+ ---------------
8790
88− The system header files, except '_mingw.h', are from the
89− 2.0 mingw distribution. See also: http://www.mingw.org/
91+ TinyCC-PE can now link windows resources in coff format as generated
92+ by MINGW's windres.exe. For example:
9093
94+ windres -O coff app.rc -o appres.o
95+ tcc app.c appres.o -o app.exe
9196
92− Compile TCC:
93− ------------
9497
95− With TCC itself just say:
98+ Header Files:
99+ -------------
96100
97− tcc src\tcc.c -lkernel32 -o tcc.new.exe
101+ The system header files, except '_mingw.h', are from the
102+ 3.7 mingw distribution. See also: http://www.mingw.org/
98103
99− Other compilers like mingw-gcc or msvc work as well.
100− To make libtcc1.a, you need 'ar' from the mingw binutils.
101104
105+ Compile TCC:
106+ ------------
102107
103− Documentation and License:
104− --------------------------
108+ With TCC itself just say:
105109
106− TCC is distributed under the GNU Lesser General Public License
107− (see COPYING file).
110+ tcc src\tcc.c -o tcc.new.exe
108111
109− Please read the original tcc-doc.html to have all the features
110− of TCC. Also visit: http://fabrice.bellard.free.fr/tcc/
112+ Other compilers like mingw-gcc or msvc work as well.
113+ To make libtcc1.a, you need 'ar' from the mingw binutils.
111114
112115
113− --------------------------------------------
114− 09.Apr.2005 - grischka@users.sourceforge.net
116+ Documentation and License:
117+ --------------------------
115118
119+ TCC is distributed under the GNU Lesser General Public License
120+ (see COPYING file).
121+
122+ Please read the original tcc-doc.html to have all the features
123+ of TCC. Also visit: http://fabrice.bellard.free.fr/tcc/
124+
125+ --
126+ grischka@users.sourceforge.net

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t