/*
- * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
* @file
* @brief Statistics for Firm. Pattern history.
* @author Michael Beck
- * @version $Id$
*/
#include "config.h"
#include "counter.h"
#include "pattern_dmp.h"
#include "hashptr.h"
-
-#ifdef FIRM_STATISTICS
+#include "error.h"
+#include "lc_printf.h"
/*
* just be make some things clear :-), the
typedef unsigned char BYTE;
/** Maximum size of the pattern store. */
-#define PATTERN_STORE_SIZE 2048
+#define PATTERN_STORE_SIZE 2048
/**
* The code buffer.
*/
-typedef struct _code_buf_t {
+typedef struct code_buf_t {
BYTE *next; /**< Next byte address to be written. */
BYTE *end; /**< End address of the buffer. */
BYTE *start; /**< Start address of the buffer. */
/*
* An entry for holding one pattern.
*/
-typedef struct _pattern_entry_t {
+typedef struct pattern_entry_t {
counter_t count; /**< Amount of pattern occurance. */
- unsigned len; /**< The length of the VLC encoded buffer. */
+ size_t len; /**< The length of the VLC encoded buffer. */
BYTE buf[1]; /**< The buffer containing the VLC encoded pattern. */
} pattern_entry_t;
/**
* Pattern info.
*/
-typedef struct _pattern_info_t {
+typedef struct pattern_info_t {
int enable; /**< If non-zero, this module is enabled. */
struct obstack obst; /**< An obstack containing the counters. */
HASH_MAP(pattern_entry_t) *pattern_hash; /**< A hash map containing the pattern. */
*/
static int pattern_cmp(const void *elt, const void *key)
{
- const pattern_entry_t *e1 = elt;
- const pattern_entry_t *e2 = key;
- int diff = e1->len - e2->len;
+ const pattern_entry_t *e1 = (const pattern_entry_t*)elt;
+ const pattern_entry_t *e2 = (const pattern_entry_t*)key;
- if (diff)
- return diff;
+ if (e1->len == e2->len)
+ return memcmp(e1->buf, e2->buf, e1->len);
- return memcmp(e1->buf, e2->buf, e1->len);
+ return e1->len < e2->len ? -1 : +1;
} /* pattern_cmp */
/**
* @param data a buffer address
* @param len the length of the data buffer
*/
-static void init_buf(CODE_BUFFER *buf, BYTE *data, unsigned len)
+static void init_buf(CODE_BUFFER *buf, BYTE *data, size_t len)
{
buf->start =
buf->next = data;
*
* @return the length of the buffer content
*/
-static unsigned buf_lenght(const CODE_BUFFER *buf)
+static size_t buf_lenght(const CODE_BUFFER *buf)
{
return buf->next - buf->start;
} /* buf_lenght */
return code;
} /* if */
/* should not happen */
- assert(0 && "Wrong code in buffer");
-
- return 0;
+ panic("Wrong code in buffer");
} /* get_code */
/**
/**
* An Environment for the pattern encoder.
*/
-typedef struct _codec_enc_t {
+typedef struct codec_enc_t {
CODE_BUFFER *buf; /**< The current code buffer. */
set *id_set; /**< A set containing all already seen Firm nodes. */
unsigned curr_id; /**< The current node id. */
/**
* An address entry.
*/
-typedef struct _addr_entry_t {
+typedef struct addr_entry_t {
void *addr; /**< the address */
unsigned id; /**< associated ID */
} addr_entry_t;
*/
static int addr_cmp(const void *p1, const void *p2, size_t size)
{
- const addr_entry_t *e1 = p1;
- const addr_entry_t *e2 = p2;
+ const addr_entry_t *e1 = (const addr_entry_t*)p1;
+ const addr_entry_t *e2 = (const addr_entry_t*)p2;
(void) size;
return e1->addr != e2->addr;
} /* addr_cmp */
+/**
+ * Return the index of a (existing) mode.
+ */
+static size_t find_mode_index(const ir_mode *mode)
+{
+ size_t i, n = get_irp_n_modes();
+
+ for (i = 0; i < n; ++i) {
+ if (get_irp_mode(i) == mode)
+ return i;
+ }
+ /* should really not happen */
+ assert(!"Cound not find index of mode in find_mode_index()");
+ return (size_t)-1;
+}
+
/**
* Encodes an IR-node, recursive worker.
*
int i, preds;
int res, depth;
- ir_opcode code = get_irn_opcode(node);
+ unsigned code = get_irn_opcode(node);
/* insert the node into our ID map */
entry.addr = node;
ir_mode *mode = get_irn_mode(node);
if (mode)
- put_code(env->buf, stat_find_mode_index(mode));
+ put_code(env->buf, find_mode_index(mode));
else
put_tag(env->buf, VLC_TAG_EMPTY);
} /* if */
/* do we need integer constants */
if (env->options & OPT_WITH_ICONST) {
if (code == iro_Const) {
- tarval *tv = get_Const_tarval(node);
+ ir_tarval *tv = get_Const_tarval(node);
if (tarval_is_long(tv)) {
long v = get_tarval_long(tv);
/**
* Decode an IR-node.
*/
-static void decode_node(BYTE *b, unsigned len, pattern_dumper_t *dump)
+static void decode_node(BYTE *b, size_t len, pattern_dumper_t *dump)
{
codec_env_t env;
CODE_BUFFER buf;
/**
* The environment for the pattern calculation.
*/
-typedef struct _pattern_env {
+typedef struct pattern_env {
int max_depth; /**< maximum depth for pattern generation. */
} pattern_env_t;
static pattern_entry_t *pattern_get_entry(CODE_BUFFER *buf, pset *set)
{
pattern_entry_t *key, *elem;
- unsigned len = buf_lenght(buf);
+ size_t len = buf_lenght(buf);
unsigned hash;
key = OALLOCF(&status->obst, pattern_entry_t, buf, len);
hash = buf_hash(buf);
- elem = pset_find(set, key, hash);
+ elem = (pattern_entry_t*)pset_find(set, key, hash);
if (elem != NULL) {
obstack_free(&status->obst, key);
return elem;
} /* if */
cnt_clr(&key->count);
- return pset_insert(set, key, hash);
+ return (pattern_entry_t*)pset_insert(set, key, hash);
} /* pattern_get_entry */
/**
*/
static void calc_nodes_pattern(ir_node *node, void *ctx)
{
- pattern_env_t *env = ctx;
+ pattern_env_t *env = (pattern_env_t*)ctx;
BYTE buffer[PATTERN_STORE_SIZE];
CODE_BUFFER buf;
int depth;
depth = encode_node(node, &buf, env->max_depth);
if (buf_overrun(&buf)) {
- fprintf(stderr, "Pattern store: buffer overrun at size %u. Pattern ignored.\n", (unsigned) sizeof(buffer));
+ lc_fprintf(stderr, "Pattern store: buffer overrun at size %zu. Pattern ignored.\n", sizeof(buffer));
} else
count_pattern(&buf, depth);
} /* calc_nodes_pattern */
{
FILE *f;
pattern_entry_t *entry;
- int i, count = pset_count(status->pattern_hash);
+ size_t i, count = pset_count(status->pattern_hash);
if (count <= 0)
return;
fwrite("FPS1", 4, 1, f);
fwrite(&count, sizeof(count), 1, f);
- for (i = 0, entry = pset_first(status->pattern_hash);
+ for (i = 0, entry = (pattern_entry_t*)pset_first(status->pattern_hash);
entry && i < count;
- entry = pset_next(status->pattern_hash), ++i) {
+ entry = (pattern_entry_t*)pset_next(status->pattern_hash), ++i) {
fwrite(entry, offsetof(pattern_entry_t, buf) + entry->len, 1, f);
} /* for */
fclose(f);
{
FILE *f;
pattern_entry_t *entry, tmp;
- int i, count;
+ size_t i, count;
unsigned j;
char magic[4];
HASH_MAP(pattern_entry_t) *pattern_hash = new_pset(pattern_cmp, 8);
for (j = 0; j < tmp.len; ++j)
put_byte(&buf, fgetc(f));
entry = pattern_get_entry(&buf, pattern_hash);
- memcpy(&entry->count, &tmp.count, sizeof(entry->count));
+ entry->count = tmp.count;
} /* for */
fclose(f);
- printf("Read %d pattern from %s\n", count, fname);
+ lc_printf("Read %zu pattern from %s\n", count, fname);
assert(pset_count(pattern_hash) == count);
return pattern_hash;
pattern_entry_t *entry;
pattern_entry_t **pattern_arr;
pattern_dumper_t *dump;
- int i, count = pset_count(status->pattern_hash);
+ size_t i, count = pset_count(status->pattern_hash);
- printf("\n%d pattern detected\n", count);
+ lc_printf("\n%zu pattern detected\n", count);
- if (count <= 0)
+ if (count == 0)
return;
/* creates a dumper */
dump = new_vcg_dumper(fname, 100);
pattern_arr = XMALLOCN(pattern_entry_t*, count);
- for (i = 0, entry = pset_first(status->pattern_hash);
+ for (i = 0, entry = (pattern_entry_t*)pset_first(status->pattern_hash);
entry && i < count;
- entry = pset_next(status->pattern_hash), ++i) {
+ entry = (pattern_entry_t*)pset_next(status->pattern_hash), ++i) {
pattern_arr[i] = entry;
} /* for */
assert(count == i);
status->enable = 0;
} /* stat_finish_pattern_history */
-
-#endif /* FIRM_STATISTICS */
projects / libfirm / blobdiff