X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=main.c;h=dc75056e110671abcfead5b79b1f093e1ab36e6b;hb=5894d20a1ca98cb5eb0916b083db5838657d6730;hp=7ea2115a92a13cc5a7d8acfb7b755167a5d2d82a;hpb=922618fb6ed53878e0aee5708bb1ae31c7c93745;p=cparser

diff --git a/main.c b/main.c
index 7ea2115..dc75056 100644
--- a/main.c
+++ b/main.c
@@ -70,35 +70,32 @@
 #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 "adt/strutil.h"
 #include "wrappergen/write_fluffy.h"
-#include "wrappergen/write_caml.h"
 #include "wrappergen/write_jna.h"
 #include "revision.h"
 #include "warning.h"
+#include "help.h"
 #include "mangle.h"
 #include "printer.h"
 
 #ifndef PREPROCESSOR
 #ifndef __WIN32__
-#define PREPROCESSOR "gcc -E -m32 -U__STRICT_ANSI__"
+#define PREPROCESSOR "gcc -E -U__STRICT_ANSI__"
 #else
-#define PREPROCESSOR "cpp -m32 -U__STRICT_ANSI__"
+#define PREPROCESSOR "cpp -U__STRICT_ANSI__"
 #endif
 #endif
 
 #ifndef LINKER
-#define LINKER    "gcc -m32"
+#define LINKER    "gcc"
 #endif
 
 #ifndef ASSEMBLER
-#ifdef __APPLE__
-#define ASSEMBLER "gcc -m32 -c -xassembler"
-#else
-#define ASSEMBLER "as --32"
-#endif
+#define ASSEMBLER "gcc -c -xassembler"
 #endif
 
 unsigned int       c_mode                    = _C89 | _ANSI | _C99 | _GNUC;
@@ -106,24 +103,20 @@ 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;
+unsigned           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;
-
-/* to switch on printing of parenthesis to indicate operator precedence */
-extern bool print_parenthesis;
-
-static const char     *target_triple;
-static int             verbose;
-static struct obstack  cppflags_obst, ldflags_obst;
-static char            dep_target[1024];
-static const char     *outname;
+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;
 
 typedef enum lang_standard_t {
 	STANDARD_DEFAULT, /* gnu99 (for C, GCC does gnu89) or gnu++98 (for C++) */
@@ -162,11 +155,6 @@ struct file_list_entry_t {
 
 static file_list_entry_t *temp_files;
 
-static void initialize_firm(void)
-{
-	firm_early_init();
-}
-
 static void get_output_name(char *buf, size_t buflen, const char *inputname,
                             const char *newext)
 {
@@ -190,17 +178,10 @@ static void get_output_name(char *buf, size_t buflen, const char *inputname,
 		panic("filename too long");
 }
 
-#include "gen_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);
 	parse();
 
@@ -216,7 +197,7 @@ static void lextest(FILE *in, const char *fname)
 		lexer_next_preprocessing_token();
 		print_token(stdout, &lexer_token);
 		putchar('\n');
-	} while (lexer_token.type != T_EOF);
+	} while (lexer_token.kind != T_EOF);
 }
 
 static void add_flag(struct obstack *obst, const char *format, ...)
@@ -289,6 +270,13 @@ static FILE *preprocess(const char *fname, filetype_t filetype)
 		add_flag(&cppflags_obst, "-U__VERSION__");
 		add_flag(&cppflags_obst, "-D__VERSION__=\"%s\"", cparser_REVISION);
 
+		if (define_intmax_types) {
+			add_flag(&cppflags_obst, "-U__INTMAX_TYPE__");
+			add_flag(&cppflags_obst, "-D__INTMAX_TYPE__=%s", type_to_string(type_intmax_t));
+			add_flag(&cppflags_obst, "-U__UINTMAX_TYPE__");
+			add_flag(&cppflags_obst, "-D__UINTMAX_TYPE__=%s", type_to_string(type_uintmax_t));
+		}
+
 		if (flags[0] != '\0') {
 			size_t len = strlen(flags);
 			obstack_1grow(&cppflags_obst, ' ');
@@ -335,56 +323,52 @@ static FILE *preprocess(const char *fname, filetype_t filetype)
 		}
 	}
 	add_flag(&cppflags_obst, fname);
-
 	obstack_1grow(&cppflags_obst, '\0');
-	char *buf = obstack_finish(&cppflags_obst);
+
+	char *commandline = obstack_finish(&cppflags_obst);
 	if (verbose) {
-		puts(buf);
+		puts(commandline);
 	}
-
-	FILE *f = popen(buf, "r");
+	FILE *f = popen(commandline, "r");
 	if (f == NULL) {
 		fprintf(stderr, "invoking preprocessor failed\n");
 		exit(EXIT_FAILURE);
 	}
-
-	/* we don't really need that anymore */
-	obstack_free(&cppflags_obst, buf);
+	/* we do not really need that anymore */
+	obstack_free(&cppflags_obst, commandline);
 
 	return f;
 }
 
 static void assemble(const char *out, const char *in)
 {
-	struct obstack asflags_obst;
-	char *buf;
-
-	obstack_init(&asflags_obst);
+	obstack_1grow(&asflags_obst, '\0');
+	const char *flags = obstack_finish(&asflags_obst);
 
 	const char *assembler = getenv("CPARSER_AS");
 	if (assembler != NULL) {
-		obstack_printf(&asflags_obst, "%s ", assembler);
+		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", ASSEMBLER);
 	}
+	if (flags[0] != '\0')
+		obstack_printf(&asflags_obst, " %s", flags);
 
-	obstack_printf(&asflags_obst, "%s -o %s", in, out);
+	obstack_printf(&asflags_obst, " %s -o %s", in, out);
 	obstack_1grow(&asflags_obst, '\0');
-	buf = obstack_finish(&asflags_obst);
 
+	char *commandline = obstack_finish(&asflags_obst);
 	if (verbose) {
-		puts(buf);
+		puts(commandline);
 	}
-
-	int err = system(buf);
-	if (err != 0) {
+	int err = system(commandline);
+	if (err != EXIT_SUCCESS) {
 		fprintf(stderr, "assembler reported an error\n");
 		exit(EXIT_FAILURE);
 	}
-
-	obstack_free(&asflags_obst, NULL);
+	obstack_free(&asflags_obst, commandline);
 }
 
 static void print_file_name(const char *file)
@@ -408,7 +392,6 @@ static void print_file_name(const char *file)
 	obstack_1grow(&ldflags_obst, '\0');
 
 	char *commandline = obstack_finish(&ldflags_obst);
-
 	if (verbose) {
 		puts(commandline);
 	}
@@ -417,6 +400,7 @@ static void print_file_name(const char *file)
 		fprintf(stderr, "linker reported an error\n");
 		exit(EXIT_FAILURE);
 	}
+	obstack_free(&ldflags_obst, commandline);
 }
 
 static const char *try_dir(const char *dir)
@@ -481,13 +465,13 @@ static FILE *make_temp_file(char *buffer, size_t buflen, const char *prefix)
 
 	int fd = mkstemp(buffer);
 	if (fd == -1) {
-		fprintf(stderr, "couldn't create temporary file: %s\n",
+		fprintf(stderr, "could not create temporary file: %s\n",
 		        strerror(errno));
 		exit(EXIT_FAILURE);
 	}
 	FILE *out = fdopen(fd, "w");
 	if (out == NULL) {
-		fprintf(stderr, "couldn't create temporary file FILE*\n");
+		fprintf(stderr, "could not create temporary file FILE*\n");
 		exit(EXIT_FAILURE);
 	}
 
@@ -531,7 +515,6 @@ typedef enum compile_mode_t {
 	LexTest,
 	PrintAst,
 	PrintFluffy,
-	PrintCaml,
 	PrintJna
 } compile_mode_t;
 
@@ -562,25 +545,211 @@ static void print_cparser_version(void)
 	     "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n");
 }
 
-static void print_help(const char *argv0)
+static void print_help_basic(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");
+	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 set_be_option(const char *arg)
+static void print_help_preprocessor(void)
 {
-	int res = be_parse_arg(arg);
+	put_help("-nostdinc",                "Do not search standard system include directories");
+	put_help("-trigraphs",               "Support ISO C trigraphs");
+	put_help("-isystem",                 "");
+	put_help("-include",                 "");
+	put_help("-I PATH",                  "");
+	put_help("-D SYMBOL[=value]",        "");
+	put_help("-U SYMBOL",                "");
+	put_help("-Wp,OPTION",               "Pass option directly to preprocessor");
+	put_help("-M",                       "");
+	put_help("-MD",                      "");
+	put_help("-MMD",                     "");
+	put_help("-MM",                      "");
+	put_help("-MP",                      "");
+	put_help("-MT",                      "");
+	put_help("-MQ",                      "");
+	put_help("-MF",                      "");
+}
+
+static void print_help_parser(void)
+{
+	put_help("-finput-charset=CHARSET",  "Select encoding of input files");
+	put_help("-fmessage-length=LEN",     "Ignored (gcc compatibility)");
+	put_help("-fshort-wchar",            "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("-Winit-self",                    "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)
+{
+	put_help("-l LIBRARY",               "");
+	put_help("-L PATH",                  "");
+	put_help("-shared",                  "Produce a shared library");
+	put_help("-static",                  "Produce statically linked binary");
+	put_help("-Wl,OPTION",               "Pass option directly to linker");
+}
+
+static void print_help_debug(void)
+{
+	put_help("--lextest",                "Preprocess and tokenize only");
+	put_help("--print-ast",              "Preprocess, parse and print AST");
+	put_help("--print-implicit-cast",    "");
+	put_help("--print-parenthesis",      "");
+	put_help("--benchmark",              "Preprocess and parse, produces no output");
+	put_help("--time",                   "Measure time of compiler passes");
+	put_help("--dump-function func",     "Preprocess, parse and output vcg graph of func");
+	put_help("--export-ir",              "Preprocess, parse and output compiler intermediate representation");
+}
+
+static void print_help_language_tools(void)
+{
+	put_help("--print-fluffy",           "Preprocess, parse and generate declarations for the fluffy language");
+	put_help("--print-jna",              "Preprocess, parse and generate declarations for JNA");
+	put_help("--jna-limit filename",     "");
+	put_help("--jna-libname name",       "");
+}
+
+static void print_help_firm(void)
+{
+	put_help("-bOPTION",                 "Directly pass option to libFirm backend");
+	int res = be_parse_arg("help");
 	(void) res;
 	assert(res);
 }
 
-static void set_option(const char *arg)
+typedef enum {
+	HELP_NONE          = 0,
+	HELP_BASIC         = 1u << 0,
+	HELP_PREPROCESSOR  = 1u << 1,
+	HELP_PARSER        = 1u << 2,
+	HELP_WARNINGS      = 1u << 3,
+	HELP_OPTIMIZATION  = 1u << 4,
+	HELP_CODEGEN       = 1u << 5,
+	HELP_LINKER        = 1u << 6,
+	HELP_LANGUAGETOOLS = 1u << 7,
+	HELP_DEBUG         = 1u << 8,
+	HELP_FIRM          = 1u << 9,
+
+	HELP_ALL           = (unsigned)-1
+} help_sections_t;
+
+static void print_help(const char *argv0, help_sections_t sections)
 {
-	int res = firm_option(arg);
+	if (sections & HELP_BASIC)         print_help_basic(argv0);
+	if (sections & HELP_PREPROCESSOR)  print_help_preprocessor();
+	if (sections & HELP_PARSER)        print_help_parser();
+	if (sections & HELP_WARNINGS)      print_help_warnings();
+	if (sections & HELP_OPTIMIZATION)  print_help_optimization();
+	if (sections & HELP_CODEGEN)       print_help_codegeneration();
+	if (sections & HELP_LINKER)        print_help_linker();
+	if (sections & HELP_LANGUAGETOOLS) print_help_language_tools();
+	if (sections & HELP_DEBUG)         print_help_debug();
+	if (sections & HELP_FIRM)          print_help_firm();
+}
+
+static void set_be_option(const char *arg)
+{
+	int res = be_parse_arg(arg);
 	(void) res;
 	assert(res);
 }
@@ -592,25 +761,11 @@ 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");
+			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, "-")) {
@@ -619,7 +774,7 @@ static FILE *open_file(const char *filename)
 
 	FILE *in = fopen(filename, "r");
 	if (in == NULL) {
-		fprintf(stderr, "Couldn't open '%s': %s\n", filename,
+		fprintf(stderr, "Could not open '%s': %s\n", filename,
 				strerror(errno));
 		exit(EXIT_FAILURE);
 	}
@@ -643,29 +798,23 @@ 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)
+static bool init_os_support(void)
 {
+	const char *os = target_machine->operating_system;
 	wchar_atomic_kind         = ATOMIC_TYPE_INT;
-	force_long_double_size    = 0;
 	enable_main_collect2_hack = false;
+	define_intmax_types       = 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");
+		long_double_size = 16;
 		set_create_ld_ident(create_name_macho);
+		define_intmax_types = true;
 	} else if (strstr(os, "mingw") != NULL || streq(os, "win32")) {
 		wchar_atomic_kind         = ATOMIC_TYPE_USHORT;
 		enable_main_collect2_hack = true;
-		set_be_option("ia32-gasmode=mingw");
 		set_create_ld_ident(create_name_win32);
 	} else {
 		return false;
@@ -676,71 +825,36 @@ static bool set_os_support(const char *os)
 
 static bool parse_target_triple(const char *arg)
 {
-	const char *manufacturer = strchr(arg, '-');
-	if (manufacturer == NULL) {
+	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;
 	}
-	manufacturer += 1;
+	target_machine = triple;
+	return true;
+}
 
-	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;
-	}
+static void setup_target_machine(void)
+{
+	if (!setup_firm_for_machine(target_machine))
+		exit(1);
 
-	/* process manufacturer, alot of people incorrectly leave out the
-	 * manufacturer instead of using unknown- */
-	if (strstart(manufacturer, "linux")) {
-		os = manufacturer;
-		manufacturer = "unknown-";
+	const backend_params *be_params = be_get_backend_param();
+	if (be_params->long_double_size % 8 != 0) {
+		fprintf(stderr, "firm-target long double size is not a multiple of 8, cannot handle this\n");
+		exit(1);
 	}
 
-	/* process operating system */
-	if (!set_os_support(os)) {
-		fprintf(stderr, "Unknown operating system '%s' in triple '%s'\n", os, arg);
-		return false;
-	}
+	byte_order_big_endian = be_params->byte_order_big_endian;
+	machine_size          = be_params->machine_size;
+	long_double_size      = be_params->long_double_size / 8;
 
-	target_triple = arg;
-	return true;
+	init_os_support();
 }
 
 int main(int argc, char **argv)
 {
-	initialize_firm();
+	firm_early_init();
 
 	const char        *dumpfunction         = NULL;
 	const char        *print_file_name_file = NULL;
@@ -752,6 +866,8 @@ int main(int argc, char **argv)
 	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);
@@ -764,28 +880,31 @@ int main(int argc, char **argv)
 
 	obstack_init(&cppflags_obst);
 	obstack_init(&ldflags_obst);
+	obstack_init(&asflags_obst);
 	obstack_init(&file_obst);
 
 #define GET_ARG_AFTER(def, args)                                             \
+	do {                                                                     \
 	def = &arg[sizeof(args)-1];                                              \
-	if (def[0] == '\0') {                                                     \
+	if (def[0] == '\0') {                                                    \
 		++i;                                                                 \
-		if (i >= argc) {                                                      \
+		if (i >= argc) {                                                     \
 			fprintf(stderr, "error: expected argument after '" args "'\n");  \
 			argument_errors = true;                                          \
 			break;                                                           \
 		}                                                                    \
 		def = argv[i];                                                       \
-		if (def[0] == '-' && def[1] != '\0') {                                \
+		if (def[0] == '-' && def[1] != '\0') {                               \
 			fprintf(stderr, "error: expected argument after '" args "'\n");  \
 			argument_errors = true;                                          \
 			continue;                                                        \
 		}                                                                    \
-	}
+	}                                                                        \
+	} while (0)
 
 #define SINGLE_OPTION(ch) (option[0] == (ch) && option[1] == '\0')
 
-	/* early options parsing (find out optimisation level and OS) */
+	/* early options parsing (find out optimization level and OS) */
 	for (int i = 1; i < argc; ++i) {
 		const char *arg = argv[i];
 		if (arg[0] != '-')
@@ -797,50 +916,22 @@ int main(int argc, char **argv)
 		}
 	}
 
-	/* 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:
-		set_option("no-opt");
-		break;
-	case 1:
-		set_option("no-inline");
-		break;
-	default:
-	case 4:
-		/* use_builtins = true; */
-		/* fallthrough */
-	case 3:
-		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);
+	if (target_machine == NULL) {
+		target_machine = firm_get_host_machine();
+	}
+	choose_optimization_pack(opt_level);
+	setup_target_machine();
 
 	/* parse rest of options */
-	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;
+	                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') {
@@ -883,7 +974,7 @@ int main(int argc, char **argv)
 			} else if (SINGLE_OPTION('v')) {
 				verbose = 1;
 			} else if (SINGLE_OPTION('w')) {
-				memset(&warning, 0, sizeof(warning));
+				disable_all_warnings();
 			} else if (option[0] == 'x') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-x");
@@ -932,6 +1023,10 @@ int main(int argc, char **argv)
 				add_flag(&cppflags_obst, "%s", arg);
 			} else if (streq(option, "pipe")) {
 				/* here for gcc compatibility */
+			} else if (streq(option, "static")) {
+				add_flag(&ldflags_obst, "-static");
+			} else if (streq(option, "shared")) {
+				add_flag(&ldflags_obst, "-shared");
 			} else if (option[0] == 'f') {
 				char const *orig_opt;
 				GET_ARG_AFTER(orig_opt, "-f");
@@ -939,9 +1034,35 @@ int main(int argc, char **argv)
 				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 (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;
+					} 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] == '-') {
@@ -949,8 +1070,8 @@ int main(int argc, char **argv)
 						opt += 3;
 					}
 
-					if (streq(opt, "builtins")) {
-						use_builtins = truth_value;
+					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")) {
@@ -958,30 +1079,32 @@ int main(int argc, char **argv)
 					} 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")) {
-						firm_option(truth_value ? "strength-red" : "no-strength-red");
+						/* 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 = true;
+						freestanding = truth_value;
 					} else if (streq(opt, "hosted")) {
-						freestanding = false;
-					} else if (truth_value == false &&
+						freestanding = !truth_value;
+					} else if (streq(opt, "profile-generate")) {
+						profile_generate = truth_value;
+					} else if (streq(opt, "profile-use")) {
+						profile_use = truth_value;
+					} else if (!truth_value &&
 					           streq(opt, "asynchronous-unwind-tables")) {
-					    /* nothing todo, a gcc feature which we don't support
+					    /* nothing todo, a gcc feature which we do not 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")             ||
+					} 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")  ||
@@ -997,28 +1120,28 @@ int main(int argc, char **argv)
 							        orig_opt);
 							argument_errors = true;
 							continue;
-						} else if (res == -1) {
-							help_displayed = true;
 						}
 					}
 				}
 			} else if (option[0] == 'b') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-b");
-				int res = be_parse_arg(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 (option[1] == '\0') {
-					/* ignore -W, our defaults are already quite verbose */
-				} else if (strstart(option + 1, "p,")) {
+				if (strstart(option + 1, "p,")) {
 					// pass options directly to the preprocessor
 					const char *opt;
 					GET_ARG_AFTER(opt, "-Wp,");
@@ -1031,6 +1154,8 @@ int main(int argc, char **argv)
 				} else if (streq(option + 1, "no-trigraphs")
 							|| streq(option + 1, "undef")) {
 					add_flag(&cppflags_obst, "%s", arg);
+				} else if (streq(option+1, "init-self")) {
+					/* ignored (gcc compatibility) */
 				} else {
 					set_warning_opt(&option[1]);
 				}
@@ -1042,24 +1167,30 @@ int main(int argc, char **argv)
 				GET_ARG_AFTER(opt, "-m");
 				if (strstart(opt, "target=")) {
 					GET_ARG_AFTER(opt, "-mtarget=");
-					if (!parse_target_triple(opt))
+					if (!parse_target_triple(opt)) {
 						argument_errors = true;
+					} else {
+						setup_target_machine();
+						target_triple = opt;
+					}
 				} else if (strstart(opt, "triple=")) {
 					GET_ARG_AFTER(opt, "-mtriple=");
-					if (!parse_target_triple(opt))
+					if (!parse_target_triple(opt)) {
 						argument_errors = true;
+					} else {
+						setup_target_machine();
+						target_triple = opt;
+					}
 				} else if (strstart(opt, "arch=")) {
 					GET_ARG_AFTER(opt, "-march=");
 					snprintf(arch_opt, sizeof(arch_opt), "%s-arch=%s", cpu_arch, opt);
 					int res = 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 = be_parse_arg(arch_opt);
-						if (res == 0)
-							argument_errors = true;
 					}
 				} else if (strstart(opt, "tune=")) {
 					GET_ARG_AFTER(opt, "-mtune=");
@@ -1080,7 +1211,7 @@ 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) {
@@ -1095,10 +1226,6 @@ int main(int argc, char **argv)
 					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=")) {
@@ -1116,7 +1243,10 @@ int main(int argc, char **argv)
 						fprintf(stderr, "error: option -m supports only 16, 32 or 64\n");
 						argument_errors = true;
 					} else {
-						machine_size = (unsigned int)value;
+						add_flag(&cppflags_obst, "-m%u", machine_size);
+						add_flag(&asflags_obst, "-m%u", machine_size);
+						add_flag(&ldflags_obst, "-m%u", machine_size);
+						/* TODO: choose/change backend based on this */
 					}
 				}
 			} else if (streq(option, "pg")) {
@@ -1125,8 +1255,6 @@ int main(int argc, char **argv)
 			} else if (streq(option, "pedantic") ||
 			           streq(option, "ansi")) {
 				fprintf(stderr, "warning: ignoring gcc option '%s'\n", arg);
-			} else if (streq(option, "shared")) {
-				add_flag(&ldflags_obst, "-shared");
 			} else if (strstart(option, "std=")) {
 				const char *const o = &option[4];
 				standard =
@@ -1177,8 +1305,6 @@ 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")) {
@@ -1205,8 +1331,25 @@ int main(int argc, char **argv)
 					print_cparser_version();
 					return EXIT_SUCCESS;
 				} else if (streq(option, "help")) {
-					print_help(argv[0]);
-					help_displayed = true;
+					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) {
@@ -1242,6 +1385,7 @@ int main(int argc, char **argv)
 							streq(suffix, "S")   ? FILETYPE_ASSEMBLER              :
 							streq(suffix, "a")   ? FILETYPE_OBJECT                 :
 							streq(suffix, "c")   ? FILETYPE_C                      :
+							streq(suffix, "i")   ? FILETYPE_PREPROCESSED_C         :
 							streq(suffix, "C")   ? FILETYPE_CXX                    :
 							streq(suffix, "cc")  ? FILETYPE_CXX                    :
 							streq(suffix, "cp")  ? FILETYPE_CXX                    :
@@ -1249,7 +1393,7 @@ int main(int argc, char **argv)
 							streq(suffix, "CPP") ? FILETYPE_CXX                    :
 							streq(suffix, "cxx") ? FILETYPE_CXX                    :
 							streq(suffix, "c++") ? FILETYPE_CXX                    :
-							streq(suffix, "ii")  ? FILETYPE_CXX                    :
+							streq(suffix, "ii")  ? FILETYPE_PREPROCESSED_CXX       :
 							streq(suffix, "h")   ? FILETYPE_C                      :
 							streq(suffix, "ir")  ? FILETYPE_IR                     :
 							streq(suffix, "o")   ? FILETYPE_OBJECT                 :
@@ -1275,7 +1419,8 @@ int main(int argc, char **argv)
 		}
 	}
 
-	if (help_displayed) {
+	if (help != HELP_NONE) {
+		print_help(argv[0], help);
 		return !argument_errors;
 	}
 
@@ -1293,15 +1438,18 @@ int main(int argc, char **argv)
 		return EXIT_FAILURE;
 	}
 
-	/* we do the lowering in ast2firm */
-	firm_opt.lower_bitfields = FALSE;
-
-	/* set the c_mode here, types depends on it */
+	/* 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();
-	byte_order_big_endian = be_get_backend_param()->byte_order_big_endian;
 	init_symbol_table();
 	init_types();
 	init_typehash();
@@ -1333,7 +1481,6 @@ int main(int argc, char **argv)
 		case BenchmarkParser:
 		case PrintAst:
 		case PrintFluffy:
-		case PrintCaml:
 		case PrintJna:
 		case LexTest:
 		case PreprocessOnly:
@@ -1375,7 +1522,7 @@ int main(int argc, char **argv)
 	} else {
 		out = fopen(outname, "w");
 		if (out == NULL) {
-			fprintf(stderr, "Couldn't open '%s' for writing: %s\n", outname,
+			fprintf(stderr, "Could not open '%s' for writing: %s\n", outname,
 					strerror(errno));
 			return EXIT_FAILURE;
 		}
@@ -1420,13 +1567,13 @@ preprocess:
 				preprocessed_in = preprocess(filename, filetype);
 				if (mode == PreprocessOnly) {
 					copy_file(out, preprocessed_in);
-					int result = pclose(preprocessed_in);
+					int pp_result = pclose(preprocessed_in);
 					fclose(out);
 					/* remove output file in case of error */
-					if (out != stdout && result != EXIT_SUCCESS) {
+					if (out != stdout && pp_result != EXIT_SUCCESS) {
 						unlink(outname);
 					}
-					return result;
+					return pp_result;
 				}
 
 				in = preprocessed_in;
@@ -1533,9 +1680,6 @@ do_parsing:
 			} 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;
@@ -1588,7 +1732,7 @@ graph_built:
 				return EXIT_SUCCESS;
 			}
 
-			gen_firm_finish(asm_out, filename, have_const_functions);
+			gen_firm_finish(asm_out, filename);
 			if (asm_out != out) {
 				fclose(asm_out);
 			}
@@ -1695,6 +1839,7 @@ graph_built:
 
 	obstack_free(&cppflags_obst, NULL);
 	obstack_free(&ldflags_obst, NULL);
+	obstack_free(&asflags_obst, NULL);
 	obstack_free(&file_obst, NULL);
 
 	exit_mangle();