#include "entity.h"
#include "irprog.h"
+#include "../be.h"
+
#include "ia32_emitter.h"
#include "ia32_gen_decls.h"
+typedef struct obstack obstack_t;
+
+typedef struct _ia32_decl_env {
+ obstack_t *rodata_obst;
+ obstack_t *data_obst;
+ obstack_t *comm_obst;
+ obstack_t *ctor_obst;
+ const be_main_env_t *main_env;
+} ia32_decl_env_t;
+
/************************************************************************/
/*
return res;
}
-static void ia32_dump_comm(struct obstack *obst, const char *name, visibility vis, int size, int align) {
+static void ia32_dump_comm(obstack_t *obst, const char *name, ir_visibility vis, int size, int align) {
switch (asm_flavour) {
case ASM_LINUX_GAS:
if (vis == visibility_local)
else
obstack_printf(obst, "\t.comm\t%s,%d\n", name, size);
break;
+ default:
+ break;
}
}
/**
* output the alignment to an obstack
*/
-static void ia32_dump_align(struct obstack *obst, int align)
+static void ia32_dump_align(obstack_t *obst, int align)
{
int h = highest_bit(align);
/**
* output a tarval
*/
-static void dump_arith_tarval(struct obstack *obst, tarval *tv, int bytes)
+static void dump_arith_tarval(obstack_t *obst, tarval *tv, int bytes)
{
switch (bytes) {
/*
* dump an atomic value
*/
-static void do_dump_atomic_init(struct obstack *obst, ir_node *init)
+static void do_dump_atomic_init(obstack_t *obst, ir_node *init)
{
ir_mode *mode = get_irn_mode(init);
int bytes = get_mode_size_bytes(mode);
obstack_printf(obst, "%s", get_entity_ld_name(get_SymConst_entity(init)));
break;
+ case symconst_ofs_ent:
+ obstack_printf(obst, "%d", get_entity_offset_bytes(get_SymConst_entity(init)));
+ break;
+
case symconst_type_size:
obstack_printf(obst, "%d", get_type_size_bytes(get_SymConst_type(init)));
break;
break;
default:
- assert(0 && "dump_atomic_init(): don't know how to init from this SymConst");
+ assert(!"dump_atomic_init(): don't know how to init from this SymConst");
}
return;
}
/*
- * dump an atomic value
+ * dumps the type for given size (.byte, .long, ...)
*/
-static void dump_atomic_init(struct obstack *obst, ir_node *init)
-{
- ir_mode *mode = get_irn_mode(init);
- int bytes = get_mode_size_bytes(mode);
-
- switch (bytes) {
+static void dump_size_type(obstack_t *obst, int size) {
+ switch (size) {
case 1:
obstack_printf(obst, "\t.byte\t");
break;
default:
- fprintf(stderr, "Try to dump an tarval with %d bytes\n", bytes);
+ fprintf(stderr, "Try to dump a type with %d bytes\n", size);
assert(0);
}
+}
+
+/*
+ * dump an atomic value
+ */
+static void dump_atomic_init(obstack_t *obst, ir_node *init)
+{
+ ir_mode *mode = get_irn_mode(init);
+ int bytes = get_mode_size_bytes(mode);
+ dump_size_type(obst, bytes);
do_dump_atomic_init(obst, init);
obstack_printf(obst, "\n");
}
* @param obst The obst to dump on.
* @param ent The entity to dump.
*/
-static void dump_string_cst(struct obstack *obst, entity *ent)
+static void dump_string_cst(obstack_t *obst, entity *ent)
{
int i, n;
/**
* Dump the size of an object
*/
-static void dump_object_size(struct obstack *obst, const char *name, int size) {
+static void dump_object_size(obstack_t *obst, const char *name, int size) {
switch (asm_flavour) {
case ASM_LINUX_GAS:
obstack_printf(obst, "\t.type\t%s,@object\n", name);
obstack_printf(obst, "\t.size\t%s,%d\n", name, size);
break;
+ default:
+ break;
}
}
* Dumps the initialization of global variables that are not
* "uninitialized".
*/
-static void dump_global(struct obstack *rdata_obstack, struct obstack *data_obstack, struct obstack *comm_obstack, entity *ent)
+static void dump_global(const be_main_env_t *main_env,
+ obstack_t *rdata_obstack, obstack_t *data_obstack,
+ obstack_t *comm_obstack, obstack_t *ctor_obstack,
+ entity *ent)
{
ir_type *ty = get_entity_type(ent);
const char *ld_name = get_entity_ld_name(ent);
+ obstack_t *obst = data_obstack;
int align, h;
- struct obstack *obst = data_obstack;
/*
* FIXME: did NOT work for partly constant values
*/
if (! is_Method_type(ty)) {
- ent_variability variability = get_entity_variability(ent);
- visibility visibility = get_entity_visibility(ent);
+ ir_variability variability = get_entity_variability(ent);
+ ir_visibility visibility = get_entity_visibility(ent);
if (variability == variability_constant) {
/* a constant entity, put it on the rdata */
/* check, whether it is initialized, if yes create data */
if (variability != variability_uninitialized) {
+ be_dbg_variable(main_env->db_handle, obst, ent);
+
if (visibility == visibility_external_visible) {
obstack_printf(obst, ".globl\t%s\n", ld_name);
}
obstack_printf(obst, "\n");
}
else if (visibility != visibility_external_allocated) {
+ be_dbg_variable(main_env->db_handle, comm_obstack, ent);
+
/* uninitialized and NOT external */
if (get_entity_owner(ent) != get_tls_type()) {
/* calculate the alignment */
} else {
/* TLS */
if (visibility == visibility_external_visible) {
- obstack_printf(obst, ".globl\t%s\n", ld_name);
+ obstack_printf(comm_obstack, ".globl\t%s\n", ld_name);
}
dump_object_size(comm_obstack, ld_name, get_type_size_bytes(ty));
align = get_type_alignment_bytes(ty);
- ia32_dump_align(obst, align);
+ ia32_dump_align(comm_obstack, align);
obstack_printf(comm_obstack, "%s:\n\t.zero %d\n", ld_name, get_type_size_bytes(ty));
}
}
+ } /* ! is method type */
+ else if (ctor_obstack && get_method_img_section(ent) == section_constructors) {
+ ia32_dump_align(ctor_obstack, get_type_alignment_bytes(ty));
+ dump_size_type(ctor_obstack, get_type_alignment_bytes(ty));
+ obstack_printf(ctor_obstack, "%s\n", ld_name);
}
}
/**
* Dumps declarations of global variables and the initialization code.
*/
-static void ia32_dump_globals(ir_type *gt, struct obstack *rdata_obstack, struct obstack *data_obstack, struct obstack *comm_obstack)
+static void ia32_dump_globals(ir_type *gt, ia32_decl_env_t *env)
{
int i, n = get_compound_n_members(gt);
for (i = 0; i < n; i++)
- dump_global(rdata_obstack, data_obstack, comm_obstack, get_compound_member(gt, i));
+ dump_global(env->main_env, env->rodata_obst, env->data_obst, env->comm_obst, env->ctor_obst,
+ get_compound_member(gt, i));
}
/************************************************************************/
-void ia32_gen_decls(FILE *out) {
- struct obstack rodata, data, comm;
+void ia32_gen_decls(FILE *out, const be_main_env_t *main_env) {
+ ia32_decl_env_t env;
+ obstack_t rodata, data, comm, ctor;
int size;
char *cp;
obstack_init(&data);
obstack_init(&comm);
- ia32_dump_globals(get_glob_type(), &rodata, &data, &comm);
+ if (main_env->options->opt_profile)
+ obstack_init(&ctor);
+
+ env.rodata_obst = &rodata;
+ env.data_obst = &data;
+ env.comm_obst = &comm;
+ env.ctor_obst = main_env->options->opt_profile ? &ctor : NULL;
+ env.main_env = main_env;
+
+ ia32_dump_globals(get_glob_type(), &env);
size = obstack_object_size(&data);
cp = obstack_finish(&data);
fwrite(cp, 1, size, out);
}
+ if (main_env->options->opt_profile) {
+ size = obstack_object_size(&ctor);
+ cp = obstack_finish(&ctor);
+ if (size > 0) {
+ ia32_switch_section(out, SECTION_CTOR);
+ fwrite(cp, 1, size, out);
+ }
+ obstack_free(&ctor, NULL);
+ }
+
obstack_free(&rodata, NULL);
obstack_free(&data, NULL);
obstack_free(&comm, NULL);
/* dump the Thread Local Storage */
obstack_init(&data);
- ia32_dump_globals(get_tls_type(), &data, &data, &data);
+
+ env.rodata_obst = &data;
+ env.data_obst = &data;
+ env.comm_obst = &data;
+ env.ctor_obst = NULL;
+
+ ia32_dump_globals(get_tls_type(), &env);
size = obstack_object_size(&data);
cp = obstack_finish(&data);
fwrite(cp, 1, size, out);
}
+ obstack_free(&data, NULL);
}
projects / libfirm / blobdiff