/*
- * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
".section\t.bss",
".section\t.tbss,\"awT\",@nobits",
".section\t.ctors,\"aw\",@progbits"
+ },
+ {
+ ".section\t.text",
+ ".section\t.data",
+ ".section\t.rodata",
+ ".section\t.bss",
+ ".section\t.tbss,\"awT\",@nobits",
+ ".section\t.ctors,\"aw\",@progbits"
}
};
* @param env the emitter environment
* @param section the section to switch to
*/
-void be_gas_emit_switch_section(be_emit_env_t *env, be_gas_section_t section) {
- be_emit_char(env, '\t');
- be_emit_string(env, get_section_name(section));
- be_emit_char(env, '\n');
- be_emit_write_line(env);
+void be_gas_emit_switch_section(be_gas_section_t section) {
+ be_emit_char('\t');
+ be_emit_string(get_section_name(section));
+ be_emit_char('\n');
+ be_emit_write_line();
}
/**
}
}
+/**
+ * Return the label prefix for labeled blocks.
+ */
+const char *be_gas_label_prefix(void) {
+ return ".LG";
+}
+
+/**
+ * Dump a label.
+ */
+static void dump_label(obstack_t *obst, ir_label_t label) {
+ obstack_printf(obst, "%s%ld", be_gas_label_prefix(), label);
+}
+
/**
* Return the tarval of an atomic initializer.
*
- * @param init a node representing the initializer (on teh const code irg)
+ * @param init a node representing the initializer (on the const code irg)
*
* @return the tarval
*/
case symconst_enum_const:
return get_enumeration_value(get_SymConst_enum(init));
+ case symconst_label:
+ return NULL;
+
default:
return NULL;
}
ir_mode *mode = get_irn_mode(init);
int bytes = get_mode_size_bytes(mode);
tarval *tv;
+ ir_label_t label;
ir_entity *ent;
switch (get_irn_opcode(init)) {
break;
case symconst_type_size:
- obstack_printf(obst, "%d", get_type_size_bytes(get_SymConst_type(init)));
+ obstack_printf(obst, "%u", get_type_size_bytes(get_SymConst_type(init)));
break;
case symconst_type_align:
- obstack_printf(obst, "%d", get_type_alignment_bytes(get_SymConst_type(init)));
+ obstack_printf(obst, "%u", get_type_alignment_bytes(get_SymConst_type(init)));
break;
case symconst_enum_const:
dump_arith_tarval(obst, tv, bytes);
break;
+ case symconst_label:
+ label = get_SymConst_label(init);
+ dump_label(obst, label);
+ break;
+
default:
assert(!"dump_atomic_init(): don't know how to init from this SymConst");
}
n = get_compound_ent_n_values(ent);
for (i = 0; i < n; ++i) {
ir_node *irn = get_compound_ent_value(ent, i);
- if(get_irn_opcode(irn) != iro_Const)
+ if (! is_Const(irn))
return 0;
c = (int) get_tarval_long(get_Const_tarval(irn));
{
normal_or_bitfield *vals;
int i, j, n = get_compound_ent_n_values(ent);
- int last_ofs;
+ unsigned k, last_ofs;
/* Find the initializer size. Sorrily gcc support a nasty feature:
The last field of a compound may be a flexible array. This allows
initializers bigger than the type size. */
last_ofs = get_type_size_bytes(get_entity_type(ent));
for (i = 0; i < n; ++i) {
- int offset = get_compound_ent_value_offset_bytes(ent, i);
- int bits_remainder = get_compound_ent_value_offset_bit_remainder(ent, i);
- const compound_graph_path *path = get_compound_ent_value_path(ent, i);
- int path_len = get_compound_graph_path_length(path);
- ir_entity *last_ent = get_compound_graph_path_node(path, path_len - 1);
- int value_len = get_type_size_bits(get_entity_type(last_ent));
+ unsigned offset = get_compound_ent_value_offset_bytes(ent, i);
+ unsigned bits_remainder = get_compound_ent_value_offset_bit_remainder(ent, i);
+ ir_node *value = get_compound_ent_value(ent, i);
+ unsigned value_len = get_mode_size_bits(get_irn_mode(value));
offset += (value_len + bits_remainder + 7) >> 3;
/* collect the values and store them at the offsets */
for (i = 0; i < n; ++i) {
- const compound_graph_path *path = get_compound_ent_value_path(ent, i);
- int path_len = get_compound_graph_path_length(path);
- int offset = get_compound_ent_value_offset_bytes(ent, i);
- int offset_bits = get_compound_ent_value_offset_bit_remainder(ent, i);
- ir_node *value = get_compound_ent_value(ent, i);
- ir_entity *last_ent = get_compound_graph_path_node(path, path_len - 1);
- int value_len = get_type_size_bits(get_entity_type(last_ent));
- assert(offset >= 0);
+ unsigned offset = get_compound_ent_value_offset_bytes(ent, i);
+ int offset_bits = get_compound_ent_value_offset_bit_remainder(ent, i);
+ ir_node *value = get_compound_ent_value(ent, i);
+ int value_len = get_mode_size_bits(get_irn_mode(value));
+
assert(offset_bits >= 0);
if (offset_bits != 0 ||
(value_len != 8 && value_len != 16 && value_len != 32 && value_len != 64)) {
- tarval *shift, *shifted;
tarval *tv = get_atomic_init_tv(value);
+ unsigned char curr_bits, last_bits = 0;
if (tv == NULL) {
panic("Couldn't get numeric value for bitfield initializer '%s'\n",
get_entity_ld_name(ent));
}
- tv = tarval_convert_to(tv, mode_Lu);
- shift = new_tarval_from_long(offset_bits, mode_Is);
- shifted = tarval_shl(tv, shift);
- if (shifted == tarval_bad || shifted == tarval_undefined) {
- panic("Couldn't shift numeric value for bitfield initializer '%s'\n",
- get_entity_ld_name(ent));
- }
+ /* normalize offset */
+ offset += offset_bits >> 3;
+ offset_bits &= 7;
- for (j = 0; value_len > 0; ++j) {
+ for (j = 0; value_len + offset_bits > 0; ++j) {
assert(offset + j < last_ofs);
assert(vals[offset + j].kind == BITFIELD || vals[offset + j].v.value == NULL);
vals[offset + j].kind = BITFIELD;
- vals[offset + j].v.bf_val |= get_tarval_sub_bits(shifted, j);
- value_len -= 8 - offset_bits;
- offset_bits = 0;
+ curr_bits = get_tarval_sub_bits(tv, j);
+ vals[offset + j].v.bf_val |= (last_bits >> (8 - offset_bits)) | (curr_bits << offset_bits);
+ value_len -= 8;
+ last_bits = curr_bits;
}
} else {
+ int i;
+
assert(offset < last_ofs);
assert(vals[offset].kind == NORMAL);
- assert(vals[offset].v.value == NULL);
+ for (i = 1; i < value_len / 8; ++i) {
+ assert(vals[offset + i].v.value == NULL);
+ }
vals[offset].v.value = value;
}
}
/* now write them sorted */
- for (i = 0; i < last_ofs; ) {
+ for (k = 0; k < last_ofs; ) {
int space = 0, skip = 0;
- if (vals[i].kind == NORMAL) {
- if(vals[i].v.value != NULL) {
- dump_atomic_init(env, obst, vals[i].v.value);
- skip = get_mode_size_bytes(get_irn_mode(vals[i].v.value)) - 1;
+ if (vals[k].kind == NORMAL) {
+ if(vals[k].v.value != NULL) {
+ dump_atomic_init(env, obst, vals[k].v.value);
+ skip = get_mode_size_bytes(get_irn_mode(vals[k].v.value)) - 1;
} else {
space = 1;
}
} else {
- assert(vals[i].kind == BITFIELD);
- obstack_printf(obst, "\t.byte\t%d\n", vals[i].v.bf_val);
+ assert(vals[k].kind == BITFIELD);
+ obstack_printf(obst, "\t.byte\t%d\n", vals[k].v.bf_val);
}
- ++i;
- space = 0;
- while (i < last_ofs && vals[i].kind == NORMAL && vals[i].v.value == NULL) {
+ ++k;
+ while (k < last_ofs && vals[k].kind == NORMAL && vals[k].v.value == NULL) {
++space;
- ++i;
+ ++k;
}
space -= skip;
assert(space >= 0);
obstack_t *obst;
ir_type *type = get_entity_type(ent);
const char *ld_name = get_entity_ld_name(ent);
- int align = get_type_alignment_bytes(type);
+ unsigned align = get_type_alignment_bytes(type);
int emit_as_common = 0;
ir_variability variability;
ir_visibility visibility;
if (is_Method_type(type)) {
if (get_method_img_section(ent) == section_constructors) {
obst = env->ctor_obst;
- obstack_printf(obst, ".balign\t%d\n", align);
+ obstack_printf(obst, ".balign\t%u\n", align);
dump_size_type(obst, align);
obstack_printf(obst, "%s\n", ld_name);
}
}
/* alignment */
if (align > 1 && !emit_as_common) {
- obstack_printf(obst, ".balign\t%d\n", align);
+ obstack_printf(obst, ".balign\t%u\n", align);
}
if (!emit_as_common) {
}
if (variability == variability_uninitialized) {
- if(emit_as_common) {
- if (be_gas_flavour == GAS_FLAVOUR_NORMAL)
- obstack_printf(obst, "\t.comm %s,%d,%d\n",
+ if (emit_as_common) {
+ switch (be_gas_flavour) {
+ case GAS_FLAVOUR_NORMAL:
+ case GAS_FLAVOUR_YASM:
+ obstack_printf(obst, "\t.comm %s,%u,%u\n",
ld_name, get_type_size_bytes(type), align);
- else
- obstack_printf(obst, "\t.comm %s,%d # %d\n",
+ break;
+ case GAS_FLAVOUR_MINGW:
+ obstack_printf(obst, "\t.comm %s,%u # %u\n",
ld_name, get_type_size_bytes(type), align);
+ break;
+ }
} else {
- obstack_printf(obst, "\t.zero %d\n", get_type_size_bytes(type));
+ obstack_printf(obst, "\t.zero %u\n", get_type_size_bytes(type));
}
} else {
if (is_atomic_entity(ent)) {
break;
case tpo_struct:
case tpo_class:
+ case tpo_union:
dump_compound_init(env, obst, ent);
break;
default:
/************************************************************************/
/* Generate all entities. */
-void be_gas_emit_decls(be_emit_env_t *emit, const be_main_env_t *main_env,
+void be_gas_emit_decls(const be_main_env_t *main_env,
int only_emit_marked_entities)
{
be_gas_decl_env_t env;
- obstack_t rodata, data, bss, ctor;
- int size;
- char *cp;
+ obstack_t rodata;
+ obstack_t data;
+ obstack_t bss;
+ obstack_t ctor;
+ int size;
+ char *cp;
/* dump the global type */
obstack_init(&rodata);
size = obstack_object_size(&data);
cp = obstack_finish(&data);
if (size > 0) {
- be_gas_emit_switch_section(emit, GAS_SECTION_DATA);
- be_emit_string_len(emit, cp, size);
- be_emit_write_line(emit);
+ be_gas_emit_switch_section(GAS_SECTION_DATA);
+ be_emit_string_len(cp, size);
+ be_emit_write_line();
}
size = obstack_object_size(&rodata);
cp = obstack_finish(&rodata);
if (size > 0) {
- be_gas_emit_switch_section(emit, GAS_SECTION_RODATA);
- be_emit_string_len(emit, cp, size);
- be_emit_write_line(emit);
+ be_gas_emit_switch_section(GAS_SECTION_RODATA);
+ be_emit_string_len(cp, size);
+ be_emit_write_line();
}
size = obstack_object_size(&bss);
cp = obstack_finish(&bss);
if (size > 0) {
- be_gas_emit_switch_section(emit, GAS_SECTION_COMMON);
- be_emit_string_len(emit, cp, size);
- be_emit_write_line(emit);
+ be_gas_emit_switch_section(GAS_SECTION_COMMON);
+ be_emit_string_len(cp, size);
+ be_emit_write_line();
}
size = obstack_object_size(&ctor);
cp = obstack_finish(&ctor);
if (size > 0) {
- be_gas_emit_switch_section(emit, GAS_SECTION_CTOR);
- be_emit_string_len(emit, cp, size);
- be_emit_write_line(emit);
+ be_gas_emit_switch_section(GAS_SECTION_CTOR);
+ be_emit_string_len(cp, size);
+ be_emit_write_line();
}
obstack_free(&rodata, NULL);
size = obstack_object_size(&data);
cp = obstack_finish(&data);
if (size > 0) {
- be_gas_emit_switch_section(emit, GAS_SECTION_TLS);
- be_emit_cstring(emit, ".balign\t32\n");
- be_emit_write_line(emit);
- be_emit_string_len(emit, cp, size);
- be_emit_write_line(emit);
+ be_gas_emit_switch_section(GAS_SECTION_TLS);
+ be_emit_cstring(".balign\t32\n");
+ be_emit_write_line();
+ be_emit_string_len(cp, size);
+ be_emit_write_line();
}
obstack_free(&data, NULL);
projects / libfirm / blobdiff