X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=main.c;h=1ca12b1d5a5b3045aa9ee846c82817c64bfc67af;hb=ff25d271feafec73df71169a5b87dcc2854fd85e;hp=c0b94489f1767831bebb1186b8445e06c4dc6367;hpb=4c8176e508a65f533caf6b526f3bf427adb52d5f;p=cparser

diff --git a/main.c b/main.c
index c0b9448..1ca12b1 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,19 +65,28 @@
 #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 "adt/error.h"
-#include "write_fluffy.h"
-#include "write_caml.h"
+#include "wrappergen/write_fluffy.h"
+#include "wrappergen/write_caml.h"
+#include "wrappergen/write_jna.h"
 #include "revision.h"
 #include "warning.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 -m32 -U__STRICT_ANSI__"
+#else
+#define PREPROCESSOR "cpp -m32 -U__STRICT_ANSI__"
+#endif
 #endif
 
 #ifndef LINKER
@@ -88,23 +94,24 @@
 #endif
 
 #ifndef ASSEMBLER
+#ifdef __APPLE__
+#define ASSEMBLER "gcc -m32 -c -xassembler"
+#else
 #define ASSEMBLER "as --32"
 #endif
+#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;
+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;
+bool               use_builtins              = false;
+bool               have_const_functions      = false;
+atomic_type_kind_t wchar_atomic_kind         = ATOMIC_TYPE_INT;
+unsigned           force_long_double_size    = 0;
+bool               enable_main_collect2_hack = false;
+bool               freestanding              = false;
 
 /* to switch on printing of implicit casts */
 extern bool print_implicit_casts;
@@ -112,8 +119,25 @@ 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;
+static const char     *target_triple;
+static int             verbose;
+static struct obstack  cppflags_obst, ldflags_obst;
+static char            dep_target[1024];
+static const char     *outname;
+
+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,74 +145,52 @@ 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 file_list_entry_t *temp_files;
 
 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)
 {
@@ -213,84 +215,215 @@ static void lextest(FILE *in, const char *fname)
 	do {
 		lexer_next_preprocessing_token();
 		print_token(stdout, &lexer_token);
-		puts("");
-	} while(lexer_token.type != T_EOF);
+		putchar('\n');
+	} while (lexer_token.type != T_EOF);
 }
 
 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));
 
-	snprintf(buf, sizeof(buf), PREPROCESSOR " %s %s", flags, fname);
-	if(verbose) {
+		add_flag(&cppflags_obst, "-U__VERSION__");
+		add_flag(&cppflags_obst, "-D__VERSION__=\"%s\"", cparser_REVISION);
+
+		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') {
+		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 *buf = obstack_finish(&cppflags_obst);
+	if (verbose) {
 		puts(buf);
 	}
 
 	FILE *f = popen(buf, "r");
-	if(f == NULL) {
+	if (f == NULL) {
 		fprintf(stderr, "invoking preprocessor failed\n");
 		exit(1);
 	}
+
+	/* we don't really need that anymore */
+	obstack_free(&cppflags_obst, buf);
+
 	return f;
 }
 
 static void assemble(const char *out, const char *in)
 {
-	char buf[4096];
+	struct obstack asflags_obst;
+	char *buf;
+
+	obstack_init(&asflags_obst);
 
-	snprintf(buf, sizeof(buf), "%s %s -o %s", ASSEMBLER, in, out);
-	if(verbose) {
+	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);
+	}
+
+	obstack_printf(&asflags_obst, "%s -o %s", in, out);
+	obstack_1grow(&asflags_obst, '\0');
+	buf = obstack_finish(&asflags_obst);
+
+	if (verbose) {
 		puts(buf);
 	}
 
 	int err = system(buf);
-	if(err != 0) {
+	if (err != 0) {
 		fprintf(stderr, "assembler reported an error\n");
 		exit(1);
 	}
+
+	obstack_free(&asflags_obst, NULL);
+}
+
+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(1);
+	}
 }
 
 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 +432,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,20 +480,45 @@ 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) {
+	if (fd == -1) {
 		fprintf(stderr, "couldn't create temporary file: %s\n",
 		        strerror(errno));
 		exit(1);
 	}
 	FILE *out = fdopen(fd, "w");
-	if(out == NULL) {
+	if (out == NULL) {
 		fprintf(stderr, "couldn't create temporary file FILE*\n");
 		exit(1);
 	}
 
+	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;
 }
 
+static void free_temp_files(void)
+{
+	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;
+}
+
 /**
  * Do the necessary lowering for compound parameters.
  */
@@ -382,39 +540,55 @@ typedef enum compile_mode_t {
 	ParseOnly,
 	Compile,
 	CompileDump,
+	CompileExportIR,
 	CompileAssemble,
 	CompileAssembleLink,
 	LexTest,
 	PrintAst,
 	PrintFluffy,
-	PrintCaml
+	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 print_help(const char *argv0)
+{
+	usage(argv0);
+	puts("");
+	puts("\t-fhelp     Display help about firm optimisation options");
+	puts("\t-bhelp     Display help about firm backend options");
+	puts("A big number of gcc flags is also supported");
 }
 
 static void set_be_option(const char *arg)
 {
-	int res = firm_be_option(arg);
+	int res = be_parse_arg(arg);
 	(void) res;
 	assert(res);
 }
@@ -432,7 +606,7 @@ 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) {
+		if (fwrite(buf, 1, read, dest) != read) {
 			perror("couldn't write output");
 		}
 	}
@@ -459,7 +633,7 @@ static FILE *open_file(const char *filename)
 	}
 
 	FILE *in = fopen(filename, "r");
-	if(in == NULL) {
+	if (in == NULL) {
 		fprintf(stderr, "Couldn't open '%s': %s\n", filename,
 				strerror(errno));
 		exit(1);
@@ -472,6 +646,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,35 +658,140 @@ static filetype_t get_filetype_from_string(const char *string)
 	return FILETYPE_UNKNOWN;
 }
 
+/**
+ * Initialize firm codegeneration for a specific operating system.
+ * The argument is the operating system part of a target-triple */
+static bool set_os_support(const char *os)
+{
+	wchar_atomic_kind         = ATOMIC_TYPE_INT;
+	force_long_double_size    = 0;
+	enable_main_collect2_hack = false;
+
+	if (strstr(os, "linux") != NULL || strstr(os, "bsd") != NULL
+			|| streq(os, "solaris")) {
+		set_be_option("ia32-gasmode=elf");
+		set_create_ld_ident(create_name_linux_elf);
+	} else if (streq(os, "darwin")) {
+		force_long_double_size = 16;
+		set_be_option("ia32-gasmode=macho");
+		set_be_option("ia32-stackalign=4");
+		set_be_option("pic=true");
+		set_create_ld_ident(create_name_macho);
+	} else if (strstr(os, "mingw") != NULL || streq(os, "win32")) {
+		wchar_atomic_kind         = ATOMIC_TYPE_USHORT;
+		enable_main_collect2_hack = true;
+		set_be_option("ia32-gasmode=mingw");
+		set_create_ld_ident(create_name_win32);
+	} else {
+		return false;
+	}
+
+	return true;
+}
+
+static bool parse_target_triple(const char *arg)
+{
+	const char *manufacturer = strchr(arg, '-');
+	if (manufacturer == NULL) {
+		fprintf(stderr, "Target-triple is not in the form 'cpu_type-manufacturer-operating_system'\n");
+		return false;
+	}
+	manufacturer += 1;
+
+	const char *os = strchr(manufacturer, '-');
+	if (os == NULL) {
+		fprintf(stderr, "Target-triple is not in the form 'cpu_type-manufacturer-operating_system'\n");
+		return false;
+	}
+	os += 1;
+
+	/* Note: Triples are more or less defined by what the config.guess and
+	 * config.sub scripts from GNU autoconf emit. We have to lookup there what
+	 * triples are possible */
+
+	/* process cpu type */
+	if (strstart(arg, "i386-")) {
+		be_parse_arg("isa=ia32");
+		be_parse_arg("ia32-arch=i386");
+	} else if (strstart(arg, "i486-")) {
+		be_parse_arg("isa=ia32");
+		be_parse_arg("ia32-arch=i486");
+	} else if (strstart(arg, "i586-")) {
+		be_parse_arg("isa=ia32");
+		be_parse_arg("ia32-arch=i586");
+	} else if (strstart(arg, "i686-")) {
+		be_parse_arg("isa=ia32");
+		be_parse_arg("ia32-arch=i686");
+	} else if (strstart(arg, "i786-")) {
+		be_parse_arg("isa=ia32");
+		be_parse_arg("ia32-arch=pentium4");
+	} else if (strstart(arg, "x86_64")) {
+		be_parse_arg("isa=amd64");
+	} else if (strstart(arg, "sparc-")) {
+		be_parse_arg("isa=sparc");
+	} else if (strstart(arg, "arm-")) {
+		be_parse_arg("isa=arm");
+	} else {
+		fprintf(stderr, "Unknown cpu in triple '%s'\n", arg);
+		return false;
+	}
+
+	/* process manufacturer, alot of people incorrectly leave out the
+	 * manufacturer instead of using unknown- */
+	if (strstart(manufacturer, "linux")) {
+		os = manufacturer;
+		manufacturer = "unknown-";
+	}
+
+	/* process operating system */
+	if (!set_os_support(os)) {
+		fprintf(stderr, "Unknown operating system '%s' in triple '%s'\n", os, arg);
+		return false;
+	}
+
+	target_triple = arg;
+	return true;
+}
+
 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;
+	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;
 	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(&file_obst);
 
 #define GET_ARG_AFTER(def, args)                                             \
 	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;                                                        \
@@ -519,18 +800,27 @@ int main(int argc, char **argv)
 
 #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 optimisation 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);
 		}
 	}
 
+	/* Guess host OS */
+#if defined(_WIN32) || defined(__CYGWIN__)
+	set_os_support("win32");
+#elif defined(__APPLE__)
+	set_os_support("darwin");
+#else
+	set_os_support("linux");
+#endif
+
 	/* apply optimisation level */
 	switch(opt_level) {
 	case 0:
@@ -541,68 +831,75 @@ int main(int argc, char **argv)
 		break;
 	default:
 	case 4:
-		set_option("strict-aliasing");
+		/* use_builtins = true; */
 		/* fallthrough */
 	case 3:
-		set_option("cond-eval");
-		set_option("if-conv");
-		use_builtins = true;
+		set_option("thread-jumps");
+		set_option("if-conversion");
 		/* fallthrough */
 	case 2:
+		set_option("strict-aliasing");
 		set_option("inline");
 		set_option("deconv");
 		set_be_option("omitfp");
 		break;
 	}
 
+	const char *target = getenv("TARGET");
+	if (target != NULL)
+		parse_target_triple(target);
+
 	/* 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;
+	bool       help_displayed  = false;
+	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')) {
 				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')) {
+				memset(&warning, 0, sizeof(warning));
+			} else if (option[0] == 'x') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-x");
 				forced_filetype = get_filetype_from_string(opt);
@@ -614,8 +911,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,54 +924,96 @@ 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);
+			} 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 (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, "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);
+				char const *orig_opt;
+				GET_ARG_AFTER(orig_opt, "-f");
+
+				if (strstart(orig_opt, "input-charset=")) {
+					char const* const encoding = strchr(orig_opt, '=') + 1;
+					select_input_encoding(encoding);
+				} else if (streq(orig_opt, "verbose-asm")) {
+					/* ignore: we always print verbose assembler */
 				} else {
-					if (! truth_value)
-						opt -= 3;
-					int res = firm_option(opt);
-					if (res == 0) {
-						fprintf(stderr, "error: unknown Firm option '-f %s'\n",
-						        opt);
-						argument_errors = true;
-						continue;
-					} else if (res == -1) {
-						help_displayed = true;
+					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, "builtins")) {
+						use_builtins = 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, "signed-char")) {
+						char_is_signed = truth_value;
+					} else if (streq(opt, "strength-reduce")) {
+						firm_option(truth_value ? "strength-red" : "no-strength-red");
+					} 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 = true;
+					} else if (streq(opt, "hosted")) {
+						freestanding = false;
+					} else if (truth_value == false &&
+					           streq(opt, "asynchronous-unwind-tables")) {
+					    /* nothing todo, a gcc feature which we don't support
+					     * anyway was deactivated */
+					} 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, "message-length=")) {
+							/* ignore: would only affect error message format */
+					} else if (streq(opt, "fast-math")               ||
+					           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")) {
+						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 (res == -1) {
+							help_displayed = true;
+						}
 					}
 				}
 			} else if (option[0] == 'b') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-b");
-				int res = firm_be_option(opt);
+				int res = be_parse_arg(opt);
 				if (res == 0) {
 					fprintf(stderr, "error: unknown Firm backend option '-b %s'\n",
 					        opt);
@@ -683,41 +1024,61 @@ int main(int argc, char **argv)
 					strncpy(cpu_arch, opt, sizeof(cpu_arch));
 				}
 			} else if (option[0] == 'W') {
-				if (strstart(option + 1, "l,")) // a gcc-style linker option
-				{
+				if (option[1] == '\0') {
+					/* ignore -W, out defaults are already quiet verbose */
+				} else 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")) {
+					add_flag(&cppflags_obst, "%s", arg);
+				} 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 if (strstart(opt, "triple=")) {
+					GET_ARG_AFTER(opt, "-mtriple=");
+					if (!parse_target_triple(opt))
+						argument_errors = true;
+				} 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);
+					if (res == 0) {
+						fprintf(stderr, "Unknown architecture '%s'\n", arch_opt);
 						argument_errors = true;
-					else {
+					} else {
 						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, "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=")) {
@@ -730,22 +1091,30 @@ int main(int argc, char **argv)
 						fprintf(stderr, "error: option -mfpumath 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, "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);
@@ -769,33 +1138,41 @@ int main(int argc, char **argv)
 			} 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")) {
@@ -812,12 +1189,19 @@ int main(int argc, char **argv)
 					mode = PrintFluffy;
 				} else if (streq(option, "print-caml")) {
 					mode = PrintCaml;
+				} else if (streq(option, "print-jna")) {
+					mode = PrintJna;
+				} else if (streq(option, "time")) {
+					do_timing = true;
 				} else if (streq(option, "version")) {
 					print_cparser_version();
 					exit(EXIT_SUCCESS);
+				} else if (streq(option, "help")) {
+					print_help(argv[0]);
+					help_displayed = true;
 				} 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 +1209,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 +1220,31 @@ 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, "cc")  ? FILETYPE_CXX                    :
+							streq(suffix, "cpp") ? FILETYPE_CXX                    :
+							streq(suffix, "cxx") ? FILETYPE_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,25 +1262,34 @@ int main(int argc, char **argv)
 		}
 	}
 
+	if (help_displayed) {
+		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;
 
+	/* set the c_mode here, types depends on it */
+	c_mode |= features_on;
+	c_mode &= ~features_off;
+
 	gen_firm_init();
+	byte_order_big_endian = be_get_backend_param()->byte_order_big_endian;
 	init_symbol_table();
-	init_tokens();
 	init_types();
 	init_typehash();
 	init_basic_types();
@@ -905,6 +1297,20 @@ int main(int argc, char **argv)
 	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) {
@@ -915,11 +1321,11 @@ int main(int argc, char **argv)
 		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 +1340,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 +1361,21 @@ int main(int argc, char **argv)
 		out = stdout;
 	} else {
 		out = fopen(outname, "w");
-		if(out == NULL) {
+		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;
 		filetype_t  filetype = file->type;
 
-		if (file->type == FILETYPE_OBJECT)
+		if (filetype == FILETYPE_OBJECT)
 			continue;
 
 		FILE *in = NULL;
@@ -977,36 +1388,47 @@ int main(int argc, char **argv)
 		}
 
 		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 result = pclose(preprocessed_in);
+					fclose(out);
+					/* remove output file in case of error */
+					if (out != stdout && result != EXIT_SUCCESS) {
+						unlink(outname);
+					}
+					return 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 +1436,110 @@ 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);
+					exit(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);
 				continue;
+			} 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 +1549,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);
 				}
 
-				dump_ir_block_graph_file(irg, out);
+				dump_ir_graph_file(out, irg);
 				fclose(out);
-				exit(0);
+				exit(EXIT_SUCCESS);
 			}
 
-			gen_firm_finish(asm_out, filename, /*c_mode=*/1,
-			                /*firm_const_exists=*/0);
+			if (mode == CompileExportIR) {
+				fclose(out);
+				ir_export(outname);
+				exit(EXIT_SUCCESS);
+			}
+
+			gen_firm_finish(asm_out, filename, have_const_functions);
 			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 +1610,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 +1631,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 +1667,24 @@ 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);
+			exit(EXIT_FAILURE);
 		}
 	}
 
+	if (do_timing)
+		timer_term(stderr);
+
 	obstack_free(&cppflags_obst, NULL);
 	obstack_free(&ldflags_obst, NULL);
 	obstack_free(&file_obst, NULL);
 
+	exit_mangle();
 	exit_ast2firm();
 	exit_parser();
 	exit_ast();
@@ -1178,5 +1693,5 @@ int main(int argc, char **argv)
 	exit_types();
 	exit_tokens();
 	exit_symbol_table();
-	return 0;
+	return EXIT_SUCCESS;
 }