X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=main.c;h=afb0b8470e11f672fb695d5f24858322b82e07e3;hb=e628f683385763274b551d468107872a058b31d7;hp=0104f31816e2bd93374ec2aa5325a9d3dfa397c7;hpb=a055fdb88eee871fd525953969970fcd0c4f7fff;p=cparser

diff --git a/main.c b/main.c
index 0104f31..afb0b84 100644
--- a/main.c
+++ b/main.c
@@ -1,6 +1,6 @@
 /*
  * This file is part of cparser.
- * Copyright (C) 2007-2008 Matthias Braun <matze@braunis.de>
+ * Copyright (C) 2007-2009 Matthias Braun <matze@braunis.de>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -70,64 +70,68 @@
 #include "diagnostic.h"
 #include "lang_features.h"
 #include "driver/firm_opt.h"
-#include "driver/firm_cmdline.h"
+#include "driver/firm_timing.h"
+#include "driver/firm_machine.h"
 #include "adt/error.h"
-#include "write_fluffy.h"
-#include "write_caml.h"
+#include "adt/strutil.h"
+#include "wrappergen/write_fluffy.h"
+#include "wrappergen/write_jna.h"
 #include "revision.h"
 #include "warning.h"
+#include "help.h"
 #include "mangle.h"
+#include "printer.h"
 
 #ifndef PREPROCESSOR
 #ifndef __WIN32__
-#define PREPROCESSOR "gcc -E -std=c99 -m32 -U__STRICT_ANSI__"
+#define PREPROCESSOR "gcc -E -U__STRICT_ANSI__"
 #else
-#define PREPROCESSOR "cpp -std=c99 -m32 -U__STRICT_ANSI__"
+#define PREPROCESSOR "cpp -U__STRICT_ANSI__"
 #endif
 #endif
 
 #ifndef LINKER
-#define LINKER    "gcc -m32"
+#define LINKER    "gcc"
 #endif
 
 #ifndef ASSEMBLER
-#ifdef __APPLE__
 #define ASSEMBLER "gcc -c -xassembler"
-#else
-#define ASSEMBLER "as --32"
-#endif
 #endif
 
-/** The current c mode/dialect. */
-unsigned int c_mode = _C89 | _ANSI | _C99 | _GNUC;
-
-/** The 'machine size', 16, 32 or 64 bit, 32bit is the default. */
-unsigned int machine_size = 32;
-
-/** true if the char type is signed. */
-bool char_is_signed = true;
-
-/** true for strict language checking. */
-bool strict_mode = false;
-
-/** use builtins for some libc functions */
-bool use_builtins = false;
-
-/** we have extern function with const attribute. */
-bool have_const_functions = false;
-
-atomic_type_kind_t wchar_atomic_kind = ATOMIC_TYPE_INT;
+unsigned int       c_mode                    = _C89 | _ANSI | _C99 | _GNUC;
+unsigned int       machine_size              = 32;
+bool               byte_order_big_endian     = false;
+bool               char_is_signed            = true;
+bool               strict_mode               = false;
+atomic_type_kind_t wchar_atomic_kind         = ATOMIC_TYPE_INT;
+unsigned           long_double_size          = 0;
+bool               enable_main_collect2_hack = false;
+bool               freestanding              = false;
+
+static machine_triple_t *target_machine;
+static const char       *target_triple;
+static int               verbose;
+static bool              use_builtins;
+static struct obstack    cppflags_obst;
+static struct obstack    ldflags_obst;
+static struct obstack    asflags_obst;
+static char              dep_target[1024];
+static const char       *outname;
+static bool              define_intmax_types;
 
-/* to switch on printing of implicit casts */
-extern bool print_implicit_casts;
-
-/* to switch on printing of parenthesis to indicate operator precedence */
-extern bool print_parenthesis;
+typedef enum lang_standard_t {
+	STANDARD_DEFAULT, /* gnu99 (for C, GCC does gnu89) or gnu++98 (for C++) */
+	STANDARD_ANSI,    /* c89 (for C) or c++98 (for C++) */
+	STANDARD_C89,     /* ISO C90 (sic) */
+	STANDARD_C90,     /* ISO C90 as modified in amendment 1 */
+	STANDARD_C99,     /* ISO C99 */
+	STANDARD_GNU89,   /* ISO C90 plus GNU extensions (including some C99) */
+	STANDARD_GNU99,   /* ISO C99 plus GNU extensions */
+	STANDARD_CXX98,   /* ISO C++ 1998 plus amendments */
+	STANDARD_GNUXX98  /* ISO C++ 1998 plus amendments and GNU extensions */
+} lang_standard_t;
 
-static int             verbose;
-static struct obstack  cppflags_obst, ldflags_obst;
-static char            dep_target[1024];
-static const char     *outname;
+static lang_standard_t standard;
 
 typedef struct file_list_entry_t file_list_entry_t;
 
@@ -140,6 +144,7 @@ typedef enum filetype_t {
 	FILETYPE_ASSEMBLER,
 	FILETYPE_PREPROCESSED_ASSEMBLER,
 	FILETYPE_OBJECT,
+	FILETYPE_IR,
 	FILETYPE_UNKNOWN
 } filetype_t;
 
@@ -151,62 +156,30 @@ struct file_list_entry_t {
 
 static file_list_entry_t *temp_files;
 
-#if defined(_DEBUG) || defined(FIRM_DEBUG)
-/**
- * Debug printf implementation.
- *
- * @param fmt  printf style format parameter
- */
-void dbg_printf(const char *fmt, ...)
-{
-	va_list list;
-
-	if (firm_dump.debug_print) {
-		va_start(list, fmt);
-		vprintf(fmt, list);
-		va_end(list);
-	}  /* if */
-}
-#endif /* defined(_DEBUG) || defined(FIRM_DEBUG) */
-
-static void initialize_firm(void)
-{
-	firm_early_init();
-
-	dump_consts_local(1);
-	dump_keepalive_edges(1);
-}
-
 static void get_output_name(char *buf, size_t buflen, const char *inputname,
                             const char *newext)
 {
-	size_t last_dot = 0xffffffff;
-	size_t i = 0;
-
-	if (inputname == NULL) {
-		snprintf(buf, buflen, "a%s", newext);
-		return;
-	}
-
-	for (const char *c = inputname; *c != 0; ++c) {
-		if (*c == '.')
-			last_dot = i;
-		++i;
-	}
-	if (last_dot == 0xffffffff)
-		last_dot = i;
-
-	if (last_dot >= buflen)
-		panic("filename too long");
-	memcpy(buf, inputname, last_dot);
-
-	size_t extlen = strlen(newext) + 1;
-	if (extlen + last_dot >= buflen)
+	if (inputname == NULL)
+		inputname = "a";
+
+	char const *const last_slash = strrchr(inputname, '/');
+	char const *const filename   =
+		last_slash != NULL ? last_slash + 1 : inputname;
+	char const *const last_dot   = strrchr(filename, '.');
+	char const *const name_end   =
+		last_dot != NULL ? last_dot : strchr(filename, '\0');
+
+	int const len = snprintf(buf, buflen, "%.*s%s",
+			(int)(name_end - filename), filename, newext);
+#ifdef _WIN32
+	if (len < 0 || buflen <= (size_t)len)
+#else
+	if (buflen <= (size_t)len)
+#endif
 		panic("filename too long");
-	memcpy(buf+last_dot, newext, extlen);
 }
 
-#include "builtins.h"
+#include "gen_builtins.h"
 
 static translation_unit_t *do_parsing(FILE *const in, const char *const input_name)
 {
@@ -237,7 +210,7 @@ static void lextest(FILE *in, const char *fname)
 
 static void add_flag(struct obstack *obst, const char *format, ...)
 {
-	char buf[4096];
+	char buf[65536];
 	va_list ap;
 
 	va_start(ap, format);
@@ -288,30 +261,65 @@ static const char *type_to_string(type_t *type)
 	return get_atomic_kind_name(type->atomic.akind);
 }
 
-static FILE *preprocess(const char *fname)
+static FILE *preprocess(const char *fname, filetype_t filetype)
 {
-	obstack_1grow(&cppflags_obst, '\0');
-	const char *flags = obstack_finish(&cppflags_obst);
-
-	obstack_printf(&cppflags_obst, "%s", PREPROCESSOR);
-
-	/* setup default defines */
-	add_flag(&cppflags_obst, "-U__WCHAR_TYPE__");
-	add_flag(&cppflags_obst, "-D__WCHAR_TYPE__=%s", type_to_string(type_wchar_t));
-	add_flag(&cppflags_obst, "-U__SIZE_TYPE__");
-	add_flag(&cppflags_obst, "-D__SIZE_TYPE__=%s", type_to_string(type_size_t));
-
-	/* TODO hack... */
-	add_flag(&cppflags_obst, "-D__builtin_abort=abort");
-	add_flag(&cppflags_obst, "-D__builtin_abs=abs");
-	add_flag(&cppflags_obst, "-D__builtin_exit=exit");
-	add_flag(&cppflags_obst, "-D__builtin_malloc=malloc");
-	add_flag(&cppflags_obst, "-D__builtin_memcmp=memcmp");
-	add_flag(&cppflags_obst, "-D__builtin_memcpy=memcpy");
-	add_flag(&cppflags_obst, "-D__builtin_memset=memset");
-	add_flag(&cppflags_obst, "-D__builtin_strlen=strlen");
-	add_flag(&cppflags_obst, "-D__builtin_strcmp=strcmp");
-	add_flag(&cppflags_obst, "-D__builtin_strcpy=strcpy");
+	static const char *common_flags = NULL;
+
+	if (common_flags == NULL) {
+		obstack_1grow(&cppflags_obst, '\0');
+		const char *flags = obstack_finish(&cppflags_obst);
+
+		/* setup default defines */
+		add_flag(&cppflags_obst, "-U__WCHAR_TYPE__");
+		add_flag(&cppflags_obst, "-D__WCHAR_TYPE__=%s", type_to_string(type_wchar_t));
+		add_flag(&cppflags_obst, "-U__SIZE_TYPE__");
+		add_flag(&cppflags_obst, "-D__SIZE_TYPE__=%s", type_to_string(type_size_t));
+
+		add_flag(&cppflags_obst, "-U__VERSION__");
+		add_flag(&cppflags_obst, "-D__VERSION__=\"%s\"", cparser_REVISION);
+
+		if (define_intmax_types) {
+			add_flag(&cppflags_obst, "-U__INTMAX_TYPE__");
+			add_flag(&cppflags_obst, "-D__INTMAX_TYPE__=%s", type_to_string(type_intmax_t));
+			add_flag(&cppflags_obst, "-U__UINTMAX_TYPE__");
+			add_flag(&cppflags_obst, "-D__UINTMAX_TYPE__=%s", type_to_string(type_uintmax_t));
+		}
+
+		if (flags[0] != '\0') {
+			size_t len = strlen(flags);
+			obstack_1grow(&cppflags_obst, ' ');
+			obstack_grow(&cppflags_obst, flags, len);
+		}
+		obstack_1grow(&cppflags_obst, '\0');
+		common_flags = obstack_finish(&cppflags_obst);
+	}
+
+	assert(obstack_object_size(&cppflags_obst) == 0);
+
+	const char *preprocessor = getenv("CPARSER_PP");
+	if (preprocessor != NULL) {
+		obstack_printf(&cppflags_obst, "%s ", preprocessor);
+	} else {
+		if (target_triple != NULL)
+			obstack_printf(&cppflags_obst, "%s-", target_triple);
+		obstack_printf(&cppflags_obst, PREPROCESSOR);
+	}
+
+	switch (filetype) {
+	case FILETYPE_C:
+		add_flag(&cppflags_obst, "-std=c99");
+		break;
+	case FILETYPE_CXX:
+		add_flag(&cppflags_obst, "-std=c++98");
+		break;
+	case FILETYPE_ASSEMBLER:
+		add_flag(&cppflags_obst, "-x");
+		add_flag(&cppflags_obst, "assembler-with-cpp");
+		break;
+	default:
+		break;
+	}
+	obstack_printf(&cppflags_obst, "%s", common_flags);
 
 	/* handle dependency generation */
 	if (dep_target[0] != '\0') {
@@ -322,40 +330,53 @@ static FILE *preprocess(const char *fname)
 				add_flag(&cppflags_obst, outname);
 		}
 	}
-	if (flags[0] != '\0') {
-		obstack_printf(&cppflags_obst, " %s", flags);
-	}
 	add_flag(&cppflags_obst, fname);
-
 	obstack_1grow(&cppflags_obst, '\0');
-	const char *buf = obstack_finish(&cppflags_obst);
+
+	char *commandline = obstack_finish(&cppflags_obst);
 	if (verbose) {
-		puts(buf);
+		puts(commandline);
 	}
-
-	FILE *f = popen(buf, "r");
+	FILE *f = popen(commandline, "r");
 	if (f == NULL) {
 		fprintf(stderr, "invoking preprocessor failed\n");
-		exit(1);
+		exit(EXIT_FAILURE);
 	}
+	/* we don't really need that anymore */
+	obstack_free(&cppflags_obst, commandline);
 
 	return f;
 }
 
 static void assemble(const char *out, const char *in)
 {
-	char buf[4096];
+	obstack_1grow(&asflags_obst, '\0');
+	const char *flags = obstack_finish(&asflags_obst);
 
-	snprintf(buf, sizeof(buf), "%s %s -o %s", ASSEMBLER, in, out);
-	if (verbose) {
-		puts(buf);
+	const char *assembler = getenv("CPARSER_AS");
+	if (assembler != NULL) {
+		obstack_printf(&asflags_obst, "%s", assembler);
+	} else {
+		if (target_triple != NULL)
+			obstack_printf(&asflags_obst, "%s-", target_triple);
+		obstack_printf(&asflags_obst, "%s", ASSEMBLER);
 	}
+	if (flags[0] != '\0')
+		obstack_printf(&asflags_obst, " %s", flags);
+
+	obstack_printf(&asflags_obst, " %s -o %s", in, out);
+	obstack_1grow(&asflags_obst, '\0');
 
-	int err = system(buf);
-	if (err != 0) {
+	char *commandline = obstack_finish(&asflags_obst);
+	if (verbose) {
+		puts(commandline);
+	}
+	int err = system(commandline);
+	if (err != EXIT_SUCCESS) {
 		fprintf(stderr, "assembler reported an error\n");
-		exit(1);
+		exit(EXIT_FAILURE);
 	}
+	obstack_free(&asflags_obst, commandline);
 }
 
 static void print_file_name(const char *file)
@@ -366,20 +387,28 @@ static void print_file_name(const char *file)
 	const char *flags = obstack_finish(&ldflags_obst);
 
 	/* construct commandline */
-	obstack_printf(&ldflags_obst, "%s ", LINKER);
+	const char *linker = getenv("CPARSER_LINK");
+	if (linker != NULL) {
+		obstack_printf(&ldflags_obst, "%s ", linker);
+	} else {
+		if (target_triple != NULL)
+			obstack_printf(&ldflags_obst, "%s-", target_triple);
+		obstack_printf(&ldflags_obst, "%s ", LINKER);
+	}
+	obstack_printf(&ldflags_obst, "%s ", linker);
 	obstack_printf(&ldflags_obst, "%s", flags);
 	obstack_1grow(&ldflags_obst, '\0');
 
 	char *commandline = obstack_finish(&ldflags_obst);
-
 	if (verbose) {
 		puts(commandline);
 	}
 	int err = system(commandline);
 	if (err != EXIT_SUCCESS) {
 		fprintf(stderr, "linker reported an error\n");
-		exit(1);
+		exit(EXIT_FAILURE);
 	}
+	obstack_free(&ldflags_obst, commandline);
 }
 
 static const char *try_dir(const char *dir)
@@ -446,12 +475,12 @@ static FILE *make_temp_file(char *buffer, size_t buflen, const char *prefix)
 	if (fd == -1) {
 		fprintf(stderr, "couldn't create temporary file: %s\n",
 		        strerror(errno));
-		exit(1);
+		exit(EXIT_FAILURE);
 	}
 	FILE *out = fdopen(fd, "w");
 	if (out == NULL) {
 		fprintf(stderr, "couldn't create temporary file FILE*\n");
-		exit(1);
+		exit(EXIT_FAILURE);
 	}
 
 	file_list_entry_t *entry = xmalloc(sizeof(*entry));
@@ -482,69 +511,252 @@ static void free_temp_files(void)
 	temp_files = NULL;
 }
 
-/**
- * Do the necessary lowering for compound parameters.
- */
-void lower_compound_params(void)
-{
-	lower_params_t params;
-
-	params.def_ptr_alignment    = 4;
-	params.flags                = LF_COMPOUND_RETURN | LF_RETURN_HIDDEN;
-	params.hidden_params        = ADD_HIDDEN_ALWAYS_IN_FRONT;
-	params.find_pointer_type    = NULL;
-	params.ret_compound_in_regs = NULL;
-	lower_calls_with_compounds(&params);
-}
-
 typedef enum compile_mode_t {
 	BenchmarkParser,
 	PreprocessOnly,
 	ParseOnly,
 	Compile,
 	CompileDump,
+	CompileExportIR,
 	CompileAssemble,
 	CompileAssembleLink,
 	LexTest,
 	PrintAst,
 	PrintFluffy,
-	PrintCaml
+	PrintJna
 } compile_mode_t;
 
 static void usage(const char *argv0)
 {
-	fprintf(stderr, "Usage %s input [-o output] [-c]\n", argv0);
+	fprintf(stderr, "Usage %s [options] input [-o output]\n", argv0);
 }
 
-static void print_cparser_version(void) {
+static void print_cparser_version(void)
+{
 	printf("cparser (%s) using libFirm (%u.%u",
-	       cparser_REVISION, firm_get_version_major(),
-	       firm_get_version_minor());
+	       cparser_REVISION, ir_get_version_major(),
+	       ir_get_version_minor());
 
-	const char *revision = firm_get_version_revision();
+	const char *revision = ir_get_version_revision();
 	if (revision[0] != 0) {
 		putchar(' ');
 		fputs(revision, stdout);
 	}
 
-	const char *build = firm_get_version_build();
+	const char *build = ir_get_version_build();
 	if (build[0] != 0) {
 		putchar(' ');
 		fputs(build, stdout);
 	}
-	puts(")\n");
+	puts(")");
+	puts("This is free software; see the source for copying conditions.  There is NO\n"
+	     "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n");
 }
 
-static void set_be_option(const char *arg)
+static void print_help_basic(const char *argv0)
+{
+	usage(argv0);
+	puts("");
+	put_help("--help",                   "Display this information");
+	put_help("--version",                "Display compiler version");
+	put_help("--help-parser",            "Display information about parser options");
+	put_help("--help-warnings",          "Display information about warning options");
+	put_help("--help-codegen",           "Display information about code-generation options");
+	put_help("--help-optimization",      "Display information about optimization options");
+	put_help("--help-linker",            "Display information about linker options");
+	put_help("--help-language-tools",    "Display information about language tools options");
+	put_help("--help-debug",             "Display information about compiler debugging options");
+	put_help("--help-firm",              "Display information about direct firm options");
+	put_help("--help-all",               "Display information about all options");
+	put_help("-c",                       "Compile and assemble but do not link");
+	put_help("-E",                       "Preprocess only");
+	put_help("-S",                       "Compile but do not assembler or link");
+	put_help("-o",                       "Specify output file");
+	put_help("-v",                       "Verbose output (show invocation of sub-processes)");
+	put_help("-x",                       "Force input language:");
+	put_choice("c",                      "C");
+	put_choice("c++",                    "C++");
+	put_choice("assembler",              "Assembler (no preprocessing)");
+	put_choice("assembler-with-cpp",     "Assembler with preprocessing");
+	put_choice("none",                   "Autodetection");
+	put_help("-pipe",                    "ignored (gcc compatibility)");
+}
+
+static void print_help_preprocessor(void)
 {
-	int res = firm_be_option(arg);
+	put_help("-nostdinc",                "Do not search standard system include directories");
+	put_help("-trigraphs",               "Support ISO C trigraphs");
+	put_help("-isystem",                 "");
+	put_help("-include",                 "");
+	put_help("-I PATH",                  "");
+	put_help("-D SYMBOL[=value]",        "");
+	put_help("-U SYMBOL",                "");
+	put_help("-Wp,OPTION",               "pass option directly to preprocessor");
+	put_help("-M",                       "");
+	put_help("-MD",                      "");
+	put_help("-MMD",                     "");
+	put_help("-MM",                      "");
+	put_help("-MP",                      "");
+	put_help("-MT",                      "");
+	put_help("-MQ",                      "");
+	put_help("-MF",                      "");
+}
+
+static void print_help_parser(void)
+{
+	put_help("-finput-charset=CHARSET",  "Select encoding of input files");
+	put_help("-fmessage-length=LEN",     "ignored (gcc compatibility)");
+	put_help("-fshort-wchar",            "wchar_t is unsigned short instead of int");
+	put_help("-fshow-column",            "show the column number in diagnostic messages");
+	put_help("-funsigned-char",          "char is an unsigned type");
+	put_help("--ms",                     "Enable msvc extensions");
+	put_help("--no-ms",                  "Disable msvc extensions");
+	put_help("--gcc",                    "Enable gcc extensions");
+	put_help("--no-gcc",                 "Disable gcc extensions");
+	put_help("-std=STANDARD",            "Specify language standard:");
+	put_choice("c99",                    "ISO C99 standard");
+	put_choice("c89",                    "ISO C89 standard");
+	put_choice("c9x",                    "deprecated");
+	put_choice("c++",                    "ISO C++ 98");
+	put_choice("c++98",                  "ISO C++ 98");
+	put_choice("gnu99",                  "ISO C99 + GNU extensions (default)");
+	put_choice("gnu89",                  "ISO C89 + GNU extensions");
+	put_choice("gnu9x",                  "deprecated");
+	put_choice("iso9899:1990",           "ISO C89");
+	put_choice("iso9899:199409",         "ISO C90");
+	put_choice("iso9899:1999",           "ISO C99");
+	put_choice("iso9899:199x",           "deprecated");
+	put_help("-pedantic",                "ignored (gcc compatibility)");
+	put_help("-ansi",                    "ignored (gcc compatibility)");
+	put_help("--strict",                 "Enable strict conformance checking");
+}
+
+static void print_help_warnings(void)
+{
+	put_help("-f[no-]diagnostics-show-option", "Show the switch, which controls a warning, after each warning");
+	put_help("-w",                             "disable all warnings");
+	put_help("-Wno-trigraphs",                 "warn if input contains trigraphs");
+	put_help("-Wundef",                        "Warn if an undefined macro is used in an #if");
+	print_warning_opt_help();
+}
+
+static void print_help_optimization(void)
+{
+	put_help("-O LEVEL",                 "select optimization level (0-4)");
+	firm_option_help(put_help);
+	put_help("-fexpensive-optimizations","ignored (gcc compatibility)");
+}
+
+static void print_help_codegeneration(void)
+{
+	put_help("-g",                       "Generate debug information");
+	put_help("-pg",                      "Instrument code for gnu gprof");
+	put_help("-fomit-frame-pointer",     "Produce code without frame pointer where possible");
+	put_help("-ffreestanding",           "compile in freestanding mode (see ISO C standard)");
+	put_help("-fhosted",                 "compile in hosted (not freestanding) mode");
+	put_help("-fprofile-generate",       "Generate instrumented code to collect profile information");
+	put_help("-fprofile-use",            "Use profile information generated by instrumented binaries");
+	put_help("-ffp-precise",             "precise floating point model");
+	put_help("-ffp-fast",                "imprecise floating point model");
+	put_help("-ffp-strict",              "strict floating point model");
+	put_help("-ffp-precise",             "precise floating point model");
+	put_help("-pthread",                 "Use pthread threading library");
+	put_help("-mtarget=TARGET",          "Specify target architecture as CPU-manufacturer-OS triple");
+	put_help("-mtriple=TARGET",          "alias for -mtarget (clang compatibility)");
+	put_help("-march=ARCH",              "");
+	put_help("-mtune=ARCH",              "");
+	put_help("-mcpu=CPU",                "");
+	put_help("-mfpmath=",                "");
+	put_help("-mpreferred-stack-boundary=", "");
+	put_help("-mrtd",                    "");
+	put_help("-mregparm=",               "not supported yet");
+	put_help("-msoft-float",             "not supported yet");
+	put_help("-m32",                     "generate 32bit code");
+	put_help("-m64",                     "generate 64bit code");
+	put_help("-fverbose-asm",            "ignored (gcc compatibility)");
+	put_help("-fjump-tables",            "ignored (gcc compatibility)");
+	put_help("-fcommon",                 "ignored (gcc compatibility)");
+	put_help("-foptimize-sibling-calls", "ignored (gcc compatibility)");
+	put_help("-falign-loops",            "ignored (gcc compatibility)");
+	put_help("-falign-jumps",            "ignored (gcc compatibility)");
+	put_help("-falign-functions",        "ignored (gcc compatibility)");
+	put_help("-fPIC",                    "ignored (gcc compatibility)");
+	put_help("-ffast-math",              "same as fp-fast (gcc compatibility)");
+	puts("");
+	puts("\tMost of these options can be used with a no- prefix to disable them");
+	puts("\te.g. -fno-signed-char");
+}
+
+static void print_help_linker(void)
+{
+	put_help("-l LIBRARY",               "");
+	put_help("-L PATH",                  "");
+	put_help("-shared",                  "Produce a shared library");
+	put_help("-static",                  "Produce statically linked binary");
+	put_help("-Wl,OPTION",               "pass option directly to linker");
+}
+
+static void print_help_debug(void)
+{
+	put_help("--lextest",                "Preprocess and tokenize only");
+	put_help("--print-ast",              "Preprocess, parse and print AST");
+	put_help("--print-implicit-cast",    "");
+	put_help("--print-parenthesis",      "");
+	put_help("--benchmark",              "Preprocess and parse, produces no output");
+	put_help("--time",                   "Measure time of compiler passes");
+	put_help("--dump-function func",     "Preprocess, parse and output vcg graph of func");
+	put_help("--export-ir",              "Preprocess, parse and output compiler intermediate representation");
+}
+
+static void print_help_language_tools(void)
+{
+	put_help("--print-fluffy",           "Preprocess, parse and generate declarations for the fluffy language");
+	put_help("--print-jna",              "Preprocess, parse and generate declarations for JNA");
+	put_help("--jna-limit filename",     "");
+	put_help("--jna-libname name",       "");
+}
+
+static void print_help_firm(void)
+{
+	put_help("-bOPTION",                 "directly pass option to libFirm backend");
+	int res = be_parse_arg("help");
 	(void) res;
 	assert(res);
 }
 
-static void set_option(const char *arg)
+typedef enum {
+	HELP_NONE          = 0,
+	HELP_BASIC         = 1u << 0,
+	HELP_PREPROCESSOR  = 1u << 1,
+	HELP_PARSER        = 1u << 2,
+	HELP_WARNINGS      = 1u << 3,
+	HELP_OPTIMIZATION  = 1u << 4,
+	HELP_CODEGEN       = 1u << 5,
+	HELP_LINKER        = 1u << 6,
+	HELP_LANGUAGETOOLS = 1u << 7,
+	HELP_DEBUG         = 1u << 8,
+	HELP_FIRM          = 1u << 9,
+
+	HELP_ALL           = (unsigned)-1
+} help_sections_t;
+
+static void print_help(const char *argv0, help_sections_t sections)
 {
-	int res = firm_option(arg);
+	if (sections & HELP_BASIC)         print_help_basic(argv0);
+	if (sections & HELP_PREPROCESSOR)  print_help_preprocessor();
+	if (sections & HELP_PARSER)        print_help_parser();
+	if (sections & HELP_WARNINGS)      print_help_warnings();
+	if (sections & HELP_OPTIMIZATION)  print_help_optimization();
+	if (sections & HELP_CODEGEN)       print_help_codegeneration();
+	if (sections & HELP_LINKER)        print_help_linker();
+	if (sections & HELP_LANGUAGETOOLS) print_help_language_tools();
+	if (sections & HELP_DEBUG)         print_help_debug();
+	if (sections & HELP_FIRM)          print_help_firm();
+}
+
+static void set_be_option(const char *arg)
+{
+	int res = be_parse_arg(arg);
 	(void) res;
 	assert(res);
 }
@@ -561,20 +773,6 @@ static void copy_file(FILE *dest, FILE *input)
 	}
 }
 
-static inline bool streq(char const* a, char const* b)
-{
-	return strcmp(a, b) == 0;
-}
-
-static inline bool strstart(char const* str, char const* start)
-{
-	do {
-		if (*start == '\0')
-			return true;
-	} while (*str++ == *start++);
-	return false;
-}
-
 static FILE *open_file(const char *filename)
 {
 	if (streq(filename, "-")) {
@@ -585,7 +783,7 @@ static FILE *open_file(const char *filename)
 	if (in == NULL) {
 		fprintf(stderr, "Couldn't open '%s': %s\n", filename,
 				strerror(errno));
-		exit(1);
+		exit(EXIT_FAILURE);
 	}
 
 	return in;
@@ -607,40 +805,63 @@ static filetype_t get_filetype_from_string(const char *string)
 	return FILETYPE_UNKNOWN;
 }
 
-static void init_os_support(void)
+static bool init_os_support(void)
 {
-	/* OS option must be set to the backend */
-	switch (firm_opt.os_support) {
-	case OS_SUPPORT_MINGW:
-		set_be_option("ia32-gasmode=mingw");
-		wchar_atomic_kind = ATOMIC_TYPE_USHORT;
-		break;
-	case OS_SUPPORT_LINUX:
-		set_be_option("ia32-gasmode=elf");
-		break;
-	case OS_SUPPORT_MACHO:
-		set_be_option("ia32-gasmode=macho");
-		set_be_option("ia32-stackalign=4");
-		set_be_option("pic");
-		break;
+	const char *os = target_machine->operating_system;
+	wchar_atomic_kind         = ATOMIC_TYPE_INT;
+	enable_main_collect2_hack = false;
+	define_intmax_types       = false;
+
+	if (strstr(os, "linux") != NULL || strstr(os, "bsd") != NULL
+			|| streq(os, "solaris")) {
+		set_create_ld_ident(create_name_linux_elf);
+	} else if (streq(os, "darwin")) {
+		long_double_size = 16;
+		set_create_ld_ident(create_name_macho);
+		define_intmax_types = true;
+	} else if (strstr(os, "mingw") != NULL || streq(os, "win32")) {
+		wchar_atomic_kind         = ATOMIC_TYPE_USHORT;
+		enable_main_collect2_hack = true;
+		set_create_ld_ident(create_name_win32);
+	} else {
+		return false;
 	}
+
+	return true;
 }
 
-typedef enum lang_standard_t {
-	STANDARD_DEFAULT, /* gnu99 (for C, GCC does gnu89) or gnu++98 (for C++) */
-	STANDARD_ANSI,    /* c89 (for C) or c++98 (for C++) */
-	STANDARD_C89,     /* ISO C90 (sic) */
-	STANDARD_C90,     /* ISO C90 as modified in amendment 1 */
-	STANDARD_C99,     /* ISO C99 */
-	STANDARD_GNU89,   /* ISO C90 plus GNU extensions (including some C99) */
-	STANDARD_GNU99,   /* ISO C99 plus GNU extensions */
-	STANDARD_CXX98,   /* ISO C++ 1998 plus amendments */
-	STANDARD_GNUXX98  /* ISO C++ 1998 plus amendments and GNU extensions */
-} lang_standard_t;
+static bool parse_target_triple(const char *arg)
+{
+	machine_triple_t *triple = firm_parse_machine_triple(arg);
+	if (triple == NULL) {
+		fprintf(stderr, "Target-triple is not in the form 'cpu_type-manufacturer-operating_system'\n");
+		return false;
+	}
+	target_machine = triple;
+	return true;
+}
+
+static void setup_target_machine(void)
+{
+	if (!setup_firm_for_machine(target_machine))
+		exit(1);
+
+	const backend_params *be_params = be_get_backend_param();
+	if (be_params->long_double_size % 8 != 0) {
+		fprintf(stderr, "firm-target long double size is not a multiple of 8, can't handle this\n");
+		exit(1);
+	}
+
+	byte_order_big_endian = be_params->byte_order_big_endian;
+	machine_size          = be_params->machine_size;
+	long_double_size      = be_params->long_double_size / 8;
+
+	init_os_support();
+}
 
 int main(int argc, char **argv)
 {
-	initialize_firm();
+	firm_early_init();
 
 	const char        *dumpfunction         = NULL;
 	const char        *print_file_name_file = NULL;
@@ -651,6 +872,9 @@ int main(int argc, char **argv)
 	file_list_entry_t *files                = NULL;
 	file_list_entry_t *last_file            = NULL;
 	bool               construct_dep_target = false;
+	bool               do_timing            = false;
+	bool               profile_generate     = false;
+	bool               profile_use          = false;
 	struct obstack     file_obst;
 
 	atexit(free_temp_files);
@@ -663,28 +887,31 @@ int main(int argc, char **argv)
 
 	obstack_init(&cppflags_obst);
 	obstack_init(&ldflags_obst);
+	obstack_init(&asflags_obst);
 	obstack_init(&file_obst);
 
 #define GET_ARG_AFTER(def, args)                                             \
+	do {                                                                     \
 	def = &arg[sizeof(args)-1];                                              \
-	if (def[0] == '\0') {                                                     \
+	if (def[0] == '\0') {                                                    \
 		++i;                                                                 \
-		if (i >= argc) {                                                      \
+		if (i >= argc) {                                                     \
 			fprintf(stderr, "error: expected argument after '" args "'\n");  \
 			argument_errors = true;                                          \
 			break;                                                           \
 		}                                                                    \
 		def = argv[i];                                                       \
-		if (def[0] == '-' && def[1] != '\0') {                                \
+		if (def[0] == '-' && def[1] != '\0') {                               \
 			fprintf(stderr, "error: expected argument after '" args "'\n");  \
 			argument_errors = true;                                          \
 			continue;                                                        \
 		}                                                                    \
-	}
+	}                                                                        \
+	} while (0)
 
 #define SINGLE_OPTION(ch) (option[0] == (ch) && option[1] == '\0')
 
-	/* early options parsing (find out optimisation level and OS) */
+	/* early options parsing (find out optimization level and OS) */
 	for (int i = 1; i < argc; ++i) {
 		const char *arg = argv[i];
 		if (arg[0] != '-')
@@ -694,48 +921,23 @@ int main(int argc, char **argv)
 		if (option[0] == 'O') {
 			sscanf(&option[1], "%d", &opt_level);
 		}
-		if (strcmp(arg, "-fwin32") == 0) {
-			firm_opt.os_support = OS_SUPPORT_MINGW;
-		} else if (strcmp(arg, "-fmac") == 0) {
-			firm_opt.os_support = OS_SUPPORT_MACHO;
-		} else if (strcmp(arg, "-flinux") == 0) {
-			firm_opt.os_support = OS_SUPPORT_LINUX;
-		}
 	}
 
-	/* set target/os specific stuff */
-	init_os_support();
-
-	/* apply optimisation level */
-	switch(opt_level) {
-	case 0:
-		set_option("no-opt");
-		break;
-	case 1:
-		set_option("no-inline");
-		break;
-	default:
-	case 4:
-		set_option("strict-aliasing");
-		/* use_builtins = true; */
-		/* fallthrough */
-	case 3:
-		set_option("cond-eval");
-		set_option("if-conv");
-		/* fallthrough */
-	case 2:
-		set_option("inline");
-		set_option("deconv");
-		set_be_option("omitfp");
-		break;
+	const char *target = getenv("TARGET");
+	if (target != NULL)
+		parse_target_triple(target);
+	if (target_machine == NULL) {
+		target_machine = firm_get_host_machine();
 	}
+	choose_optimization_pack(opt_level);
+	setup_target_machine();
 
 	/* parse rest of options */
-	lang_standard_t standard        = STANDARD_DEFAULT;
+	                standard        = STANDARD_DEFAULT;
 	unsigned        features_on     = 0;
 	unsigned        features_off    = 0;
 	filetype_t      forced_filetype = FILETYPE_AUTODETECT;
-	bool            help_displayed  = false;
+	help_sections_t help            = HELP_NONE;
 	bool            argument_errors = false;
 	for (int i = 1; i < argc; ++i) {
 		const char *arg = argv[i];
@@ -779,7 +981,7 @@ int main(int argc, char **argv)
 			} else if (SINGLE_OPTION('v')) {
 				verbose = 1;
 			} else if (SINGLE_OPTION('w')) {
-				memset(&warning, 0, sizeof(warning));
+				disable_all_warnings();
 			} else if (option[0] == 'x') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-x");
@@ -815,23 +1017,49 @@ int main(int argc, char **argv)
 				GET_ARG_AFTER(opt, "-isystem");
 				add_flag(&cppflags_obst, "-isystem");
 				add_flag(&cppflags_obst, "%s", opt);
+#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__CYGWIN__)
+			} else if (streq(option, "pthread")) {
+				/* set flags for the preprocessor */
+				add_flag(&cppflags_obst, "-D_REENTRANT");
+				/* set flags for the linker */
+				add_flag(&ldflags_obst, "-lpthread");
+#endif
 			} else if (streq(option, "nostdinc")
 					|| streq(option, "trigraphs")) {
 				/* pass these through to the preprocessor */
 				add_flag(&cppflags_obst, "%s", arg);
 			} else if (streq(option, "pipe")) {
 				/* here for gcc compatibility */
+			} else if (streq(option, "static")) {
+				add_flag(&ldflags_obst, "-static");
+			} else if (streq(option, "shared")) {
+				add_flag(&ldflags_obst, "-shared");
 			} else if (option[0] == 'f') {
 				char const *orig_opt;
 				GET_ARG_AFTER(orig_opt, "-f");
 
-				if (strstart(orig_opt, "align-loops=") ||
-				    strstart(orig_opt, "align-jumps=") ||
-				    strstart(orig_opt, "align-functions=")) {
+				if (strstart(orig_opt, "input-charset=")) {
+					char const* const encoding = strchr(orig_opt, '=') + 1;
+					select_input_encoding(encoding);
+				} else if (strstart(orig_opt, "align-loops=") ||
+				           strstart(orig_opt, "align-jumps=") ||
+				           strstart(orig_opt, "align-functions=")) {
 					fprintf(stderr, "ignoring gcc option '-f%s'\n", orig_opt);
-				} else if (streq(orig_opt, "verbose-asm")) {
-					/* ignore: we always print verbose assembler */
+				} else if (strstart(orig_opt, "visibility=")) {
+					const char *val = strchr(orig_opt, '=')+1;
+					elf_visibility_tag_t visibility
+						= get_elf_visibility_from_string(val);
+					if (visibility == ELF_VISIBILITY_ERROR) {
+						fprintf(stderr, "invalid visibility '%s' specified\n",
+						        val);
+						argument_errors = true;
+					} else {
+						set_default_visibility(visibility);
+					}
+				} else if (strstart(orig_opt, "message-length=")) {
+					/* ignore: would only affect error message format */
 				} else {
+					/* -f options which have an -fno- variant */
 					char const *opt         = orig_opt;
 					bool        truth_value = true;
 					if (opt[0] == 'n' && opt[1] == 'o' && opt[2] == '-') {
@@ -839,29 +1067,60 @@ int main(int argc, char **argv)
 						opt += 3;
 					}
 
-					if (streq(opt, "dollars-in-identifiers")) {
-						allow_dollar_in_symbol = truth_value;
-					} if (streq(opt, "builtins")) {
+					if (streq(opt, "builtins")) {
 						use_builtins = truth_value;
+					} else if (streq(opt, "diagnostics-show-option")) {
+						diagnostics_show_option = truth_value;
+					} else if (streq(opt, "dollars-in-identifiers")) {
+						allow_dollar_in_symbol = truth_value;
+					} else if (streq(opt, "omit-frame-pointer")) {
+						set_be_option(truth_value ? "omitfp" : "omitfp=no");
 					} else if (streq(opt, "short-wchar")) {
 						wchar_atomic_kind = truth_value ? ATOMIC_TYPE_USHORT
 							: ATOMIC_TYPE_INT;
+					} else if (streq(opt, "show-column")) {
+						show_column = truth_value;
+					} else if (streq(opt, "signed-char")) {
+						char_is_signed = truth_value;
+					} else if (streq(opt, "strength-reduce")) {
+						/* does nothing, for gcc compatibility (even gcc does
+						 * nothing for this switch anymore) */
 					} else if (streq(opt, "syntax-only")) {
 						mode = truth_value ? ParseOnly : CompileAssembleLink;
-					} else if (streq(opt, "omit-frame-pointer")) {
-						set_be_option(truth_value ? "omitfp" : "omitfp=no");
-					} else if (streq(opt, "strength-reduce")) {
-						firm_option(truth_value ? "strength-red" : "no-strength-red");
-					} else if (streq(opt, "fast-math")               ||
-					           streq(opt, "jump-tables")             ||
-					           streq(opt, "unroll-loops")            ||
+					} else if (streq(opt, "unsigned-char")) {
+						char_is_signed = !truth_value;
+					} else if (streq(opt, "freestanding")) {
+						freestanding = truth_value;
+					} else if (streq(opt, "hosted")) {
+						freestanding = !truth_value;
+					} else if (streq(opt, "profile-generate")) {
+						profile_generate = truth_value;
+					} else if (streq(opt, "profile-use")) {
+						profile_use = truth_value;
+					} else if (!truth_value &&
+					           streq(opt, "asynchronous-unwind-tables")) {
+					    /* nothing todo, a gcc feature which we don't support
+					     * anyway was deactivated */
+					} else if (streq(opt, "verbose-asm")) {
+						/* ignore: we always print verbose assembler */
+					} else if (streq(opt, "fast-math") || streq(opt, "fp-fast")) {
+						firm_fp_model = fp_model_fast;
+					} else if (streq(opt, "fp-precise")) {
+						firm_fp_model = fp_model_precise;
+					} else if (streq(opt, "fp-strict")) {
+						firm_fp_model = fp_model_strict;
+					} else if (streq(opt, "jump-tables")             ||
 					           streq(opt, "expensive-optimizations") ||
 					           streq(opt, "common")                  ||
-					           streq(opt, "PIC")                     ||
+					           streq(opt, "optimize-sibling-calls")  ||
 					           streq(opt, "align-loops")             ||
 					           streq(opt, "align-jumps")             ||
-					           streq(opt, "align-functions")) {
+					           streq(opt, "align-functions")         ||
+					           streq(opt, "PIC")) {
 						fprintf(stderr, "ignoring gcc option '-f%s'\n", orig_opt);
+					} else if (streq(opt, "help")) {
+						fprintf(stderr, "warning: -fhelp is deprecated\n");
+						help |= HELP_OPTIMIZATION;
 					} else {
 						int res = firm_option(orig_opt);
 						if (res == 0) {
@@ -869,23 +1128,25 @@ int main(int argc, char **argv)
 							        orig_opt);
 							argument_errors = true;
 							continue;
-						} else if (res == -1) {
-							help_displayed = true;
 						}
 					}
 				}
 			} else if (option[0] == 'b') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-b");
-				int res = firm_be_option(opt);
-				if (res == 0) {
-					fprintf(stderr, "error: unknown Firm backend option '-b %s'\n",
-					        opt);
-					argument_errors = true;
-				} else if (res == -1) {
-					help_displayed = true;
-				} else if (strstart(opt, "isa=")) {
-					strncpy(cpu_arch, opt, sizeof(cpu_arch));
+
+				if (streq(opt, "help")) {
+					fprintf(stderr, "warning: -bhelp is deprecated (use --help-firm)\n");
+					help |= HELP_FIRM;
+				} else {
+					int res = be_parse_arg(opt);
+					if (res == 0) {
+						fprintf(stderr, "error: unknown Firm backend option '-b %s'\n",
+								opt);
+						argument_errors = true;
+					} else if (strstart(opt, "isa=")) {
+						strncpy(cpu_arch, opt, sizeof(cpu_arch));
+					}
 				}
 			} else if (option[0] == 'W') {
 				if (strstart(option + 1, "p,")) {
@@ -910,28 +1171,43 @@ int main(int argc, char **argv)
 				char arch_opt[64];
 
 				GET_ARG_AFTER(opt, "-m");
-				if (strstart(opt, "arch=")) {
+				if (strstart(opt, "target=")) {
+					GET_ARG_AFTER(opt, "-mtarget=");
+					if (!parse_target_triple(opt)) {
+						argument_errors = true;
+					} else {
+						setup_target_machine();
+						target_triple = opt;
+					}
+				} else if (strstart(opt, "triple=")) {
+					GET_ARG_AFTER(opt, "-mtriple=");
+					if (!parse_target_triple(opt)) {
+						argument_errors = true;
+					} else {
+						setup_target_machine();
+						target_triple = opt;
+					}
+				} else if (strstart(opt, "arch=")) {
 					GET_ARG_AFTER(opt, "-march=");
 					snprintf(arch_opt, sizeof(arch_opt), "%s-arch=%s", cpu_arch, opt);
-					int res = firm_be_option(arch_opt);
-					if (res == 0)
+					int res = be_parse_arg(arch_opt);
+					snprintf(arch_opt, sizeof(arch_opt), "%s-opt=%s", cpu_arch, opt);
+					res &= be_parse_arg(arch_opt);
+
+					if (res == 0) {
+						fprintf(stderr, "Unknown architecture '%s'\n", arch_opt);
 						argument_errors = true;
-					else {
-						snprintf(arch_opt, sizeof(arch_opt), "%s-opt=%s", cpu_arch, opt);
-						int res = firm_be_option(arch_opt);
-						if (res == 0)
-							argument_errors = true;
 					}
 				} else if (strstart(opt, "tune=")) {
 					GET_ARG_AFTER(opt, "-mtune=");
 					snprintf(arch_opt, sizeof(arch_opt), "%s-opt=%s", cpu_arch, opt);
-					int res = firm_be_option(arch_opt);
+					int res = be_parse_arg(arch_opt);
 					if (res == 0)
 						argument_errors = true;
 				} else if (strstart(opt, "cpu=")) {
 					GET_ARG_AFTER(opt, "-mcpu=");
 					snprintf(arch_opt, sizeof(arch_opt), "%s-arch=%s", cpu_arch, opt);
-					int res = firm_be_option(arch_opt);
+					int res = be_parse_arg(arch_opt);
 					if (res == 0)
 						argument_errors = true;
 				} else if (strstart(opt, "fpmath=")) {
@@ -941,37 +1217,42 @@ int main(int argc, char **argv)
 					else if (streq(opt, "sse"))
 						opt = "sse2";
 					else {
-						fprintf(stderr, "error: option -mfpumath supports only 387 or sse\n");
+						fprintf(stderr, "error: option -mfpmath supports only 387 or sse\n");
 						argument_errors = true;
 					}
 					if (!argument_errors) {
 						snprintf(arch_opt, sizeof(arch_opt), "%s-fpunit=%s", cpu_arch, opt);
-						int res = firm_be_option(arch_opt);
+						int res = be_parse_arg(arch_opt);
 						if (res == 0)
 							argument_errors = true;
 					}
 				} else if (strstart(opt, "preferred-stack-boundary=")) {
 					GET_ARG_AFTER(opt, "-mpreferred-stack-boundary=");
 					snprintf(arch_opt, sizeof(arch_opt), "%s-stackalign=%s", cpu_arch, opt);
-					int res = firm_be_option(arch_opt);
+					int res = be_parse_arg(arch_opt);
 					if (res == 0)
 						argument_errors = true;
-				} else if (streq(opt, "omit-leaf-frame-pointer")) {
-					set_be_option("omitleaffp=1");
-				} else if (streq(opt, "no-omit-leaf-frame-pointer")) {
-					set_be_option("omitleaffp=0");
+				} else if (streq(opt, "rtd")) {
+					default_calling_convention = CC_STDCALL;
+				} else if (strstart(opt, "regparm=")) {
+					fprintf(stderr, "error: regparm convention not supported yet\n");
+					argument_errors = true;
+				} else if (streq(opt, "soft-float")) {
+					fprintf(stderr, "error: software floatingpoint not supported yet\n");
+					argument_errors = true;
 				} else {
-					char *endptr;
-					long int value = strtol(opt, &endptr, 10);
-					if (*endptr != '\0') {
+					long int value = strtol(opt, NULL, 10);
+					if (value == 0) {
 						fprintf(stderr, "error: wrong option '-m %s'\n",  opt);
 						argument_errors = true;
-					}
-					if (value != 16 && value != 32 && value != 64) {
+					} else if (value != 16 && value != 32 && value != 64) {
 						fprintf(stderr, "error: option -m supports only 16, 32 or 64\n");
 						argument_errors = true;
 					} else {
-						machine_size = (unsigned int)value;
+						add_flag(&cppflags_obst, "-m%u", machine_size);
+						add_flag(&asflags_obst, "-m%u", machine_size);
+						add_flag(&ldflags_obst, "-m%u", machine_size);
+						/* TODO: choose/change backend based on this */
 					}
 				}
 			} else if (streq(option, "pg")) {
@@ -980,8 +1261,6 @@ int main(int argc, char **argv)
 			} else if (streq(option, "pedantic") ||
 			           streq(option, "ansi")) {
 				fprintf(stderr, "warning: ignoring gcc option '%s'\n", arg);
-			} else if (streq(option, "shared")) {
-				add_flag(&ldflags_obst, "-shared");
 			} else if (strstart(option, "std=")) {
 				const char *const o = &option[4];
 				standard =
@@ -1018,10 +1297,6 @@ int main(int argc, char **argv)
 				} else if (streq(option, "no-ms")) {
 					features_on  &= ~_MS;
 					features_off |=  _MS;
-				} else if (streq(option, "signed-chars")) {
-					char_is_signed = true;
-				} else if (streq(option, "unsigned-chars")) {
-					char_is_signed = false;
 				} else if (streq(option, "strict")) {
 					strict_mode = true;
 				} else if (streq(option, "lextest")) {
@@ -1036,11 +1311,51 @@ int main(int argc, char **argv)
 					print_parenthesis = true;
 				} else if (streq(option, "print-fluffy")) {
 					mode = PrintFluffy;
-				} else if (streq(option, "print-caml")) {
-					mode = PrintCaml;
+				} else if (streq(option, "print-jna")) {
+					mode = PrintJna;
+				} else if (streq(option, "jna-limit")) {
+					++i;
+					if (i >= argc) {
+						fprintf(stderr, "error: "
+						        "expected argument after '--jna-limit'\n");
+						argument_errors = true;
+						break;
+					}
+					jna_limit_output(argv[i]);
+				} else if (streq(option, "jna-libname")) {
+					++i;
+					if (i >= argc) {
+						fprintf(stderr, "error: "
+						        "expected argument after '--jna-libname'\n");
+						argument_errors = true;
+						break;
+					}
+					jna_set_libname(argv[i]);
+				} else if (streq(option, "time")) {
+					do_timing = true;
 				} else if (streq(option, "version")) {
 					print_cparser_version();
-					exit(EXIT_SUCCESS);
+					return EXIT_SUCCESS;
+				} else if (streq(option, "help")) {
+					help |= HELP_BASIC;
+				} else if (streq(option, "help-parser")) {
+					help |= HELP_PARSER;
+				} else if (streq(option, "help-warnings")) {
+					help |= HELP_WARNINGS;
+				} else if (streq(option, "help-codegen")) {
+					help |= HELP_CODEGEN;
+				} else if (streq(option, "help-linker")) {
+					help |= HELP_LINKER;
+				} else if (streq(option, "help-optimization")) {
+					help |= HELP_OPTIMIZATION;
+				} else if (streq(option, "help-language-tools")) {
+					help |= HELP_LANGUAGETOOLS;
+				} else if (streq(option, "help-debug")) {
+					help |= HELP_DEBUG;
+				} else if (streq(option, "help-firm")) {
+					help |= HELP_FIRM;
+				} else if (streq(option, "help-all")) {
+					help |= HELP_ALL;
 				} else if (streq(option, "dump-function")) {
 					++i;
 					if (i >= argc) {
@@ -1051,6 +1366,8 @@ int main(int argc, char **argv)
 					}
 					dumpfunction = argv[i];
 					mode         = CompileDump;
+				} else if (streq(option, "export-ir")) {
+					mode = CompileExportIR;
 				} else {
 					fprintf(stderr, "error: unknown argument '%s'\n", arg);
 					argument_errors = true;
@@ -1074,21 +1391,23 @@ int main(int argc, char **argv)
 							streq(suffix, "S")   ? FILETYPE_ASSEMBLER              :
 							streq(suffix, "a")   ? FILETYPE_OBJECT                 :
 							streq(suffix, "c")   ? FILETYPE_C                      :
+							streq(suffix, "i")   ? FILETYPE_PREPROCESSED_C         :
+							streq(suffix, "C")   ? FILETYPE_CXX                    :
 							streq(suffix, "cc")  ? FILETYPE_CXX                    :
+							streq(suffix, "cp")  ? FILETYPE_CXX                    :
 							streq(suffix, "cpp") ? FILETYPE_CXX                    :
+							streq(suffix, "CPP") ? FILETYPE_CXX                    :
 							streq(suffix, "cxx") ? FILETYPE_CXX                    :
+							streq(suffix, "c++") ? FILETYPE_CXX                    :
+							streq(suffix, "ii")  ? FILETYPE_PREPROCESSED_CXX       :
 							streq(suffix, "h")   ? FILETYPE_C                      :
+							streq(suffix, "ir")  ? FILETYPE_IR                     :
 							streq(suffix, "o")   ? FILETYPE_OBJECT                 :
 							streq(suffix, "s")   ? FILETYPE_PREPROCESSED_ASSEMBLER :
 							streq(suffix, "so")  ? FILETYPE_OBJECT                 :
-							FILETYPE_AUTODETECT;
+							FILETYPE_OBJECT; /* gcc behavior: unknown file extension means object file */
 					}
 				}
-
-				if (type == FILETYPE_AUTODETECT) {
-					fprintf(stderr, "'%s': file format not recognized\n", arg);
-					continue;
-				}
 			}
 
 			file_list_entry_t *entry
@@ -1106,26 +1425,35 @@ int main(int argc, char **argv)
 		}
 	}
 
+	if (help != HELP_NONE) {
+		print_help(argv[0], help);
+		return !argument_errors;
+	}
+
 	if (print_file_name_file != NULL) {
 		print_file_name(print_file_name_file);
-		return 0;
+		return EXIT_SUCCESS;
 	}
-
 	if (files == NULL) {
 		fprintf(stderr, "error: no input files specified\n");
 		argument_errors = true;
 	}
 
-	if (help_displayed) {
-		return !argument_errors;
-	}
 	if (argument_errors) {
 		usage(argv[0]);
-		return 1;
+		return EXIT_FAILURE;
 	}
 
-	/* we do the lowering in ast2firm */
-	firm_opt.lower_bitfields = FALSE;
+	/* apply some effects from switches */
+	c_mode |= features_on;
+	c_mode &= ~features_off;
+	if (profile_generate) {
+		add_flag(&ldflags_obst, "-lfirmprof");
+		set_be_option("profilegenerate");
+	}
+	if (profile_use) {
+		set_be_option("profileuse");
+	}
 
 	gen_firm_init();
 	init_symbol_table();
@@ -1138,6 +1466,9 @@ int main(int argc, char **argv)
 	init_ast2firm();
 	init_mangle();
 
+	if (do_timing)
+		timer_init();
+
 	if (construct_dep_target) {
 		if (outname != 0 && strlen(outname) >= 2) {
 			get_output_name(dep_target, sizeof(dep_target), outname, ".d");
@@ -1156,7 +1487,7 @@ int main(int argc, char **argv)
 		case BenchmarkParser:
 		case PrintAst:
 		case PrintFluffy:
-		case PrintCaml:
+		case PrintJna:
 		case LexTest:
 		case PreprocessOnly:
 		case ParseOnly:
@@ -1175,6 +1506,10 @@ int main(int argc, char **argv)
 			                ".vcg");
 			outname = outnamebuf;
 			break;
+		case CompileExportIR:
+			get_output_name(outnamebuf, sizeof(outnamebuf), filename, ".ir");
+			outname = outnamebuf;
+			break;
 		case CompileAssembleLink:
 #ifdef _WIN32
 			outname = "a.exe";
@@ -1195,11 +1530,12 @@ int main(int argc, char **argv)
 		if (out == NULL) {
 			fprintf(stderr, "Couldn't open '%s' for writing: %s\n", outname,
 					strerror(errno));
-			return 1;
+			return EXIT_FAILURE;
 		}
 	}
 
 	file_list_entry_t *file;
+	bool               already_constructed_firm = false;
 	for (file = files; file != NULL; file = file->next) {
 		char        asm_tempfile[1024];
 		const char *filename = file->name;
@@ -1214,40 +1550,40 @@ int main(int argc, char **argv)
 				in = open_file(filename);
 			lextest(in, filename);
 			fclose(in);
-			exit(EXIT_SUCCESS);
+			return EXIT_SUCCESS;
 		}
 
 		FILE *preprocessed_in = NULL;
+		filetype_t next_filetype = filetype;
 		switch (filetype) {
 			case FILETYPE_C:
-				filetype = FILETYPE_PREPROCESSED_C;
+				next_filetype = FILETYPE_PREPROCESSED_C;
 				goto preprocess;
 			case FILETYPE_CXX:
-				filetype = FILETYPE_PREPROCESSED_CXX;
+				next_filetype = FILETYPE_PREPROCESSED_CXX;
 				goto preprocess;
 			case FILETYPE_ASSEMBLER:
-				filetype = FILETYPE_PREPROCESSED_ASSEMBLER;
-				add_flag(&cppflags_obst, "-x");
-				add_flag(&cppflags_obst, "assembler-with-cpp");
+				next_filetype = FILETYPE_PREPROCESSED_ASSEMBLER;
 				goto preprocess;
 preprocess:
 				/* no support for input on FILE* yet */
 				if (in != NULL)
 					panic("internal compiler error: in for preprocessor != NULL");
 
-				preprocessed_in = preprocess(filename);
+				preprocessed_in = preprocess(filename, filetype);
 				if (mode == PreprocessOnly) {
 					copy_file(out, preprocessed_in);
-					int result = pclose(preprocessed_in);
+					int pp_result = pclose(preprocessed_in);
 					fclose(out);
 					/* remove output file in case of error */
-					if (out != stdout && result != EXIT_SUCCESS) {
+					if (out != stdout && pp_result != EXIT_SUCCESS) {
 						unlink(outname);
 					}
-					return result;
+					return pp_result;
 				}
 
 				in = preprocessed_in;
+				filetype = next_filetype;
 				break;
 
 			default:
@@ -1270,7 +1606,7 @@ preprocess:
 			switch (standard) {
 				case STANDARD_ANSI:
 				case STANDARD_C89:   c_mode = _C89;                break;
-				/* TODO ^v determine difference between these two */
+				/* TODO determine difference between these two */
 				case STANDARD_C90:   c_mode = _C89;                break;
 				case STANDARD_C99:   c_mode = _C89 | _C99;         break;
 				case STANDARD_GNU89: c_mode = _C89 |        _GNUC; break;
@@ -1310,13 +1646,18 @@ default_cxx_warn:
 do_parsing:
 			c_mode |= features_on;
 			c_mode &= ~features_off;
+
+			/* do the actual parsing */
+			ir_timer_t *t_parsing = ir_timer_new();
+			timer_register(t_parsing, "Frontend: Parsing");
+			timer_push(t_parsing);
 			init_tokens();
 			translation_unit_t *const unit = do_parsing(in, filename);
+			timer_pop(t_parsing);
 
 			/* prints the AST even if errors occurred */
 			if (mode == PrintAst) {
-				type_set_output(out);
-				ast_set_output(out);
+				print_to_file(out);
 				print_ast(unit);
 			}
 
@@ -1336,7 +1677,7 @@ do_parsing:
 					/* remove output file */
 					if (out != stdout)
 						unlink(outname);
-					exit(EXIT_FAILURE);
+					return EXIT_FAILURE;
 				}
 			}
 
@@ -1345,13 +1686,23 @@ do_parsing:
 			} else if (mode == PrintFluffy) {
 				write_fluffy_decls(out, unit);
 				continue;
-			} else if (mode == PrintCaml) {
-				write_caml_decls(out, unit);
+			} else if (mode == PrintJna) {
+				write_jna_decls(out, unit);
 				continue;
 			}
 
+			/* build the firm graph */
+			ir_timer_t *t_construct = ir_timer_new();
+			timer_register(t_construct, "Frontend: Graph construction");
+			timer_push(t_construct);
+			if (already_constructed_firm) {
+				panic("compiling multiple files/translation units not possible");
+			}
 			translation_unit_to_firm(unit);
+			already_constructed_firm = true;
+			timer_pop(t_construct);
 
+graph_built:
 			if (mode == ParseOnly) {
 				continue;
 			}
@@ -1373,19 +1724,28 @@ do_parsing:
 				if (irg == NULL) {
 					fprintf(stderr, "No graph for function '%s' found\n",
 					        dumpfunction);
-					exit(1);
+					return EXIT_FAILURE;
 				}
 
-				dump_ir_block_graph_file(irg, out);
+				dump_ir_graph_file(out, irg);
+				fclose(out);
+				return EXIT_SUCCESS;
+			}
+
+			if (mode == CompileExportIR) {
 				fclose(out);
-				exit(0);
+				ir_export(outname);
+				return EXIT_SUCCESS;
 			}
 
-			gen_firm_finish(asm_out, filename, /*c_mode=*/1,
-			                have_const_functions);
+			gen_firm_finish(asm_out, filename);
 			if (asm_out != out) {
 				fclose(asm_out);
 			}
+		} else if (filetype == FILETYPE_IR) {
+			fclose(in);
+			ir_import(filename);
+			goto graph_built;
 		} else if (filetype == FILETYPE_PREPROCESSED_ASSEMBLER) {
 			copy_file(asm_out, in);
 			if (in == preprocessed_in) {
@@ -1446,7 +1806,15 @@ do_parsing:
 		const char *flags = obstack_finish(&ldflags_obst);
 
 		/* construct commandline */
-		obstack_printf(&file_obst, "%s", LINKER);
+		const char *linker = getenv("CPARSER_LINK");
+		if (linker != NULL) {
+			obstack_printf(&file_obst, "%s ", linker);
+		} else {
+			if (target_triple != NULL)
+				obstack_printf(&file_obst, "%s-", target_triple);
+			obstack_printf(&file_obst, "%s ", LINKER);
+		}
+
 		for (file_list_entry_t *entry = files; entry != NULL;
 				entry = entry->next) {
 			if (entry->type != FILETYPE_OBJECT)
@@ -1468,12 +1836,16 @@ do_parsing:
 		int err = system(commandline);
 		if (err != EXIT_SUCCESS) {
 			fprintf(stderr, "linker reported an error\n");
-			exit(1);
+			return EXIT_FAILURE;
 		}
 	}
 
+	if (do_timing)
+		timer_term(stderr);
+
 	obstack_free(&cppflags_obst, NULL);
 	obstack_free(&ldflags_obst, NULL);
+	obstack_free(&asflags_obst, NULL);
 	obstack_free(&file_obst, NULL);
 
 	exit_mangle();
@@ -1485,5 +1857,5 @@ do_parsing:
 	exit_types();
 	exit_tokens();
 	exit_symbol_table();
-	return 0;
+	return EXIT_SUCCESS;
 }