{
put_help("-l LIBRARY", "");
put_help("-L PATH", "");
+ put_help("-s", "Do not produce symbol table and relocation information");
put_help("-shared", "Produce a shared library");
put_help("-static", "Produce statically linked binary");
put_help("-Wl,OPTION", "Pass option directly to linker");
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;
}
-static bool is_ia32_cpu(const char *architecture)
+/**
+ * Copy atomic type properties except the integer conversion rank
+ */
+static void copy_typeprops(atomic_type_properties_t *dest,
+ const atomic_type_properties_t *src)
{
- return streq(architecture, "i386")
- || streq(architecture, "i486")
- || streq(architecture, "i586")
- || streq(architecture, "i686")
- || streq(architecture, "i786");
+ 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)
set_typeprops_type(&props[ATOMIC_TYPE_LONGLONG], type_long_long);
ir_type *type_unsigned_long_long = be_params->type_unsigned_long_long;
- if (type_long_long != NULL)
+ if (type_unsigned_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 (machine_size == 32) {
- props[ATOMIC_TYPE_DOUBLE].struct_alignment = 4;
- props[ATOMIC_TYPE_LONG_DOUBLE].size = 16;
- props[ATOMIC_TYPE_LONG_DOUBLE].alignment = 16;
+ props[ATOMIC_TYPE_LONGLONG].struct_alignment = 4;
+ props[ATOMIC_TYPE_ULONGLONG].struct_alignment = 4;
+ props[ATOMIC_TYPE_DOUBLE].struct_alignment = 4;
+ props[ATOMIC_TYPE_LONG_DOUBLE].size = 16;
+ props[ATOMIC_TYPE_LONG_DOUBLE].alignment = 16;
+ props[ATOMIC_TYPE_LONG_DOUBLE].struct_alignment = 16;
}
} else if (is_windows_os(os)) {
if (machine_size == 64) {
/* 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 */
mode = CompileAssemble;
} else if (SINGLE_OPTION('E')) {
mode = PreprocessOnly;
+ } else if (SINGLE_OPTION('s')) {
+ add_flag(&ldflags_obst, "-s");
} else if (SINGLE_OPTION('S')) {
mode = Compile;
} else if (option[0] == 'O') {
} else if (SINGLE_OPTION('v')) {
verbose = 1;
} else if (SINGLE_OPTION('w')) {
+ add_flag(&cppflags_obst, "-w");
disable_all_warnings();
} else if (option[0] == 'x') {
const char *opt;
|| streq(option + 1, "endif-labels")) {
add_flag(&cppflags_obst, "%s", arg);
} else if (streq(option+1, "init-self")) {
- /* ignored (asme as gcc does) */
+ /* ignored (same as gcc does) */
} else if (streq(option+1, "format-y2k")
|| streq(option+1, "format-security")
|| streq(option+1, "old-style-declaration")
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