?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dxgi: Avoid LPCSTR.
[wine.git] / tools / winegcc / winegcc.c
blobbe0d31f2c0cb844aae3270440b79a4963f27070e
1 /*
2 * MinGW wrapper: makes gcc behave like MinGW.
3 *
4 * Copyright 2000 Manuel Novoa III
5 * Copyright 2000 Francois Gouget
6 * Copyright 2002 Dimitrie O. Paun
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 *
22 * DESCRIPTION
23 *
24 * all options for gcc start with '-' and are for the most part
25 * single options (no parameters as separate argument).
26 * There are of course exceptions to this rule, so here is an
27 * exhaustive list of options that do take parameters (potentially)
28 * as a separate argument:
29 *
30 * Compiler:
31 * -x language
32 * -o filename
33 * -aux-info filename
34 *
35 * Preprocessor:
36 * -D name
37 * -U name
38 * -I dir
39 * -MF file
40 * -MT target
41 * -MQ target
42 * (all -i.* arg)
43 * -include file
44 * -imacros file
45 * -idirafter dir
46 * -iwithprefix dir
47 * -iwithprefixbefore dir
48 * -isystem dir
49 * -A predicate=answer
50 *
51 * Linking:
52 * -l library
53 * -Xlinker option
54 * -u symbol
55 *
56 * Misc:
57 * -b machine
58 * -V version
59 * -G num (see NOTES below)
60 *
61 * NOTES
62 * There is -G option for compatibility with System V that
63 * takes no parameters. This makes "-G num" parsing ambiguous.
64 * This option is synonymous to -shared, and as such we will
65 * not support it for now.
66 *
67 * Special interest options
68 *
69 * Assembler Option
70 * -Wa,option
71 *
72 * Linker Options
73 * object-file-name -llibrary -nostartfiles -nodefaultlibs
74 * -nostdlib -s -static -static-libgcc -shared -shared-libgcc
75 * -symbolic -Wl,option -Xlinker option -u symbol --image-base
76 *
77 * Directory Options
78 * -Bprefix -Idir -I- -Ldir -specs=file
79 *
80 * Target Options
81 * -b machine -V version
82 *
83 * Please note that the Target Options are relevant to everything:
84 * compiler, linker, assembler, preprocessor.
85 *
86 */
87
88 #include "config.h"
89 #include "wine/port.h"
90
91 #include <assert.h>
92 #include <stdio.h>
93 #include <stdlib.h>
94 #include <signal.h>
95 #include <stdarg.h>
96 #include <string.h>
97 #include <errno.h>
98
99 #include "utils.h"
100
101 static const char* app_loader_template =
102 "#!/bin/sh\n"
103 "\n"
104 "appname=\"%s\"\n"
105 "# determine the application directory\n"
106 "appdir=''\n"
107 "case \"$0\" in\n"
108 " */*)\n"
109 " # $0 contains a path, use it\n"
110 " appdir=`dirname \"$0\"`\n"
111 " ;;\n"
112 " *)\n"
113 " # no directory in $0, search in PATH\n"
114 " saved_ifs=$IFS\n"
115 " IFS=:\n"
116 " for d in $PATH\n"
117 " do\n"
118 " IFS=$saved_ifs\n"
119 " if [ -x \"$d/$appname\" ]; then appdir=\"$d\"; break; fi\n"
120 " done\n"
121 " ;;\n"
122 "esac\n"
123 "\n"
124 "# figure out the full app path\n"
125 "if [ -n \"$appdir\" ]; then\n"
126 " apppath=\"$appdir/$appname\"\n"
127 " WINEDLLPATH=\"$appdir:$WINEDLLPATH\"\n"
128 " export WINEDLLPATH\n"
129 "else\n"
130 " apppath=\"$appname\"\n"
131 "fi\n"
132 "\n"
133 "# determine the WINELOADER\n"
134 "if [ ! -x \"$WINELOADER\" ]; then WINELOADER=\"wine\"; fi\n"
135 "\n"
136 "# and try to start the app\n"
137 "exec \"$WINELOADER\" \"$apppath\" \"$@\"\n"
138 ;
139
140 static int keep_generated = 0;
141 static strarray* tmp_files;
142 #ifdef HAVE_SIGSET_T
143 static sigset_t signal_mask;
144 #endif
145
146 enum processor { proc_cc, proc_cxx, proc_cpp, proc_as };
147
148 static const struct
149 {
150 const char *name;
151 enum target_cpu cpu;
152 } cpu_names[] =
153 {
154 { "i386", CPU_x86 },
155 { "i486", CPU_x86 },
156 { "i586", CPU_x86 },
157 { "i686", CPU_x86 },
158 { "i786", CPU_x86 },
159 { "amd64", CPU_x86_64 },
160 { "x86_64", CPU_x86_64 },
161 { "powerpc", CPU_POWERPC },
162 { "arm", CPU_ARM },
163 { "aarch64", CPU_ARM64 }
164 };
165
166 static const struct
167 {
168 const char *name;
169 enum target_platform platform;
170 } platform_names[] =
171 {
172 { "macos", PLATFORM_APPLE },
173 { "darwin", PLATFORM_APPLE },
174 { "solaris", PLATFORM_SOLARIS },
175 { "cygwin", PLATFORM_CYGWIN },
176 { "mingw32", PLATFORM_WINDOWS },
177 { "windows", PLATFORM_WINDOWS },
178 { "winnt", PLATFORM_WINDOWS }
179 };
180
181 struct options
182 {
183 enum processor processor;
184 enum target_cpu target_cpu;
185 enum target_platform target_platform;
186 const char *target;
187 const char *version;
188 int shared;
189 int use_msvcrt;
190 int nostdinc;
191 int nostdlib;
192 int nostartfiles;
193 int nodefaultlibs;
194 int noshortwchar;
195 int gui_app;
196 int unicode_app;
197 int win16_app;
198 int compile_only;
199 int force_pointer_size;
200 int large_address_aware;
201 int unwind_tables;
202 int strip;
203 const char* wine_objdir;
204 const char* output_name;
205 const char* image_base;
206 const char* section_align;
207 const char* lib_suffix;
208 strarray* prefix;
209 strarray* lib_dirs;
210 strarray* linker_args;
211 strarray* compiler_args;
212 strarray* winebuild_args;
213 strarray* files;
214 };
215
216 #ifdef __i386__
217 static const enum target_cpu build_cpu = CPU_x86;
218 #elif defined(__x86_64__)
219 static const enum target_cpu build_cpu = CPU_x86_64;
220 #elif defined(__powerpc__)
221 static const enum target_cpu build_cpu = CPU_POWERPC;
222 #elif defined(__arm__)
223 static const enum target_cpu build_cpu = CPU_ARM;
224 #elif defined(__aarch64__)
225 static const enum target_cpu build_cpu = CPU_ARM64;
226 #else
227 #error Unsupported CPU
228 #endif
229
230 #ifdef __APPLE__
231 static enum target_platform build_platform = PLATFORM_APPLE;
232 #elif defined(__sun)
233 static enum target_platform build_platform = PLATFORM_SOLARIS;
234 #elif defined(__CYGWIN__)
235 static enum target_platform build_platform = PLATFORM_CYGWIN;
236 #elif defined(_WIN32)
237 static enum target_platform build_platform = PLATFORM_WINDOWS;
238 #else
239 static enum target_platform build_platform = PLATFORM_UNSPECIFIED;
240 #endif
241
242 static void clean_temp_files(void)
243 {
244 unsigned int i;
245
246 if (keep_generated) return;
247
248 for (i = 0; i < tmp_files->size; i++)
249 unlink(tmp_files->base[i]);
250 }
251
252 /* clean things up when aborting on a signal */
253 static void exit_on_signal( int sig )
254 {
255 exit(1); /* this will call the atexit functions */
256 }
257
258 static char* get_temp_file(const char* prefix, const char* suffix)
259 {
260 int fd;
261 char* tmp = strmake("%s-XXXXXX%s", prefix, suffix);
262
263 #ifdef HAVE_SIGPROCMASK
264 sigset_t old_set;
265 /* block signals while manipulating the temp files list */
266 sigprocmask( SIG_BLOCK, &signal_mask, &old_set );
267 #endif
268 fd = mkstemps( tmp, strlen(suffix) );
269 if (fd == -1)
270 {
271 /* could not create it in current directory, try in /tmp */
272 free(tmp);
273 tmp = strmake("/tmp/%s-XXXXXX%s", prefix, suffix);
274 fd = mkstemps( tmp, strlen(suffix) );
275 if (fd == -1) error( "could not create temp file\n" );
276 }
277 close( fd );
278 strarray_add(tmp_files, tmp);
279 #ifdef HAVE_SIGPROCMASK
280 sigprocmask( SIG_SETMASK, &old_set, NULL );
281 #endif
282 return tmp;
283 }
284
285 static char* build_tool_name(struct options *opts, const char* base, const char* deflt)
286 {
287 char* str;
288
289 if (opts->target && opts->version)
290 {
291 str = strmake("%s-%s-%s", opts->target, base, opts->version);
292 }
293 else if (opts->target)
294 {
295 str = strmake("%s-%s", opts->target, base);
296 }
297 else if (opts->version)
298 {
299 str = strmake("%s-%s", base, opts->version);
300 }
301 else
302 str = xstrdup(deflt);
303 return str;
304 }
305
306 static const strarray* get_translator(struct options *opts)
307 {
308 char *str = NULL;
309 strarray *ret;
310
311 switch(opts->processor)
312 {
313 case proc_cpp:
314 str = build_tool_name(opts, "cpp", CPP);
315 break;
316 case proc_cc:
317 case proc_as:
318 str = build_tool_name(opts, "gcc", CC);
319 break;
320 case proc_cxx:
321 str = build_tool_name(opts, "g++", CXX);
322 break;
323 default:
324 assert(0);
325 }
326 ret = strarray_fromstring( str, " " );
327 free(str);
328 if (opts->force_pointer_size)
329 strarray_add( ret, strmake("-m%u", 8 * opts->force_pointer_size ));
330 return ret;
331 }
332
333 static int try_link( const strarray *prefix, const strarray *link_tool, const char *cflags )
334 {
335 const char *in = get_temp_file( "try_link", ".c" );
336 const char *out = get_temp_file( "try_link", ".out" );
337 const char *err = get_temp_file( "try_link", ".err" );
338 strarray *link = strarray_dup( link_tool );
339 int sout = -1, serr = -1;
340 int ret;
341
342 create_file( in, 0644, "int main(void){return 1;}\n" );
343
344 strarray_add( link, "-o" );
345 strarray_add( link, out );
346 strarray_addall( link, strarray_fromstring( cflags, " " ) );
347 strarray_add( link, in );
348
349 sout = dup( fileno(stdout) );
350 freopen( err, "w", stdout );
351 serr = dup( fileno(stderr) );
352 freopen( err, "w", stderr );
353 ret = spawn( prefix, link, 1 );
354 if (sout >= 0)
355 {
356 dup2( sout, fileno(stdout) );
357 close( sout );
358 }
359 if (serr >= 0)
360 {
361 dup2( serr, fileno(stderr) );
362 close( serr );
363 }
364 strarray_free( link );
365 return ret;
366 }
367
368 static const strarray* get_lddllflags( const struct options *opts, const strarray *link_tool )
369 {
370 strarray *flags = strarray_alloc();
371 switch (opts->target_platform)
372 {
373 case PLATFORM_APPLE:
374 strarray_add( flags, "-bundle" );
375 strarray_add( flags, "-multiply_defined" );
376 strarray_add( flags, "suppress" );
377 if (opts->target_cpu == CPU_POWERPC)
378 {
379 strarray_add( flags, "-read_only_relocs" );
380 strarray_add( flags, "warning" );
381 }
382 break;
383
384 case PLATFORM_SOLARIS:
385 case PLATFORM_UNSPECIFIED:
386 strarray_add( flags, "-shared" );
387 strarray_add( flags, "-Wl,-Bsymbolic" );
388
389 /* Try all options first - this is likely to succeed on modern compilers */
390 if (!try_link( opts->prefix, link_tool, "-fPIC -shared -Wl,-Bsymbolic "
391 "-Wl,-z,defs -Wl,-init,__wine_spec_init,-fini,_wine_spec_fini" ))
392 {
393 strarray_add( flags, "-Wl,-z,defs" );
394 strarray_add( flags, "-Wl,-init,__wine_spec_init,-fini,__wine_spec_fini" );
395 }
396 else /* otherwise figure out which ones are allowed */
397 {
398 if (!try_link( opts->prefix, link_tool, "-fPIC -shared -Wl,-Bsymbolic -Wl,-z,defs" ))
399 strarray_add( flags, "-Wl,-z,defs" );
400 if (!try_link( opts->prefix, link_tool, "-fPIC -shared -Wl,-Bsymbolic "
401 "-Wl,-init,__wine_spec_init,-fini,_wine_spec_fini" ))
402 strarray_add( flags, "-Wl,-init,__wine_spec_init,-fini,__wine_spec_fini" );
403 }
404 break;
405
406 default:
407 assert(0);
408 }
409 return flags;
410 }
411
412 /* check that file is a library for the correct platform */
413 static int check_platform( struct options *opts, const char *file )
414 {
415 int ret = 0, fd = open( file, O_RDONLY );
416 if (fd != -1)
417 {
418 unsigned char header[16];
419 if (read( fd, header, sizeof(header) ) == sizeof(header))
420 {
421 /* FIXME: only ELF is supported, platform is not checked beyond 32/64 */
422 if (!memcmp( header, "\177ELF", 4 ))
423 {
424 if (header[4] == 2) /* 64-bit */
425 ret = (opts->target_cpu == CPU_x86_64 || opts->target_cpu == CPU_ARM64);
426 else
427 ret = (opts->target_cpu != CPU_x86_64 && opts->target_cpu != CPU_ARM64);
428 }
429 }
430 close( fd );
431 }
432 return ret;
433 }
434
435 static char *get_lib_dir( struct options *opts )
436 {
437 static const char *stdlibpath[] = { LIBDIR, "/usr/lib", "/usr/local/lib", "/lib" };
438 static const char libwine[] = "/libwine.so";
439 unsigned int i;
440
441 for (i = 0; i < sizeof(stdlibpath)/sizeof(stdlibpath[0]); i++)
442 {
443 char *p, *buffer = xmalloc( strlen(stdlibpath[i]) + strlen("/arm-linux-gnueabi") + strlen(libwine) + 1 );
444 strcpy( buffer, stdlibpath[i] );
445 p = buffer + strlen(buffer);
446 while (p > buffer && p[-1] == '/') p--;
447 strcpy( p, libwine );
448 if (check_platform( opts, buffer )) goto found;
449 if (p > buffer + 2 && (!memcmp( p - 2, "32", 2 ) || !memcmp( p - 2, "64", 2 ))) p -= 2;
450 if (opts->target_cpu != CPU_x86_64 && opts->target_cpu != CPU_ARM64)
451 {
452 strcpy( p, "32" );
453 strcat( p, libwine );
454 if (check_platform( opts, buffer )) goto found;
455 }
456 if (opts->target_cpu == CPU_x86_64 || opts->target_cpu == CPU_ARM64)
457 {
458 strcpy( p, "64" );
459 strcat( p, libwine );
460 if (check_platform( opts, buffer )) goto found;
461 }
462 switch(opts->target_cpu)
463 {
464 case CPU_x86: strcpy( p, "/i386-linux-gnu" ); break;
465 case CPU_x86_64: strcpy( p, "/x86_64-linux-gnu" ); break;
466 case CPU_ARM: strcpy( p, "/arm-linux-gnueabi" ); break;
467 case CPU_ARM64: strcpy( p, "/aarch64-linux-gnu" ); break;
468 case CPU_POWERPC: strcpy( p, "/powerpc-linux-gnu" ); break;
469 default:
470 assert(0);
471 }
472 strcat( p, libwine );
473 if (check_platform( opts, buffer )) goto found;
474 free( buffer );
475 continue;
476
477 found:
478 buffer[strlen(buffer) - strlen(libwine)] = 0;
479 return buffer;
480 }
481 return xstrdup( LIBDIR );
482 }
483
484 static void compile(struct options* opts, const char* lang)
485 {
486 strarray* comp_args = strarray_alloc();
487 unsigned int i, j;
488 int gcc_defs = 0;
489 strarray* gcc;
490 strarray* gpp;
491
492 strarray_addall(comp_args, get_translator(opts));
493 switch(opts->processor)
494 {
495 case proc_cpp: gcc_defs = 1; break;
496 case proc_as: gcc_defs = 0; break;
497 /* Note: if the C compiler is gcc we assume the C++ compiler is too */
498 /* mixing different C and C++ compilers isn't supported in configure anyway */
499 case proc_cc:
500 case proc_cxx:
501 gcc = strarray_fromstring(build_tool_name(opts, "gcc", CC), " ");
502 gpp = strarray_fromstring(build_tool_name(opts, "g++", CXX), " ");
503 for ( j = 0; !gcc_defs && j < comp_args->size; j++ )
504 {
505 const char *cc = comp_args->base[j];
506
507 for (i = 0; !gcc_defs && i < gcc->size; i++)
508 gcc_defs = gcc->base[i][0] != '-' && strendswith(cc, gcc->base[i]);
509 for (i = 0; !gcc_defs && i < gpp->size; i++)
510 gcc_defs = gpp->base[i][0] != '-' && strendswith(cc, gpp->base[i]);
511 }
512 strarray_free(gcc);
513 strarray_free(gpp);
514 break;
515 }
516
517 if (opts->target_platform == PLATFORM_WINDOWS || opts->target_platform == PLATFORM_CYGWIN)
518 goto no_compat_defines;
519
520 if (opts->processor != proc_cpp)
521 {
522 if (gcc_defs && !opts->wine_objdir && !opts->noshortwchar)
523 {
524 strarray_add(comp_args, "-fshort-wchar");
525 strarray_add(comp_args, "-DWINE_UNICODE_NATIVE");
526 }
527 strarray_add(comp_args, "-D_REENTRANT");
528 strarray_add(comp_args, "-fPIC");
529 }
530
531 if (opts->target_cpu == CPU_x86_64 || opts->target_cpu == CPU_ARM64)
532 {
533 strarray_add(comp_args, "-DWIN64");
534 strarray_add(comp_args, "-D_WIN64");
535 strarray_add(comp_args, "-D__WIN64");
536 strarray_add(comp_args, "-D__WIN64__");
537 }
538
539 strarray_add(comp_args, "-DWIN32");
540 strarray_add(comp_args, "-D_WIN32");
541 strarray_add(comp_args, "-D__WIN32");
542 strarray_add(comp_args, "-D__WIN32__");
543 strarray_add(comp_args, "-D__WINNT");
544 strarray_add(comp_args, "-D__WINNT__");
545
546 if (gcc_defs)
547 {
548 int fastcall_done = 0;
549 if (opts->target_cpu == CPU_x86_64)
550 {
551 strarray_add(comp_args, "-D__stdcall=__attribute__((ms_abi))");
552 strarray_add(comp_args, "-D__cdecl=__attribute__((ms_abi))");
553 strarray_add(comp_args, "-D_stdcall=__attribute__((ms_abi))");
554 strarray_add(comp_args, "-D_cdecl=__attribute__((ms_abi))");
555 strarray_add(comp_args, "-D__fastcall=__attribute__((ms_abi))");
556 strarray_add(comp_args, "-D_fastcall=__attribute__((ms_abi))");
557 fastcall_done = 1;
558 }
559 else if (opts->target_platform == PLATFORM_APPLE)
560 {
561 /* Mac OS X uses a 16-byte aligned stack and not a 4-byte one */
562 strarray_add(comp_args, "-D__stdcall=__attribute__((__stdcall__)) __attribute__((__force_align_arg_pointer__))");
563 strarray_add(comp_args, "-D__cdecl=__attribute__((__cdecl__)) __attribute__((__force_align_arg_pointer__))");
564 strarray_add(comp_args, "-D_stdcall=__attribute__((__stdcall__)) __attribute__((__force_align_arg_pointer__))");
565 strarray_add(comp_args, "-D_cdecl=__attribute__((__cdecl__)) __attribute__((__force_align_arg_pointer__))");
566 }
567 else
568 {
569 strarray_add(comp_args, "-D__stdcall=__attribute__((__stdcall__))");
570 strarray_add(comp_args, "-D__cdecl=__attribute__((__cdecl__))");
571 strarray_add(comp_args, "-D_stdcall=__attribute__((__stdcall__))");
572 strarray_add(comp_args, "-D_cdecl=__attribute__((__cdecl__))");
573 }
574
575 if (!fastcall_done)
576 {
577 strarray_add(comp_args, "-D__fastcall=__attribute__((__fastcall__))");
578 strarray_add(comp_args, "-D_fastcall=__attribute__((__fastcall__))");
579 }
580 strarray_add(comp_args, "-D__declspec(x)=__declspec_##x");
581 strarray_add(comp_args, "-D__declspec_align(x)=__attribute__((aligned(x)))");
582 strarray_add(comp_args, "-D__declspec_allocate(x)=__attribute__((section(x)))");
583 strarray_add(comp_args, "-D__declspec_deprecated=__attribute__((deprecated))");
584 strarray_add(comp_args, "-D__declspec_dllimport=__attribute__((dllimport))");
585 strarray_add(comp_args, "-D__declspec_dllexport=__attribute__((dllexport))");
586 strarray_add(comp_args, "-D__declspec_naked=__attribute__((naked))");
587 strarray_add(comp_args, "-D__declspec_noinline=__attribute__((noinline))");
588 strarray_add(comp_args, "-D__declspec_noreturn=__attribute__((noreturn))");
589 strarray_add(comp_args, "-D__declspec_nothrow=__attribute__((nothrow))");
590 strarray_add(comp_args, "-D__declspec_novtable=__attribute__(())"); /* ignore it */
591 strarray_add(comp_args, "-D__declspec_selectany=__attribute__((weak))");
592 strarray_add(comp_args, "-D__declspec_thread=__thread");
593 }
594
595 strarray_add(comp_args, "-D__int8=char");
596 strarray_add(comp_args, "-D__int16=short");
597 strarray_add(comp_args, "-D__int32=int");
598 if (opts->target_cpu == CPU_x86_64 || opts->target_cpu == CPU_ARM64)
599 strarray_add(comp_args, "-D__int64=long");
600 else
601 strarray_add(comp_args, "-D__int64=long long");
602
603 no_compat_defines:
604 strarray_add(comp_args, "-D__WINE__");
605
606 /* options we handle explicitly */
607 if (opts->compile_only)
608 strarray_add(comp_args, "-c");
609 if (opts->output_name)
610 {
611 strarray_add(comp_args, "-o");
612 strarray_add(comp_args, opts->output_name);
613 }
614
615 /* the rest of the pass-through parameters */
616 for ( j = 0 ; j < opts->compiler_args->size ; j++ )
617 strarray_add(comp_args, opts->compiler_args->base[j]);
618
619 /* the language option, if any */
620 if (lang && strcmp(lang, "-xnone"))
621 strarray_add(comp_args, lang);
622
623 /* last, but not least, the files */
624 for ( j = 0; j < opts->files->size; j++ )
625 {
626 if (opts->files->base[j][0] != '-')
627 strarray_add(comp_args, opts->files->base[j]);
628 }
629
630 /* standard includes come last in the include search path */
631 if (!opts->wine_objdir && !opts->nostdinc)
632 {
633 if (opts->use_msvcrt)
634 {
635 strarray_add(comp_args, gcc_defs ? "-isystem" INCLUDEDIR "/msvcrt" : "-I" INCLUDEDIR "/msvcrt" );
636 strarray_add(comp_args, "-D__MSVCRT__");
637 }
638 strarray_add(comp_args, gcc_defs ? "-isystem" INCLUDEDIR "/windows" : "-I" INCLUDEDIR "/windows" );
639 }
640 else if (opts->wine_objdir)
641 strarray_add(comp_args, strmake("-I%s/include", opts->wine_objdir) );
642
643 spawn(opts->prefix, comp_args, 0);
644 strarray_free(comp_args);
645 }
646
647 static const char* compile_to_object(struct options* opts, const char* file, const char* lang)
648 {
649 struct options copts;
650 char* base_name;
651
652 /* make a copy so we don't change any of the initial stuff */
653 /* a shallow copy is exactly what we want in this case */
654 base_name = get_basename(file);
655 copts = *opts;
656 copts.output_name = get_temp_file(base_name, ".o");
657 copts.compile_only = 1;
658 copts.files = strarray_alloc();
659 strarray_add(copts.files, file);
660 compile(&copts, lang);
661 strarray_free(copts.files);
662 free(base_name);
663
664 return copts.output_name;
665 }
666
667 /* return the initial set of options needed to run winebuild */
668 static strarray *get_winebuild_args(struct options *opts)
669 {
670 const char* winebuild = getenv("WINEBUILD");
671 strarray *spec_args = strarray_alloc();
672
673 if (!winebuild) winebuild = "winebuild";
674 strarray_add( spec_args, winebuild );
675 if (verbose) strarray_add( spec_args, "-v" );
676 if (keep_generated) strarray_add( spec_args, "--save-temps" );
677 if (opts->target)
678 {
679 strarray_add( spec_args, "--target" );
680 strarray_add( spec_args, opts->target );
681 }
682 if (opts->unwind_tables) strarray_add( spec_args, "-fasynchronous-unwind-tables" );
683 else strarray_add( spec_args, "-fno-asynchronous-unwind-tables" );
684 return spec_args;
685 }
686
687 static const char* compile_resources_to_object(struct options* opts, const strarray *resources,
688 const char *res_o_name)
689 {
690 strarray *winebuild_args = get_winebuild_args( opts );
691
692 strarray_add( winebuild_args, "--resources" );
693 strarray_add( winebuild_args, "-o" );
694 strarray_add( winebuild_args, res_o_name );
695 strarray_addall( winebuild_args, resources );
696
697 spawn( opts->prefix, winebuild_args, 0 );
698 strarray_free( winebuild_args );
699 return res_o_name;
700 }
701
702 /* check if there is a static lib associated to a given dll */
703 static char *find_static_lib( const char *dll )
704 {
705 char *lib = strmake("%s.a", dll);
706 if (get_file_type(lib) == file_arh) return lib;
707 free( lib );
708 return NULL;
709 }
710
711 /* add specified library to the list of files */
712 static void add_library( struct options *opts, strarray *lib_dirs, strarray *files, const char *library )
713 {
714 char *static_lib, *fullname = 0;
715
716 switch(get_lib_type(opts->target_platform, lib_dirs, library, opts->lib_suffix, &fullname))
717 {
718 case file_arh:
719 strarray_add(files, strmake("-a%s", fullname));
720 break;
721 case file_dll:
722 strarray_add(files, strmake("-d%s", fullname));
723 if ((static_lib = find_static_lib(fullname)))
724 {
725 strarray_add(files, strmake("-a%s",static_lib));
726 free(static_lib);
727 }
728 break;
729 case file_so:
730 default:
731 /* keep it anyway, the linker may know what to do with it */
732 strarray_add(files, strmake("-l%s", library));
733 break;
734 }
735 free(fullname);
736 }
737
738 /* hack a main or WinMain function to work around Mingw's lack of Unicode support */
739 static const char *mingw_unicode_hack( struct options *opts )
740 {
741 char *main_stub = get_temp_file( opts->output_name, ".c" );
742
743 create_file( main_stub, 0644,
744 "typedef unsigned short wchar_t;\n"
745 "extern void * __stdcall LoadLibraryA(const char *);\n"
746 "extern void * __stdcall GetProcAddress(void *,const char *);\n"
747 "extern int wmain( int argc, wchar_t *argv[] );\n\n"
748 "int main( int argc, char *argv[] )\n{\n"
749 " int wargc;\n"
750 " wchar_t **wargv, **wenv;\n"
751 " void *msvcrt = LoadLibraryA( \"msvcrt.dll\" );\n"
752 " void (*__wgetmainargs)(int *argc, wchar_t** *wargv, wchar_t** *wenvp, int expand_wildcards,\n"
753 " int *new_mode) = GetProcAddress( msvcrt, \"__wgetmainargs\" );\n"
754 " __wgetmainargs( &wargc, &wargv, &wenv, 0, 0 );\n"
755 " return wmain( wargc, wargv );\n}\n" );
756 return compile_to_object( opts, main_stub, NULL );
757 }
758
759 static void build(struct options* opts)
760 {
761 strarray *lib_dirs, *files;
762 strarray *spec_args, *link_args;
763 char *output_file;
764 const char *spec_o_name;
765 const char *output_name, *spec_file, *lang;
766 int generate_app_loader = 1;
767 int fake_module = 0;
768 unsigned int j;
769
770 /* NOTE: for the files array we'll use the following convention:
771 * -axxx: xxx is an archive (.a)
772 * -dxxx: xxx is a DLL (.def)
773 * -lxxx: xxx is an unsorted library
774 * -oxxx: xxx is an object (.o)
775 * -rxxx: xxx is a resource (.res)
776 * -sxxx: xxx is a shared lib (.so)
777 * -xlll: lll is the language (c, c++, etc.)
778 */
779
780 output_file = strdup( opts->output_name ? opts->output_name : "a.out" );
781
782 /* 'winegcc -o app xxx.exe.so' only creates the load script */
783 if (opts->files->size == 1 && strendswith(opts->files->base[0], ".exe.so"))
784 {
785 create_file(output_file, 0755, app_loader_template, opts->files->base[0]);
786 return;
787 }
788
789 /* generate app loader only for .exe */
790 if (opts->shared || strendswith(output_file, ".so"))
791 generate_app_loader = 0;
792
793 if (strendswith(output_file, ".fake")) fake_module = 1;
794
795 /* normalize the filename a bit: strip .so, ensure it has proper ext */
796 if (strendswith(output_file, ".so"))
797 output_file[strlen(output_file) - 3] = 0;
798 if ((output_name = strrchr(output_file, '/'))) output_name++;
799 else output_name = output_file;
800 if (!strchr(output_name, '.'))
801 output_file = strmake("%s.%s", output_file, opts->shared ? "dll" : "exe");
802
803 /* get the filename from the path */
804 if ((output_name = strrchr(output_file, '/'))) output_name++;
805 else output_name = output_file;
806
807 /* prepare the linking path */
808 if (!opts->wine_objdir)
809 {
810 char *lib_dir = get_lib_dir( opts );
811 lib_dirs = strarray_dup(opts->lib_dirs);
812 strarray_add( lib_dirs, strmake( "%s/wine", lib_dir ));
813 strarray_add( lib_dirs, lib_dir );
814 }
815 else
816 {
817 lib_dirs = strarray_alloc();
818 strarray_add(lib_dirs, strmake("%s/dlls", opts->wine_objdir));
819 strarray_add(lib_dirs, strmake("%s/libs/wine", opts->wine_objdir));
820 strarray_addall(lib_dirs, opts->lib_dirs);
821 }
822
823 /* mark the files with their appropriate type */
824 spec_file = lang = 0;
825 files = strarray_alloc();
826 link_args = strarray_alloc();
827 for ( j = 0; j < opts->files->size; j++ )
828 {
829 const char* file = opts->files->base[j];
830 if (file[0] != '-')
831 {
832 switch(get_file_type(file))
833 {
834 case file_def:
835 case file_spec:
836 if (spec_file)
837 error("Only one spec file can be specified\n");
838 spec_file = file;
839 break;
840 case file_rc:
841 /* FIXME: invoke wrc to build it */
842 error("Can't compile .rc file at the moment: %s\n", file);
843 break;
844 case file_res:
845 strarray_add(files, strmake("-r%s", file));
846 break;
847 case file_obj:
848 strarray_add(files, strmake("-o%s", file));
849 break;
850 case file_arh:
851 strarray_add(files, strmake("-a%s", file));
852 break;
853 case file_so:
854 strarray_add(files, strmake("-s%s", file));
855 break;
856 case file_na:
857 error("File does not exist: %s\n", file);
858 break;
859 default:
860 file = compile_to_object(opts, file, lang);
861 strarray_add(files, strmake("-o%s", file));
862 break;
863 }
864 }
865 else if (file[1] == 'l')
866 add_library(opts, lib_dirs, files, file + 2 );
867 else if (file[1] == 'x')
868 lang = file;
869 }
870
871 /* building for Windows is completely different */
872
873 if (opts->target_platform == PLATFORM_WINDOWS || opts->target_platform == PLATFORM_CYGWIN)
874 {
875 strarray *resources = strarray_alloc();
876 char *res_o_name = NULL;
877
878 if (opts->win16_app)
879 error( "Building 16-bit code is not supported for Windows\n" );
880
881 strarray_addall(link_args, get_translator(opts));
882
883 if (opts->shared)
884 {
885 /* run winebuild to generate the .def file */
886 char *spec_def_name = get_temp_file(output_name, ".spec.def");
887 spec_args = get_winebuild_args( opts );
888 strarray_add(spec_args, "--def");
889 strarray_add(spec_args, "-o");
890 strarray_add(spec_args, spec_def_name);
891 if (spec_file)
892 {
893 strarray_add(spec_args, "--export");
894 strarray_add(spec_args, spec_file);
895 }
896 spawn(opts->prefix, spec_args, 0);
897 strarray_free(spec_args);
898
899 strarray_add(link_args, "-shared");
900 if (verbose) strarray_add(link_args, "-v");
901 strarray_add(link_args, "-Wl,--kill-at");
902 strarray_add(link_args, spec_def_name);
903 }
904 else
905 {
906 strarray_add(link_args, opts->gui_app ? "-mwindows" : "-mconsole");
907 if (opts->nodefaultlibs) strarray_add(link_args, "-nodefaultlibs");
908 }
909
910 for ( j = 0 ; j < opts->linker_args->size ; j++ )
911 strarray_add(link_args, opts->linker_args->base[j]);
912
913 strarray_add(link_args, "-o");
914 strarray_add(link_args, output_file);
915
916 if (opts->image_base)
917 strarray_add(link_args, strmake("-Wl,--image-base,%s", opts->image_base));
918
919 if (opts->large_address_aware) strarray_add( link_args, "-Wl,--large-address-aware" );
920
921 if (opts->unicode_app && !opts->shared)
922 strarray_add(link_args, mingw_unicode_hack(opts));
923
924 for ( j = 0; j < lib_dirs->size; j++ )
925 strarray_add(link_args, strmake("-L%s", lib_dirs->base[j]));
926
927 if (!opts->nodefaultlibs)
928 {
929 add_library(opts, lib_dirs, files, "winecrt0");
930 add_library(opts, lib_dirs, files, "kernel32");
931 add_library(opts, lib_dirs, files, "ntdll");
932 }
933 if (opts->shared && !opts->nostdlib) add_library(opts, lib_dirs, files, "wine");
934 if (!opts->shared && opts->use_msvcrt && opts->target_platform == PLATFORM_CYGWIN)
935 add_library(opts, lib_dirs, files, "msvcrt");
936
937 for ( j = 0; j < files->size; j++ )
938 {
939 const char* name = files->base[j] + 2;
940
941 switch(files->base[j][1])
942 {
943 case 'l':
944 case 'd':
945 strarray_add(link_args, strmake("-l%s", name));
946 break;
947 case 's':
948 case 'o':
949 strarray_add(link_args, name);
950 break;
951 case 'a':
952 if (strchr(name, '/'))
953 {
954 /* turn the path back into -Ldir -lfoo options
955 * this makes sure that we use the specified libs even
956 * when mingw adds its own import libs to the link */
957 char *lib = xstrdup( name );
958 char *p = strrchr( lib, '/' );
959
960 *p++ = 0;
961 if (!strncmp( p, "lib", 3 ))
962 {
963 char *ext = strrchr( p, '.' );
964
965 if (ext) *ext = 0;
966 p += 3;
967 strarray_add(link_args, strmake("-L%s", lib ));
968 strarray_add(link_args, strmake("-l%s", p ));
969 free( lib );
970 break;
971 }
972 free( lib );
973 }
974 strarray_add(link_args, name);
975 break;
976 case 'r':
977 if (!res_o_name)
978 {
979 res_o_name = get_temp_file( output_name, ".res.o" );
980 strarray_add( link_args, res_o_name );
981 }
982 strarray_add( resources, name );
983 break;
984 }
985 }
986
987 if (res_o_name) compile_resources_to_object( opts, resources, res_o_name );
988
989 spawn(opts->prefix, link_args, 0);
990 strarray_free (resources);
991 strarray_free (link_args);
992 strarray_free (lib_dirs);
993 strarray_free (files);
994 return;
995 }
996
997 /* add the default libraries, if needed */
998 if (!opts->nostdlib && opts->use_msvcrt) add_library(opts, lib_dirs, files, "msvcrt");
999
1000 if (!opts->wine_objdir && !opts->nodefaultlibs)
1001 {
1002 if (opts->gui_app)
1003 {
1004 add_library(opts, lib_dirs, files, "shell32");
1005 add_library(opts, lib_dirs, files, "comdlg32");
1006 add_library(opts, lib_dirs, files, "gdi32");
1007 }
1008 add_library(opts, lib_dirs, files, "advapi32");
1009 add_library(opts, lib_dirs, files, "user32");
1010 }
1011
1012 if (!opts->nodefaultlibs)
1013 {
1014 add_library(opts, lib_dirs, files, "winecrt0");
1015 if (opts->win16_app) add_library(opts, lib_dirs, files, "kernel");
1016 add_library(opts, lib_dirs, files, "kernel32");
1017 add_library(opts, lib_dirs, files, "ntdll");
1018 }
1019 if (!opts->nostdlib) add_library(opts, lib_dirs, files, "wine");
1020
1021 /* run winebuild to generate the .spec.o file */
1022 spec_args = get_winebuild_args( opts );
1023 strarray_add( spec_args, strmake( "--cc-cmd=%s", build_tool_name( opts, "gcc", CC )));
1024 spec_o_name = get_temp_file(output_name, ".spec.o");
1025 if (opts->force_pointer_size)
1026 strarray_add(spec_args, strmake("-m%u", 8 * opts->force_pointer_size ));
1027 strarray_add(spec_args, "-D_REENTRANT");
1028 strarray_add(spec_args, "-fPIC");
1029 strarray_add(spec_args, opts->shared ? "--dll" : "--exe");
1030 if (fake_module)
1031 {
1032 strarray_add(spec_args, "--fake-module");
1033 strarray_add(spec_args, "-o");
1034 strarray_add(spec_args, output_file);
1035 }
1036 else
1037 {
1038 strarray_add(spec_args, "-o");
1039 strarray_add(spec_args, spec_o_name);
1040 }
1041 if (spec_file)
1042 {
1043 strarray_add(spec_args, "-E");
1044 strarray_add(spec_args, spec_file);
1045 }
1046 if (opts->win16_app) strarray_add(spec_args, "-m16");
1047
1048 if (!opts->shared)
1049 {
1050 strarray_add(spec_args, "-F");
1051 strarray_add(spec_args, output_name);
1052 strarray_add(spec_args, "--subsystem");
1053 strarray_add(spec_args, opts->gui_app ? "windows" : "console");
1054 if (opts->unicode_app)
1055 {
1056 strarray_add(spec_args, "--entry");
1057 strarray_add(spec_args, "__wine_spec_exe_wentry");
1058 }
1059 if (opts->large_address_aware) strarray_add( spec_args, "--large-address-aware" );
1060 }
1061
1062 for ( j = 0; j < lib_dirs->size; j++ )
1063 strarray_add(spec_args, strmake("-L%s", lib_dirs->base[j]));
1064
1065 for ( j = 0 ; j < opts->winebuild_args->size ; j++ )
1066 strarray_add(spec_args, opts->winebuild_args->base[j]);
1067
1068 /* add resource files */
1069 for ( j = 0; j < files->size; j++ )
1070 if (files->base[j][1] == 'r') strarray_add(spec_args, files->base[j]);
1071
1072 /* add other files */
1073 strarray_add(spec_args, "--");
1074 for ( j = 0; j < files->size; j++ )
1075 {
1076 switch(files->base[j][1])
1077 {
1078 case 'd':
1079 case 'a':
1080 case 'o':
1081 strarray_add(spec_args, files->base[j] + 2);
1082 break;
1083 }
1084 }
1085
1086 spawn(opts->prefix, spec_args, 0);
1087 strarray_free (spec_args);
1088 if (fake_module) return; /* nothing else to do */
1089
1090 /* link everything together now */
1091 strarray_addall(link_args, get_translator(opts));
1092 strarray_addall(link_args, get_lddllflags(opts, link_args));
1093
1094 strarray_add(link_args, "-o");
1095 strarray_add(link_args, strmake("%s.so", output_file));
1096
1097 for ( j = 0 ; j < opts->linker_args->size ; j++ )
1098 strarray_add(link_args, opts->linker_args->base[j]);
1099
1100 switch (opts->target_platform)
1101 {
1102 case PLATFORM_APPLE:
1103 if (opts->image_base)
1104 {
1105 strarray_add(link_args, "-image_base");
1106 strarray_add(link_args, opts->image_base);
1107 }
1108 if (opts->strip)
1109 strarray_add(link_args, "-Wl,-x");
1110 break;
1111 case PLATFORM_SOLARIS:
1112 {
1113 char *mapfile = get_temp_file( output_name, ".map" );
1114 const char *align = opts->section_align ? opts->section_align : "0x1000";
1115
1116 create_file( mapfile, 0644, "text = A%s;\ndata = A%s;\n", align, align );
1117 strarray_add(link_args, strmake("-Wl,-M,%s", mapfile));
1118 strarray_add(tmp_files, mapfile);
1119 }
1120 break;
1121 default:
1122 break;
1123 }
1124
1125 for ( j = 0; j < lib_dirs->size; j++ )
1126 strarray_add(link_args, strmake("-L%s", lib_dirs->base[j]));
1127
1128 strarray_add(link_args, spec_o_name);
1129
1130 for ( j = 0; j < files->size; j++ )
1131 {
1132 const char* name = files->base[j] + 2;
1133 switch(files->base[j][1])
1134 {
1135 case 'l':
1136 strarray_add(link_args, strmake("-l%s", name));
1137 break;
1138 case 's':
1139 case 'a':
1140 case 'o':
1141 strarray_add(link_args, name);
1142 break;
1143 }
1144 }
1145
1146 if (!opts->nostdlib)
1147 {
1148 strarray_add(link_args, "-lm");
1149 strarray_add(link_args, "-lc");
1150 }
1151
1152 spawn(opts->prefix, link_args, 0);
1153 strarray_free (link_args);
1154
1155 /* set the base address */
1156 if (opts->image_base && !opts->target)
1157 {
1158 const char *prelink = PRELINK;
1159 if (prelink[0] && strcmp(prelink,"false"))
1160 {
1161 strarray *prelink_args = strarray_alloc();
1162 strarray_add(prelink_args, prelink);
1163 strarray_add(prelink_args, "--reloc-only");
1164 strarray_add(prelink_args, opts->image_base);
1165 strarray_add(prelink_args, strmake("%s.so", output_file));
1166 spawn(opts->prefix, prelink_args, 1);
1167 strarray_free(prelink_args);
1168 }
1169 }
1170
1171 /* create the loader script */
1172 if (generate_app_loader)
1173 create_file(output_file, 0755, app_loader_template, strmake("%s.so", output_name));
1174 }
1175
1176
1177 static void forward(int argc, char **argv, struct options* opts)
1178 {
1179 strarray* args = strarray_alloc();
1180 int j;
1181
1182 strarray_addall(args, get_translator(opts));
1183
1184 for( j = 1; j < argc; j++ )
1185 strarray_add(args, argv[j]);
1186
1187 spawn(opts->prefix, args, 0);
1188 strarray_free (args);
1189 }
1190
1191 /*
1192 * Linker Options
1193 * object-file-name -llibrary -nostartfiles -nodefaultlibs
1194 * -nostdlib -s -static -static-libgcc -shared -shared-libgcc
1195 * -symbolic -Wl,option -Xlinker option -u symbol
1196 * -framework name
1197 */
1198 static int is_linker_arg(const char* arg)
1199 {
1200 static const char* link_switches[] =
1201 {
1202 "-nostartfiles", "-nostdlib", "-s",
1203 "-static", "-static-libgcc", "-shared", "-shared-libgcc", "-symbolic",
1204 "-framework", "--coverage", "-fprofile-generate", "-fprofile-use"
1205 };
1206 unsigned int j;
1207
1208 switch (arg[1])
1209 {
1210 case 'R':
1211 case 'z':
1212 case 'l':
1213 case 'u':
1214 return 1;
1215 case 'W':
1216 if (strncmp("-Wl,", arg, 4) == 0) return 1;
1217 break;
1218 case 'X':
1219 if (strcmp("-Xlinker", arg) == 0) return 1;
1220 break;
1221 case 'a':
1222 if (strcmp("-arch", arg) == 0) return 1;
1223 break;
1224 }
1225
1226 for (j = 0; j < sizeof(link_switches)/sizeof(link_switches[0]); j++)
1227 if (strcmp(link_switches[j], arg) == 0) return 1;
1228
1229 return 0;
1230 }
1231
1232 /*
1233 * Target Options
1234 * -b machine -V version
1235 */
1236 static int is_target_arg(const char* arg)
1237 {
1238 return arg[1] == 'b' || arg[1] == 'V';
1239 }
1240
1241
1242 /*
1243 * Directory Options
1244 * -Bprefix -Idir -I- -Ldir -specs=file
1245 */
1246 static int is_directory_arg(const char* arg)
1247 {
1248 return arg[1] == 'B' || arg[1] == 'L' || arg[1] == 'I' || strncmp("-specs=", arg, 7) == 0;
1249 }
1250
1251 /*
1252 * MinGW Options
1253 * -mno-cygwin -mwindows -mconsole -mthreads -municode
1254 */
1255 static int is_mingw_arg(const char* arg)
1256 {
1257 static const char* mingw_switches[] =
1258 {
1259 "-mno-cygwin", "-mwindows", "-mconsole", "-mthreads", "-municode"
1260 };
1261 unsigned int j;
1262
1263 for (j = 0; j < sizeof(mingw_switches)/sizeof(mingw_switches[0]); j++)
1264 if (strcmp(mingw_switches[j], arg) == 0) return 1;
1265
1266 return 0;
1267 }
1268
1269 static void parse_target_option( struct options *opts, const char *target )
1270 {
1271 char *p, *platform, *spec = xstrdup( target );
1272 unsigned int i;
1273
1274 /* target specification is in the form CPU-MANUFACTURER-OS or CPU-MANUFACTURER-KERNEL-OS */
1275
1276 /* get the CPU part */
1277
1278 if ((p = strchr( spec, '-' )))
1279 {
1280 *p++ = 0;
1281 for (i = 0; i < sizeof(cpu_names)/sizeof(cpu_names[0]); i++)
1282 {
1283 if (!strcmp( cpu_names[i].name, spec ))
1284 {
1285 opts->target_cpu = cpu_names[i].cpu;
1286 break;
1287 }
1288 }
1289 if (i == sizeof(cpu_names)/sizeof(cpu_names[0]))
1290 error( "Unrecognized CPU '%s'\n", spec );
1291 platform = p;
1292 if ((p = strrchr( p, '-' ))) platform = p + 1;
1293 }
1294 else if (!strcmp( spec, "mingw32" ))
1295 {
1296 opts->target_cpu = CPU_x86;
1297 platform = spec;
1298 }
1299 else
1300 error( "Invalid target specification '%s'\n", target );
1301
1302 /* get the OS part */
1303
1304 opts->target_platform = PLATFORM_UNSPECIFIED; /* default value */
1305 for (i = 0; i < sizeof(platform_names)/sizeof(platform_names[0]); i++)
1306 {
1307 if (!strncmp( platform_names[i].name, platform, strlen(platform_names[i].name) ))
1308 {
1309 opts->target_platform = platform_names[i].platform;
1310 break;
1311 }
1312 }
1313
1314 free( spec );
1315 opts->target = xstrdup( target );
1316 }
1317
1318 int main(int argc, char **argv)
1319 {
1320 int i, c, next_is_arg = 0, linking = 1;
1321 int raw_compiler_arg, raw_linker_arg;
1322 const char* option_arg;
1323 struct options opts;
1324 char* lang = 0;
1325 char* str;
1326
1327 #ifdef SIGHUP
1328 signal( SIGHUP, exit_on_signal );
1329 #endif
1330 signal( SIGTERM, exit_on_signal );
1331 signal( SIGINT, exit_on_signal );
1332 #ifdef HAVE_SIGADDSET
1333 sigemptyset( &signal_mask );
1334 sigaddset( &signal_mask, SIGHUP );
1335 sigaddset( &signal_mask, SIGTERM );
1336 sigaddset( &signal_mask, SIGINT );
1337 #endif
1338
1339 /* setup tmp file removal at exit */
1340 tmp_files = strarray_alloc();
1341 atexit(clean_temp_files);
1342
1343 /* initialize options */
1344 memset(&opts, 0, sizeof(opts));
1345 opts.target_cpu = build_cpu;
1346 opts.target_platform = build_platform;
1347 opts.lib_dirs = strarray_alloc();
1348 opts.files = strarray_alloc();
1349 opts.linker_args = strarray_alloc();
1350 opts.compiler_args = strarray_alloc();
1351 opts.winebuild_args = strarray_alloc();
1352
1353 /* determine the processor type */
1354 if (strendswith(argv[0], "winecpp")) opts.processor = proc_cpp;
1355 else if (strendswith(argv[0], "++")) opts.processor = proc_cxx;
1356
1357 /* parse options */
1358 for ( i = 1 ; i < argc ; i++ )
1359 {
1360 if (argv[i][0] == '-') /* option */
1361 {
1362 /* determine if this switch is followed by a separate argument */
1363 next_is_arg = 0;
1364 option_arg = 0;
1365 switch(argv[i][1])
1366 {
1367 case 'x': case 'o': case 'D': case 'U':
1368 case 'I': case 'A': case 'l': case 'u':
1369 case 'b': case 'V': case 'G': case 'L':
1370 case 'B': case 'R': case 'z':
1371 if (argv[i][2]) option_arg = &argv[i][2];
1372 else next_is_arg = 1;
1373 break;
1374 case 'i':
1375 next_is_arg = 1;
1376 break;
1377 case 'a':
1378 if (strcmp("-aux-info", argv[i]) == 0)
1379 next_is_arg = 1;
1380 if (strcmp("-arch", argv[i]) == 0)
1381 next_is_arg = 1;
1382 break;
1383 case 'X':
1384 if (strcmp("-Xlinker", argv[i]) == 0)
1385 next_is_arg = 1;
1386 break;
1387 case 'M':
1388 c = argv[i][2];
1389 if (c == 'F' || c == 'T' || c == 'Q')
1390 {
1391 if (argv[i][3]) option_arg = &argv[i][3];
1392 else next_is_arg = 1;
1393 }
1394 break;
1395 case 'f':
1396 if (strcmp("-framework", argv[i]) == 0)
1397 next_is_arg = 1;
1398 break;
1399 case '-':
1400 if (strcmp("--param", argv[i]) == 0)
1401 next_is_arg = 1;
1402 break;
1403 }
1404 if (next_is_arg)
1405 {
1406 if (i + 1 >= argc) error("option -%c requires an argument\n", argv[i][1]);
1407 option_arg = argv[i+1];
1408 }
1409
1410 /* determine what options go 'as is' to the linker & the compiler */
1411 raw_compiler_arg = raw_linker_arg = 0;
1412 if (is_linker_arg(argv[i]))
1413 {
1414 raw_linker_arg = 1;
1415 }
1416 else
1417 {
1418 if (is_directory_arg(argv[i]) || is_target_arg(argv[i]))
1419 raw_linker_arg = 1;
1420 raw_compiler_arg = !is_mingw_arg(argv[i]);
1421 }
1422
1423 /* these things we handle explicitly so we don't pass them 'as is' */
1424 if (argv[i][1] == 'l' || argv[i][1] == 'I' || argv[i][1] == 'L')
1425 raw_linker_arg = 0;
1426 if (argv[i][1] == 'c' || argv[i][1] == 'L')
1427 raw_compiler_arg = 0;
1428 if (argv[i][1] == 'o' || argv[i][1] == 'b' || argv[i][1] == 'V')
1429 raw_compiler_arg = raw_linker_arg = 0;
1430
1431 /* do a bit of semantic analysis */
1432 switch (argv[i][1])
1433 {
1434 case 'B':
1435 str = strdup(option_arg);
1436 if (strendswith(str, "/")) str[strlen(str) - 1] = 0;
1437 if (strendswith(str, "/tools/winebuild"))
1438 {
1439 char *objdir = strdup(str);
1440 objdir[strlen(objdir) - sizeof("/tools/winebuild") + 1] = 0;
1441 opts.wine_objdir = objdir;
1442 /* don't pass it to the compiler, this generates warnings */
1443 raw_compiler_arg = raw_linker_arg = 0;
1444 }
1445 if (!opts.prefix) opts.prefix = strarray_alloc();
1446 strarray_add(opts.prefix, str);
1447 break;
1448 case 'b':
1449 parse_target_option( &opts, option_arg );
1450 break;
1451 case 'V':
1452 opts.version = xstrdup( option_arg );
1453 break;
1454 case 'c': /* compile or assemble */
1455 if (argv[i][2] == 0) opts.compile_only = 1;
1456 /* fall through */
1457 case 'S': /* generate assembler code */
1458 case 'E': /* preprocess only */
1459 if (argv[i][2] == 0) linking = 0;
1460 break;
1461 case 'f':
1462 if (strcmp("-fno-short-wchar", argv[i]) == 0)
1463 opts.noshortwchar = 1;
1464 else if (!strcmp("-fasynchronous-unwind-tables", argv[i]))
1465 opts.unwind_tables = 1;
1466 else if (!strcmp("-fno-asynchronous-unwind-tables", argv[i]))
1467 opts.unwind_tables = 0;
1468 break;
1469 case 'l':
1470 strarray_add(opts.files, strmake("-l%s", option_arg));
1471 break;
1472 case 'L':
1473 strarray_add(opts.lib_dirs, option_arg);
1474 break;
1475 case 'M': /* map file generation */
1476 linking = 0;
1477 break;
1478 case 'm':
1479 if (strcmp("-mno-cygwin", argv[i]) == 0)
1480 opts.use_msvcrt = 1;
1481 else if (strcmp("-mwindows", argv[i]) == 0)
1482 opts.gui_app = 1;
1483 else if (strcmp("-mconsole", argv[i]) == 0)
1484 opts.gui_app = 0;
1485 else if (strcmp("-municode", argv[i]) == 0)
1486 opts.unicode_app = 1;
1487 else if (strcmp("-m16", argv[i]) == 0)
1488 opts.win16_app = 1;
1489 else if (strcmp("-m32", argv[i]) == 0)
1490 {
1491 if (opts.target_cpu == CPU_x86_64)
1492 opts.target_cpu = CPU_x86;
1493 else if (opts.target_cpu == CPU_ARM64)
1494 opts.target_cpu = CPU_ARM;
1495 opts.force_pointer_size = 4;
1496 raw_linker_arg = 1;
1497 }
1498 else if (strcmp("-m64", argv[i]) == 0)
1499 {
1500 if (opts.target_cpu == CPU_x86)
1501 opts.target_cpu = CPU_x86_64;
1502 else if (opts.target_cpu == CPU_ARM)
1503 opts.target_cpu = CPU_ARM64;
1504 opts.force_pointer_size = 8;
1505 raw_linker_arg = 1;
1506 }
1507 else if (strncmp("-mcpu=", argv[i], 6) == 0)
1508 strarray_add(opts.winebuild_args, argv[i]);
1509 break;
1510 case 'n':
1511 if (strcmp("-nostdinc", argv[i]) == 0)
1512 opts.nostdinc = 1;
1513 else if (strcmp("-nodefaultlibs", argv[i]) == 0)
1514 opts.nodefaultlibs = 1;
1515 else if (strcmp("-nostdlib", argv[i]) == 0)
1516 opts.nostdlib = 1;
1517 else if (strcmp("-nostartfiles", argv[i]) == 0)
1518 opts.nostartfiles = 1;
1519 break;
1520 case 'o':
1521 opts.output_name = option_arg;
1522 break;
1523 case 's':
1524 if (strcmp("-static", argv[i]) == 0)
1525 linking = -1;
1526 else if(strcmp("-save-temps", argv[i]) == 0)
1527 keep_generated = 1;
1528 else if(strcmp("-shared", argv[i]) == 0)
1529 {
1530 opts.shared = 1;
1531 raw_compiler_arg = raw_linker_arg = 0;
1532 }
1533 else if (strcmp("-s", argv[i]) == 0 && opts.target_platform == PLATFORM_APPLE)
1534 {
1535 /* On Mac, change -s into -Wl,-x. ld's -s switch
1536 * is deprecated, and it doesn't work on Tiger with
1537 * MH_BUNDLEs anyway
1538 */
1539 opts.strip = 1;
1540 raw_linker_arg = 0;
1541 }
1542 break;
1543 case 'v':
1544 if (argv[i][2] == 0) verbose++;
1545 break;
1546 case 'W':
1547 if (strncmp("-Wl,", argv[i], 4) == 0)
1548 {
1549 unsigned int j;
1550 strarray* Wl = strarray_fromstring(argv[i] + 4, ",");
1551 for (j = 0; j < Wl->size; j++)
1552 {
1553 if (!strcmp(Wl->base[j], "--image-base") && j < Wl->size - 1)
1554 {
1555 opts.image_base = strdup( Wl->base[++j] );
1556 continue;
1557 }
1558 if (!strcmp(Wl->base[j], "--section-alignment") && j < Wl->size - 1)
1559 {
1560 opts.section_align = strdup( Wl->base[++j] );
1561 continue;
1562 }
1563 if (!strcmp(Wl->base[j], "--large-address-aware"))
1564 {
1565 opts.large_address_aware = 1;
1566 continue;
1567 }
1568 if (!strcmp(Wl->base[j], "-static")) linking = -1;
1569 strarray_add(opts.linker_args, strmake("-Wl,%s",Wl->base[j]));
1570 }
1571 strarray_free(Wl);
1572 raw_compiler_arg = raw_linker_arg = 0;
1573 }
1574 else if (strncmp("-Wb,", argv[i], 4) == 0)
1575 {
1576 strarray* Wb = strarray_fromstring(argv[i] + 4, ",");
1577 strarray_addall(opts.winebuild_args, Wb);
1578 strarray_free(Wb);
1579 /* don't pass it to the compiler, it generates errors */
1580 raw_compiler_arg = raw_linker_arg = 0;
1581 }
1582 break;
1583 case 'x':
1584 lang = strmake("-x%s", option_arg);
1585 strarray_add(opts.files, lang);
1586 /* we'll pass these flags ourselves, explicitly */
1587 raw_compiler_arg = raw_linker_arg = 0;
1588 break;
1589 case '-':
1590 if (strcmp("-static", argv[i]+1) == 0)
1591 linking = -1;
1592 else if (!strncmp("--sysroot", argv[i], 9) && opts.wine_objdir)
1593 {
1594 if (argv[i][9] == '=') opts.wine_objdir = argv[i] + 10;
1595 else opts.wine_objdir = argv[++i];
1596 raw_compiler_arg = raw_linker_arg = 0;
1597 }
1598 else if (!strncmp("--lib-suffix", argv[i], 12) && opts.wine_objdir)
1599 {
1600 if (argv[i][12] == '=') opts.lib_suffix = argv[i] + 13;
1601 else opts.lib_suffix = argv[++i];
1602 raw_compiler_arg = raw_linker_arg = 0;
1603 }
1604 break;
1605 }
1606
1607 /* put the arg into the appropriate bucket */
1608 if (raw_linker_arg)
1609 {
1610 strarray_add(opts.linker_args, argv[i]);
1611 if (next_is_arg && (i + 1 < argc))
1612 strarray_add(opts.linker_args, argv[i + 1]);
1613 }
1614 if (raw_compiler_arg)
1615 {
1616 strarray_add(opts.compiler_args, argv[i]);
1617 if (next_is_arg && (i + 1 < argc))
1618 strarray_add(opts.compiler_args, argv[i + 1]);
1619 }
1620
1621 /* skip the next token if it's an argument */
1622 if (next_is_arg) i++;
1623 }
1624 else
1625 {
1626 strarray_add(opts.files, argv[i]);
1627 }
1628 }
1629
1630 if (opts.processor == proc_cpp) linking = 0;
1631 if (linking == -1) error("Static linking is not supported\n");
1632
1633 if (opts.files->size == 0) forward(argc, argv, &opts);
1634 else if (linking) build(&opts);
1635 else compile(&opts, lang);
1636
1637 return 0;
1638 }
Windows API implementation