static char dep_target[1024];
static const char *outname;
static bool define_intmax_types;
+static const char *input_encoding;
typedef enum lang_standard_t {
STANDARD_DEFAULT, /* gnu99 (for C, GCC does gnu89) or gnu++98 (for C++) */
{
start_parsing();
- lexer_open_stream(in, input_name);
+ input_t *input = input_from_stream(in, input_encoding);
+ lexer_switch_input(input, input_name);
parse();
-
translation_unit_t *unit = finish_parsing();
+ input_free(input);
+
return unit;
}
static void lextest(FILE *in, const char *fname)
{
- lexer_open_stream(in, fname);
+ input_t *input = input_from_stream(in, input_encoding);
+ lexer_switch_input(input, fname);
do {
lexer_next_preprocessing_token();
print_token(stdout, &lexer_token);
putchar('\n');
} while (lexer_token.kind != T_EOF);
+ input_free(input);
}
static void add_flag(struct obstack *obst, const char *format, ...)
put_help("-w", "Disable all warnings");
put_help("-Wno-trigraphs", "Warn if input contains trigraphs");
put_help("-Wundef", "Warn if an undefined macro is used in an #if");
+ put_help("-Wmissing-include-dirs", "Warn about missing user-specified include directories");
+ put_help("-Wendif-labels", "Warn about stray text after #elif and #endif");
put_help("-Winit-self", "Ignored (gcc compatibility)");
+ put_help("-Wformat-y2k", "Ignored (gcc compatibility)");
+ put_help("-Wformat-security", "Ignored (gcc compatibility)");
+ put_help("-Wold-style-declaration", "Ignored (gcc compatibility)");
+ put_help("-Wtype-limits", "Ignored (gcc compatibility)");
print_warning_opt_help();
}
return type_size;
}
-static void setup_target_machine(void)
+static bool is_ia32_cpu(const char *architecture)
+{
+ return streq(architecture, "i386")
+ || streq(architecture, "i486")
+ || streq(architecture, "i586")
+ || streq(architecture, "i686")
+ || streq(architecture, "i786");
+}
+
+static const char *setup_isa_from_tripel(const machine_triple_t *machine)
+{
+ const char *cpu = machine->cpu_type;
+
+ if (is_ia32_cpu(cpu)) {
+ return "ia32";
+ } else if (streq(cpu, "x86_64")) {
+ return "amd64";
+ } else if (streq(cpu, "sparc")) {
+ return "sparc";
+ } else if (streq(cpu, "arm")) {
+ return "arm";
+ } else {
+ fprintf(stderr, "Unknown cpu '%s' in target-triple\n", cpu);
+ return NULL;
+ }
+}
+
+static const char *setup_target_machine(void)
{
if (!setup_firm_for_machine(target_machine))
exit(1);
+ const char *isa = setup_isa_from_tripel(target_machine);
+
+ if (isa == NULL)
+ exit(1);
+
init_os_support();
+
+ return isa;
}
/**
props->struct_alignment = props->alignment;
}
+/**
+ * Copy atomic type properties except the integer conversion rank
+ */
+static void copy_typeprops(atomic_type_properties_t *dest,
+ const atomic_type_properties_t *src)
+{
+ dest->size = src->size;
+ dest->alignment = src->alignment;
+ dest->struct_alignment = src->struct_alignment;
+ dest->flags = src->flags;
+}
+
static void init_types_and_adjust(void)
{
const backend_params *be_params = be_get_backend_param();
/* on windows long double is not supported */
props[ATOMIC_TYPE_LONG_DOUBLE] = props[ATOMIC_TYPE_DOUBLE];
} else if (is_unixish_os(os)) {
- if (machine_size == 32) {
+ if (is_ia32_cpu(target_machine->cpu_type)) {
/* System V has a broken alignment for double so we have to add
* a hack here */
props[ATOMIC_TYPE_DOUBLE].struct_alignment = 4;
/* stuff decided after processing operating system specifics and
* commandline flags */
- props[ATOMIC_TYPE_WCHAR_T] = props[wchar_atomic_kind];
if (char_is_signed) {
props[ATOMIC_TYPE_CHAR].flags |= ATOMIC_TYPE_FLAG_SIGNED;
} else {
props[ATOMIC_TYPE_CHAR].flags &= ~ATOMIC_TYPE_FLAG_SIGNED;
}
+ /* copy over wchar_t properties (including rank) */
+ props[ATOMIC_TYPE_WCHAR_T] = props[wchar_atomic_kind];
/* initialize defaults for unsupported types */
if (type_long_long == NULL) {
- props[ATOMIC_TYPE_LONGLONG] = props[ATOMIC_TYPE_LONG];
- }
- if (type_long_double == NULL) {
- props[ATOMIC_TYPE_LONG_DOUBLE] = props[ATOMIC_TYPE_DOUBLE];
+ copy_typeprops(&props[ATOMIC_TYPE_LONGLONG], &props[ATOMIC_TYPE_LONG]);
}
if (type_unsigned_long_long == NULL) {
- props[ATOMIC_TYPE_ULONGLONG] = props[ATOMIC_TYPE_ULONG];
+ copy_typeprops(&props[ATOMIC_TYPE_ULONGLONG],
+ &props[ATOMIC_TYPE_ULONG]);
+ }
+ if (type_long_double == NULL) {
+ copy_typeprops(&props[ATOMIC_TYPE_LONG_DOUBLE],
+ &props[ATOMIC_TYPE_DOUBLE]);
}
/* initialize firm pointer modes */
if (strstart(orig_opt, "input-charset=")) {
char const* const encoding = strchr(orig_opt, '=') + 1;
- select_input_encoding(encoding);
+ input_encoding = encoding;
} else if (strstart(orig_opt, "align-loops=") ||
strstart(orig_opt, "align-jumps=") ||
strstart(orig_opt, "align-functions=")) {
streq(opt, "align-loops") ||
streq(opt, "align-jumps") ||
streq(opt, "align-functions") ||
- streq(opt, "PIC")) {
+ streq(opt, "PIC") ||
+ streq(opt, "stack-protector") ||
+ streq(opt, "stack-protector-all")) {
fprintf(stderr, "ignoring gcc option '-f%s'\n", orig_opt);
} else {
int res = firm_option(orig_opt);
GET_ARG_AFTER(opt, "-Wl,");
add_flag(&ldflags_obst, "-Wl,%s", opt);
} else if (streq(option + 1, "no-trigraphs")
- || streq(option + 1, "undef")) {
+ || streq(option + 1, "undef")
+ || streq(option + 1, "missing-include-dirs")
+ || streq(option + 1, "endif-labels")) {
add_flag(&cppflags_obst, "%s", arg);
} else if (streq(option+1, "init-self")) {
- /* ignored (gcc compatibility) */
+ /* ignored (asme as gcc does) */
+ } else if (streq(option+1, "format-y2k")
+ || streq(option+1, "format-security")
+ || streq(option+1, "old-style-declaration")
+ || streq(option+1, "type-limits")) {
+ /* ignore (gcc compatibility) */
} else {
set_warning_opt(&option[1]);
}
if (!parse_target_triple(opt)) {
argument_errors = true;
} else {
- setup_target_machine();
+ const char *isa = setup_target_machine();
+ strncpy(cpu_arch, isa, sizeof(cpu_arch));
target_triple = opt;
}
} else if (strstart(opt, "triple=")) {
if (!parse_target_triple(opt)) {
argument_errors = true;
} else {
- setup_target_machine();
+ const char *isa = setup_target_machine();
+ strncpy(cpu_arch, isa, sizeof(cpu_arch));
target_triple = opt;
}
} else if (strstart(opt, "arch=")) {
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;
+ add_flag(&ldflags_obst, "-msoft-float");
+ snprintf(arch_opt, sizeof(arch_opt), "%s-fpunit=softfloat", cpu_arch);
+ int res = be_parse_arg(arch_opt);
+ if (res == 0)
+ argument_errors = true;
} else {
long int value = strtol(opt, NULL, 10);
if (value == 0) {
projects / cparser / blobdiff