X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ir%2Fbe%2Fbearch.h;h=02daa70b4e125318c9fe59c12e551b6c46751f32;hb=df2faee01a5832057bb3ca0ba5f67e979c916e19;hp=8778c8694d8e6c5a5b69ce700d0f3c745b95237a;hpb=e89eea0fd3c14ea7dda2a43f10856260d16132e9;p=libfirm

diff --git a/ir/be/bearch.h b/ir/be/bearch.h
index 8778c8694..02daa70b4 100644
--- a/ir/be/bearch.h
+++ b/ir/be/bearch.h
@@ -212,12 +212,6 @@ static inline unsigned arch_get_irn_n_outs(const ir_node *node)
 #define be_foreach_out(node, i) \
 	for (unsigned i = 0, i##__n = arch_get_irn_n_outs(node); i != i##__n; ++i)
 
-/**
- * Start codegeneration
- */
-arch_env_t *arch_env_begin_codegeneration(const arch_isa_if_t *isa,
-                                          be_main_env_t *main_env);
-
 /**
  * Register an instruction set architecture
  */
@@ -431,7 +425,7 @@ struct arch_isa_if_t {
 	 * Start codegeneration
 	 * @return a new isa instance
 	 */
-	arch_env_t *(*begin_codegeneration)(const be_main_env_t *env);
+	arch_env_t *(*begin_codegeneration)(void);
 
 	/**
 	 * Free the isa instance.
@@ -526,9 +520,6 @@ struct arch_isa_if_t {
 #define arch_env_handle_intrinsics(env)                \
 	do { if((env)->impl->handle_intrinsics != NULL) (env)->impl->handle_intrinsics(); } while(0)
 #define arch_env_get_call_abi(env,tp,abi)              ((env)->impl->get_call_abi((tp), (abi)))
-#define arch_env_get_params(env)                       ((env)->impl->get_params())
-#define arch_env_parse_asm_constraint(env,c)           ((env)->impl->parse_asm_constraint((c))
-#define arch_env_is_valid_clobber(env,clobber)         ((env)->impl->is_valid_clobber((clobber))
 #define arch_env_mark_remat(env,node) \
 	do { if ((env)->impl->mark_remat != NULL) (env)->impl->mark_remat((node)); } while(0)
 
@@ -547,7 +538,6 @@ struct arch_env_t {
 	const arch_register_t *sp;               /**< The stack pointer register. */
 	const arch_register_t *bp;               /**< The base pointer register. */
 	int                    stack_alignment;  /**< power of 2 stack alignment */
-	const be_main_env_t   *main_env;         /**< the be main environment */
 	int                    spill_cost;       /**< cost for a be_Spill node */
 	int                    reload_cost;      /**< cost for a be_Reload node */
 	bool                   custom_abi : 1;   /**< backend does all abi handling
@@ -568,38 +558,56 @@ static inline bool arch_irn_consider_in_reg_alloc(
 	return req->cls == cls && !arch_register_req_is(req, ignore);
 }
 
+#define be_foreach_value(node, value, code) \
+	do { \
+		if (get_irn_mode(node) == mode_T) { \
+			foreach_out_edge(node, node##__edge) { \
+				ir_node *const value = get_edge_src_irn(node##__edge); \
+				if (!is_Proj(value)) \
+					continue; \
+				code \
+			} \
+		} else { \
+			ir_node *const value = node; \
+			code \
+		} \
+	} while (0)
+
 /**
  * Iterate over all values defined by an instruction.
  * Only looks at values in a certain register class where the requirements
  * are not marked as ignore.
  * Executes @p code for each definition.
  */
-#define be_foreach_definition_(node, ccls, value, code)                    \
-	do {                                                                   \
-	if (get_irn_mode(node) == mode_T) {                                    \
-		foreach_out_edge(node, edge_) {                                    \
-			ir_node                   *const value = get_edge_src_irn(edge_); \
-			arch_register_req_t const *const req_  = arch_get_irn_register_req(value); \
-			if (req_->cls != ccls)                                         \
-				continue;                                                  \
-			code                                                           \
-		}                                                                  \
-	} else {                                                               \
-		arch_register_req_t const *const req_  = arch_get_irn_register_req(node); \
-		ir_node                   *const value = node; \
-		if (req_->cls == ccls) {                                           \
-			code                                                           \
-		}                                                                  \
-	}                                                                      \
-	} while (0)
+#define be_foreach_definition_(node, ccls, value, req, code) \
+	be_foreach_value(node, value, \
+		arch_register_req_t const *const req = arch_get_irn_register_req(value); \
+		if (req->cls != ccls) \
+			continue; \
+		code \
+	)
 
-#define be_foreach_definition(node, ccls, value, code) \
-	be_foreach_definition_(node, ccls, value, \
-		if (arch_register_req_is(req_, ignore)) \
+#define be_foreach_definition(node, ccls, value, req, code) \
+	be_foreach_definition_(node, ccls, value, req, \
+		if (arch_register_req_is(req, ignore)) \
 			continue; \
 		code \
 	)
 
+#define be_foreach_use(node, ccls, in_req, value, value_req, code)           \
+	do {                                                                     \
+	for (int i_ = 0, n_ = get_irn_arity(node); i_ < n_; ++i_) {              \
+		const arch_register_req_t *in_req = arch_get_irn_register_req_in(node, i_); \
+		if (in_req->cls != ccls)                                             \
+			continue;                                                        \
+		ir_node                   *value     = get_irn_n(node, i_);              \
+		const arch_register_req_t *value_req = arch_get_irn_register_req(value); \
+		if (value_req->type & arch_register_req_type_ignore)                 \
+			continue;                                                        \
+		code                                                                 \
+	}                                                                        \
+	} while (0)
+
 static inline const arch_register_class_t *arch_get_irn_reg_class(
 		const ir_node *node)
 {