"warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n");
}
+static void print_cparser_version_short(void)
+{
+ puts(cparser_REVISION);
+}
+
static void print_help_basic(const char *argv0)
{
usage(argv0);
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_BASIC = 1 << 0,
+ HELP_PREPROCESSOR = 1 << 1,
+ HELP_PARSER = 1 << 2,
+ HELP_WARNINGS = 1 << 3,
+ HELP_OPTIMIZATION = 1 << 4,
+ HELP_CODEGEN = 1 << 5,
+ HELP_LINKER = 1 << 6,
+ HELP_LANGUAGETOOLS = 1 << 7,
+ HELP_DEBUG = 1 << 8,
+ HELP_FIRM = 1 << 9,
+
+ HELP_ALL = -1
} help_sections_t;
static void print_help(const char *argv0, help_sections_t sections)
return FILETYPE_UNKNOWN;
}
-static bool is_windows_os(const char *os)
-{
- return strstr(os, "mingw") != NULL || streq(os, "win32");
-}
-
-static bool is_unixish_os(const char *os)
-{
- return strstr(os, "linux") != NULL || strstr(os, "bsd") != NULL
- || streq(os, "solaris");
-}
-
-static bool is_darwin_os(const char *os)
-{
- return streq(os, "darwin");
-}
-
static bool init_os_support(void)
{
- const char *os = target_machine->operating_system;
wchar_atomic_kind = ATOMIC_TYPE_INT;
enable_main_collect2_hack = false;
define_intmax_types = false;
- if (is_unixish_os(os)) {
+ if (firm_is_unixish_os(target_machine)) {
set_create_ld_ident(create_name_linux_elf);
- } else if (is_darwin_os(os)) {
+ } else if (firm_is_darwin_os(target_machine)) {
set_create_ld_ident(create_name_macho);
define_intmax_types = true;
- } else if (is_windows_os(os)) {
+ } else if (firm_is_windows_os(target_machine)) {
wchar_atomic_kind = ATOMIC_TYPE_USHORT;
enable_main_collect2_hack = true;
set_create_ld_ident(create_name_win32);
set_typeprops_type(&props[ATOMIC_TYPE_ULONGLONG], type_unsigned_long_long);
/* operating system ABI specifics */
- const char *os = target_machine->operating_system;
- if (is_darwin_os(os)) {
+ if (firm_is_darwin_os(target_machine)) {
if (machine_size == 32) {
props[ATOMIC_TYPE_LONGLONG].struct_alignment = 4;
props[ATOMIC_TYPE_ULONGLONG].struct_alignment = 4;
props[ATOMIC_TYPE_LONG_DOUBLE].alignment = 16;
props[ATOMIC_TYPE_LONG_DOUBLE].struct_alignment = 16;
}
- } else if (is_windows_os(os)) {
+ } else if (firm_is_windows_os(target_machine)) {
if (machine_size == 64) {
/* to ease porting of old c-code microsoft decided to use 32bits
* even for long */
/* on windows long double is not supported */
props[ATOMIC_TYPE_LONG_DOUBLE] = props[ATOMIC_TYPE_DOUBLE];
- } else if (is_unixish_os(os)) {
+ } else if (firm_is_unixish_os(target_machine)) {
if (is_ia32_cpu(target_machine->cpu_type)) {
/* System V has a broken alignment for double so we have to add
* a hack here */
int main(int argc, char **argv)
{
- firm_early_init();
-
const char *dumpfunction = NULL;
const char *print_file_name_file = NULL;
compile_mode_t mode = CompileAssembleLink;
#define SINGLE_OPTION(ch) (option[0] == (ch) && option[1] == '\0')
+ /* initialize this early because it has to parse options */
+ gen_firm_init();
+
/* early options parsing (find out optimization level and OS) */
for (int i = 1; i < argc; ++i) {
const char *arg = argv[i];
}
}
- const char *target = getenv("TARGET");
- if (target != NULL)
- parse_target_triple(target);
if (target_machine == NULL) {
target_machine = firm_get_host_machine();
}
streq(opt, "align-loops") ||
streq(opt, "align-jumps") ||
streq(opt, "align-functions") ||
+ streq(opt, "unroll-loops") ||
streq(opt, "PIC") ||
streq(opt, "stack-protector") ||
streq(opt, "stack-protector-all")) {
int res = be_parse_arg(arch_opt);
if (res == 0)
argument_errors = true;
+ } else if (streq(opt, "sse2")) {
+ /* ignore for now, our x86 backend always uses sse when
+ * sse is requested */
} else {
long int value = strtol(opt, NULL, 10);
if (value == 0) {
(fprintf(stderr, "warning: ignoring gcc option '%s'\n", arg), standard);
} else if (streq(option, "version")) {
print_cparser_version();
+ return EXIT_SUCCESS;
+ } else if (streq(option, "dumpversion")) {
+ /* gcc compatibility option */
+ print_cparser_version_short();
+ return EXIT_SUCCESS;
} else if (strstart(option, "print-file-name=")) {
GET_ARG_AFTER(print_file_name_file, "-print-file-name=");
} else if (option[0] == '-') {
mode = CompileDump;
} else if (streq(option, "export-ir")) {
mode = CompileExportIR;
+ } else if (streq(option, "unroll-loops")) {
+ /* ignore (gcc compatibility) */
} else {
fprintf(stderr, "error: unknown argument '%s'\n", arg);
argument_errors = true;
set_be_option("profileuse");
}
- gen_firm_init();
init_symbol_table();
init_types_and_adjust();
init_typehash();
if (already_constructed_firm) {
panic("compiling multiple files/translation units not possible");
}
+ init_implicit_optimizations();
translation_unit_to_firm(unit);
already_constructed_firm = true;
timer_pop(t_construct);
return EXIT_SUCCESS;
}
- gen_firm_finish(asm_out, filename);
+ generate_code(asm_out, filename);
if (asm_out != out) {
fclose(asm_out);
}
obstack_free(&asflags_obst, NULL);
obstack_free(&file_obst, NULL);
+ gen_firm_finish();
exit_mangle();
exit_ast2firm();
exit_parser();