X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firnode.c;h=83bf3edbd5034d2f36b7e575719e01bf93120e35;hb=2af4a97900b435e35d7c20350604e3863aff2b4c;hp=f61d90af688916011eccc8834ef83b8712796b63;hpb=896321f0a34f3aed88c02b159d056ef7afc2ce41;p=libfirm

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index f61d90af6..83bf3edbd 100644
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -184,6 +184,25 @@ new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mod
 	if (get_irg_phase_state(irg) == phase_backend) {
 		be_info_new_node(res);
 	}
+	// Init the VRP structures
+	res->vrp.range_type = VRP_UNDEFINED;
+	res->vrp.valid = 0;
+	if(mode_is_int(mode)) {
+		// We are assuming that 0 is always represented as 0x0000
+		res->vrp.bits_set = new_tarval_from_long(0, mode);
+		res->vrp.bits_not_set = new_tarval_from_long(0, mode);
+		res->vrp.range_bottom = get_tarval_top();
+		res->vrp.range_top = get_tarval_top();
+	} else {
+		res->vrp.bits_set = get_tarval_bad();
+		res->vrp.bits_not_set = get_tarval_bad();
+		res->vrp.range_bottom = get_tarval_bad();
+		res->vrp.range_top = get_tarval_bad();
+	}
+	res->vrp.bits_node = NULL;
+	res->vrp.range_node = NULL;
+	res->vrp.range_op = VRP_NONE;
+
 
 	return res;
 }
@@ -233,7 +252,7 @@ ir_node **get_irn_in(const ir_node *node) {
 void set_irn_in(ir_node *node, int arity, ir_node **in) {
 	int i;
 	ir_node *** pOld_in;
-	ir_graph *irg = current_ir_graph;
+	ir_graph *irg = get_irn_irg(node);
 
 	assert(node);
 #ifdef INTERPROCEDURAL_VIEW
@@ -818,10 +837,11 @@ ir_entity *create_Block_entity(ir_node *block) {
 
 		glob = get_glob_type();
 		entity = new_entity(glob, id_unique("block_%u"), get_code_type());
+		set_entity_visibility(entity, ir_visibility_local);
+		set_entity_linkage(entity, IR_LINKAGE_CONSTANT);
 		nr = get_irp_next_label_nr();
 		set_entity_label(entity, nr);
 		set_entity_compiler_generated(entity, 1);
-		set_entity_allocation(entity, allocation_static);
 
 		block->attr.block.entity = entity;
 	}
@@ -995,49 +1015,6 @@ void set_IJmp_target(ir_node *ijmp, ir_node *tgt) {
 	set_irn_n(ijmp, 0, tgt);
 }
 
-/*
-> Implementing the case construct (which is where the constant Proj node is
-> important) involves far more than simply determining the constant values.
-> We could argue that this is more properly a function of the translator from
-> Firm to the target machine.  That could be done if there was some way of
-> projecting "default" out of the Cond node.
-I know it's complicated.
-Basically there are two problems:
- - determining the gaps between the Projs
- - determining the biggest case constant to know the proj number for
-   the default node.
-I see several solutions:
-1. Introduce a ProjDefault node.  Solves both problems.
-   This means to extend all optimizations executed during construction.
-2. Give the Cond node for switch two flavors:
-   a) there are no gaps in the Projs  (existing flavor)
-   b) gaps may exist, default proj is still the Proj with the largest
-      projection number.  This covers also the gaps.
-3. Fix the semantic of the Cond to that of 2b)
-
-Solution 2 seems to be the best:
-Computing the gaps in the Firm representation is not too hard, i.e.,
-libFIRM can implement a routine that transforms between the two
-flavours.  This is also possible for 1) but 2) does not require to
-change any existing optimization.
-Further it should be far simpler to determine the biggest constant than
-to compute all gaps.
-I don't want to choose 3) as 2a) seems to have advantages for
-dataflow analysis and 3) does not allow to convert the representation to
-2a).
-*/
-
-const char *get_cond_kind_name(cond_kind kind)
-{
-#define X(a)    case a: return #a;
-	switch (kind) {
-		X(dense);
-		X(fragmentary);
-	}
-	return "<unknown>";
-#undef X
-}
-
 ir_node *
 get_Cond_selector(const ir_node *node) {
 	assert(is_Cond(node));
@@ -1050,18 +1027,6 @@ set_Cond_selector(ir_node *node, ir_node *selector) {
 	set_irn_n(node, 0, selector);
 }
 
-cond_kind
-get_Cond_kind(const ir_node *node) {
-	assert(is_Cond(node));
-	return node->attr.cond.kind;
-}
-
-void
-set_Cond_kind(ir_node *node, cond_kind kind) {
-	assert(is_Cond(node));
-	node->attr.cond.kind = kind;
-}
-
 long
 get_Cond_default_proj(const ir_node *node) {
 	assert(is_Cond(node));
@@ -2837,6 +2802,10 @@ int (is_irn_machine_user)(const ir_node *node, unsigned n) {
 	return _is_irn_machine_user(node, n);
 }
 
+/* Returns non-zero for nodes that are CSE neutral to its users. */
+int (is_irn_cse_neutral)(const ir_node *node) {
+	return _is_irn_cse_neutral(node);
+}
 
 /* Gets the string representation of the jump prediction .*/
 const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred) {
@@ -2977,7 +2946,11 @@ unsigned firm_default_hash(const ir_node *node) {
 
 	/* consider all in nodes... except the block if not a control flow. */
 	for (i = is_cfop(node) ? -1 : 0;  i < irn_arity;  ++i) {
-		h = 9*h + HASH_PTR(get_irn_intra_n(node, i));
+		ir_node *pred = get_irn_intra_n(node, i);
+		if (is_irn_cse_neutral(pred))
+			h *= 9;
+		else
+			h = 9*h + HASH_PTR(pred);
 	}
 
 	/* ...mode,... */