| /* |
| * MinGW wrapper: makes gcc behave like MinGW. |
| * |
| * Copyright 2000 Manuel Novoa III |
| * Copyright 2000 Francois Gouget |
| * Copyright 2002 Dimitrie O. Paun |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| * |
| * DESCRIPTION |
| * |
| * all options for gcc start with '-' and are for the most part |
| * single options (no parameters as separate argument). |
| * There are of course exceptions to this rule, so here is an |
| * exhaustive list of options that do take parameters (potentially) |
| * as a separate argument: |
| * |
| * Compiler: |
| * -x language |
| * -o filename |
| * -aux-info filename |
| * |
| * Preprocessor: |
| * -D name |
| * -U name |
| * -I dir |
| * -MF file |
| * -MT target |
| * -MQ target |
| * (all -i.* arg) |
| * -include file |
| * -imacros file |
| * -idirafter dir |
| * -iwithprefix dir |
| * -iwithprefixbefore dir |
| * -isystem dir |
| * -A predicate=answer |
| * |
| * Linking: |
| * -l library |
| * -Xlinker option |
| * -u symbol |
| * |
| * Misc: |
| * -b machine |
| * -V version |
| * -G num (see NOTES below) |
| * |
| * NOTES |
| * There is -G option for compatibility with System V that |
| * takes no parameters. This makes "-G num" parsing ambiguous. |
| * This option is synonymous to -shared, and as such we will |
| * not support it for now. |
| * |
| * Special interest options |
| * |
| * Assembler Option |
| * -Wa,option |
| * |
| * Linker Options |
| * object-file-name -llibrary -nostartfiles -nodefaultlibs |
| * -nostdlib -s -static -static-libgcc -shared -shared-libgcc |
| * -symbolic -Wl,option -Xlinker option -u symbol --image-base |
| * |
| * Directory Options |
| * -Bprefix -Idir -I- -Ldir -specs=file |
| * |
| * Target Options |
| * -b machine -V version |
| * |
| * Please note that the Target Options are relevant to everything: |
| * compiler, linker, assembler, preprocessor. |
| * |
| */ |
| |
| #include "config.h" |
| #include "wine/port.h" |
| |
| #include <assert.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <signal.h> |
| #include <stdarg.h> |
| #include <string.h> |
| #include <errno.h> |
| |
| #include "utils.h" |
| |
| static const char* app_loader_template = |
| "#!/bin/sh\n" |
| "\n" |
| "appname=\"%s\"\n" |
| "# determine the application directory\n" |
| "appdir=''\n" |
| "case \"$0\" in\n" |
| " */*)\n" |
| " # $0 contains a path, use it\n" |
| " appdir=`dirname \"$0\"`\n" |
| " ;;\n" |
| " *)\n" |
| " # no directory in $0, search in PATH\n" |
| " saved_ifs=$IFS\n" |
| " IFS=:\n" |
| " for d in $PATH\n" |
| " do\n" |
| " IFS=$saved_ifs\n" |
| " if [ -x \"$d/$appname\" ]; then appdir=\"$d\"; break; fi\n" |
| " done\n" |
| " ;;\n" |
| "esac\n" |
| "\n" |
| "# figure out the full app path\n" |
| "if [ -n \"$appdir\" ]; then\n" |
| " apppath=\"$appdir/$appname\"\n" |
| " WINEDLLPATH=\"$appdir:$WINEDLLPATH\"\n" |
| " export WINEDLLPATH\n" |
| "else\n" |
| " apppath=\"$appname\"\n" |
| "fi\n" |
| "\n" |
| "# determine the WINELOADER\n" |
| "if [ ! -x \"$WINELOADER\" ]; then WINELOADER=\"wine\"; fi\n" |
| "\n" |
| "# and try to start the app\n" |
| "exec \"$WINELOADER\" \"$apppath\" \"$@\"\n" |
| ; |
| |
| static int keep_generated = 0; |
| static strarray* tmp_files; |
| #ifdef HAVE_SIGSET_T |
| static sigset_t signal_mask; |
| #endif |
| |
| enum processor { proc_cc, proc_cxx, proc_cpp, proc_as }; |
| |
| static const struct |
| { |
| const char *name; |
| enum target_cpu cpu; |
| } cpu_names[] = |
| { |
| { "i386", CPU_x86 }, |
| { "i486", CPU_x86 }, |
| { "i586", CPU_x86 }, |
| { "i686", CPU_x86 }, |
| { "i786", CPU_x86 }, |
| { "amd64", CPU_x86_64 }, |
| { "x86_64", CPU_x86_64 }, |
| { "powerpc", CPU_POWERPC }, |
| { "arm", CPU_ARM }, |
| { "armv5", CPU_ARM }, |
| { "armv6", CPU_ARM }, |
| { "armv7", CPU_ARM }, |
| { "arm64", CPU_ARM64 }, |
| { "aarch64", CPU_ARM64 }, |
| }; |
| |
| static const struct |
| { |
| const char *name; |
| enum target_platform platform; |
| } platform_names[] = |
| { |
| { "macos", PLATFORM_APPLE }, |
| { "darwin", PLATFORM_APPLE }, |
| { "android", PLATFORM_ANDROID }, |
| { "solaris", PLATFORM_SOLARIS }, |
| { "cygwin", PLATFORM_CYGWIN }, |
| { "mingw32", PLATFORM_WINDOWS }, |
| { "windows", PLATFORM_WINDOWS }, |
| { "winnt", PLATFORM_WINDOWS } |
| }; |
| |
| struct options |
| { |
| enum processor processor; |
| enum target_cpu target_cpu; |
| enum target_platform target_platform; |
| const char *target; |
| const char *version; |
| int shared; |
| int use_msvcrt; |
| int nostdinc; |
| int nostdlib; |
| int nostartfiles; |
| int nodefaultlibs; |
| int noshortwchar; |
| int gui_app; |
| int unicode_app; |
| int win16_app; |
| int compile_only; |
| int force_pointer_size; |
| int large_address_aware; |
| int unwind_tables; |
| int strip; |
| const char* wine_objdir; |
| const char* output_name; |
| const char* image_base; |
| const char* section_align; |
| const char* lib_suffix; |
| strarray* prefix; |
| strarray* lib_dirs; |
| strarray* linker_args; |
| strarray* compiler_args; |
| strarray* winebuild_args; |
| strarray* files; |
| }; |
| |
| #ifdef __i386__ |
| static const enum target_cpu build_cpu = CPU_x86; |
| #elif defined(__x86_64__) |
| static const enum target_cpu build_cpu = CPU_x86_64; |
| #elif defined(__powerpc__) |
| static const enum target_cpu build_cpu = CPU_POWERPC; |
| #elif defined(__arm__) |
| static const enum target_cpu build_cpu = CPU_ARM; |
| #elif defined(__aarch64__) |
| static const enum target_cpu build_cpu = CPU_ARM64; |
| #else |
| #error Unsupported CPU |
| #endif |
| |
| #ifdef __APPLE__ |
| static enum target_platform build_platform = PLATFORM_APPLE; |
| #elif defined(__ANDROID__) |
| static enum target_platform build_platform = PLATFORM_ANDROID; |
| #elif defined(__sun) |
| static enum target_platform build_platform = PLATFORM_SOLARIS; |
| #elif defined(__CYGWIN__) |
| static enum target_platform build_platform = PLATFORM_CYGWIN; |
| #elif defined(_WIN32) |
| static enum target_platform build_platform = PLATFORM_WINDOWS; |
| #else |
| static enum target_platform build_platform = PLATFORM_UNSPECIFIED; |
| #endif |
| |
| static void clean_temp_files(void) |
| { |
| unsigned int i; |
| |
| if (keep_generated) return; |
| |
| for (i = 0; i < tmp_files->size; i++) |
| unlink(tmp_files->base[i]); |
| } |
| |
| /* clean things up when aborting on a signal */ |
| static void exit_on_signal( int sig ) |
| { |
| exit(1); /* this will call the atexit functions */ |
| } |
| |
| static char* get_temp_file(const char* prefix, const char* suffix) |
| { |
| int fd; |
| char* tmp = strmake("%s-XXXXXX%s", prefix, suffix); |
| |
| #ifdef HAVE_SIGPROCMASK |
| sigset_t old_set; |
| /* block signals while manipulating the temp files list */ |
| sigprocmask( SIG_BLOCK, &signal_mask, &old_set ); |
| #endif |
| fd = mkstemps( tmp, strlen(suffix) ); |
| if (fd == -1) |
| { |
| /* could not create it in current directory, try in TMPDIR */ |
| const char* tmpdir; |
| |
| free(tmp); |
| if (!(tmpdir = getenv("TMPDIR"))) tmpdir = "/tmp"; |
| tmp = strmake("%s/%s-XXXXXX%s", tmpdir, prefix, suffix); |
| fd = mkstemps( tmp, strlen(suffix) ); |
| if (fd == -1) error( "could not create temp file\n" ); |
| } |
| close( fd ); |
| strarray_add(tmp_files, tmp); |
| #ifdef HAVE_SIGPROCMASK |
| sigprocmask( SIG_SETMASK, &old_set, NULL ); |
| #endif |
| return tmp; |
| } |
| |
| static char* build_tool_name(struct options *opts, const char* base, const char* deflt) |
| { |
| char* str; |
| |
| if (opts->target && opts->version) |
| { |
| str = strmake("%s-%s-%s", opts->target, base, opts->version); |
| } |
| else if (opts->target) |
| { |
| str = strmake("%s-%s", opts->target, base); |
| } |
| else if (opts->version) |
| { |
| str = strmake("%s-%s", base, opts->version); |
| } |
| else |
| str = xstrdup(deflt); |
| return str; |
| } |
| |
| static const strarray* get_translator(struct options *opts) |
| { |
| char *str = NULL; |
| strarray *ret; |
| |
| switch(opts->processor) |
| { |
| case proc_cpp: |
| str = build_tool_name(opts, "cpp", CPP); |
| break; |
| case proc_cc: |
| case proc_as: |
| str = build_tool_name(opts, "gcc", CC); |
| break; |
| case proc_cxx: |
| str = build_tool_name(opts, "g++", CXX); |
| break; |
| default: |
| assert(0); |
| } |
| ret = strarray_fromstring( str, " " ); |
| free(str); |
| if (opts->force_pointer_size) |
| strarray_add( ret, strmake("-m%u", 8 * opts->force_pointer_size )); |
| return ret; |
| } |
| |
| static int try_link( const strarray *prefix, const strarray *link_tool, const char *cflags ) |
| { |
| const char *in = get_temp_file( "try_link", ".c" ); |
| const char *out = get_temp_file( "try_link", ".out" ); |
| const char *err = get_temp_file( "try_link", ".err" ); |
| strarray *link = strarray_dup( link_tool ); |
| int sout = -1, serr = -1; |
| int ret; |
| |
| create_file( in, 0644, "int main(void){return 1;}\n" ); |
| |
| strarray_add( link, "-o" ); |
| strarray_add( link, out ); |
| strarray_addall( link, strarray_fromstring( cflags, " " ) ); |
| strarray_add( link, in ); |
| |
| sout = dup( fileno(stdout) ); |
| freopen( err, "w", stdout ); |
| serr = dup( fileno(stderr) ); |
| freopen( err, "w", stderr ); |
| ret = spawn( prefix, link, 1 ); |
| if (sout >= 0) |
| { |
| dup2( sout, fileno(stdout) ); |
| close( sout ); |
| } |
| if (serr >= 0) |
| { |
| dup2( serr, fileno(stderr) ); |
| close( serr ); |
| } |
| strarray_free( link ); |
| return ret; |
| } |
| |
| static const strarray* get_lddllflags( const struct options *opts, const strarray *link_tool ) |
| { |
| strarray *flags = strarray_alloc(); |
| switch (opts->target_platform) |
| { |
| case PLATFORM_APPLE: |
| strarray_add( flags, "-bundle" ); |
| strarray_add( flags, "-multiply_defined" ); |
| strarray_add( flags, "suppress" ); |
| if (opts->target_cpu == CPU_POWERPC) |
| { |
| strarray_add( flags, "-read_only_relocs" ); |
| strarray_add( flags, "warning" ); |
| } |
| break; |
| |
| case PLATFORM_ANDROID: |
| case PLATFORM_SOLARIS: |
| case PLATFORM_UNSPECIFIED: |
| strarray_add( flags, "-shared" ); |
| strarray_add( flags, "-Wl,-Bsymbolic" ); |
| |
| /* Try all options first - this is likely to succeed on modern compilers */ |
| if (!try_link( opts->prefix, link_tool, "-fPIC -shared -Wl,-Bsymbolic " |
| "-Wl,-z,defs -Wl,-init,__wine_spec_init,-fini,_wine_spec_fini" )) |
| { |
| strarray_add( flags, "-Wl,-z,defs" ); |
| strarray_add( flags, "-Wl,-init,__wine_spec_init,-fini,__wine_spec_fini" ); |
| } |
| else /* otherwise figure out which ones are allowed */ |
| { |
| if (!try_link( opts->prefix, link_tool, "-fPIC -shared -Wl,-Bsymbolic -Wl,-z,defs" )) |
| strarray_add( flags, "-Wl,-z,defs" ); |
| if (!try_link( opts->prefix, link_tool, "-fPIC -shared -Wl,-Bsymbolic " |
| "-Wl,-init,__wine_spec_init,-fini,_wine_spec_fini" )) |
| strarray_add( flags, "-Wl,-init,__wine_spec_init,-fini,__wine_spec_fini" ); |
| } |
| break; |
| |
| default: |
| assert(0); |
| } |
| return flags; |
| } |
| |
| /* check that file is a library for the correct platform */ |
| static int check_platform( struct options *opts, const char *file ) |
| { |
| int ret = 0, fd = open( file, O_RDONLY ); |
| if (fd != -1) |
| { |
| unsigned char header[16]; |
| if (read( fd, header, sizeof(header) ) == sizeof(header)) |
| { |
| /* FIXME: only ELF is supported, platform is not checked beyond 32/64 */ |
| if (!memcmp( header, "\177ELF", 4 )) |
| { |
| if (header[4] == 2) /* 64-bit */ |
| ret = (opts->target_cpu == CPU_x86_64 || opts->target_cpu == CPU_ARM64); |
| else |
| ret = (opts->target_cpu != CPU_x86_64 && opts->target_cpu != CPU_ARM64); |
| } |
| } |
| close( fd ); |
| } |
| return ret; |
| } |
| |
| static char *get_lib_dir( struct options *opts ) |
| { |
| static const char *stdlibpath[] = { LIBDIR, "/usr/lib", "/usr/local/lib", "/lib" }; |
| static const char libwine[] = "/libwine.so"; |
| unsigned int i; |
| |
| for (i = 0; i < sizeof(stdlibpath)/sizeof(stdlibpath[0]); i++) |
| { |
| char *p, *buffer = xmalloc( strlen(stdlibpath[i]) + strlen("/arm-linux-gnueabi") + strlen(libwine) + 1 ); |
| strcpy( buffer, stdlibpath[i] ); |
| p = buffer + strlen(buffer); |
| while (p > buffer && p[-1] == '/') p--; |
| strcpy( p, libwine ); |
| if (check_platform( opts, buffer )) goto found; |
| if (p > buffer + 2 && (!memcmp( p - 2, "32", 2 ) || !memcmp( p - 2, "64", 2 ))) p -= 2; |
| if (opts->target_cpu != CPU_x86_64 && opts->target_cpu != CPU_ARM64) |
| { |
| strcpy( p, "32" ); |
| strcat( p, libwine ); |
| if (check_platform( opts, buffer )) goto found; |
| } |
| if (opts->target_cpu == CPU_x86_64 || opts->target_cpu == CPU_ARM64) |
| { |
| strcpy( p, "64" ); |
| strcat( p, libwine ); |
| if (check_platform( opts, buffer )) goto found; |
| } |
| switch(opts->target_cpu) |
| { |
| case CPU_x86: strcpy( p, "/i386-linux-gnu" ); break; |
| case CPU_x86_64: strcpy( p, "/x86_64-linux-gnu" ); break; |
| case CPU_ARM: strcpy( p, "/arm-linux-gnueabi" ); break; |
| case CPU_ARM64: strcpy( p, "/aarch64-linux-gnu" ); break; |
| case CPU_POWERPC: strcpy( p, "/powerpc-linux-gnu" ); break; |
| default: |
| assert(0); |
| } |
| strcat( p, libwine ); |
| if (check_platform( opts, buffer )) goto found; |
| free( buffer ); |
| continue; |
| |
| found: |
| buffer[strlen(buffer) - strlen(libwine)] = 0; |
| return buffer; |
| } |
| return xstrdup( LIBDIR ); |
| } |
| |
| static void compile(struct options* opts, const char* lang) |
| { |
| strarray* comp_args = strarray_alloc(); |
| unsigned int i, j; |
| int gcc_defs = 0; |
| strarray* gcc; |
| strarray* gpp; |
| |
| strarray_addall(comp_args, get_translator(opts)); |
| switch(opts->processor) |
| { |
| case proc_cpp: gcc_defs = 1; break; |
| case proc_as: gcc_defs = 0; break; |
| /* Note: if the C compiler is gcc we assume the C++ compiler is too */ |
| /* mixing different C and C++ compilers isn't supported in configure anyway */ |
| case proc_cc: |
| case proc_cxx: |
| gcc = strarray_fromstring(build_tool_name(opts, "gcc", CC), " "); |
| gpp = strarray_fromstring(build_tool_name(opts, "g++", CXX), " "); |
| for ( j = 0; !gcc_defs && j < comp_args->size; j++ ) |
| { |
| const char *cc = comp_args->base[j]; |
| |
| for (i = 0; !gcc_defs && i < gcc->size; i++) |
| gcc_defs = gcc->base[i][0] != '-' && strendswith(cc, gcc->base[i]); |
| for (i = 0; !gcc_defs && i < gpp->size; i++) |
| gcc_defs = gpp->base[i][0] != '-' && strendswith(cc, gpp->base[i]); |
| } |
| strarray_free(gcc); |
| strarray_free(gpp); |
| break; |
| } |
| |
| if (opts->target_platform == PLATFORM_WINDOWS || opts->target_platform == PLATFORM_CYGWIN) |
| goto no_compat_defines; |
| |
| if (opts->processor != proc_cpp) |
| { |
| if (gcc_defs && !opts->wine_objdir && !opts->noshortwchar) |
| { |
| strarray_add(comp_args, "-fshort-wchar"); |
| strarray_add(comp_args, "-DWINE_UNICODE_NATIVE"); |
| } |
| strarray_add(comp_args, "-D_REENTRANT"); |
| strarray_add(comp_args, "-fPIC"); |
| } |
| |
| if (opts->target_cpu == CPU_x86_64 || opts->target_cpu == CPU_ARM64) |
| { |
| strarray_add(comp_args, "-DWIN64"); |
| strarray_add(comp_args, "-D_WIN64"); |
| strarray_add(comp_args, "-D__WIN64"); |
| strarray_add(comp_args, "-D__WIN64__"); |
| } |
| |
| strarray_add(comp_args, "-DWIN32"); |
| strarray_add(comp_args, "-D_WIN32"); |
| strarray_add(comp_args, "-D__WIN32"); |
| strarray_add(comp_args, "-D__WIN32__"); |
| strarray_add(comp_args, "-D__WINNT"); |
| strarray_add(comp_args, "-D__WINNT__"); |
| |
| if (gcc_defs) |
| { |
| switch (opts->target_cpu) |
| { |
| case CPU_x86_64: |
| strarray_add(comp_args, "-D__stdcall=__attribute__((ms_abi))"); |
| strarray_add(comp_args, "-D__cdecl=__attribute__((ms_abi))"); |
| strarray_add(comp_args, "-D_stdcall=__attribute__((ms_abi))"); |
| strarray_add(comp_args, "-D_cdecl=__attribute__((ms_abi))"); |
| strarray_add(comp_args, "-D__fastcall=__attribute__((ms_abi))"); |
| strarray_add(comp_args, "-D_fastcall=__attribute__((ms_abi))"); |
| break; |
| case CPU_x86: |
| strarray_add(comp_args, "-D__stdcall=__attribute__((__stdcall__)) __attribute__((__force_align_arg_pointer__))"); |
| strarray_add(comp_args, "-D__cdecl=__attribute__((__cdecl__)) __attribute__((__force_align_arg_pointer__))"); |
| strarray_add(comp_args, "-D_stdcall=__attribute__((__stdcall__)) __attribute__((__force_align_arg_pointer__))"); |
| strarray_add(comp_args, "-D_cdecl=__attribute__((__cdecl__)) __attribute__((__force_align_arg_pointer__))"); |
| strarray_add(comp_args, "-D__fastcall=__attribute__((__fastcall__))"); |
| strarray_add(comp_args, "-D_fastcall=__attribute__((__fastcall__))"); |
| break; |
| case CPU_ARM: |
| case CPU_ARM64: |
| case CPU_POWERPC: |
| strarray_add(comp_args, "-D__stdcall="); |
| strarray_add(comp_args, "-D__cdecl="); |
| strarray_add(comp_args, "-D_stdcall="); |
| strarray_add(comp_args, "-D_cdecl="); |
| strarray_add(comp_args, "-D__fastcall="); |
| strarray_add(comp_args, "-D_fastcall="); |
| break; |
| } |
| strarray_add(comp_args, "-D__declspec(x)=__declspec_##x"); |
| strarray_add(comp_args, "-D__declspec_align(x)=__attribute__((aligned(x)))"); |
| strarray_add(comp_args, "-D__declspec_allocate(x)=__attribute__((section(x)))"); |
| strarray_add(comp_args, "-D__declspec_deprecated=__attribute__((deprecated))"); |
| strarray_add(comp_args, "-D__declspec_dllimport=__attribute__((dllimport))"); |
| strarray_add(comp_args, "-D__declspec_dllexport=__attribute__((dllexport))"); |
| strarray_add(comp_args, "-D__declspec_naked=__attribute__((naked))"); |
| strarray_add(comp_args, "-D__declspec_noinline=__attribute__((noinline))"); |
| strarray_add(comp_args, "-D__declspec_noreturn=__attribute__((noreturn))"); |
| strarray_add(comp_args, "-D__declspec_nothrow=__attribute__((nothrow))"); |
| strarray_add(comp_args, "-D__declspec_novtable=__attribute__(())"); /* ignore it */ |
| strarray_add(comp_args, "-D__declspec_selectany=__attribute__((weak))"); |
| strarray_add(comp_args, "-D__declspec_thread=__thread"); |
| } |
| |
| strarray_add(comp_args, "-D__int8=char"); |
| strarray_add(comp_args, "-D__int16=short"); |
| strarray_add(comp_args, "-D__int32=int"); |
| if (opts->target_cpu == CPU_x86_64 || opts->target_cpu == CPU_ARM64) |
| strarray_add(comp_args, "-D__int64=long"); |
| else |
| strarray_add(comp_args, "-D__int64=long long"); |
| |
| no_compat_defines: |
| strarray_add(comp_args, "-D__WINE__"); |
| |
| /* options we handle explicitly */ |
| if (opts->compile_only) |
| strarray_add(comp_args, "-c"); |
| if (opts->output_name) |
| { |
| strarray_add(comp_args, "-o"); |
| strarray_add(comp_args, opts->output_name); |
| } |
| |
| /* the rest of the pass-through parameters */ |
| for ( j = 0 ; j < opts->compiler_args->size ; j++ ) |
| strarray_add(comp_args, opts->compiler_args->base[j]); |
| |
| /* the language option, if any */ |
| if (lang && strcmp(lang, "-xnone")) |
| strarray_add(comp_args, lang); |
| |
| /* last, but not least, the files */ |
| for ( j = 0; j < opts->files->size; j++ ) |
| { |
| if (opts->files->base[j][0] != '-') |
| strarray_add(comp_args, opts->files->base[j]); |
| } |
| |
| /* standard includes come last in the include search path */ |
| if (!opts->wine_objdir && !opts->nostdinc) |
| { |
| if (opts->use_msvcrt) |
| { |
| strarray_add(comp_args, gcc_defs ? "-isystem" INCLUDEDIR "/msvcrt" : "-I" INCLUDEDIR "/msvcrt" ); |
| strarray_add(comp_args, "-D__MSVCRT__"); |
| } |
| strarray_add(comp_args, gcc_defs ? "-isystem" INCLUDEDIR "/windows" : "-I" INCLUDEDIR "/windows" ); |
| } |
| else if (opts->wine_objdir) |
| strarray_add(comp_args, strmake("-I%s/include", opts->wine_objdir) ); |
| |
| spawn(opts->prefix, comp_args, 0); |
| strarray_free(comp_args); |
| } |
| |
| static const char* compile_to_object(struct options* opts, const char* file, const char* lang) |
| { |
| struct options copts; |
| char* base_name; |
| |
| /* make a copy so we don't change any of the initial stuff */ |
| /* a shallow copy is exactly what we want in this case */ |
| base_name = get_basename(file); |
| copts = *opts; |
| copts.output_name = get_temp_file(base_name, ".o"); |
| copts.compile_only = 1; |
| copts.files = strarray_alloc(); |
| strarray_add(copts.files, file); |
| compile(&copts, lang); |
| strarray_free(copts.files); |
| free(base_name); |
| |
| return copts.output_name; |
| } |
| |
| /* return the initial set of options needed to run winebuild */ |
| static strarray *get_winebuild_args(struct options *opts) |
| { |
| const char* winebuild = getenv("WINEBUILD"); |
| strarray *spec_args = strarray_alloc(); |
| |
| if (!winebuild) winebuild = "winebuild"; |
| strarray_add( spec_args, winebuild ); |
| if (verbose) strarray_add( spec_args, "-v" ); |
| if (keep_generated) strarray_add( spec_args, "--save-temps" ); |
| if (opts->target) |
| { |
| strarray_add( spec_args, "--target" ); |
| strarray_add( spec_args, opts->target ); |
| } |
| if (opts->unwind_tables) strarray_add( spec_args, "-fasynchronous-unwind-tables" ); |
| else strarray_add( spec_args, "-fno-asynchronous-unwind-tables" ); |
| return spec_args; |
| } |
| |
| static const char* compile_resources_to_object(struct options* opts, const strarray *resources, |
| const char *res_o_name) |
| { |
| strarray *winebuild_args = get_winebuild_args( opts ); |
| |
| strarray_add( winebuild_args, "--resources" ); |
| strarray_add( winebuild_args, "-o" ); |
| strarray_add( winebuild_args, res_o_name ); |
| strarray_addall( winebuild_args, resources ); |
| |
| spawn( opts->prefix, winebuild_args, 0 ); |
| strarray_free( winebuild_args ); |
| return res_o_name; |
| } |
| |
| /* check if there is a static lib associated to a given dll */ |
| static char *find_static_lib( const char *dll ) |
| { |
| char *lib = strmake("%s.a", dll); |
| if (get_file_type(lib) == file_arh) return lib; |
| free( lib ); |
| return NULL; |
| } |
| |
| /* add specified library to the list of files */ |
| static void add_library( struct options *opts, strarray *lib_dirs, strarray *files, const char *library ) |
| { |
| char *static_lib, *fullname = 0; |
| |
| switch(get_lib_type(opts->target_platform, lib_dirs, library, opts->lib_suffix, &fullname)) |
| { |
| case file_arh: |
| strarray_add(files, strmake("-a%s", fullname)); |
| break; |
| case file_dll: |
| strarray_add(files, strmake("-d%s", fullname)); |
| if ((static_lib = find_static_lib(fullname))) |
| { |
| strarray_add(files, strmake("-a%s",static_lib)); |
| free(static_lib); |
| } |
| break; |
| case file_so: |
| default: |
| /* keep it anyway, the linker may know what to do with it */ |
| strarray_add(files, strmake("-l%s", library)); |
| break; |
| } |
| free(fullname); |
| } |
| |
| /* hack a main or WinMain function to work around Mingw's lack of Unicode support */ |
| static const char *mingw_unicode_hack( struct options *opts ) |
| { |
| char *main_stub = get_temp_file( opts->output_name, ".c" ); |
| |
| create_file( main_stub, 0644, |
| "typedef unsigned short wchar_t;\n" |
| "extern void * __stdcall LoadLibraryA(const char *);\n" |
| "extern void * __stdcall GetProcAddress(void *,const char *);\n" |
| "extern int wmain( int argc, wchar_t *argv[] );\n\n" |
| "int main( int argc, char *argv[] )\n{\n" |
| " int wargc;\n" |
| " wchar_t **wargv, **wenv;\n" |
| " void *msvcrt = LoadLibraryA( \"msvcrt.dll\" );\n" |
| " void (*__wgetmainargs)(int *argc, wchar_t** *wargv, wchar_t** *wenvp, int expand_wildcards,\n" |
| " int *new_mode) = GetProcAddress( msvcrt, \"__wgetmainargs\" );\n" |
| " __wgetmainargs( &wargc, &wargv, &wenv, 0, 0 );\n" |
| " return wmain( wargc, wargv );\n}\n" ); |
| return compile_to_object( opts, main_stub, NULL ); |
| } |
| |
| static void build(struct options* opts) |
| { |
| strarray *lib_dirs, *files; |
| strarray *spec_args, *link_args; |
| char *output_file; |
| const char *spec_o_name; |
| const char *output_name, *spec_file, *lang; |
| const char *prelink = NULL; |
| int generate_app_loader = 1; |
| int fake_module = 0; |
| unsigned int j; |
| |
| /* NOTE: for the files array we'll use the following convention: |
| * -axxx: xxx is an archive (.a) |
| * -dxxx: xxx is a DLL (.def) |
| * -lxxx: xxx is an unsorted library |
| * -oxxx: xxx is an object (.o) |
| * -rxxx: xxx is a resource (.res) |
| * -sxxx: xxx is a shared lib (.so) |
| * -xlll: lll is the language (c, c++, etc.) |
| */ |
| |
| output_file = strdup( opts->output_name ? opts->output_name : "a.out" ); |
| |
| /* 'winegcc -o app xxx.exe.so' only creates the load script */ |
| if (opts->files->size == 1 && strendswith(opts->files->base[0], ".exe.so")) |
| { |
| create_file(output_file, 0755, app_loader_template, opts->files->base[0]); |
| return; |
| } |
| |
| /* generate app loader only for .exe */ |
| if (opts->shared || strendswith(output_file, ".so")) |
| generate_app_loader = 0; |
| |
| if (strendswith(output_file, ".fake")) fake_module = 1; |
| |
| /* normalize the filename a bit: strip .so, ensure it has proper ext */ |
| if (strendswith(output_file, ".so")) |
| output_file[strlen(output_file) - 3] = 0; |
| if ((output_name = strrchr(output_file, '/'))) output_name++; |
| else output_name = output_file; |
| if (!strchr(output_name, '.')) |
| output_file = strmake("%s.%s", output_file, opts->shared ? "dll" : "exe"); |
| |
| /* get the filename from the path */ |
| if ((output_name = strrchr(output_file, '/'))) output_name++; |
| else output_name = output_file; |
| |
| /* prepare the linking path */ |
| if (!opts->wine_objdir) |
| { |
| char *lib_dir = get_lib_dir( opts ); |
| lib_dirs = strarray_dup(opts->lib_dirs); |
| strarray_add( lib_dirs, strmake( "%s/wine", lib_dir )); |
| strarray_add( lib_dirs, lib_dir ); |
| } |
| else |
| { |
| lib_dirs = strarray_alloc(); |
| strarray_add(lib_dirs, strmake("%s/dlls", opts->wine_objdir)); |
| strarray_add(lib_dirs, strmake("%s/libs/wine", opts->wine_objdir)); |
| strarray_addall(lib_dirs, opts->lib_dirs); |
| } |
| |
| /* mark the files with their appropriate type */ |
| spec_file = lang = 0; |
| files = strarray_alloc(); |
| link_args = strarray_alloc(); |
| for ( j = 0; j < opts->files->size; j++ ) |
| { |
| const char* file = opts->files->base[j]; |
| if (file[0] != '-') |
| { |
| switch(get_file_type(file)) |
| { |
| case file_def: |
| case file_spec: |
| if (spec_file) |
| error("Only one spec file can be specified\n"); |
| spec_file = file; |
| break; |
| case file_rc: |
| /* FIXME: invoke wrc to build it */ |
| error("Can't compile .rc file at the moment: %s\n", file); |
| break; |
| case file_res: |
| strarray_add(files, strmake("-r%s", file)); |
| break; |
| case file_obj: |
| strarray_add(files, strmake("-o%s", file)); |
| break; |
| case file_arh: |
| strarray_add(files, strmake("-a%s", file)); |
| break; |
| case file_so: |
| strarray_add(files, strmake("-s%s", file)); |
| break; |
| case file_na: |
| error("File does not exist: %s\n", file); |
| break; |
| default: |
| file = compile_to_object(opts, file, lang); |
| strarray_add(files, strmake("-o%s", file)); |
| break; |
| } |
| } |
| else if (file[1] == 'l') |
| add_library(opts, lib_dirs, files, file + 2 ); |
| else if (file[1] == 'x') |
| lang = file; |
| } |
| |
| /* building for Windows is completely different */ |
| |
| if (opts->target_platform == PLATFORM_WINDOWS || opts->target_platform == PLATFORM_CYGWIN) |
| { |
| strarray *resources = strarray_alloc(); |
| char *res_o_name = NULL; |
| |
| if (opts->win16_app) |
| error( "Building 16-bit code is not supported for Windows\n" ); |
| |
| strarray_addall(link_args, get_translator(opts)); |
| |
| if (opts->shared) |
| { |
| /* run winebuild to generate the .def file */ |
| char *spec_def_name = get_temp_file(output_name, ".spec.def"); |
| spec_args = get_winebuild_args( opts ); |
| strarray_add(spec_args, "--def"); |
| strarray_add(spec_args, "-o"); |
| strarray_add(spec_args, spec_def_name); |
| if (spec_file) |
| { |
| strarray_add(spec_args, "--export"); |
| strarray_add(spec_args, spec_file); |
| } |
| spawn(opts->prefix, spec_args, 0); |
| strarray_free(spec_args); |
| |
| strarray_add(link_args, "-shared"); |
| if (verbose) strarray_add(link_args, "-v"); |
| strarray_add(link_args, "-Wl,--kill-at"); |
| strarray_add(link_args, spec_def_name); |
| } |
| else |
| { |
| strarray_add(link_args, opts->gui_app ? "-mwindows" : "-mconsole"); |
| if (opts->nodefaultlibs) strarray_add(link_args, "-nodefaultlibs"); |
| } |
| |
| for ( j = 0 ; j < opts->linker_args->size ; j++ ) |
| strarray_add(link_args, opts->linker_args->base[j]); |
| |
| strarray_add(link_args, "-o"); |
| strarray_add(link_args, output_file); |
| |
| if (opts->image_base) |
| strarray_add(link_args, strmake("-Wl,--image-base,%s", opts->image_base)); |
| |
| if (opts->large_address_aware && opts->target_cpu == CPU_x86) |
| strarray_add( link_args, "-Wl,--large-address-aware" ); |
| |
| if (opts->unicode_app && !opts->shared) |
| strarray_add(link_args, mingw_unicode_hack(opts)); |
| |
| for ( j = 0; j < lib_dirs->size; j++ ) |
| strarray_add(link_args, strmake("-L%s", lib_dirs->base[j])); |
| |
| if (!opts->nodefaultlibs) |
| { |
| add_library(opts, lib_dirs, files, "winecrt0"); |
| add_library(opts, lib_dirs, files, "kernel32"); |
| add_library(opts, lib_dirs, files, "ntdll"); |
| } |
| if (!opts->shared && opts->use_msvcrt && opts->target_platform == PLATFORM_CYGWIN) |
| add_library(opts, lib_dirs, files, "msvcrt"); |
| |
| for ( j = 0; j < files->size; j++ ) |
| { |
| const char* name = files->base[j] + 2; |
| |
| switch(files->base[j][1]) |
| { |
| case 'l': |
| case 'd': |
| strarray_add(link_args, strmake("-l%s", name)); |
| break; |
| case 's': |
| case 'o': |
| strarray_add(link_args, name); |
| break; |
| case 'a': |
| if (!opts->lib_suffix && strchr(name, '/')) |
| { |
| /* turn the path back into -Ldir -lfoo options |
| * this makes sure that we use the specified libs even |
| * when mingw adds its own import libs to the link */ |
| char *lib = xstrdup( name ); |
| char *p = strrchr( lib, '/' ); |
| |
| *p++ = 0; |
| if (!strncmp( p, "lib", 3 )) |
| { |
| char *ext = strrchr( p, '.' ); |
| |
| if (ext) *ext = 0; |
| p += 3; |
| strarray_add(link_args, strmake("-L%s", lib )); |
| strarray_add(link_args, strmake("-l%s", p )); |
| free( lib ); |
| break; |
| } |
| free( lib ); |
| } |
| strarray_add(link_args, name); |
| break; |
| case 'r': |
| if (!res_o_name) |
| { |
| res_o_name = get_temp_file( output_name, ".res.o" ); |
| strarray_add( link_args, res_o_name ); |
| } |
| strarray_add( resources, name ); |
| break; |
| } |
| } |
| |
| if (res_o_name) compile_resources_to_object( opts, resources, res_o_name ); |
| |
| spawn(opts->prefix, link_args, 0); |
| strarray_free (resources); |
| strarray_free (link_args); |
| strarray_free (lib_dirs); |
| strarray_free (files); |
| return; |
| } |
| |
| /* add the default libraries, if needed */ |
| if (!opts->nostdlib && opts->use_msvcrt) add_library(opts, lib_dirs, files, "msvcrt"); |
| |
| if (!opts->wine_objdir && !opts->nodefaultlibs) |
| { |
| if (opts->gui_app) |
| { |
| add_library(opts, lib_dirs, files, "shell32"); |
| add_library(opts, lib_dirs, files, "comdlg32"); |
| add_library(opts, lib_dirs, files, "gdi32"); |
| } |
| add_library(opts, lib_dirs, files, "advapi32"); |
| add_library(opts, lib_dirs, files, "user32"); |
| } |
| |
| if (!opts->nodefaultlibs) |
| { |
| add_library(opts, lib_dirs, files, "winecrt0"); |
| if (opts->win16_app) add_library(opts, lib_dirs, files, "kernel"); |
| add_library(opts, lib_dirs, files, "kernel32"); |
| add_library(opts, lib_dirs, files, "ntdll"); |
| } |
| if (!opts->nostdlib) add_library(opts, lib_dirs, files, "wine"); |
| |
| /* run winebuild to generate the .spec.o file */ |
| spec_args = get_winebuild_args( opts ); |
| strarray_add( spec_args, strmake( "--cc-cmd=%s", build_tool_name( opts, "gcc", CC ))); |
| strarray_add( spec_args, strmake( "--ld-cmd=%s", build_tool_name( opts, "ld", LD ))); |
| |
| spec_o_name = get_temp_file(output_name, ".spec.o"); |
| if (opts->force_pointer_size) |
| strarray_add(spec_args, strmake("-m%u", 8 * opts->force_pointer_size )); |
| strarray_add(spec_args, "-D_REENTRANT"); |
| strarray_add(spec_args, "-fPIC"); |
| strarray_add(spec_args, opts->shared ? "--dll" : "--exe"); |
| if (fake_module) |
| { |
| strarray_add(spec_args, "--fake-module"); |
| strarray_add(spec_args, "-o"); |
| strarray_add(spec_args, output_file); |
| } |
| else |
| { |
| strarray_add(spec_args, "-o"); |
| strarray_add(spec_args, spec_o_name); |
| } |
| if (spec_file) |
| { |
| strarray_add(spec_args, "-E"); |
| strarray_add(spec_args, spec_file); |
| } |
| if (opts->win16_app) strarray_add(spec_args, "-m16"); |
| |
| if (!opts->shared) |
| { |
| strarray_add(spec_args, "-F"); |
| strarray_add(spec_args, output_name); |
| strarray_add(spec_args, "--subsystem"); |
| strarray_add(spec_args, opts->gui_app ? "windows" : "console"); |
| if (opts->unicode_app) |
| { |
| strarray_add(spec_args, "--entry"); |
| strarray_add(spec_args, "__wine_spec_exe_wentry"); |
| } |
| if (opts->large_address_aware) strarray_add( spec_args, "--large-address-aware" ); |
| } |
| |
| for ( j = 0; j < lib_dirs->size; j++ ) |
| strarray_add(spec_args, strmake("-L%s", lib_dirs->base[j])); |
| |
| for ( j = 0 ; j < opts->winebuild_args->size ; j++ ) |
| strarray_add(spec_args, opts->winebuild_args->base[j]); |
| |
| /* add resource files */ |
| for ( j = 0; j < files->size; j++ ) |
| if (files->base[j][1] == 'r') strarray_add(spec_args, files->base[j]); |
| |
| /* add other files */ |
| strarray_add(spec_args, "--"); |
| for ( j = 0; j < files->size; j++ ) |
| { |
| switch(files->base[j][1]) |
| { |
| case 'd': |
| case 'a': |
| case 'o': |
| strarray_add(spec_args, files->base[j] + 2); |
| break; |
| } |
| } |
| |
| spawn(opts->prefix, spec_args, 0); |
| strarray_free (spec_args); |
| if (fake_module) return; /* nothing else to do */ |
| |
| /* link everything together now */ |
| strarray_addall(link_args, get_translator(opts)); |
| strarray_addall(link_args, get_lddllflags(opts, link_args)); |
| |
| strarray_add(link_args, "-o"); |
| strarray_add(link_args, strmake("%s.so", output_file)); |
| |
| for ( j = 0 ; j < opts->linker_args->size ; j++ ) |
| strarray_add(link_args, opts->linker_args->base[j]); |
| |
| switch (opts->target_platform) |
| { |
| case PLATFORM_APPLE: |
| if (opts->image_base) |
| { |
| strarray_add(link_args, "-image_base"); |
| strarray_add(link_args, opts->image_base); |
| } |
| if (opts->strip) |
| strarray_add(link_args, "-Wl,-x"); |
| break; |
| case PLATFORM_SOLARIS: |
| { |
| char *mapfile = get_temp_file( output_name, ".map" ); |
| const char *align = opts->section_align ? opts->section_align : "0x1000"; |
| |
| create_file( mapfile, 0644, "text = A%s;\ndata = A%s;\n", align, align ); |
| strarray_add(link_args, strmake("-Wl,-M,%s", mapfile)); |
| strarray_add(tmp_files, mapfile); |
| } |
| break; |
| case PLATFORM_ANDROID: |
| /* the Android loader requires a soname for all libraries */ |
| strarray_add( link_args, strmake( "-Wl,-soname,%s.so", output_name )); |
| break; |
| default: |
| if (opts->image_base) |
| { |
| if (!try_link(opts->prefix, link_args, "-Wl,-z,max-page-size=0x1000")) |
| strarray_add(link_args, "-Wl,-z,max-page-size=0x1000"); |
| if (!try_link(opts->prefix, link_args, strmake("-Wl,-Ttext-segment=%s", opts->image_base))) |
| strarray_add(link_args, strmake("-Wl,-Ttext-segment=%s", opts->image_base)); |
| else |
| prelink = PRELINK; |
| } |
| break; |
| } |
| |
| for ( j = 0; j < lib_dirs->size; j++ ) |
| strarray_add(link_args, strmake("-L%s", lib_dirs->base[j])); |
| |
| strarray_add(link_args, spec_o_name); |
| |
| for ( j = 0; j < files->size; j++ ) |
| { |
| const char* name = files->base[j] + 2; |
| switch(files->base[j][1]) |
| { |
| case 'l': |
| strarray_add(link_args, strmake("-l%s", name)); |
| break; |
| case 's': |
| case 'a': |
| case 'o': |
| strarray_add(link_args, name); |
| break; |
| } |
| } |
| |
| if (!opts->nostdlib) |
| { |
| strarray_add(link_args, "-lm"); |
| strarray_add(link_args, "-lc"); |
| } |
| |
| spawn(opts->prefix, link_args, 0); |
| strarray_free (link_args); |
| |
| /* set the base address with prelink if linker support is not present */ |
| if (prelink && !opts->target) |
| { |
| if (prelink[0] && strcmp(prelink,"false")) |
| { |
| strarray *prelink_args = strarray_alloc(); |
| strarray_add(prelink_args, prelink); |
| strarray_add(prelink_args, "--reloc-only"); |
| strarray_add(prelink_args, opts->image_base); |
| strarray_add(prelink_args, strmake("%s.so", output_file)); |
| spawn(opts->prefix, prelink_args, 1); |
| strarray_free(prelink_args); |
| } |
| } |
| |
| /* create the loader script */ |
| if (generate_app_loader) |
| create_file(output_file, 0755, app_loader_template, strmake("%s.so", output_name)); |
| } |
| |
| |
| static void forward(int argc, char **argv, struct options* opts) |
| { |
| strarray* args = strarray_alloc(); |
| int j; |
| |
| strarray_addall(args, get_translator(opts)); |
| |
| for( j = 1; j < argc; j++ ) |
| strarray_add(args, argv[j]); |
| |
| spawn(opts->prefix, args, 0); |
| strarray_free (args); |
| } |
| |
| /* |
| * Linker Options |
| * object-file-name -llibrary -nostartfiles -nodefaultlibs |
| * -nostdlib -s -static -static-libgcc -shared -shared-libgcc |
| * -symbolic -Wl,option -Xlinker option -u symbol |
| * -framework name |
| */ |
| static int is_linker_arg(const char* arg) |
| { |
| static const char* link_switches[] = |
| { |
| "-nostartfiles", "-nostdlib", "-s", |
| "-static", "-static-libgcc", "-shared", "-shared-libgcc", "-symbolic", |
| "-framework", "--coverage", "-fprofile-generate", "-fprofile-use" |
| }; |
| unsigned int j; |
| |
| switch (arg[1]) |
| { |
| case 'R': |
| case 'z': |
| case 'l': |
| case 'u': |
| return 1; |
| case 'W': |
| if (strncmp("-Wl,", arg, 4) == 0) return 1; |
| break; |
| case 'X': |
| if (strcmp("-Xlinker", arg) == 0) return 1; |
| break; |
| case 'a': |
| if (strcmp("-arch", arg) == 0) return 1; |
| break; |
| } |
| |
| for (j = 0; j < sizeof(link_switches)/sizeof(link_switches[0]); j++) |
| if (strcmp(link_switches[j], arg) == 0) return 1; |
| |
| return 0; |
| } |
| |
| /* |
| * Target Options |
| * -b machine -V version |
| */ |
| static int is_target_arg(const char* arg) |
| { |
| return arg[1] == 'b' || arg[1] == 'V'; |
| } |
| |
| |
| /* |
| * Directory Options |
| * -Bprefix -Idir -I- -Ldir -specs=file |
| */ |
| static int is_directory_arg(const char* arg) |
| { |
| return arg[1] == 'B' || arg[1] == 'L' || arg[1] == 'I' || strncmp("-specs=", arg, 7) == 0; |
| } |
| |
| /* |
| * MinGW Options |
| * -mno-cygwin -mwindows -mconsole -mthreads -municode |
| */ |
| static int is_mingw_arg(const char* arg) |
| { |
| static const char* mingw_switches[] = |
| { |
| "-mno-cygwin", "-mwindows", "-mconsole", "-mthreads", "-municode" |
| }; |
| unsigned int j; |
| |
| for (j = 0; j < sizeof(mingw_switches)/sizeof(mingw_switches[0]); j++) |
| if (strcmp(mingw_switches[j], arg) == 0) return 1; |
| |
| return 0; |
| } |
| |
| static void parse_target_option( struct options *opts, const char *target ) |
| { |
| char *p, *platform, *spec = xstrdup( target ); |
| unsigned int i; |
| |
| /* target specification is in the form CPU-MANUFACTURER-OS or CPU-MANUFACTURER-KERNEL-OS */ |
| |
| /* get the CPU part */ |
| |
| if ((p = strchr( spec, '-' ))) |
| { |
| *p++ = 0; |
| for (i = 0; i < sizeof(cpu_names)/sizeof(cpu_names[0]); i++) |
| { |
| if (!strcmp( cpu_names[i].name, spec )) |
| { |
| opts->target_cpu = cpu_names[i].cpu; |
| break; |
| } |
| } |
| if (i == sizeof(cpu_names)/sizeof(cpu_names[0])) |
| error( "Unrecognized CPU '%s'\n", spec ); |
| platform = p; |
| if ((p = strrchr( p, '-' ))) platform = p + 1; |
| } |
| else if (!strcmp( spec, "mingw32" )) |
| { |
| opts->target_cpu = CPU_x86; |
| platform = spec; |
| } |
| else |
| error( "Invalid target specification '%s'\n", target ); |
| |
| /* get the OS part */ |
| |
| opts->target_platform = PLATFORM_UNSPECIFIED; /* default value */ |
| for (i = 0; i < sizeof(platform_names)/sizeof(platform_names[0]); i++) |
| { |
| if (!strncmp( platform_names[i].name, platform, strlen(platform_names[i].name) )) |
| { |
| opts->target_platform = platform_names[i].platform; |
| break; |
| } |
| } |
| |
| free( spec ); |
| opts->target = xstrdup( target ); |
| } |
| |
| int main(int argc, char **argv) |
| { |
| int i, c, next_is_arg = 0, linking = 1; |
| int raw_compiler_arg, raw_linker_arg; |
| const char* option_arg; |
| struct options opts; |
| char* lang = 0; |
| char* str; |
| |
| #ifdef SIGHUP |
| signal( SIGHUP, exit_on_signal ); |
| #endif |
| signal( SIGTERM, exit_on_signal ); |
| signal( SIGINT, exit_on_signal ); |
| #ifdef HAVE_SIGADDSET |
| sigemptyset( &signal_mask ); |
| sigaddset( &signal_mask, SIGHUP ); |
| sigaddset( &signal_mask, SIGTERM ); |
| sigaddset( &signal_mask, SIGINT ); |
| #endif |
| |
| /* setup tmp file removal at exit */ |
| tmp_files = strarray_alloc(); |
| atexit(clean_temp_files); |
| |
| /* initialize options */ |
| memset(&opts, 0, sizeof(opts)); |
| opts.target_cpu = build_cpu; |
| opts.target_platform = build_platform; |
| opts.lib_dirs = strarray_alloc(); |
| opts.files = strarray_alloc(); |
| opts.linker_args = strarray_alloc(); |
| opts.compiler_args = strarray_alloc(); |
| opts.winebuild_args = strarray_alloc(); |
| |
| /* determine the processor type */ |
| if (strendswith(argv[0], "winecpp")) opts.processor = proc_cpp; |
| else if (strendswith(argv[0], "++")) opts.processor = proc_cxx; |
| |
| /* parse options */ |
| for ( i = 1 ; i < argc ; i++ ) |
| { |
| if (argv[i][0] == '-') /* option */ |
| { |
| /* determine if this switch is followed by a separate argument */ |
| next_is_arg = 0; |
| option_arg = 0; |
| switch(argv[i][1]) |
| { |
| case 'x': case 'o': case 'D': case 'U': |
| case 'I': case 'A': case 'l': case 'u': |
| case 'b': case 'V': case 'G': case 'L': |
| case 'B': case 'R': case 'z': |
| if (argv[i][2]) option_arg = &argv[i][2]; |
| else next_is_arg = 1; |
| break; |
| case 'i': |
| next_is_arg = 1; |
| break; |
| case 'a': |
| if (strcmp("-aux-info", argv[i]) == 0) |
| next_is_arg = 1; |
| if (strcmp("-arch", argv[i]) == 0) |
| next_is_arg = 1; |
| break; |
| case 'X': |
| if (strcmp("-Xlinker", argv[i]) == 0) |
| next_is_arg = 1; |
| break; |
| case 'M': |
| c = argv[i][2]; |
| if (c == 'F' || c == 'T' || c == 'Q') |
| { |
| if (argv[i][3]) option_arg = &argv[i][3]; |
| else next_is_arg = 1; |
| } |
| break; |
| case 'f': |
| if (strcmp("-framework", argv[i]) == 0) |
| next_is_arg = 1; |
| break; |
| case '-': |
| if (strcmp("--param", argv[i]) == 0) |
| next_is_arg = 1; |
| break; |
| } |
| if (next_is_arg) |
| { |
| if (i + 1 >= argc) error("option -%c requires an argument\n", argv[i][1]); |
| option_arg = argv[i+1]; |
| } |
| |
| /* determine what options go 'as is' to the linker & the compiler */ |
| raw_compiler_arg = raw_linker_arg = 0; |
| if (is_linker_arg(argv[i])) |
| { |
| raw_linker_arg = 1; |
| } |
| else |
| { |
| if (is_directory_arg(argv[i]) || is_target_arg(argv[i])) |
| raw_linker_arg = 1; |
| raw_compiler_arg = !is_mingw_arg(argv[i]); |
| } |
| |
| /* these things we handle explicitly so we don't pass them 'as is' */ |
| if (argv[i][1] == 'l' || argv[i][1] == 'I' || argv[i][1] == 'L') |
| raw_linker_arg = 0; |
| if (argv[i][1] == 'c' || argv[i][1] == 'L') |
| raw_compiler_arg = 0; |
| if (argv[i][1] == 'o' || argv[i][1] == 'b' || argv[i][1] == 'V') |
| raw_compiler_arg = raw_linker_arg = 0; |
| |
| /* do a bit of semantic analysis */ |
| switch (argv[i][1]) |
| { |
| case 'B': |
| str = strdup(option_arg); |
| if (strendswith(str, "/")) str[strlen(str) - 1] = 0; |
| if (strendswith(str, "/tools/winebuild")) |
| { |
| char *objdir = strdup(str); |
| objdir[strlen(objdir) - sizeof("/tools/winebuild") + 1] = 0; |
| opts.wine_objdir = objdir; |
| /* don't pass it to the compiler, this generates warnings */ |
| raw_compiler_arg = raw_linker_arg = 0; |
| } |
| else if (!strcmp(str, "tools/winebuild")) |
| { |
| opts.wine_objdir = "."; |
| raw_compiler_arg = raw_linker_arg = 0; |
| } |
| if (!opts.prefix) opts.prefix = strarray_alloc(); |
| strarray_add(opts.prefix, str); |
| break; |
| case 'b': |
| parse_target_option( &opts, option_arg ); |
| break; |
| case 'V': |
| opts.version = xstrdup( option_arg ); |
| break; |
| case 'c': /* compile or assemble */ |
| if (argv[i][2] == 0) opts.compile_only = 1; |
| /* fall through */ |
| case 'S': /* generate assembler code */ |
| case 'E': /* preprocess only */ |
| if (argv[i][2] == 0) linking = 0; |
| break; |
| case 'f': |
| if (strcmp("-fno-short-wchar", argv[i]) == 0) |
| opts.noshortwchar = 1; |
| else if (!strcmp("-fasynchronous-unwind-tables", argv[i])) |
| opts.unwind_tables = 1; |
| else if (!strcmp("-fno-asynchronous-unwind-tables", argv[i])) |
| opts.unwind_tables = 0; |
| break; |
| case 'l': |
| strarray_add(opts.files, strmake("-l%s", option_arg)); |
| break; |
| case 'L': |
| strarray_add(opts.lib_dirs, option_arg); |
| break; |
| case 'M': /* map file generation */ |
| linking = 0; |
| break; |
| case 'm': |
| if (strcmp("-mno-cygwin", argv[i]) == 0) |
| opts.use_msvcrt = 1; |
| else if (strcmp("-mwindows", argv[i]) == 0) |
| opts.gui_app = 1; |
| else if (strcmp("-mconsole", argv[i]) == 0) |
| opts.gui_app = 0; |
| else if (strcmp("-municode", argv[i]) == 0) |
| opts.unicode_app = 1; |
| else if (strcmp("-m16", argv[i]) == 0) |
| opts.win16_app = 1; |
| else if (strcmp("-m32", argv[i]) == 0) |
| { |
| if (opts.target_cpu == CPU_x86_64) |
| opts.target_cpu = CPU_x86; |
| else if (opts.target_cpu == CPU_ARM64) |
| opts.target_cpu = CPU_ARM; |
| opts.force_pointer_size = 4; |
| raw_linker_arg = 1; |
| } |
| else if (strcmp("-m64", argv[i]) == 0) |
| { |
| if (opts.target_cpu == CPU_x86) |
| opts.target_cpu = CPU_x86_64; |
| else if (opts.target_cpu == CPU_ARM) |
| opts.target_cpu = CPU_ARM64; |
| opts.force_pointer_size = 8; |
| raw_linker_arg = 1; |
| } |
| else if (!strcmp("-marm", argv[i] ) || !strcmp("-mthumb", argv[i] )) |
| { |
| strarray_add(opts.winebuild_args, argv[i]); |
| raw_linker_arg = 1; |
| } |
| else if (strncmp("-mcpu=", argv[i], 6) == 0 || strncmp("-march=", argv[i], 7) == 0) |
| strarray_add(opts.winebuild_args, argv[i]); |
| break; |
| case 'n': |
| if (strcmp("-nostdinc", argv[i]) == 0) |
| opts.nostdinc = 1; |
| else if (strcmp("-nodefaultlibs", argv[i]) == 0) |
| opts.nodefaultlibs = 1; |
| else if (strcmp("-nostdlib", argv[i]) == 0) |
| opts.nostdlib = 1; |
| else if (strcmp("-nostartfiles", argv[i]) == 0) |
| opts.nostartfiles = 1; |
| break; |
| case 'o': |
| opts.output_name = option_arg; |
| break; |
| case 's': |
| if (strcmp("-static", argv[i]) == 0) |
| linking = -1; |
| else if(strcmp("-save-temps", argv[i]) == 0) |
| keep_generated = 1; |
| else if(strcmp("-shared", argv[i]) == 0) |
| { |
| opts.shared = 1; |
| raw_compiler_arg = raw_linker_arg = 0; |
| } |
| else if (strcmp("-s", argv[i]) == 0 && opts.target_platform == PLATFORM_APPLE) |
| { |
| /* On Mac, change -s into -Wl,-x. ld's -s switch |
| * is deprecated, and it doesn't work on Tiger with |
| * MH_BUNDLEs anyway |
| */ |
| opts.strip = 1; |
| raw_linker_arg = 0; |
| } |
| break; |
| case 'v': |
| if (argv[i][2] == 0) verbose++; |
| break; |
| case 'W': |
| if (strncmp("-Wl,", argv[i], 4) == 0) |
| { |
| unsigned int j; |
| strarray* Wl = strarray_fromstring(argv[i] + 4, ","); |
| for (j = 0; j < Wl->size; j++) |
| { |
| if (!strcmp(Wl->base[j], "--image-base") && j < Wl->size - 1) |
| { |
| opts.image_base = strdup( Wl->base[++j] ); |
| continue; |
| } |
| if (!strcmp(Wl->base[j], "--section-alignment") && j < Wl->size - 1) |
| { |
| opts.section_align = strdup( Wl->base[++j] ); |
| continue; |
| } |
| if (!strcmp(Wl->base[j], "--large-address-aware")) |
| { |
| opts.large_address_aware = 1; |
| continue; |
| } |
| if (!strcmp(Wl->base[j], "-static")) linking = -1; |
| strarray_add(opts.linker_args, strmake("-Wl,%s",Wl->base[j])); |
| } |
| strarray_free(Wl); |
| raw_compiler_arg = raw_linker_arg = 0; |
| } |
| else if (strncmp("-Wb,", argv[i], 4) == 0) |
| { |
| strarray* Wb = strarray_fromstring(argv[i] + 4, ","); |
| strarray_addall(opts.winebuild_args, Wb); |
| strarray_free(Wb); |
| /* don't pass it to the compiler, it generates errors */ |
| raw_compiler_arg = raw_linker_arg = 0; |
| } |
| break; |
| case 'x': |
| lang = strmake("-x%s", option_arg); |
| strarray_add(opts.files, lang); |
| /* we'll pass these flags ourselves, explicitly */ |
| raw_compiler_arg = raw_linker_arg = 0; |
| break; |
| case '-': |
| if (strcmp("-static", argv[i]+1) == 0) |
| linking = -1; |
| else if (!strncmp("--sysroot", argv[i], 9) && opts.wine_objdir) |
| { |
| if (argv[i][9] == '=') opts.wine_objdir = argv[i] + 10; |
| else opts.wine_objdir = argv[++i]; |
| raw_compiler_arg = raw_linker_arg = 0; |
| } |
| else if (!strncmp("--lib-suffix", argv[i], 12) && opts.wine_objdir) |
| { |
| if (argv[i][12] == '=') opts.lib_suffix = argv[i] + 13; |
| else opts.lib_suffix = argv[++i]; |
| raw_compiler_arg = raw_linker_arg = 0; |
| } |
| break; |
| } |
| |
| /* put the arg into the appropriate bucket */ |
| if (raw_linker_arg) |
| { |
| strarray_add(opts.linker_args, argv[i]); |
| if (next_is_arg && (i + 1 < argc)) |
| strarray_add(opts.linker_args, argv[i + 1]); |
| } |
| if (raw_compiler_arg) |
| { |
| strarray_add(opts.compiler_args, argv[i]); |
| if (next_is_arg && (i + 1 < argc)) |
| strarray_add(opts.compiler_args, argv[i + 1]); |
| } |
| |
| /* skip the next token if it's an argument */ |
| if (next_is_arg) i++; |
| } |
| else |
| { |
| strarray_add(opts.files, argv[i]); |
| } |
| } |
| |
| if (opts.processor == proc_cpp) linking = 0; |
| if (linking == -1) error("Static linking is not supported\n"); |
| |
| if (opts.files->size == 0) forward(argc, argv, &opts); |
| else if (linking) build(&opts); |
| else compile(&opts, lang); |
| |
| return 0; |
| } |
