* @date 11.9.2006
* @version $Id$
*/
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
+#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include "pdeq.h"
#include "irtools.h"
#include "obst.h"
-#include "array.h"
+#include "array_t.h"
#include "be_dbgout_t.h"
#include "beabi.h"
#include "bemodule.h"
#include "beemitter.h"
#include "dbginfo.h"
+#include "begnuas.h"
/* Non-Stab Symbol and Stab Symbol Types */
enum stabs_types {
*/
typedef struct stabs_handle {
dbg_handle base; /**< the base class */
- ir_entity *cur_ent; /**< current method entity */
+ const ir_entity *cur_ent; /**< current method entity */
const be_stack_layout_t *layout; /**< current stack layout */
unsigned next_type_nr; /**< next type number */
pmap *type_map; /**< a map from type to type number */
/**
* Returns the stabs type number of a Firm type.
*/
-static unsigned get_type_number(stabs_handle *h, ir_type *tp) {
+static unsigned get_type_number(stabs_handle *h, ir_type *tp)
+{
pmap_entry *entry;
unsigned num;
/**
* Map a given Type to void by assigned the type number 0.
*/
-static void map_to_void(stabs_handle *h, ir_type *tp) {
+static void map_to_void(stabs_handle *h, ir_type *tp)
+{
pmap_insert(h->type_map, tp, INT_TO_PTR(0));
}
/**
* generate the void type.
*/
-static void gen_void_type(stabs_handle *h) {
+static void gen_void_type(stabs_handle *h)
+{
(void) h;
be_emit_irprintf("\t.stabs\t\"void:t%u=%u\",%d,0,0,0\n", 0, 0, N_LSYM);
be_emit_write_line();
do { \
set_type_link(tp, (void *)1); \
waitq_put(wq, tp); \
- } while(0)
+ } while (0)
/* a the is ready */
#define SET_TYPE_READY(tp) set_type_link(tp, NULL)
#define SKIP_PTR(tp) (is_Pointer_type(tp) ? get_pointer_points_to_type(tp) : tp)
#endif
+/**
+ * mode_info for output as decimal
+ */
+static const tarval_mode_info dec_output = {
+ TVO_DECIMAL,
+ NULL,
+ NULL,
+};
+
+/**
+ * emit a tarval as decimal
+ */
+static void be_emit_tv_as_decimal(tarval *tv)
+{
+ ir_mode *mode = get_tarval_mode(tv);
+ const tarval_mode_info *old = get_tarval_mode_output_option(mode);
+
+ set_tarval_mode_output_option(mode, &dec_output);
+ be_emit_tarval(tv);
+ set_tarval_mode_output_option(mode, old);
+}
+
+static void emit_type_name(const ir_type *type)
+{
+ char buf[256];
+ ir_print_type(buf, sizeof(buf), type);
+ be_emit_string(buf);
+}
+
/**
* Generates a primitive type.
*
* @param h the stabs handle
* @param tp the type
*/
-static void gen_primitive_type(stabs_handle *h, ir_type *tp) {
+static void gen_primitive_type(stabs_handle *h, ir_type *tp)
+{
ir_mode *mode = get_type_mode(tp);
unsigned type_num;
type_num = get_type_number(h, tp);
if (mode_is_int(mode)) {
- be_emit_irprintf("\t.stabs\t\"%s:t%u=r%u;", get_type_name(tp), type_num, type_num);
- be_emit_tarval(get_mode_min(mode));
+ be_emit_cstring("\t.stabs\t\"");
+ emit_type_name(tp);
+ be_emit_irprintf(":t%u=r%u;", type_num, type_num);
+ be_emit_tv_as_decimal(get_mode_min(mode));
be_emit_char(';');
- be_emit_tarval(get_mode_max(mode));
+ be_emit_tv_as_decimal(get_mode_max(mode));
be_emit_irprintf(";\",%d,0,0,0\n", N_LSYM);
be_emit_write_line();
} else if (mode_is_float(mode)) {
int size = get_type_size_bytes(tp);
- be_emit_irprintf("\t.stabs\t\"%s:t%u=r1;%d;0;\",%d,0,0,0\n", get_type_name(tp), type_num, size, N_LSYM);
+ be_emit_cstring("\t.stabs\t\"");
+ emit_type_name(tp);
+ be_emit_irprintf(":t%u=r1;%d;0;\",%d,0,0,0\n", type_num, size, N_LSYM);
be_emit_write_line();
}
} /* gen_primitive_type */
* @param h the stabs handle
* @param tp the type
*/
-static void gen_enum_type(stabs_handle *h, ir_type *tp) {
+static void gen_enum_type(stabs_handle *h, ir_type *tp)
+{
unsigned type_num = get_type_number(h, tp);
int i, n;
SET_TYPE_READY(tp);
- be_emit_irprintf("\t.stabs\t\"%s:T%u=e", get_type_name(tp), type_num);
+ be_emit_cstring("\t.stabs\t\"");
+ emit_type_name(tp);
+ be_emit_irprintf(":T%u=e", type_num);
for (i = 0, n = get_enumeration_n_enums(tp); i < n; ++i) {
ir_enum_const *ec = get_enumeration_const(tp, i);
char buf[64];
tarval_snprintf(buf, sizeof(buf), get_enumeration_value(ec));
- be_emit_irprintf("%s:%s,", get_enumeration_name(ec), buf);
+ be_emit_irprintf("%s:%s,", get_enumeration_const_name(ec), buf);
}
be_emit_irprintf(";\",%d,0,0,0\n", N_LSYM);
be_emit_write_line();
/**
* print a pointer type
*/
-void print_pointer_type(stabs_handle *h, ir_type *tp, int local) {
+static void print_pointer_type(stabs_handle *h, ir_type *tp, int local)
+{
unsigned type_num = local ? h->next_type_nr++ : get_type_number(h, tp);
ir_type *el_tp = get_pointer_points_to_type(tp);
unsigned el_num = get_type_number(h, el_tp);
* @param env the walker environment
* @param tp the type
*/
-static void gen_pointer_type(wenv_t *env, ir_type *tp) {
+static void gen_pointer_type(wenv_t *env, ir_type *tp)
+{
stabs_handle *h = env->h;
ir_type *el_tp = get_pointer_points_to_type(tp);
if (! IS_TYPE_READY(el_tp))
waitq_put(env->wq, el_tp);
- be_emit_irprintf("\t.stabs\t\"%s:t", get_type_name(tp));
+ be_emit_cstring("\t.stabs\t\"");
+ emit_type_name(tp);
+ be_emit_cstring(":t");
print_pointer_type(h, tp, 0);
be_emit_irprintf("\",%d,0,0,0\n", N_LSYM);
be_emit_write_line();
/**
* print an array type
*/
-static void print_array_type(stabs_handle *h, ir_type *tp, int local) {
+static void print_array_type(stabs_handle *h, ir_type *tp, int local)
+{
ir_type *etp = get_array_element_type(tp);
int i, n = get_array_n_dimensions(tp);
unsigned type_num = local ? h->next_type_nr++ : get_type_number(h, tp);
* @param env the walker environment
* @param tp the type
*/
-static void gen_array_type(wenv_t *env, ir_type *tp) {
+static void gen_array_type(wenv_t *env, ir_type *tp)
+{
stabs_handle *h = env->h;
ir_type *etp = get_array_element_type(tp);
if (! IS_TYPE_READY(etp))
waitq_put(env->wq, etp);
- be_emit_irprintf("\t.stabs\t\"%s:t", get_type_name(tp));
+ be_emit_cstring("\t.stabs\t\"");
+ emit_type_name(tp);
+ be_emit_cstring(":t");
print_array_type(h, tp, 0);
* @param env the walker environment
* @param tp the type
*/
-static void gen_struct_union_type(wenv_t *env, ir_type *tp) {
+static void gen_struct_union_type(wenv_t *env, ir_type *tp)
+{
stabs_handle *h = env->h;
unsigned type_num = get_type_number(h, tp);
int i, n;
else if (is_Union_type(tp))
desc = 'u';
- be_emit_irprintf("\t.stabs\t\"%s:Tt%u=%c%d",
- get_type_name(tp), type_num, desc, get_type_size_bytes(tp));
+ be_emit_cstring("\t.stabs\t\"");
+ emit_type_name(tp);
+ be_emit_irprintf(":Tt%u=%c%d", type_num, desc, get_type_size_bytes(tp));
for (i = 0, n = get_compound_n_members(tp); i < n; ++i) {
ir_entity *ent = get_compound_member(tp, i);
* @param env the walker environment
* @param tp the type
*/
-static void gen_method_type(wenv_t *env, ir_type *tp) {
+static void gen_method_type(wenv_t *env, ir_type *tp)
+{
stabs_handle *h = env->h;
unsigned type_num = get_type_number(h, tp);
ir_type *rtp = NULL;
}
res_type_num = get_type_number(h, rtp);
- be_emit_irprintf("\t.stabs\t\"%s:t%u=f%u", get_type_name(tp), type_num, res_type_num);
+ be_emit_cstring("\t.stabs\t\"");
+ emit_type_name(tp);
+ be_emit_irprintf(":t%u=f%u", type_num, res_type_num);
/* handle more than one return type */
for (i = 1; i < n; ++i) {
* type-walker: generate declaration for simple types,
* put all other types on a wait queue
*/
-static void walk_type(type_or_ent *tore, void *ctx)
+static void walk_type(type_or_ent tore, void *ctx)
{
wenv_t *env = ctx;
ir_type *tp;
- if (get_kind(tore) == k_type) {
- tp = (ir_type *)tore;
+ if (is_type(tore.typ)) {
+ tp = tore.typ;
/* ignore the unknown type */
if (tp == firm_unknown_type)
/**
* generate all types.
*/
-static void gen_types(stabs_handle *h) {
+static void gen_types(stabs_handle *h)
+{
wenv_t env;
env.h = h;
/**
* start a new source object (compilation unit)
*/
-static void stabs_so(dbg_handle *handle, const char *filename) {
+static void stabs_so(dbg_handle *handle, const char *filename)
+{
stabs_handle *h = (stabs_handle *)handle;
h->main_file = h->curr_file = filename;
- be_emit_irprintf("\t.stabs\t\"%s\",%d,0,0,.Ltext0\n", filename, N_SO);
+ be_emit_irprintf("\t.stabs\t\"%s\",%d,0,0,%stext0\n", filename, N_SO, be_gas_get_private_prefix());
be_emit_write_line();
} /* stabs_so */
/**
* Main Program
*/
-static void stabs_main_program(dbg_handle *handle) {
+static void stabs_main_program(dbg_handle *handle)
+{
ir_graph *irg = get_irp_main_irg();
(void) handle;
return;
if (handle->curr_file != fname) {
- /* TODO: escape filename correctly */
- if (handle->curr_file != handle->main_file) {
- be_emit_irprintf("\t.stabs\t\"%s\",%d,0,0,0\n", handle->curr_file,
- N_EINCL);
- be_emit_write_line();
- }
if (fname != handle->main_file) {
be_emit_irprintf("\t.stabs\t\"%s\",%d,0,0,0\n", fname, N_SOL);
be_emit_write_line();
/**
* dump the stabs for a method begin
*/
-static void stabs_method_begin(dbg_handle *handle, ir_entity *ent, const be_stack_layout_t *layout) {
+static void stabs_method_begin(dbg_handle *handle, const ir_entity *ent, const be_stack_layout_t *layout)
+{
stabs_handle *h = (stabs_handle *)handle;
ir_type *mtp, *rtp;
unsigned type_num;
type_num = get_type_number(h, rtp);
be_emit_irprintf("\t.stabs\t\"%s:%c%u\",%u,0,0,%s\n",
get_entity_name(ent),
- get_entity_visibility(ent) == visibility_external_visible ? 'F' : 'f',
+ get_entity_visibility(ent) == ir_visibility_local ? 'f' : 'F',
type_num,
N_FUN,
get_entity_ld_name(ent));
/**
* dump the stabs for a method end
*/
-static void stabs_method_end(dbg_handle *handle) {
+static void stabs_method_end(dbg_handle *handle)
+{
stabs_handle *h = (stabs_handle *)handle;
- ir_entity *ent = h->cur_ent;
+ const ir_entity *ent = h->cur_ent;
const be_stack_layout_t *layout = h->layout;
const char *ld_name = get_entity_ld_name(ent);
int i, n, frame_size;
/**
* dump types
*/
-static void stabs_types(dbg_handle *handle) {
+static void stabs_types(dbg_handle *handle)
+{
stabs_handle *h = (stabs_handle *)handle;
/* allocate the zero for the void type */
/**
* dump a variable in the global type
*/
-static void stabs_variable(dbg_handle *handle, ir_entity *ent) {
+static void stabs_variable(dbg_handle *handle, const ir_entity *ent)
+{
stabs_handle *h = (stabs_handle *)handle;
unsigned tp_num = get_type_number(h, get_entity_type(ent));
char buf[1024];
- if (get_entity_visibility(ent) == visibility_external_visible) {
- /* a global variable */
- snprintf(buf, sizeof(buf), "\t.stabs\t\"%s:G%u\",%d,0,0,0\n",
- get_entity_name(ent), tp_num, N_GSYM);
- } else { /* some kind of local */
- ir_variability variability = get_entity_variability(ent);
+ if (get_entity_visibility(ent) == ir_visibility_local) {
+ /* some kind of local */
+ ir_linkage linkage = get_entity_linkage(ent);
int kind = N_STSYM;
- if (variability == variability_uninitialized)
- kind = N_LCSYM;
- else if (variability == variability_constant)
+ if (linkage & IR_LINKAGE_CONSTANT)
kind = N_ROSYM;
snprintf(buf, sizeof(buf), "\t.stabs\t\"%s:S%u\",%d,0,0,%s\n",
get_entity_name(ent), tp_num, kind, get_entity_ld_name(ent));
+ } else {
+ /* a global variable */
+ snprintf(buf, sizeof(buf), "\t.stabs\t\"%s:G%u\",%d,0,0,0\n",
+ get_entity_name(ent), tp_num, N_GSYM);
}
buf[sizeof(buf) - 1] = '\0';
/**
* Close the stabs handler.
*/
-static void stabs_close(dbg_handle *handle) {
+static void stabs_close(dbg_handle *handle)
+{
stabs_handle *h = (stabs_handle *)handle;
pmap_destroy(h->type_map);
free(h);
};
/* Opens a stabs handler */
-dbg_handle *be_stabs_open(void) {
- stabs_handle *h = xmalloc(sizeof(*h));
+static dbg_handle *be_stabs_open(void)
+{
+ stabs_handle *h = XMALLOCZ(stabs_handle);
h->base.ops = &stabs_ops;
- h->cur_ent = NULL;
- h->layout = NULL;
- h->next_type_nr = 0;
h->type_map = pmap_create_ex(64);
- h->main_file = NULL;
- h->curr_file = NULL;
return &h->base;
}
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_stabs);
void be_init_stabs(void)
{
be_register_dbgout_module("stabs", be_stabs_open);
}
-
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_stabs);
projects / libfirm / blobdiff