X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=main.c;h=85964f0454f92d486e6ac94fe2f674040f1d5f98;hb=6833c6f5a5ade3d5ad0c9ec21c9a89b7985517f4;hp=d91bb0bd64c21220334918e108965e2579b87d77;hpb=f6ce055c234d29a630518ce0566eae0b75cd128a;p=cparser

diff --git a/main.c b/main.c
index d91bb0b..85964f0 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
@@ -50,16 +50,13 @@
 #define fdopen(fd, mode)         _fdopen(fd, mode)
 #define popen(cmd, mode)         _popen(cmd, mode)
 #define pclose(file)             _pclose(file)
+#define unlink(filename)         _unlink(filename)
 
 #else
 #include <unistd.h>
 #define HAVE_MKSTEMP
 #endif
 
-#ifndef WITH_LIBCORE
-#define WITH_LIBCORE
-#endif
-
 #include <libfirm/firm.h>
 #include <libfirm/be.h>
 
@@ -68,52 +65,73 @@
 #include "types.h"
 #include "type_hash.h"
 #include "parser.h"
+#include "type_t.h"
 #include "ast2firm.h"
 #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
-#define PREPROCESSOR "cpp -std=c99 -U__WCHAR_TYPE__ -D__WCHAR_TYPE__=int -U__SIZE_TYPE__ -D__SIZE_TYPE__=__SIZE_TYPE__ -m32 -U__STRICT_ANSI__"
+#ifndef __WIN32__
+#define PREPROCESSOR "gcc -E -U__STRICT_ANSI__"
+#else
+#define PREPROCESSOR "cpp -U__STRICT_ANSI__"
+#endif
 #endif
 
 #ifndef LINKER
-#define LINKER    "gcc -m32"
+#define LINKER    "gcc"
 #endif
 
 #ifndef ASSEMBLER
-#define ASSEMBLER "as --32"
+#define ASSEMBLER "gcc -c -xassembler"
 #endif
 
-/** The current c mode/dialect. */
-unsigned int c_mode = _C89|_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;
-
-/* 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;
-
-static int            verbose;
-static struct obstack cppflags_obst, ldflags_obst;
+unsigned int        c_mode                    = _C89 | _ANSI | _C99 | _GNUC;
+bool                byte_order_big_endian     = false;
+bool                strict_mode               = false;
+bool                enable_main_collect2_hack = false;
+bool                freestanding              = false;
+unsigned            architecture_modulo_shift = 0;
+
+static bool               char_is_signed      = true;
+static atomic_type_kind_t wchar_atomic_kind   = ATOMIC_TYPE_INT;
+
+static machine_triple_t *target_machine;
+static const char       *target_triple;
+static int               verbose;
+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;
+static const char       *input_encoding;
+
+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 lang_standard_t standard;
 
 typedef struct file_list_entry_t file_list_entry_t;
 
@@ -121,176 +139,280 @@ typedef enum filetype_t {
 	FILETYPE_AUTODETECT,
 	FILETYPE_C,
 	FILETYPE_PREPROCESSED_C,
+	FILETYPE_CXX,
+	FILETYPE_PREPROCESSED_CXX,
 	FILETYPE_ASSEMBLER,
 	FILETYPE_PREPROCESSED_ASSEMBLER,
 	FILETYPE_OBJECT,
+	FILETYPE_IR,
 	FILETYPE_UNKNOWN
 } filetype_t;
 
 struct file_list_entry_t {
-	const char        *name; /**< filename or NULL for stdin */
-	filetype_t         type;
+	const char  *name; /**< filename or NULL for stdin */
+	filetype_t   type;
 	file_list_entry_t *next;
 };
 
-#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 file_list_entry_t *temp_files;
 
 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"
-
 static translation_unit_t *do_parsing(FILE *const in, const char *const input_name)
 {
 	start_parsing();
 
-	if (use_builtins) {
-		lexer_open_buffer(builtins, sizeof(builtins)-1, "<builtin>");
-		parse();
-	}
-
-	lexer_open_stream(in, input_name);
+	input_t *input = input_from_stream(in, input_encoding);
+	lexer_switch_input(input, input_name);
 	parse();
-
 	translation_unit_t *unit = finish_parsing();
+	input_free(input);
+
 	return unit;
 }
 
 static void lextest(FILE *in, const char *fname)
 {
-	lexer_open_stream(in, fname);
+	input_t *input = input_from_stream(in, input_encoding);
+	lexer_switch_input(input, fname);
 
 	do {
 		lexer_next_preprocessing_token();
 		print_token(stdout, &lexer_token);
-		puts("");
-	} while(lexer_token.type != T_EOF);
+		putchar('\n');
+	} while (lexer_token.kind != T_EOF);
+	input_free(input);
 }
 
 static void add_flag(struct obstack *obst, const char *format, ...)
 {
+	char buf[65536];
 	va_list ap;
-	va_start(ap, format);
 
-	char buf[4096];
-	vsnprintf(buf, sizeof(buf), format, ap);
+	va_start(ap, format);
+#ifdef _WIN32
+	int len =
+#endif
+		vsnprintf(buf, sizeof(buf), format, ap);
+	va_end(ap);
 
-	/* escape stuff... */
 	obstack_1grow(obst, ' ');
+#ifdef _WIN32
+	obstack_1grow(obst, '"');
+	obstack_grow(obst, buf, len);
+	obstack_1grow(obst, '"');
+#else
+	/* escape stuff... */
 	for (char *c = buf; *c != '\0'; ++c) {
 		switch(*c) {
-		case '"':
-		case '\'':
-		case '`':
 		case ' ':
-		case '\t':
-		case '\n':
-		case '\r':
-		case '\\':
+		case '"':
 		case '$':
+		case '&':
 		case '(':
 		case ')':
+		case ';':
+		case '<':
+		case '>':
+		case '\'':
+		case '\\':
+		case '\n':
+		case '\r':
+		case '\t':
+		case '`':
+		case '|':
 			obstack_1grow(obst, '\\');
-			/* fallthrough */
+			/* FALLTHROUGH */
 		default:
 			obstack_1grow(obst, *c);
 			break;
 		}
 	}
+#endif
+}
 
-	va_end(ap);
+static const char *type_to_string(type_t *type)
+{
+	assert(type->kind == TYPE_ATOMIC);
+	return get_atomic_kind_name(type->atomic.akind);
 }
 
-static FILE *preprocess(const char *fname)
+static FILE *preprocess(const char *fname, filetype_t filetype)
 {
-	char buf[4096];
-	obstack_1grow(&cppflags_obst, '\0');
-	const char *flags = obstack_finish(&cppflags_obst);
+	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));
+		}
 
-	snprintf(buf, sizeof(buf), PREPROCESSOR " %s %s", flags, fname);
-	if(verbose) {
-		puts(buf);
+		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);
 	}
 
-	FILE *f = popen(buf, "r");
-	if(f == NULL) {
+	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') {
+		add_flag(&cppflags_obst, "-MF");
+		add_flag(&cppflags_obst, dep_target);
+		if (outname != NULL) {
+				add_flag(&cppflags_obst, "-MQ");
+				add_flag(&cppflags_obst, outname);
+		}
+	}
+	add_flag(&cppflags_obst, fname);
+	obstack_1grow(&cppflags_obst, '\0');
+
+	char *commandline = obstack_finish(&cppflags_obst);
+	if (verbose) {
+		puts(commandline);
+	}
+	FILE *f = popen(commandline, "r");
+	if (f == NULL) {
 		fprintf(stderr, "invoking preprocessor failed\n");
-		exit(1);
+		exit(EXIT_FAILURE);
 	}
+	/* we do not 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);
 
-	int err = system(buf);
-	if(err != 0) {
+	obstack_printf(&asflags_obst, " %s -o %s", in, out);
+	obstack_1grow(&asflags_obst, '\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)
+{
+	add_flag(&ldflags_obst, "-print-file-name=%s", file);
+
+	obstack_1grow(&ldflags_obst, '\0');
+	const char *flags = obstack_finish(&ldflags_obst);
+
+	/* construct commandline */
+	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(EXIT_FAILURE);
 	}
+	obstack_free(&ldflags_obst, commandline);
 }
 
 static const char *try_dir(const char *dir)
 {
-	if(dir == NULL)
+	if (dir == NULL)
 		return dir;
-	if(access(dir, R_OK | W_OK | X_OK) == 0)
+	if (access(dir, R_OK | W_OK | X_OK) == 0)
 		return dir;
 	return NULL;
 }
@@ -299,29 +421,29 @@ static const char *get_tempdir(void)
 {
 	static const char *tmpdir = NULL;
 
-	if(tmpdir != NULL)
+	if (tmpdir != NULL)
 		return tmpdir;
 
-	if(tmpdir == NULL)
+	if (tmpdir == NULL)
 		tmpdir = try_dir(getenv("TMPDIR"));
-	if(tmpdir == NULL)
+	if (tmpdir == NULL)
 		tmpdir = try_dir(getenv("TMP"));
-	if(tmpdir == NULL)
+	if (tmpdir == NULL)
 		tmpdir = try_dir(getenv("TEMP"));
 
 #ifdef P_tmpdir
-	if(tmpdir == NULL)
+	if (tmpdir == NULL)
 		tmpdir = try_dir(P_tmpdir);
 #endif
 
-	if(tmpdir == NULL)
+	if (tmpdir == NULL)
 		tmpdir = try_dir("/var/tmp");
-	if(tmpdir == NULL)
+	if (tmpdir == NULL)
 		tmpdir = try_dir("/usr/tmp");
-	if(tmpdir == NULL)
+	if (tmpdir == NULL)
 		tmpdir = try_dir("/tmp");
 
-	if(tmpdir == NULL)
+	if (tmpdir == NULL)
 		tmpdir = ".";
 
 	return tmpdir;
@@ -347,33 +469,43 @@ static FILE *make_temp_file(char *buffer, size_t buflen, const char *prefix)
 	snprintf(buffer, buflen, "%s/%sXXXXXX", tempdir, prefix);
 
 	int fd = mkstemp(buffer);
-	if(fd == -1) {
-		fprintf(stderr, "couldn't create temporary file: %s\n",
+	if (fd == -1) {
+		fprintf(stderr, "could not 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);
+	if (out == NULL) {
+		fprintf(stderr, "could not create temporary file FILE*\n");
+		exit(EXIT_FAILURE);
 	}
 
+	file_list_entry_t *entry = xmalloc(sizeof(*entry));
+	memset(entry, 0, sizeof(*entry));
+
+	size_t  name_len = strlen(buffer) + 1;
+	char   *name     = malloc(name_len);
+	memcpy(name, buffer, name_len);
+	entry->name      = name;
+
+	entry->next = temp_files;
+	temp_files  = entry;
+
 	return out;
 }
 
-/**
- * Do the necessary lowering for compound parameters.
- */
-void lower_compound_params(void)
+static void free_temp_files(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);
+	file_list_entry_t *entry = temp_files;
+	file_list_entry_t *next;
+	for ( ; entry != NULL; entry = next) {
+		next = entry->next;
+
+		unlink(entry->name);
+		free((char*) entry->name);
+		free(entry);
+	}
+	temp_files = NULL;
 }
 
 typedef enum compile_mode_t {
@@ -382,46 +514,254 @@ typedef enum compile_mode_t {
 	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) {
-	firm_version_t ver;
-	firm_get_version(&ver);
-
+static void print_cparser_version(void)
+{
 	printf("cparser (%s) using libFirm (%u.%u",
-		cparser_REVISION, ver.major, ver.minor);
-	if(ver.revision[0] != 0) {
+	       cparser_REVISION, ir_get_version_major(),
+	       ir_get_version_minor());
+
+	const char *revision = ir_get_version_revision();
+	if (revision[0] != 0) {
 		putchar(' ');
-		fputs(ver.revision, stdout);
+		fputs(revision, stdout);
 	}
-	if(ver.build[0] != 0) {
+
+	const char *build = ir_get_version_build();
+	if (build[0] != 0) {
 		putchar(' ');
-		fputs(ver.build, stdout);
+		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)
+{
+	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",            "Type \"wchar_t\" is unsigned short instead of int");
+	put_help("-fshow-column",            "Show the column number in diagnostic messages");
+	put_help("-fsigned-char",            "Type \"char\" is a signed type");
+	put_help("-funsigned-char",          "Type \"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");
+	put_help("-Wmissing-include-dirs",         "Warn about missing user-specified include directories");
+	put_help("-Wendif-labels",                 "Warn about stray text after #elif and #endif");
+	put_help("-Winit-self",                    "Ignored (gcc compatibility)");
+	put_help("-Wformat-y2k",                   "Ignored (gcc compatibility)");
+	put_help("-Wformat-security",              "Ignored (gcc compatibility)");
+	put_help("-Wold-style-declaration",        "Ignored (gcc compatibility)");
+	put_help("-Wtype-limits",                  "Ignored (gcc compatibility)");
+	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("-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 -ffp-fast (gcc compatibility)");
+	puts("");
+	puts("\tMost of these options can be used with a no- prefix to disable them");
+	puts("\te.g. -fno-omit-frame-pointer");
+}
+
+static void print_help_linker(void)
 {
-	int res = firm_be_option(arg);
+	put_help("-l LIBRARY",               "");
+	put_help("-L PATH",                  "");
+	put_help("-s",                       "Do not produce symbol table and relocation information");
+	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)
+{
+	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 = firm_option(arg);
+	int res = be_parse_arg(arg);
 	(void) res;
 	assert(res);
 }
@@ -432,26 +772,12 @@ static void copy_file(FILE *dest, FILE *input)
 
 	while (!feof(input) && !ferror(dest)) {
 		size_t read = fread(buf, 1, sizeof(buf), input);
-		if(fwrite(buf, 1, read, dest) != read) {
-			perror("couldn't write output");
+		if (fwrite(buf, 1, read, dest) != read) {
+			perror("could not write output");
 		}
 	}
 }
 
-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, "-")) {
@@ -459,10 +785,10 @@ static FILE *open_file(const char *filename)
 	}
 
 	FILE *in = fopen(filename, "r");
-	if(in == NULL) {
-		fprintf(stderr, "Couldn't open '%s': %s\n", filename,
+	if (in == NULL) {
+		fprintf(stderr, "Could not open '%s': %s\n", filename,
 				strerror(errno));
-		exit(1);
+		exit(EXIT_FAILURE);
 	}
 
 	return in;
@@ -472,6 +798,8 @@ static filetype_t get_filetype_from_string(const char *string)
 {
 	if (streq(string, "c") || streq(string, "c-header"))
 		return FILETYPE_C;
+	if (streq(string, "c++") || streq(string, "c++-header"))
+		return FILETYPE_CXX;
 	if (streq(string, "assembler"))
 		return FILETYPE_PREPROCESSED_ASSEMBLER;
 	if (streq(string, "assembler-with-cpp"))
@@ -482,127 +810,368 @@ static filetype_t get_filetype_from_string(const char *string)
 	return FILETYPE_UNKNOWN;
 }
 
+static bool is_windows_os(const char *os)
+{
+	return strstr(os, "mingw") != NULL || streq(os, "win32");
+}
+
+static bool is_unixish_os(const char *os)
+{
+	return strstr(os, "linux") != NULL || strstr(os, "bsd") != NULL
+	       || streq(os, "solaris");
+}
+
+static bool is_darwin_os(const char *os)
+{
+	return streq(os, "darwin");
+}
+
+static bool init_os_support(void)
+{
+	const char *os = target_machine->operating_system;
+	wchar_atomic_kind         = ATOMIC_TYPE_INT;
+	enable_main_collect2_hack = false;
+	define_intmax_types       = false;
+
+	if (is_unixish_os(os)) {
+		set_create_ld_ident(create_name_linux_elf);
+	} else if (is_darwin_os(os)) {
+		set_create_ld_ident(create_name_macho);
+		define_intmax_types = true;
+	} else if (is_windows_os(os)) {
+		wchar_atomic_kind         = ATOMIC_TYPE_USHORT;
+		enable_main_collect2_hack = true;
+		set_create_ld_ident(create_name_win32);
+	} else {
+		return false;
+	}
+
+	return true;
+}
+
+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 unsigned decide_modulo_shift(unsigned type_size)
+{
+	if (architecture_modulo_shift == 0)
+		return 0;
+	if (type_size < architecture_modulo_shift)
+		return architecture_modulo_shift;
+	return type_size;
+}
+
+static bool is_ia32_cpu(const char *architecture)
+{
+	return streq(architecture, "i386")
+	    || streq(architecture, "i486")
+	    || streq(architecture, "i586")
+	    || streq(architecture, "i686")
+	    || streq(architecture, "i786");
+}
+
+static const char *setup_isa_from_tripel(const machine_triple_t *machine)
+{
+	const char *cpu = machine->cpu_type;
+
+	if (is_ia32_cpu(cpu)) {
+		return "ia32";
+	} else if (streq(cpu, "x86_64")) {
+		return "amd64";
+	} else if (streq(cpu, "sparc")) {
+		return "sparc";
+	} else if (streq(cpu, "arm")) {
+		return "arm";
+	} else {
+		fprintf(stderr, "Unknown cpu '%s' in target-triple\n", cpu);
+		return NULL;
+	}
+}
+
+static const char *setup_target_machine(void)
+{
+	if (!setup_firm_for_machine(target_machine))
+		exit(1);
+
+	const char *isa = setup_isa_from_tripel(target_machine);
+
+	if (isa == NULL)
+		exit(1);
+
+	init_os_support();
+
+	return isa;
+}
+
+/**
+ * initialize cparser type properties based on a firm type
+ */
+static void set_typeprops_type(atomic_type_properties_t* props, ir_type *type)
+{
+	props->size             = get_type_size_bytes(type);
+	props->alignment        = get_type_alignment_bytes(type);
+	props->struct_alignment = props->alignment;
+}
+
+/**
+ * Copy atomic type properties except the integer conversion rank
+ */
+static void copy_typeprops(atomic_type_properties_t *dest,
+                           const atomic_type_properties_t *src)
+{
+	dest->size             = src->size;
+	dest->alignment        = src->alignment;
+	dest->struct_alignment = src->struct_alignment;
+	dest->flags            = src->flags;
+}
+
+static void init_types_and_adjust(void)
+{
+	const backend_params *be_params = be_get_backend_param();
+	unsigned machine_size = be_params->machine_size;
+	init_types(machine_size);
+
+	atomic_type_properties_t *props = atomic_type_properties;
+
+	/* adjust types as requested by target architecture */
+	ir_type *type_long_double = be_params->type_long_double;
+	if (type_long_double != NULL)
+		set_typeprops_type(&props[ATOMIC_TYPE_LONG_DOUBLE], type_long_double);
+
+	ir_type *type_long_long = be_params->type_long_long;
+	if (type_long_long != NULL)
+		set_typeprops_type(&props[ATOMIC_TYPE_LONGLONG], type_long_long);
+
+	ir_type *type_unsigned_long_long = be_params->type_unsigned_long_long;
+	if (type_unsigned_long_long != NULL)
+		set_typeprops_type(&props[ATOMIC_TYPE_ULONGLONG], type_unsigned_long_long);
+
+	/* operating system ABI specifics */
+	const char *os = target_machine->operating_system;
+	if (is_darwin_os(os)) {
+		if (machine_size == 32) {
+			props[ATOMIC_TYPE_LONGLONG].struct_alignment    =  4;
+			props[ATOMIC_TYPE_ULONGLONG].struct_alignment   =  4;
+			props[ATOMIC_TYPE_DOUBLE].struct_alignment      =  4;
+			props[ATOMIC_TYPE_LONG_DOUBLE].size             = 16;
+			props[ATOMIC_TYPE_LONG_DOUBLE].alignment        = 16;
+			props[ATOMIC_TYPE_LONG_DOUBLE].struct_alignment = 16;
+		}
+	} else if (is_windows_os(os)) {
+		if (machine_size == 64) {
+			/* to ease porting of old c-code microsoft decided to use 32bits
+			 * even for long */
+			props[ATOMIC_TYPE_LONG]  = props[ATOMIC_TYPE_INT];
+			props[ATOMIC_TYPE_ULONG] = props[ATOMIC_TYPE_UINT];
+		}
+
+		/* on windows long double is not supported */
+		props[ATOMIC_TYPE_LONG_DOUBLE] = props[ATOMIC_TYPE_DOUBLE];
+	} else if (is_unixish_os(os)) {
+		if (is_ia32_cpu(target_machine->cpu_type)) {
+			/* System V has a broken alignment for double so we have to add
+			 * a hack here */
+			props[ATOMIC_TYPE_DOUBLE].struct_alignment    = 4;
+			props[ATOMIC_TYPE_LONGLONG].struct_alignment  = 4;
+			props[ATOMIC_TYPE_ULONGLONG].struct_alignment = 4;
+		}
+	}
+
+	/* stuff decided after processing operating system specifics and
+	 * commandline flags */
+	if (char_is_signed) {
+		props[ATOMIC_TYPE_CHAR].flags |= ATOMIC_TYPE_FLAG_SIGNED;
+	} else {
+		props[ATOMIC_TYPE_CHAR].flags &= ~ATOMIC_TYPE_FLAG_SIGNED;
+	}
+	/* copy over wchar_t properties (including rank) */
+	props[ATOMIC_TYPE_WCHAR_T] = props[wchar_atomic_kind];
+
+	/* initialize defaults for unsupported types */
+	if (type_long_long == NULL) {
+		copy_typeprops(&props[ATOMIC_TYPE_LONGLONG], &props[ATOMIC_TYPE_LONG]);
+	}
+	if (type_unsigned_long_long == NULL) {
+		copy_typeprops(&props[ATOMIC_TYPE_ULONGLONG],
+		               &props[ATOMIC_TYPE_ULONG]);
+	}
+	if (type_long_double == NULL) {
+		copy_typeprops(&props[ATOMIC_TYPE_LONG_DOUBLE],
+		               &props[ATOMIC_TYPE_DOUBLE]);
+	}
+
+	/* initialize firm pointer modes */
+	char               name[64];
+	ir_mode_sort       sort         = irms_reference;
+	unsigned           bit_size     = machine_size;
+	bool               is_signed    = 0;
+	ir_mode_arithmetic arithmetic   = irma_twos_complement;
+	unsigned           modulo_shift = decide_modulo_shift(bit_size);
+
+	snprintf(name, sizeof(name), "p%u", machine_size);
+	ir_mode *ptr_mode = new_ir_mode(name, sort, bit_size, is_signed, arithmetic,
+	                                modulo_shift);
+
+	if (machine_size == 16) {
+		set_reference_mode_signed_eq(ptr_mode, mode_Hs);
+		set_reference_mode_unsigned_eq(ptr_mode, mode_Hu);
+	} else if (machine_size == 32) {
+		set_reference_mode_signed_eq(ptr_mode, mode_Is);
+		set_reference_mode_unsigned_eq(ptr_mode, mode_Iu);
+	} else if (machine_size == 64) {
+		set_reference_mode_signed_eq(ptr_mode, mode_Ls);
+		set_reference_mode_unsigned_eq(ptr_mode, mode_Lu);
+	} else {
+		panic("strange machine_size when determining pointer modes");
+	}
+
+	/* Hmm, pointers should be machine size */
+	set_modeP_data(ptr_mode);
+	set_modeP_code(ptr_mode);
+
+	byte_order_big_endian = be_params->byte_order_big_endian;
+	if (be_params->modulo_shift_efficient) {
+		architecture_modulo_shift = machine_size;
+	} else {
+		architecture_modulo_shift = 0;
+	}
+}
+
 int main(int argc, char **argv)
 {
-	initialize_firm();
-
-	const char        *outname      = NULL;
-	const char        *dumpfunction = NULL;
-	compile_mode_t     mode         = CompileAssembleLink;
-	int                opt_level    = 1;
-	int                result       = EXIT_SUCCESS;
-	char               cpu_arch[16] = "ia32";
-	file_list_entry_t *files        = NULL;
-	file_list_entry_t *last_file    = NULL;
+	firm_early_init();
+
+	const char        *dumpfunction         = NULL;
+	const char        *print_file_name_file = NULL;
+	compile_mode_t     mode                 = CompileAssembleLink;
+	int                opt_level            = 1;
+	int                result               = EXIT_SUCCESS;
+	char               cpu_arch[16]         = "ia32";
+	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);
+
+	/* hack for now... */
+	if (strstr(argv[0], "pptest") != NULL) {
+		extern int pptest_main(int argc, char **argv);
+		return pptest_main(argc, 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) */
-	for(int i = 1; i < argc; ++i) {
+	/* early options parsing (find out optimization level and OS) */
+	for (int i = 1; i < argc; ++i) {
 		const char *arg = argv[i];
-		if(arg[0] != '-')
+		if (arg[0] != '-')
 			continue;
 
 		const char *option = &arg[1];
-		if(option[0] == 'O') {
+		if (option[0] == 'O') {
 			sscanf(&option[1], "%d", &opt_level);
 		}
 	}
 
-	/* 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");
-		/* fallthrough */
-	case 3:
-		set_option("cond-eval");
-		set_option("if-conv");
-		use_builtins = true;
-		/* 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 */
-	filetype_t  forced_filetype = FILETYPE_AUTODETECT;
-	bool        help_displayed  = false;
-	bool        argument_errors = false;
-	for(int i = 1; i < argc; ++i) {
+	                standard        = STANDARD_DEFAULT;
+	unsigned        features_on     = 0;
+	unsigned        features_off    = 0;
+	filetype_t      forced_filetype = FILETYPE_AUTODETECT;
+	help_sections_t help            = HELP_NONE;
+	bool            argument_errors = false;
+	for (int i = 1; i < argc; ++i) {
 		const char *arg = argv[i];
-		if(arg[0] == '-' && arg[1] != 0) {
+		if (arg[0] == '-' && arg[1] != '\0') {
 			/* an option */
 			const char *option = &arg[1];
-			if(option[0] == 'o') {
+			if (option[0] == 'o') {
 				GET_ARG_AFTER(outname, "-o");
-			} else if(option[0] == 'g') {
+			} else if (option[0] == 'g') {
 				set_be_option("debuginfo=stabs");
 				set_be_option("omitfp=no");
 				set_be_option("ia32-nooptcc=yes");
-			} else if(SINGLE_OPTION('c')) {
+			} else if (SINGLE_OPTION('c')) {
 				mode = CompileAssemble;
-			} else if(SINGLE_OPTION('E')) {
+			} else if (SINGLE_OPTION('E')) {
 				mode = PreprocessOnly;
-			} else if(SINGLE_OPTION('S')) {
+			} else if (SINGLE_OPTION('s')) {
+				add_flag(&ldflags_obst, "-s");
+			} else if (SINGLE_OPTION('S')) {
 				mode = Compile;
-			} else if(option[0] == 'O') {
+			} else if (option[0] == 'O') {
 				continue;
-			} else if(option[0] == 'I') {
+			} else if (option[0] == 'I') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-I");
 				add_flag(&cppflags_obst, "-I%s", opt);
-			} else if(option[0] == 'D') {
+			} else if (option[0] == 'D') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-D");
 				add_flag(&cppflags_obst, "-D%s", opt);
-			} else if(option[0] == 'U') {
+			} else if (option[0] == 'U') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-U");
 				add_flag(&cppflags_obst, "-U%s", opt);
-			} else if(option[0] == 'l') {
+			} else if (option[0] == 'l') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-l");
 				add_flag(&ldflags_obst, "-l%s", opt);
-			} else if(option[0] == 'L') {
+			} else if (option[0] == 'L') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-L");
 				add_flag(&ldflags_obst, "-L%s", opt);
-			} else if(SINGLE_OPTION('v')) {
+			} else if (SINGLE_OPTION('v')) {
 				verbose = 1;
-			} else if(SINGLE_OPTION('w')) {
-				inhibit_all_warnings = true;
-			} else if(option[0] == 'x') {
+			} else if (SINGLE_OPTION('w')) {
+				add_flag(&cppflags_obst, "-w");
+				disable_all_warnings();
+			} else if (option[0] == 'x') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-x");
 				forced_filetype = get_filetype_from_string(opt);
@@ -614,8 +1183,10 @@ int main(int argc, char **argv)
 				mode = PreprocessOnly;
 				add_flag(&cppflags_obst, "-M");
 			} else if (streq(option, "MMD") ||
-			           streq(option, "MD")  ||
-			           streq(option, "MM")  ||
+			           streq(option, "MD")) {
+			    construct_dep_target = true;
+				add_flag(&cppflags_obst, "-%s", option);
+			} else if (streq(option, "MM")  ||
 			           streq(option, "MP")) {
 				add_flag(&cppflags_obst, "-%s", option);
 			} else if (streq(option, "MT") ||
@@ -625,99 +1196,219 @@ int main(int argc, char **argv)
 				GET_ARG_AFTER(opt, "-MT");
 				add_flag(&cppflags_obst, "-%s", option);
 				add_flag(&cppflags_obst, "%s", opt);
+			} else if (streq(option, "include")) {
+				const char *opt;
+				GET_ARG_AFTER(opt, "-include");
+				add_flag(&cppflags_obst, "-include");
+				add_flag(&cppflags_obst, "%s", opt);
+			} else if (streq(option, "isystem")) {
+				const char *opt;
+				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') {
-				bool truth_value = true;
-				const char *opt;
-				GET_ARG_AFTER(opt, "-f");
-				if (opt[0] == 'n' && opt[1] == 'o' && opt[2] == '-') {
-					truth_value = false;
-					opt += 3;
-				}
-
-				if (streq(opt, "dollars-in-identifiers")) {
-					allow_dollar_in_symbol = truth_value;
-				} else if (streq(opt, "short-wchar")) {
-					opt_short_wchar_t = truth_value;
-				} else if (streq(opt, "syntax-only")) {
-					mode = ParseOnly;
-				} else if (streq(opt, "omit-frame-pointer")) {
-					set_be_option(truth_value ? "omitfp" : "omitfp=no");
-				} else if (streq(opt, "strength-reduce")) {
-					firm_option("strength-red");
-				} else if (streq(opt, "fast-math")               ||
-				           streq(opt, "jump-tables")             ||
-				           streq(opt, "unroll-loops")            ||
-				           streq(opt, "expensive-optimizations") ||
-				           streq(opt, "no-common")               ||
-				           streq(opt, "PIC")                     ||
-				           strstart(opt, "align-loops=")         ||
-				           strstart(opt, "align-jumps=")         ||
-				           strstart(opt, "align-functions=")) {
-					fprintf(stderr, "ignoring gcc option '-f%s'\n", truth_value ? opt : opt - 3);
-				} else {
-					if (! truth_value)
-						opt -= 3;
-					int res = firm_option(opt);
-					if (res == 0) {
-						fprintf(stderr, "error: unknown Firm option '-f %s'\n",
-						        opt);
+				char const *orig_opt;
+				GET_ARG_AFTER(orig_opt, "-f");
+
+				if (strstart(orig_opt, "input-charset=")) {
+					char const* const encoding = strchr(orig_opt, '=') + 1;
+					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 (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;
-						continue;
-					} else if (res == -1) {
-						help_displayed = true;
+					} else {
+						set_default_visibility(visibility);
+					}
+				} else if (strstart(orig_opt, "message-length=")) {
+					/* ignore: would only affect error message format */
+				} else if (streq(orig_opt, "fast-math") ||
+				           streq(orig_opt, "fp-fast")) {
+					firm_fp_model = fp_model_fast;
+				} else if (streq(orig_opt, "fp-precise")) {
+					firm_fp_model = fp_model_precise;
+				} else if (streq(orig_opt, "fp-strict")) {
+					firm_fp_model = fp_model_strict;
+				} else if (streq(orig_opt, "help")) {
+					fprintf(stderr, "warning: -fhelp is deprecated\n");
+					help |= HELP_OPTIMIZATION;
+				} 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] == '-') {
+						truth_value = false;
+						opt += 3;
+					}
+
+					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, "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 do not support
+					     * anyway was deactivated */
+					} else if (streq(opt, "verbose-asm")) {
+						/* ignore: we always print verbose assembler */
+					} else if (streq(opt, "jump-tables")             ||
+					           streq(opt, "expensive-optimizations") ||
+					           streq(opt, "common")                  ||
+					           streq(opt, "optimize-sibling-calls")  ||
+					           streq(opt, "align-loops")             ||
+					           streq(opt, "align-jumps")             ||
+					           streq(opt, "align-functions")         ||
+					           streq(opt, "PIC")                     ||
+					           streq(opt, "stack-protector")         ||
+					           streq(opt, "stack-protector-all")) {
+						fprintf(stderr, "ignoring gcc option '-f%s'\n", orig_opt);
+					} else {
+						int res = firm_option(orig_opt);
+						if (res == 0) {
+							fprintf(stderr, "error: unknown Firm option '-f%s'\n",
+							        orig_opt);
+							argument_errors = true;
+							continue;
+						}
 					}
 				}
 			} 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, "l,")) // a gcc-style linker option
-				{
+				if (strstart(option + 1, "p,")) {
+					// pass options directly to the preprocessor
+					const char *opt;
+					GET_ARG_AFTER(opt, "-Wp,");
+					add_flag(&cppflags_obst, "-Wp,%s", opt);
+				} else if (strstart(option + 1, "l,")) {
+					// pass options directly to the linker
 					const char *opt;
 					GET_ARG_AFTER(opt, "-Wl,");
 					add_flag(&ldflags_obst, "-Wl,%s", opt);
+				} else if (streq(option + 1, "no-trigraphs")
+							|| streq(option + 1, "undef")
+							|| streq(option + 1, "missing-include-dirs")
+							|| streq(option + 1, "endif-labels")) {
+					add_flag(&cppflags_obst, "%s", arg);
+				} else if (streq(option+1, "init-self")) {
+					/* ignored (same as gcc does) */
+				} else if (streq(option+1, "format-y2k")
+				           || streq(option+1, "format-security")
+				           || streq(option+1, "old-style-declaration")
+				           || streq(option+1, "type-limits")) {
+				    /* ignore (gcc compatibility) */
+				} else {
+					set_warning_opt(&option[1]);
 				}
-				else set_warning_opt(&option[1]);
-			} else if(option[0] == 'm') {
+			} else if (option[0] == 'm') {
 				/* -m options */
 				const char *opt;
 				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 {
+						const char *isa = setup_target_machine();
+						strncpy(cpu_arch, isa, sizeof(cpu_arch));
+						target_triple = opt;
+					}
+				} else if (strstart(opt, "triple=")) {
+					GET_ARG_AFTER(opt, "-mtriple=");
+					if (!parse_target_triple(opt)) {
+						argument_errors = true;
+					} else {
+						const char *isa = setup_target_machine();
+						strncpy(cpu_arch, isa, sizeof(cpu_arch));
+						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=")) {
@@ -727,37 +1418,46 @@ 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) {
+					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, "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")) {
+					add_flag(&ldflags_obst, "-msoft-float");
+					snprintf(arch_opt, sizeof(arch_opt), "%s-fpunit=softfloat", cpu_arch);
+					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 {
-					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;
+						unsigned machine_size = (unsigned)value;
+						/* TODO: choose/change backend based on this */
+						add_flag(&cppflags_obst, "-m%u", machine_size);
+						add_flag(&asflags_obst, "-m%u", machine_size);
+						add_flag(&ldflags_obst, "-m%u", machine_size);
 					}
 				}
 			} else if (streq(option, "pg")) {
@@ -766,36 +1466,42 @@ 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=")) {
-				if (streq(&option[4], "c99")) {
-					c_mode = _C89|_C99;
-				} else if (streq(&option[4], "c89")) {
-					c_mode = _C89;
-				} else if (streq(&option[4], "gnu99")) {
-					c_mode = _C89|_C99|_GNUC;
-				} else if (streq(&option[4], "microsoft")) {
-					c_mode = _C89|_C99|_MS;
-				} else
-					fprintf(stderr, "warning: ignoring gcc option '%s'\n", arg);
+				const char *const o = &option[4];
+				standard =
+					streq(o, "c++")            ? STANDARD_CXX98   :
+					streq(o, "c++98")          ? STANDARD_CXX98   :
+					streq(o, "c89")            ? STANDARD_C89     :
+					streq(o, "c99")            ? STANDARD_C99     :
+					streq(o, "c9x")            ? STANDARD_C99     : // deprecated
+					streq(o, "gnu++98")        ? STANDARD_GNUXX98 :
+					streq(o, "gnu89")          ? STANDARD_GNU89   :
+					streq(o, "gnu99")          ? STANDARD_GNU99   :
+					streq(o, "gnu9x")          ? STANDARD_GNU99   : // deprecated
+					streq(o, "iso9899:1990")   ? STANDARD_C89     :
+					streq(o, "iso9899:199409") ? STANDARD_C90     :
+					streq(o, "iso9899:1999")   ? STANDARD_C99     :
+					streq(o, "iso9899:199x")   ? STANDARD_C99     : // deprecated
+					(fprintf(stderr, "warning: ignoring gcc option '%s'\n", arg), standard);
 			} else if (streq(option, "version")) {
 				print_cparser_version();
+			} else if (strstart(option, "print-file-name=")) {
+				GET_ARG_AFTER(print_file_name_file, "-print-file-name=");
 			} else if (option[0] == '-') {
 				/* double dash option */
 				++option;
 				if (streq(option, "gcc")) {
-					c_mode |= _GNUC;
+					features_on  |=  _GNUC;
+					features_off &= ~_GNUC;
 				} else if (streq(option, "no-gcc")) {
-					c_mode &= ~_GNUC;
+					features_on  &= ~_GNUC;
+					features_off |=  _GNUC;
 				} else if (streq(option, "ms")) {
-					c_mode |= _MS;
+					features_on  |=  _MS;
+					features_off &= ~_MS;
 				} else if (streq(option, "no-ms")) {
-					c_mode &= ~_MS;
-				} else if (streq(option, "signed-chars")) {
-					char_is_signed = true;
-				} else if (streq(option, "unsigned-chars")) {
-					char_is_signed = false;
+					features_on  &= ~_MS;
+					features_off |=  _MS;
 				} else if (streq(option, "strict")) {
 					strict_mode = true;
 				} else if (streq(option, "lextest")) {
@@ -810,14 +1516,54 @@ 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) {
+					if (i >= argc) {
 						fprintf(stderr, "error: "
 						        "expected argument after '--dump-function'\n");
 						argument_errors = true;
@@ -825,6 +1571,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;
@@ -834,34 +1582,37 @@ int main(int argc, char **argv)
 				argument_errors = true;
 			}
 		} else {
-			filetype_t  type     = forced_filetype;
-			const char *filename = arg;
+			filetype_t type = forced_filetype;
 			if (type == FILETYPE_AUTODETECT) {
-				size_t const len = strlen(arg);
-				if (len < 2 && arg[0] == '-') {
+				if (streq(arg, "-")) {
 					/* - implicitly means C source file */
-					type     = FILETYPE_C;
-					filename = NULL;
-				} else if (len > 2 && arg[len - 2] == '.') {
-					switch (arg[len - 1]) {
-					case 'c': type = FILETYPE_C;                      break;
-					case 'h': type = FILETYPE_C;                      break;
-					case 's': type = FILETYPE_PREPROCESSED_ASSEMBLER; break;
-					case 'S': type = FILETYPE_ASSEMBLER;              break;
-
-					case 'a':
-					case 'o': type = FILETYPE_OBJECT;                 break;
-					}
-				} else if (len > 3 && arg[len - 3] == '.') {
-					if (streq(arg + len - 2, "so")) {
-						type = FILETYPE_OBJECT;
+					type = FILETYPE_C;
+				} else {
+					const char *suffix = strrchr(arg, '.');
+					/* Ensure there is at least one char before the suffix */
+					if (suffix != NULL && suffix != arg) {
+						++suffix;
+						type =
+							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_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
@@ -879,32 +1630,65 @@ 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 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();
-	init_tokens();
-	init_types();
+	init_types_and_adjust();
 	init_typehash();
 	init_basic_types();
+	if (wchar_atomic_kind == ATOMIC_TYPE_INT)
+		init_wchar_types(type_int);
+	else if (wchar_atomic_kind == ATOMIC_TYPE_SHORT)
+		init_wchar_types(type_short);
+	else
+		panic("unexpected wchar type");
 	init_lexer();
 	init_ast();
 	init_parser();
 	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");
+		} else {
+			get_output_name(dep_target, sizeof(dep_target), files->name, ".d");
+		}
+	} else {
+		dep_target[0] = '\0';
+	}
 
 	char outnamebuf[4096];
 	if (outname == NULL) {
@@ -914,12 +1698,11 @@ int main(int argc, char **argv)
 		case BenchmarkParser:
 		case PrintAst:
 		case PrintFluffy:
-		case PrintCaml:
+		case PrintJna:
 		case LexTest:
 		case PreprocessOnly:
-			outname = "-";
-			break;
 		case ParseOnly:
+			outname = "-";
 			break;
 		case Compile:
 			get_output_name(outnamebuf, sizeof(outnamebuf), filename, ".s");
@@ -934,6 +1717,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";
@@ -951,20 +1738,21 @@ int main(int argc, char **argv)
 		out = stdout;
 	} else {
 		out = fopen(outname, "w");
-		if(out == NULL) {
-			fprintf(stderr, "Couldn't open '%s' for writing: %s\n", outname,
+		if (out == NULL) {
+			fprintf(stderr, "Could not 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;
 		filetype_t  filetype = file->type;
 
-		if (file->type == FILETYPE_OBJECT)
+		if (filetype == FILETYPE_OBJECT)
 			continue;
 
 		FILE *in = NULL;
@@ -973,40 +1761,51 @@ 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;
-		if (filetype == FILETYPE_C || filetype == FILETYPE_ASSEMBLER) {
-			/* no support for input on FILE* yet */
-			if (in != NULL)
-				panic("internal compiler error: in for preprocessor != NULL");
-
-			preprocessed_in = preprocess(filename);
-			if (mode == PreprocessOnly) {
-				copy_file(out, preprocessed_in);
-				int result = pclose(preprocessed_in);
-				fclose(out);
-				return result;
-			}
+		filetype_t next_filetype = filetype;
+		switch (filetype) {
+			case FILETYPE_C:
+				next_filetype = FILETYPE_PREPROCESSED_C;
+				goto preprocess;
+			case FILETYPE_CXX:
+				next_filetype = FILETYPE_PREPROCESSED_CXX;
+				goto preprocess;
+			case FILETYPE_ASSEMBLER:
+				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, filetype);
+				if (mode == PreprocessOnly) {
+					copy_file(out, preprocessed_in);
+					int pp_result = pclose(preprocessed_in);
+					fclose(out);
+					/* remove output file in case of error */
+					if (out != stdout && pp_result != EXIT_SUCCESS) {
+						unlink(outname);
+					}
+					return pp_result;
+				}
 
-			if (filetype == FILETYPE_C) {
-				filetype = FILETYPE_PREPROCESSED_C;
-			} else if (filetype == FILETYPE_ASSEMBLER) {
-				filetype = FILETYPE_PREPROCESSED_ASSEMBLER;
-			} else {
-				panic("internal compiler error: unknown filetype at preproc");
-			}
+				in = preprocessed_in;
+				filetype = next_filetype;
+				break;
 
-			in = preprocessed_in;
+			default:
+				break;
 		}
 
 		FILE *asm_out;
-		if(mode == Compile) {
+		if (mode == Compile) {
 			asm_out = out;
 		} else {
-			asm_out = make_temp_file(asm_tempfile, sizeof(asm_tempfile),
-			                         "ccs");
+			asm_out = make_temp_file(asm_tempfile, sizeof(asm_tempfile), "ccs");
 		}
 
 		if (in == NULL)
@@ -1014,43 +1813,107 @@ int main(int argc, char **argv)
 
 		/* preprocess and compile */
 		if (filetype == FILETYPE_PREPROCESSED_C) {
-			translation_unit_t *const unit = do_parsing(in, filename);
-			if (in == preprocessed_in) {
-				int pp_result = pclose(preprocessed_in);
-				if (pp_result != EXIT_SUCCESS) {
-					exit(EXIT_FAILURE);
-				}
+			char const* invalid_mode;
+			switch (standard) {
+				case STANDARD_ANSI:
+				case STANDARD_C89:   c_mode = _C89;                break;
+				/* 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;
+
+default_c_warn:
+					fprintf(stderr,
+							"warning: command line option \"-std=%s\" is not valid for C\n",
+							invalid_mode);
+					/* FALLTHROUGH */
+				case STANDARD_DEFAULT:
+				case STANDARD_GNU99:   c_mode = _C89 | _C99 | _GNUC; break;
+
+				case STANDARD_CXX98:   invalid_mode = "c++98"; goto default_c_warn;
+				case STANDARD_GNUXX98: invalid_mode = "gnu98"; goto default_c_warn;
+			}
+			goto do_parsing;
+		} else if (filetype == FILETYPE_PREPROCESSED_CXX) {
+			char const* invalid_mode;
+			switch (standard) {
+				case STANDARD_C89:   invalid_mode = "c89";   goto default_cxx_warn;
+				case STANDARD_C90:   invalid_mode = "c90";   goto default_cxx_warn;
+				case STANDARD_C99:   invalid_mode = "c99";   goto default_cxx_warn;
+				case STANDARD_GNU89: invalid_mode = "gnu89"; goto default_cxx_warn;
+				case STANDARD_GNU99: invalid_mode = "gnu99"; goto default_cxx_warn;
+
+				case STANDARD_ANSI:
+				case STANDARD_CXX98: c_mode = _CXX; break;
+
+default_cxx_warn:
+					fprintf(stderr,
+							"warning: command line option \"-std=%s\" is not valid for C++\n",
+							invalid_mode);
+				case STANDARD_DEFAULT:
+				case STANDARD_GNUXX98: c_mode = _CXX | _GNUC; break;
 			}
 
+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);
 			}
 
-			if(error_count > 0) {
+			if (error_count > 0) {
 				/* parsing failed because of errors */
 				fprintf(stderr, "%u error(s), %u warning(s)\n", error_count,
 				        warning_count);
 				result = EXIT_FAILURE;
 				continue;
-			} else if(warning_count > 0) {
+			} else if (warning_count > 0) {
 				fprintf(stderr, "%u warning(s)\n", warning_count);
 			}
 
-			if(mode == BenchmarkParser) {
+			if (in == preprocessed_in) {
+				int pp_result = pclose(preprocessed_in);
+				if (pp_result != EXIT_SUCCESS) {
+					/* remove output file */
+					if (out != stdout)
+						unlink(outname);
+					return EXIT_FAILURE;
+				}
+			}
+
+			if (mode == BenchmarkParser) {
 				return result;
-			} else if(mode == PrintFluffy) {
+			} 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;
 			}
@@ -1060,41 +1923,52 @@ int main(int argc, char **argv)
 				ident    *id     = new_id_from_str(dumpfunction);
 				ir_graph *irg    = NULL;
 				int       n_irgs = get_irp_n_irgs();
-				for(int i = 0; i < n_irgs; ++i) {
+				for (int i = 0; i < n_irgs; ++i) {
 					ir_graph *tirg   = get_irp_irg(i);
 					ident    *irg_id = get_entity_ident(get_irg_entity(tirg));
-					if(irg_id == id) {
+					if (irg_id == id) {
 						irg = tirg;
 						break;
 					}
 				}
 
-				if(irg == NULL) {
+				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);
-				exit(0);
+				return EXIT_SUCCESS;
 			}
 
-			gen_firm_finish(asm_out, filename, /*c_mode=*/1,
-			                /*firm_const_exists=*/0);
+			if (mode == CompileExportIR) {
+				fclose(out);
+				ir_export(outname);
+				return EXIT_SUCCESS;
+			}
+
+			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) {
 				int pp_result = pclose(preprocessed_in);
 				if (pp_result != EXIT_SUCCESS) {
+					/* remove output in error case */
+					if (out != stdout)
+						unlink(outname);
 					return pp_result;
 				}
 			}
-			if(asm_out != out) {
+			if (asm_out != out) {
 				fclose(asm_out);
 			}
 		}
@@ -1110,7 +1984,7 @@ int main(int argc, char **argv)
 		if (filetype == FILETYPE_PREPROCESSED_ASSEMBLER) {
 			char        temp[1024];
 			const char *filename_o;
-			if(mode == CompileAssemble) {
+			if (mode == CompileAssemble) {
 				fclose(out);
 				filename_o = outname;
 			} else {
@@ -1131,16 +2005,27 @@ int main(int argc, char **argv)
 		file->type = filetype;
 	}
 
-	if (result != EXIT_SUCCESS)
+	if (result != EXIT_SUCCESS) {
+		if (out != stdout)
+			unlink(outname);
 		return result;
+	}
 
 	/* link program file */
-	if(mode == CompileAssembleLink) {
+	if (mode == CompileAssembleLink) {
 		obstack_1grow(&ldflags_obst, '\0');
 		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)
@@ -1156,20 +2041,25 @@ int main(int argc, char **argv)
 
 		char *commandline = obstack_finish(&file_obst);
 
-		if(verbose) {
+		if (verbose) {
 			puts(commandline);
 		}
 		int err = system(commandline);
-		if(err != EXIT_SUCCESS) {
+		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();
 	exit_ast2firm();
 	exit_parser();
 	exit_ast();
@@ -1178,5 +2068,5 @@ int main(int argc, char **argv)
 	exit_types();
 	exit_tokens();
 	exit_symbol_table();
-	return 0;
+	return EXIT_SUCCESS;
 }