X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Ffirm%2Fbearch_firm.c;h=96f42a3160e01a73044b981ab5aa2cb9d63626df;hb=17e47394fa72025d14172a2acef2d258a067aa42;hp=ed68e6a64c7cc41c14e55713c6970d93d38d1a72;hpb=7507003420c69d2a84403d07daf26a305c631b43;p=libfirm

diff --git a/ir/be/firm/bearch_firm.c b/ir/be/firm/bearch_firm.c
index ed68e6a64..96f42a316 100644
--- a/ir/be/firm/bearch_firm.c
+++ b/ir/be/firm/bearch_firm.c
@@ -21,9 +21,11 @@
 #include "irgwalk.h"
 #include "type.h"
 
+#include "../be_t.h"
 #include "../bearch.h"
 #include "../besched.h"
 #include "../beutil.h"
+#include "../beabi.h"
 
 #define N_REGS 3
 
@@ -38,7 +40,7 @@ typedef struct {
 static arch_register_t datab_regs[N_REGS];
 
 static arch_register_class_t reg_classes[] = {
-  { "datab", N_REGS, datab_regs },
+  { "datab", N_REGS, NULL, datab_regs },
 };
 
 static ir_op *op_push;
@@ -124,7 +126,7 @@ static void *firm_init(void)
 {
   static struct obstack obst;
   static int inited = 0;
-	arch_isa_t *isa = malloc(sizeof(*isa));
+	arch_isa_t *isa = xmalloc(sizeof(*isa));
   int k;
 
 	isa->impl = &firm_isa;
@@ -136,9 +138,10 @@ static void *firm_init(void)
   obstack_init(&obst);
 
   for(k = 0; k < N_CLASSES; ++k) {
-    const arch_register_class_t *cls = &reg_classes[k];
+    arch_register_class_t *cls = &reg_classes[k];
     int i;
 
+	cls->mode = mode_Is;
     for(i = 0; i < cls->n_regs; ++i) {
       int n;
       char buf[8];
@@ -196,6 +199,41 @@ static const arch_register_class_t *firm_get_reg_class(const void *self, int i)
   return &reg_classes[i];
 }
 
+static const arch_register_class_t *firm_get_reg_class_for_mode(const void *self, const ir_mode *irm)
+{
+	return mode_is_datab(irm) ? &reg_classes[CLS_DATAB] : NULL;
+}
+
+static void firm_get_call_abi(const void *self, ir_type *method_type, be_abi_call_t *abi)
+{
+	static ir_type *between_type = NULL;
+	const arch_register_class_t *cls = &reg_classes[CLS_DATAB];
+	int i, n;
+
+	if(!between_type) {
+		between_type = new_type_class(new_id_from_str("firm_be_between"));
+		set_type_size_bytes(between_type, 0);
+	}
+
+
+	for(i = 0, n = get_method_n_params(method_type); i < n; ++i) {
+		ir_type *t = get_method_param_type(method_type, i);
+		if(is_Primitive_type(t))
+			be_abi_call_param_reg(abi, i, &cls->regs[i]);
+		else
+			be_abi_call_param_stack(abi, i);
+	}
+
+	for(i = 0, n = get_method_n_ress(method_type); i < n; ++i) {
+		ir_type *t = get_method_res_type(method_type, i);
+		if(is_Primitive_type(t))
+			be_abi_call_res_reg(abi, i, &cls->regs[i]);
+	}
+
+	be_abi_call_set_flags(abi, BE_ABI_NONE, between_type);
+}
+
+
 static const arch_register_req_t firm_std_reg_req = {
   arch_register_req_type_normal,
   &reg_classes[CLS_DATAB],
@@ -204,7 +242,7 @@ static const arch_register_req_t firm_std_reg_req = {
 };
 
 static const arch_register_req_t *
-firm_get_irn_reg_req(const arch_irn_ops_t *self,
+firm_get_irn_reg_req(const void *self,
     arch_register_req_t *req, const ir_node *irn, int pos)
 {
   if(is_firm_be_mode(get_irn_mode(irn)))
@@ -242,19 +280,19 @@ static struct irn_reg_assoc *get_irn_reg_assoc(const ir_node *irn)
   return set_insert(reg_set, &templ, sizeof(templ), HASH_PTR(irn));
 }
 
-static void firm_set_irn_reg(const arch_irn_ops_t *self, ir_node *irn, const arch_register_t *reg)
+static void firm_set_irn_reg(const void *self, ir_node *irn, const arch_register_t *reg)
 {
   struct irn_reg_assoc *assoc = get_irn_reg_assoc(irn);
   assoc->reg = reg;
 }
 
-static const arch_register_t *firm_get_irn_reg(const arch_irn_ops_t *self, const ir_node *irn)
+static const arch_register_t *firm_get_irn_reg(const void *self, const ir_node *irn)
 {
   struct irn_reg_assoc *assoc = get_irn_reg_assoc(irn);
   return assoc->reg;
 }
 
-static arch_irn_class_t firm_classify(const arch_irn_ops_t *self, const ir_node *irn)
+static arch_irn_class_t firm_classify(const void *self, const ir_node *irn)
 {
     arch_irn_class_t res;
 
@@ -263,6 +301,9 @@ static arch_irn_class_t firm_classify(const arch_irn_ops_t *self, const ir_node
         case iro_Jmp:
             res = arch_irn_class_branch;
             break;
+		case iro_Call:
+			res = arch_irn_class_call;
+			break;
         default:
             res = arch_irn_class_normal;
     }
@@ -270,9 +311,9 @@ static arch_irn_class_t firm_classify(const arch_irn_ops_t *self, const ir_node
 	return res;
 }
 
-static arch_irn_flags_t firm_get_flags(const arch_irn_ops_t *self, const ir_node *irn)
+static arch_irn_flags_t firm_get_flags(const void *self, const ir_node *irn)
 {
-	arch_irn_flags_t res = arch_irn_flags_spillable;
+	arch_irn_flags_t res = 0;
 
 	if(get_irn_op(irn) == op_imm)
 		res |= arch_irn_flags_rematerializable;
@@ -295,22 +336,37 @@ static arch_irn_flags_t firm_get_flags(const arch_irn_ops_t *self, const ir_node
 	return res;
 }
 
-static const arch_irn_ops_t irn_ops = {
-  firm_get_irn_reg_req,
-  firm_set_irn_reg,
-  firm_get_irn_reg,
-  firm_classify,
-	firm_get_flags
+static void firm_set_stack_bias(const void *self, ir_node *irn, int bias)
+{
+}
+
+static entity *firm_get_frame_entity(const void *self, const ir_node *irn)
+{
+	return NULL;
+}
+
+static const arch_irn_ops_if_t firm_irn_ops_if = {
+	firm_get_irn_reg_req,
+	firm_set_irn_reg,
+	firm_get_irn_reg,
+	firm_classify,
+	firm_get_flags,
+	firm_get_frame_entity,
+	firm_set_stack_bias
+};
+
+static const arch_irn_ops_t firm_irn_ops = {
+	&firm_irn_ops_if
 };
 
-static const arch_irn_ops_t *firm_get_irn_ops(const arch_irn_handler_t *self,
-    const ir_node *irn)
+static const void *firm_get_irn_ops(const arch_irn_handler_t *self,
+	const ir_node *irn)
 {
-  return &irn_ops;
+	return &firm_irn_ops;
 }
 
 const arch_irn_handler_t firm_irn_handler = {
-  firm_get_irn_ops,
+	firm_get_irn_ops,
 };
 
 static ir_node *new_Push(ir_graph *irg, ir_node *bl, ir_node *push, ir_node *arg)
@@ -491,28 +547,30 @@ static void firm_codegen_done(void *self)
 	free(self);
 }
 
-static void *firm_cg_init(FILE *file_handle, ir_graph *irg, const arch_env_t *env);
+static void *firm_cg_init(FILE *file_handle, const be_irg_t *birg);
 
-static const arch_code_generator_if_t firm_code_gen = {
+static const arch_code_generator_if_t firm_code_gen_if = {
 	firm_cg_init,
 	firm_prepare_graph,
 	firm_before_sched,
 	firm_before_ra,
+	NULL,  /* lower spill */
+	NULL,  /* lower reload */
 	firm_codegen_done
 };
 
-static void *firm_cg_init(FILE *file_handle, ir_graph *irg, const arch_env_t *env)
+static void *firm_cg_init(FILE *file_handle, const be_irg_t *birg)
 {
 	firm_code_gen_t *cg = xmalloc(sizeof(*cg));
-	cg->impl = &firm_code_gen;
-	cg->irg  = irg;
+	cg->impl = &firm_code_gen_if;
+	cg->irg  = birg->irg;
 	return cg;
 }
 
 
-static const arch_code_generator_if_t *firm_get_code_generator(void *self)
+static const arch_code_generator_if_t *firm_get_code_generator_if(void *self)
 {
-	return &firm_code_gen;
+	return &firm_code_gen_if;
 }
 
 static const list_sched_selector_t *firm_get_list_sched_selector(const void *self) {
@@ -533,7 +591,9 @@ const arch_isa_if_t firm_isa = {
 	firm_done,
 	firm_get_n_reg_class,
 	firm_get_reg_class,
+	firm_get_reg_class_for_mode,
+	firm_get_call_abi,
 	firm_get_irn_handler,
-	firm_get_code_generator,
+	firm_get_code_generator_if,
 	firm_get_list_sched_selector
 };