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_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;
typedef enum filetype_t {
return get_atomic_kind_name(type->atomic.akind);
}
-static FILE *preprocess(const char *fname, filetype_t filetype)
+static FILE *preprocess(const char *fname, filetype_t filetype,
+ lang_standard_t standard)
{
static const char *common_flags = NULL;
obstack_printf(&cppflags_obst, PREPROCESSOR);
}
+ char const *lang;
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;
+ case FILETYPE_C: lang = "c"; break;
+ case FILETYPE_CXX: lang = "c++"; break;
+ case FILETYPE_ASSEMBLER: lang = "assembler-with-cpp"; break;
+ default: lang = NULL; break;
+ }
+ if (lang)
+ add_flag(&cppflags_obst, "-x%s", lang);
+
+ char const *std = NULL;
+ switch (standard) {
+ case STANDARD_C89: std = "-std=c89"; break;
+ case STANDARD_C90: std = "-std=iso9899:199409"; break;
+ case STANDARD_C99: std = "-std=c99"; break;
+ case STANDARD_GNU89: std = "-std=gnu89"; break;
+ case STANDARD_GNU99: std = "-std=gnu99"; break;
+ case STANDARD_CXX98: std = "-std=c++98"; break;
+ case STANDARD_GNUXX98: std = "-std=gnu++98"; break;
+ case STANDARD_DEFAULT: panic("invalid standard");
}
+ if (std)
+ add_flag(&cppflags_obst, std);
+
obstack_printf(&cppflags_obst, "%s", common_flags);
/* handle dependency generation */
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, "-MQ");
+ add_flag(&cppflags_obst, outname);
}
}
add_flag(&cppflags_obst, fname);
const char *revision = ir_get_version_revision();
if (revision[0] != 0) {
- putchar(' ');
+ putchar('-');
fputs(revision, stdout);
}
"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);
/* adjust types as requested by target architecture */
ir_type *type_long_double = be_params->type_long_double;
- if (type_long_double != NULL)
+ if (type_long_double != NULL) {
set_typeprops_type(&props[ATOMIC_TYPE_LONG_DOUBLE], type_long_double);
+ atomic_modes[ATOMIC_TYPE_LONG_DOUBLE] = get_type_mode(type_long_double);
+ }
ir_type *type_long_long = be_params->type_long_long;
if (type_long_long != NULL)
set_typeprops_type(&props[ATOMIC_TYPE_ULONGLONG], type_unsigned_long_long);
/* operating system ABI specifics */
- const char *os = target_machine->operating_system;
- if (is_darwin_os(os)) {
+ if (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 */
/* initialize firm pointer modes */
char name[64];
- ir_mode_sort sort = irms_reference;
unsigned bit_size = machine_size;
- bool is_signed = 0;
- ir_mode_arithmetic arithmetic = irma_twos_complement;
unsigned modulo_shift = decide_modulo_shift(bit_size);
snprintf(name, sizeof(name), "p%u", machine_size);
- ir_mode *ptr_mode = new_ir_mode(name, sort, bit_size, is_signed, arithmetic,
- modulo_shift);
+ ir_mode *ptr_mode = new_reference_mode(name, irma_twos_complement, bit_size, modulo_shift);
if (machine_size == 16) {
set_reference_mode_signed_eq(ptr_mode, mode_Hs);
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();
}
setup_target_machine();
/* parse rest of options */
- standard = STANDARD_DEFAULT;
+ lang_standard_t standard = STANDARD_DEFAULT;
unsigned features_on = 0;
unsigned features_off = 0;
filetype_t forced_filetype = FILETYPE_AUTODETECT;
if (option[0] == 'o') {
GET_ARG_AFTER(outname, "-o");
} else if (option[0] == 'g') {
- set_be_option("debuginfo=stabs");
- set_be_option("omitfp=no");
+ /* TODO: parse -gX with 0<=x<=3... */
+ set_be_option("debug=frameinfo");
set_be_option("ia32-nooptcc=yes");
} else if (SINGLE_OPTION('c')) {
mode = CompileAssemble;
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) {
} else if (streq(option, "pg")) {
set_be_option("gprof");
add_flag(&ldflags_obst, "-pg");
- } else if (streq(option, "pedantic") ||
- streq(option, "ansi")) {
+ } else if (streq(option, "ansi")) {
+ add_flag(&cppflags_obst, "-ansi");
+ } else if (streq(option, "pedantic")) {
fprintf(stderr, "warning: ignoring gcc option '%s'\n", arg);
} else if (strstart(option, "std=")) {
const char *const o = &option[4];
(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();
init_basic_types();
if (wchar_atomic_kind == ATOMIC_TYPE_INT)
init_wchar_types(type_int);
- else if (wchar_atomic_kind == ATOMIC_TYPE_SHORT)
+ else if (wchar_atomic_kind == ATOMIC_TYPE_USHORT)
init_wchar_types(type_short);
else
panic("unexpected wchar type");
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;
+ char asm_tempfile[1024];
+ const char *filename = file->name;
+ filetype_t filetype = file->type;
+ lang_standard_t file_standard = standard;
if (filetype == FILETYPE_OBJECT)
continue;
+ if (file_standard == STANDARD_DEFAULT) {
+ switch (filetype) {
+ case FILETYPE_C:
+ case FILETYPE_PREPROCESSED_C:
+ file_standard = STANDARD_GNU99;
+ break;
+ case FILETYPE_CXX:
+ case FILETYPE_PREPROCESSED_CXX:
+ file_standard = STANDARD_GNUXX98;
+ break;
+ default:
+ break;
+ }
+ }
FILE *in = NULL;
if (mode == LexTest) {
if (in != NULL)
panic("internal compiler error: in for preprocessor != NULL");
- preprocessed_in = preprocess(filename, filetype);
+ preprocessed_in = preprocess(filename, filetype,
+ file_standard);
if (mode == PreprocessOnly) {
copy_file(out, preprocessed_in);
int pp_result = pclose(preprocessed_in);
/* preprocess and compile */
if (filetype == FILETYPE_PREPROCESSED_C) {
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;
+ switch (file_standard) {
+ 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;
+ fprintf(stderr,
+ "warning: command line option \"-std=%s\" is not valid for C\n",
+ invalid_mode);
+ /* FALLTHROUGH */
+ 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;
+ case STANDARD_DEFAULT: panic("invalid standard");
}
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;
+ switch (file_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;
+ 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;
+ fprintf(stderr,
+ "warning: command line option \"-std=%s\" is not valid for C++\n",
+ invalid_mode);
+ case STANDARD_GNUXX98: c_mode = _CXX | _GNUC; break;
+ case STANDARD_DEFAULT: panic("invalid standard");
}
do_parsing:
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);
}
if (mode == CompileExportIR) {
- fclose(out);
- ir_export(outname);
+ ir_export_file(out);
+ if (ferror(out) != 0) {
+ fprintf(stderr, "Error while writing to output\n");
+ return EXIT_FAILURE;
+ }
return EXIT_SUCCESS;
}
- gen_firm_finish(asm_out, filename);
+ generate_code(asm_out, filename);
if (asm_out != out) {
fclose(asm_out);
}
} else if (filetype == FILETYPE_IR) {
fclose(in);
- ir_import(filename);
+ int res = ir_import(filename);
+ if (res != 0) {
+ fprintf(stderr, "Firm-Program import failed\n");
+ return EXIT_FAILURE;
+ }
goto graph_built;
} else if (filetype == FILETYPE_PREPROCESSED_ASSEMBLER) {
copy_file(asm_out, in);
obstack_free(&asflags_obst, NULL);
obstack_free(&file_obst, NULL);
+ gen_firm_finish();
exit_mangle();
exit_ast2firm();
exit_parser();
projects / cparser / blobdiff