X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fstat%2Fpattern.c;h=bba16fb0c327da6d38008909801a3ac670bcec84;hb=e997eedfb605aa149004122d63c7c54a8e384132;hp=6bb7010b03c58b09537a02bedf7be7b2b45f5e16;hpb=a1e9069afa4fa1e16e2d176bcd7905d6a1ed4677;p=libfirm

diff --git a/ir/stat/pattern.c b/ir/stat/pattern.c
index 6bb7010b0..bba16fb0c 100644
--- a/ir/stat/pattern.c
+++ b/ir/stat/pattern.c
@@ -1,27 +1,12 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
- *
  * This file is part of libFirm.
- *
- * This file may be distributed and/or modified under the terms of the
- * GNU General Public License version 2 as published by the Free Software
- * Foundation and appearing in the file LICENSE.GPL included in the
- * packaging of this file.
- *
- * Licensees holding valid libFirm Professional Edition licenses may use
- * this file in accordance with the libFirm Commercial License.
- * Agreement provided with the Software.
- *
- * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
- * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE.
+ * Copyright (C) 2012 University of Karlsruhe.
  */
 
 /**
  * @file
  * @brief   Statistics for Firm. Pattern history.
  * @author  Michael Beck
- * @version $Id$
  */
 #include "config.h"
 
@@ -40,8 +25,7 @@
 #include "pattern_dmp.h"
 #include "hashptr.h"
 #include "error.h"
-
-#ifdef FIRM_STATISTICS
+#include "lc_printf.h"
 
 /*
  * just be make some things clear :-), the
@@ -91,7 +75,7 @@ enum vlc_code_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;
 
@@ -138,22 +122,21 @@ static int pattern_count_cmp(const void *elt, const void *key)
 	cmp = cnt_cmp(&(*e2)->count, &(*e1)->count);
 
 	return cmp;
-}  /* pattern_count_cmp */
+}
 
 /**
  * Compare two pattern for its pattern hash.
  */
 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);
-}  /* pattern_cmp */
+	return e1->len < e2->len ? -1 : +1;
+}
 
 /**
  * Initialize a code buffer.
@@ -162,14 +145,14 @@ static int pattern_cmp(const void *elt, const void *key)
  * @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;
 	buf->end     = data + len;
 	buf->hash    = 0x2BAD4;      /* An arbitrary seed. */
 	buf->overrun = 0;
-}  /* init_buf */
+}
 
 /**
  * Put a byte into the buffer.
@@ -186,8 +169,8 @@ static inline void put_byte(CODE_BUFFER *buf, BYTE byte)
 		buf->hash = (buf->hash * 9) ^ byte;
 	} else {
 		buf->overrun = 1;
-	}  /* if */
-}  /* put_byte */
+	}
+}
 
 /**
  * Returns the current length of a buffer.
@@ -196,10 +179,10 @@ static inline void put_byte(CODE_BUFFER *buf, BYTE byte)
  *
  * @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 */
+}
 
 /**
  * Returns the current content of a buffer.
@@ -211,7 +194,7 @@ static unsigned buf_lenght(const CODE_BUFFER *buf)
 static const BYTE *buf_content(const CODE_BUFFER *buf)
 {
 	return buf->start;
-}  /* buf_content */
+}
 
 /**
  * Returns the hash value of a buffer.
@@ -223,7 +206,7 @@ static const BYTE *buf_content(const CODE_BUFFER *buf)
 static unsigned buf_hash(const CODE_BUFFER *buf)
 {
 	return buf->hash;
-}  /* buf_hash */
+}
 
 /**
  * Returns non-zero if a buffer overrun has occurred.
@@ -233,7 +216,7 @@ static unsigned buf_hash(const CODE_BUFFER *buf)
 static unsigned buf_overrun(const CODE_BUFFER *buf)
 {
 	return buf->overrun;
-}  /* buf_overrun */
+}
 
 /**
  * Returns the next byte from the buffer WITHOUT dropping.
@@ -247,7 +230,7 @@ static inline BYTE look_byte(CODE_BUFFER *buf)
 	if (buf->next < buf->end)
 		return *buf->next;
 	return VLC_TAG_END;
-}  /* look_byte */
+}
 
 /**
  * Returns the next byte from the buffer WITH dropping.
@@ -261,7 +244,7 @@ static inline BYTE get_byte(CODE_BUFFER *buf)
 	if (buf->next < buf->end)
 		return *buf->next++;
 	return VLC_TAG_END;
-}  /* get_byte */
+}
 
 #define BITS(n)   (1 << (n))
 
@@ -293,8 +276,8 @@ static void put_code(CODE_BUFFER *buf, unsigned code)
 		put_byte(buf, code >> 16);
 		put_byte(buf, code >> 8);
 		put_byte(buf, code);
-	}  /* if */
-}  /* put_code */
+	}
+}
 
 #define BIT_MASK(n) ((1 << (n)) - 1)
 
@@ -317,23 +300,23 @@ static unsigned get_code(CODE_BUFFER *buf)
 		code  = ((code & BIT_MASK(5)) << 16) | (get_byte(buf) << 8);
 		code |= get_byte(buf);
 		return code;
-	}  /* if */
+	}
 	if (code < VLC_32BIT) {
 		code  = ((code & BIT_MASK(4)) << 24) | (get_byte(buf) << 16);
 		code |= get_byte(buf) <<  8;
 		code |= get_byte(buf);
 		return code;
-	}  /* if */
+	}
 	if (code == VLC_32BIT) {
 		code  = get_byte(buf) << 24;
 		code |= get_byte(buf) << 16;
 		code |= get_byte(buf) <<  8;
 		code |= get_byte(buf);
 		return code;
-	}  /* if */
+	}
 	/* should not happen */
 	panic("Wrong code in buffer");
-}  /* get_code */
+}
 
 /**
  * Put a tag into the buffer.
@@ -346,7 +329,7 @@ static void put_tag(CODE_BUFFER *buf, BYTE tag)
 	assert(tag >= VLC_TAG_FIRST && "invalid tag");
 
 	put_byte(buf, tag);
-}  /* put_tag */
+}
 
 /**
  * Returns the next tag or zero if the next code isn't a tag.
@@ -362,7 +345,7 @@ static BYTE next_tag(CODE_BUFFER *buf)
 	if (b >= VLC_TAG_FIRST)
 		return get_byte(buf);
 	return 0;
-}  /* next_tag */
+}
 
 /**
  * An Environment for the pattern encoder.
@@ -388,23 +371,27 @@ typedef struct 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 */
+}
 
-static unsigned find_mode_index(const ir_mode *mode)
+/**
+ * Return the index of a (existing) mode.
+ */
+static size_t find_mode_index(const ir_mode *mode)
 {
-	int n = get_irp_n_modes();
-	int i;
+	size_t i, n = ir_get_n_modes();
 
 	for (i = 0; i < n; ++i) {
-		if (get_irp_mode(i) == mode)
+		if (ir_get_mode(i) == mode)
 			return i;
 	}
-	return -1;
+	/* should really not happen */
+	assert(!"Cound not find index of mode in find_mode_index()");
+	return (size_t)-1;
 }
 
 /**
@@ -419,13 +406,13 @@ static int _encode_node(ir_node *node, int max_depth, codec_env_t *env)
 	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;
 	entry.id   = env->curr_id;
 
-	s_entry = set_hinsert(env->id_set, &entry, sizeof(entry), HASH_PTR(node));
+	s_entry = set_hinsert(env->id_set, &entry, sizeof(entry), hash_ptr(node));
 	r_entry = (addr_entry_t *)s_entry->dptr;
 
 	if (r_entry->id != env->curr_id) {
@@ -437,7 +424,7 @@ static int _encode_node(ir_node *node, int max_depth, codec_env_t *env)
 	} else {
 		/* a new entry, proceed */
 		++env->curr_id;
-	}  /* if */
+	}
 
 	put_code(env->buf, (unsigned)code);
 
@@ -449,28 +436,28 @@ static int _encode_node(ir_node *node, int max_depth, codec_env_t *env)
 			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);
 
 				put_tag(env->buf, VLC_TAG_ICONST);
 				put_code(env->buf, v);
-			}  /* if */
-		}  /* if */
-	}  /* if */
+			}
+		}
+	}
 
 	--max_depth;
 
 	if (max_depth <= 0) {
 		put_code(env->buf, 0);
 		return max_depth;
-	} /* if */
+	}
 
 	preds = get_irn_arity(node);
 	put_code(env->buf, preds);
@@ -488,7 +475,7 @@ static int _encode_node(ir_node *node, int max_depth, codec_env_t *env)
 		} else if (opcode_diff == 0 && l != r) {
 			/* Both nodes have the same opcode, but are different.
 			   Need a better method here to decide which goes to the left side. */
-		}  /* if */
+		}
 
 		/* special handling for commutative operators */
 		depth = _encode_node(l, max_depth, env);
@@ -504,10 +491,10 @@ static int _encode_node(ir_node *node, int max_depth, codec_env_t *env)
 			depth = _encode_node(n, max_depth, env);
 			if (depth < res)
 				res = depth;
-		}  /* for */
-	}  /* if */
+		}
+	}
 	return res;
-}  /* _encode_node */
+}
 
 /**
  * Encode a DAG starting by the IR-node node.
@@ -538,7 +525,7 @@ static int encode_node(ir_node *node, CODE_BUFFER *buf, int max_depth)
 	if (env.options) {
 		put_tag(buf, VLC_TAG_OPTION);
 		put_code(buf, env.options);
-	}  /* if */
+	}
 
 	res = _encode_node(node, max_depth, &env);
 
@@ -546,7 +533,7 @@ static int encode_node(ir_node *node, CODE_BUFFER *buf, int max_depth)
 		del_set(env.id_set);
 
 	return max_depth - res;
-}  /* encode_node */
+}
 
 /**
  * Decode an IR-node, recursive walker.
@@ -572,13 +559,13 @@ static void _decode_node(unsigned parent, int position, codec_env_t *env)
 			 * we don't know the target here, it's a ref.
 			 */
 			pattern_dump_edge(env->dmp, code, parent, position, edge_mode);
-		}  /* if */
+		}
 
 		/* dump the node ref */
 		pattern_dump_ref(env->dmp, code);
 
 		return;
-	}  /* if */
+	}
 
 	/* get the opcode */
 	op_code = get_code(env->buf);
@@ -587,14 +574,14 @@ static void _decode_node(unsigned parent, int position, codec_env_t *env)
 	if (env->options & OPT_WITH_MODE) {
 		if (next_tag(env->buf) != VLC_TAG_EMPTY) {
 			mode_code = get_code(env->buf);
-		}  /* if */
-	}  /* if */
+		}
+	}
 
 	/* check, if a ICONST attribute is given */
 	if (next_tag(env->buf) == VLC_TAG_ICONST) {
 		iconst = get_code(env->buf);
 		attr   = &iconst;
-	}  /* if */
+	}
 
 	/* dump the edge */
 	if (parent) {
@@ -606,7 +593,7 @@ static void _decode_node(unsigned parent, int position, codec_env_t *env)
 		 * we need it anyway for ref's.
 		 */
 		pattern_dump_edge(env->dmp, env->curr_id, parent, position, edge_mode);
-	}  /* if */
+	}
 
 	/* dump the node */
 	parent = env->curr_id;
@@ -625,16 +612,16 @@ static void _decode_node(unsigned parent, int position, codec_env_t *env)
 			pattern_start_children(env->dmp, parent);
 			for (i = 0; i < preds; ++i) {
 				_decode_node(parent, i, env);
-			}  /* for */
+			}
 			pattern_finish_children(env->dmp, parent);
-		}  /* if */
-	}  /* if */
-}  /* _decode_node */
+		}
+	}
+}
 
 /**
  * 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;
@@ -650,11 +637,11 @@ static void decode_node(BYTE *b, unsigned len, pattern_dumper_t *dump)
 	code = next_tag(&buf);
 	if (code == VLC_TAG_OPTION) {
 		options = get_code(&buf);
-	}  /* if */
+	}
 	env.options = options;
 
 	_decode_node(0, 0, &env);
-}  /* decode_node */
+}
 
 /**
  * The environment for the pattern calculation.
@@ -677,7 +664,7 @@ typedef struct pattern_env {
 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);
@@ -686,15 +673,15 @@ static pattern_entry_t *pattern_get_entry(CODE_BUFFER *buf, pset *set)
 
 	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);
-}  /* pattern_get_entry */
+	return (pattern_entry_t*)pset_insert(set, key, hash);
+}
 
 /**
  * Increase the count for a pattern.
@@ -714,15 +701,15 @@ static void count_pattern(CODE_BUFFER *buf, int depth)
 
 		/* increase count */
 		cnt_inc(&entry->count);
-	}  /* if */
-}  /* count_pattern */
+	}
+}
 
 /**
  * Pre-walker for nodes pattern calculation.
  */
 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;
@@ -731,10 +718,10 @@ static void calc_nodes_pattern(ir_node *node, void *ctx)
 	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 */
+}
 
 /**
  * Store all collected patterns.
@@ -744,8 +731,7 @@ static void calc_nodes_pattern(ir_node *node, void *ctx)
 static void store_pattern(const char *fname)
 {
 	FILE *f;
-	pattern_entry_t *entry;
-	int i, count = pset_count(status->pattern_hash);
+	size_t count = pset_count(status->pattern_hash);
 
 	if (count <= 0)
 		return;
@@ -754,18 +740,16 @@ static void store_pattern(const char *fname)
 	if (! f) {
 		perror(fname);
 		return;
-	}  /* if */
+	}
 
 	fwrite("FPS1", 4, 1, f);
 	fwrite(&count, sizeof(count), 1, f);
 
-	for (i = 0, entry = pset_first(status->pattern_hash);
-	     entry && i < count;
-	     entry = pset_next(status->pattern_hash), ++i) {
+	foreach_pset(status->pattern_hash, pattern_entry_t, entry) {
 		fwrite(entry, offsetof(pattern_entry_t, buf) + entry->len, 1, f);
-	}  /* for */
+	}
 	fclose(f);
-}  /* store_pattern */
+}
 
 /**
  * Read collected patterns from a file.
@@ -776,44 +760,51 @@ static HASH_MAP(pattern_entry_t) *read_pattern(const char *fname)
 {
 	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);
 	BYTE            buffer[PATTERN_STORE_SIZE];
 	CODE_BUFFER     buf;
+	int             res;
 
 	f = fopen(fname, "rb");
 	if (! f) {
 		perror(fname);
 		return NULL;
-	}  /* if */
+	}
 
-	fread(magic, 4, 1, f);
+	res = fread(magic, 4, 1, f);
+	if (res != 1)
+		goto read_error;
 	count = 0;
-	fread(&count, sizeof(count), 1, f);
-	if (memcmp(magic, "FPS1", 4) != 0 || count <= 0) {
-		fprintf(stderr, "Error: %s is not a Firm pattern store. Ignored.\n", fname);
-		fclose(f);
-		return NULL;
-	}  /* if */
+	res = fread(&count, sizeof(count), 1, f);
+	if (res != 1 || memcmp(magic, "FPS1", 4) != 0 || count <= 0)
+		goto read_error;
 
 	/* read all pattern entries and put them into the hash table. */
 	for (i = 0; i < count; ++i) {
 		init_buf(&buf, buffer, sizeof(buffer));
-		fread(&tmp, offsetof(pattern_entry_t, buf), 1, f);
+		res = fread(&tmp, offsetof(pattern_entry_t, buf), 1, f);
+		if (res != 1)
+			goto read_error;
 		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));
-	}  /* for */
+		entry->count = tmp.count;
+	}
 	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;
-}  /* read_pattern */
+
+read_error:
+	fprintf(stderr, "Error: %s is not a Firm pattern store. Ignored.\n", fname);
+	fclose(f);
+	return NULL;
+}
 
 /**
  * Write the collected patterns to a VCG file for inspection.
@@ -822,25 +813,23 @@ static HASH_MAP(pattern_entry_t) *read_pattern(const char *fname)
  */
 static void pattern_output(const char *fname)
 {
-	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);
-	     entry && i < count;
-	     entry = pset_next(status->pattern_hash), ++i) {
-		pattern_arr[i] =  entry;
-	}  /* for */
+	i           = 0;
+	foreach_pset(status->pattern_hash, pattern_entry_t, entry) {
+		pattern_arr[i++] =  entry;
+	}
 	assert(count == i);
 	count = i;
 
@@ -848,7 +837,7 @@ static void pattern_output(const char *fname)
 	qsort(pattern_arr, count, sizeof(*pattern_arr), pattern_count_cmp);
 
 	for (i = 0; i < count; ++i) {
-		entry = pattern_arr[i];
+		pattern_entry_t *const entry = pattern_arr[i];
 		if (cnt_to_uint(&entry->count) < status->bound)
 			continue;
 
@@ -856,11 +845,11 @@ static void pattern_output(const char *fname)
 		pattern_dump_new_pattern(dump, &entry->count);
 		decode_node(entry->buf, entry->len, dump);
 		pattern_dump_finish_pattern(dump);
-	}  /* for */
+	}
 
 	/* destroy it */
 	pattern_end(dump);
-}  /* pattern_output */
+}
 
 /*
  * Calculates the pattern history.
@@ -880,8 +869,8 @@ void stat_calc_pattern_history(ir_graph *irg)
 	for (i = status->min_depth; i <= status->max_depth; ++i) {
 		env.max_depth = i;
 		irg_walk_graph(irg, calc_nodes_pattern, NULL, &env);
-	}  /* for */
-}  /* stat_calc_pattern_history */
+	}
+}
 
 /*
  * Initializes the pattern history.
@@ -907,7 +896,7 @@ void stat_init_pattern_history(int enable)
 	if (pattern_hash == NULL)
 		pattern_hash = new_pset(pattern_cmp, 8);
 	status->pattern_hash = pattern_hash;
-}  /* stat_init_pattern_history */
+}
 
 /*
  * Finish the pattern history.
@@ -925,6 +914,4 @@ void stat_finish_pattern_history(const char *fname)
 	obstack_free(&status->obst, NULL);
 
 	status->enable = 0;
-}  /* stat_finish_pattern_history */
-
-#endif /* FIRM_STATISTICS */
+}