From: yu.dongliang <18588496441@163.com>
Date: Fri, 7 Jul 2023 06:20:09 +0000 (+0800)
Subject: eda
X-Git-Url: http://baseworks.info/?a=commitdiff_plain;h=d0c25ee8ca74407021ae45ddfc3c40cdc1c511a3;p=ses.git

eda
---

diff --git a/main.c b/main.c
index 351b568..f68fb56 100644
--- a/main.c
+++ b/main.c
@@ -4,6 +4,8 @@
 #include"scf_eda_pb.h"
 #include"scf_def.h"
 
+
+
 int main(int argc, char* argv[])
 {
 	if (argc < 2) {
@@ -41,37 +43,36 @@ int main(int argc, char* argv[])
 	fclose(fp);
 	fp = NULL;
 
-	ScfEboard* p = scf_eboard__unpack(NULL, len, pb);
+	ScfEcomponent* c;
+	ScfEfunction*  f;
+	ScfEpin*       p;
+
+	ScfEboard* b = scf_eboard__unpack(NULL, len, pb);
 
 	size_t i;
 	size_t j;
 	size_t k;
 	size_t l;
 
-	for (i = 0; i < p->n_functions; i++) {
-		ScfEfunction* pf = p->functions[i];
-
-		printf("f: %s\n", pf->name);
+	for (i = 0; i < b->n_functions; i++) {
+		f  =        b->functions[i];
 
-		for (l = 0; l < pf->n_components; l++) {
-			ScfEcomponent* pc = pf->components[l];
+		printf("f: %s\n", f->name);
 
-			printf("i: %ld, pc: %p, id: %ld, cid: %ld, n_pins: %ld\n", i, pc, pc->id, pc->type, pc->n_pins);
+		for (j = 0; j < f->n_components; j++) {
+			c  =        f->components[j];
 
-			for (j = 0; j < pc->n_pins; j++) {
-				ScfEpin* pp = pc->pins[j];
+			printf("c: %ld\n", c->id);
 
-				printf("j: %ld, pp: %p, n_tos: %ld\n", j, pp, pp->n_tos);
+			for (k = 0; k < c->n_pins; k++) {
+				p  =        c->pins[k];
 
-				for (k = 0; k + 1 < pp->n_tos; k += 2) {
-					printf("k: %ld, cid: %ld, pid: %ld\n", k, pp->tos[k], pp->tos[k + 1]);
-				}
+				printf("cid: %ld, pid: %ld\n", p->cid, p->id);
 			}
-			printf("\n");
 		}
 		printf("\n\n");
 	}
 
-	scf_eboard__free_unpacked(p, NULL);
+	scf_eboard__free_unpacked(b, NULL);
 	return 0;
 }
diff --git a/scf_eda.c b/scf_eda.c
new file mode 100644
index 0000000..fec807a
--- /dev/null
+++ b/scf_eda.c
@@ -0,0 +1,148 @@
+#include"scf_eda.h"
+#include"scf_basic_block.h"
+#include"scf_3ac.h"
+
+int	scf_eda_open(scf_native_t* ctx, const char* arch)
+{
+	scf_eda_context_t* eda = calloc(1, sizeof(scf_eda_context_t));
+	if (!eda)
+		return -ENOMEM;
+
+	ctx->priv = eda;
+	return 0;
+}
+
+int scf_eda_close(scf_native_t* ctx)
+{
+	scf_eda_context_t* eda = ctx->priv;
+
+	if (eda) {
+		free(eda);
+		eda = NULL;
+	}
+	return 0;
+}
+
+static int _eda_make_insts_for_list(scf_native_t* ctx, scf_list_t* h, int bb_offset)
+{
+	scf_list_t* l;
+	int ret;
+
+	for (l = scf_list_head(h); l != scf_list_sentinel(h); l = scf_list_next(l)) {
+
+		scf_3ac_code_t* c = scf_list_data(l, scf_3ac_code_t, list);
+
+		eda_inst_handler_t* h = scf_eda_find_inst_handler(c->op->type);
+		if (!h) {
+			scf_loge("3ac operator '%s' not supported\n", c->op->name);
+			return -EINVAL;
+		}
+
+		ret = h->func(ctx, c);
+		if (ret < 0) {
+			scf_3ac_code_print(c, NULL);
+			scf_loge("3ac op '%s' make inst failed\n", c->op->name);
+			return ret;
+		}
+
+		if (!c->instructions)
+			continue;
+
+		scf_3ac_code_print(c, NULL);
+	}
+
+	return bb_offset;
+}
+
+int	_scf_eda_select_inst(scf_native_t* ctx)
+{
+	scf_eda_context_t*	eda = ctx->priv;
+	scf_function_t*     f   = eda->f;
+	scf_basic_block_t*  bb;
+	scf_bb_group_t*     bbg;
+
+	int i;
+	int j;
+	int ret = 0;
+
+	for (i  = 0; i < f->bb_groups->size; i++) {
+		bbg =        f->bb_groups->data[i];
+
+		for (j = 0; j < bbg->body->size; j++) {
+			bb =        bbg->body->data[j];
+
+			assert(!bb->native_flag);
+
+			scf_loge("************ bb: %d\n", bb->index);
+			ret = _eda_make_insts_for_list(ctx, &bb->code_list_head, 0);
+			if (ret < 0)
+				return ret;
+			bb->native_flag = 1;
+			scf_loge("************ bb: %d\n", bb->index);
+		}
+	}
+
+	for (i  = 0; i < f->bb_loops->size; i++) {
+		bbg =        f->bb_loops->data[i];
+
+		for (j = 0; j < bbg->body->size; j++) {
+			bb =        bbg->body->data[j];
+
+			assert(!bb->native_flag);
+
+			ret = _eda_make_insts_for_list(ctx, &bb->code_list_head, 0);
+			if (ret < 0)
+				return ret;
+			bb->native_flag = 1;
+		}
+	}
+
+	return 0;
+}
+
+int scf_eda_select_inst(scf_native_t* ctx, scf_function_t* f)
+{
+	scf_eda_context_t* eda = ctx->priv;
+	ScfEcomponent*     B   = NULL;
+
+	scf_dag_node_t*    dn;
+	scf_list_t*        l;
+
+	eda->f = f;
+
+	assert(!f->ef);
+
+	f->ef = scf_efunction__alloc(f->node.w->text->data);
+	if (!f->ef)
+		return -ENOMEM;
+
+	EDA_INST_ADD_COMPONENT(f, B, SCF_EDA_Battery);
+
+	int ret = _scf_eda_select_inst(ctx);
+	if (ret < 0)
+		return ret;
+
+	for (l = scf_list_head(&f->dag_list_head); l != scf_list_sentinel(&f->dag_list_head); l = scf_list_next(l)) {
+
+		dn = scf_list_data(l, scf_dag_node_t, list);
+
+		if (dn->var && dn->var->arg_flag) {
+
+			int i;
+			for (i = 0; i < dn->n_pins; i++)
+				dn->pins[i]->flags |= SCF_EDA_PIN_IN;
+		}
+	}
+
+	return 0;
+}
+
+scf_native_ops_t	native_ops_eda = {
+	.name            = "eda",
+
+	.open            = scf_eda_open,
+	.close           = scf_eda_close,
+
+	.select_inst     = scf_eda_select_inst,
+};
+
diff --git a/scf_eda.h b/scf_eda.h
new file mode 100644
index 0000000..5dafe64
--- /dev/null
+++ b/scf_eda.h
@@ -0,0 +1,66 @@
+#ifndef SCF_EDA_H
+#define SCF_EDA_H
+
+#include"scf_native.h"
+#include"scf_eda_pb.h"
+
+#define EDA_INST_ADD_COMPONENT(_f, _c, _type) \
+	do { \
+		_c = scf_ecomponent__alloc(_type); \
+		if (!_c) \
+			return -ENOMEM; \
+		\
+		(_c)->id = (_f)->ef->n_components; \
+		\
+		int ret = scf_efunction__add_component((_f)->ef, _c); \
+		if (ret < 0) { \
+			scf_ecomponent__free(_c); \
+			_c = NULL; \
+			return ret; \
+		} \
+		\
+		for (size_t i = 0;  i < (_c)->n_pins; i++) \
+			(_c)->pins[i]->cid = (_c)->id; \
+	} while (0)
+
+
+#define EDA_PIN_ADD_COMPONENT(_pin, _cid, _pid) \
+	do { \
+		int ret = scf_epin__add_component((_pin), (_cid), (_pid)); \
+		if (ret < 0) \
+			return ret; \
+		\
+	} while (0)
+
+typedef struct {
+
+	scf_function_t*     f;
+
+} scf_eda_context_t;
+
+typedef struct {
+	int 	type;
+	int		(*func)(scf_native_t* ctx, scf_3ac_code_t* c);
+} eda_inst_handler_t;
+
+eda_inst_handler_t* scf_eda_find_inst_handler(const int op_type);
+
+int scf_eda_open  (scf_native_t* ctx, const char* arch);
+int scf_eda_close (scf_native_t* ctx);
+int scf_eda_select(scf_native_t* ctx);
+
+static inline int eda_variable_size(scf_variable_t* v)
+{
+	if (v->nb_dimentions + v->nb_pointers > 0)
+		return 64;
+
+	if (v->type >= SCF_STRUCT)
+		return 64;
+
+	if (SCF_VAR_BIT == v->type)
+		return 1;
+
+	return v->size << 3;
+}
+
+#endif
diff --git a/scf_eda.pb-c.c b/scf_eda.pb-c.c
index 190f5b8..c4ce916 100644
--- a/scf_eda.pb-c.c
+++ b/scf_eda.pb-c.c
@@ -299,7 +299,7 @@ const ProtobufCMessageDescriptor scf_eline__descriptor =
   (ProtobufCMessageInit) scf_eline__init,
   NULL,NULL,NULL    /* reserved[123] */
 };
-static const ProtobufCFieldDescriptor scf_epin__field_descriptors[6] =
+static const ProtobufCFieldDescriptor scf_epin__field_descriptors[7] =
 {
   {
     "tos",
@@ -326,11 +326,23 @@ static const ProtobufCFieldDescriptor scf_epin__field_descriptors[6] =
     0,NULL,NULL    /* reserved1,reserved2, etc */
   },
   {
-    "flags",
+    "cid",
     3,
     PROTOBUF_C_LABEL_REQUIRED,
     PROTOBUF_C_TYPE_UINT64,
     0,   /* quantifier_offset */
+    offsetof(ScfEpin, cid),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "flags",
+    4,
+    PROTOBUF_C_LABEL_REQUIRED,
+    PROTOBUF_C_TYPE_UINT64,
+    0,   /* quantifier_offset */
     offsetof(ScfEpin, flags),
     NULL,
     NULL,
@@ -339,7 +351,7 @@ static const ProtobufCFieldDescriptor scf_epin__field_descriptors[6] =
   },
   {
     "x",
-    4,
+    5,
     PROTOBUF_C_LABEL_REQUIRED,
     PROTOBUF_C_TYPE_UINT32,
     0,   /* quantifier_offset */
@@ -351,7 +363,7 @@ static const ProtobufCFieldDescriptor scf_epin__field_descriptors[6] =
   },
   {
     "y",
-    5,
+    6,
     PROTOBUF_C_LABEL_REQUIRED,
     PROTOBUF_C_TYPE_UINT32,
     0,   /* quantifier_offset */
@@ -363,7 +375,7 @@ static const ProtobufCFieldDescriptor scf_epin__field_descriptors[6] =
   },
   {
     "lines",
-    6,
+    7,
     PROTOBUF_C_LABEL_REPEATED,
     PROTOBUF_C_TYPE_MESSAGE,
     offsetof(ScfEpin, n_lines),
@@ -375,17 +387,18 @@ static const ProtobufCFieldDescriptor scf_epin__field_descriptors[6] =
   },
 };
 static const unsigned scf_epin__field_indices_by_name[] = {
-  2,   /* field[2] = flags */
+  2,   /* field[2] = cid */
+  3,   /* field[3] = flags */
   1,   /* field[1] = id */
-  5,   /* field[5] = lines */
+  6,   /* field[6] = lines */
   0,   /* field[0] = tos */
-  3,   /* field[3] = x */
-  4,   /* field[4] = y */
+  4,   /* field[4] = x */
+  5,   /* field[5] = y */
 };
 static const ProtobufCIntRange scf_epin__number_ranges[1 + 1] =
 {
   { 1, 0 },
-  { 0, 6 }
+  { 0, 7 }
 };
 const ProtobufCMessageDescriptor scf_epin__descriptor =
 {
@@ -395,7 +408,7 @@ const ProtobufCMessageDescriptor scf_epin__descriptor =
   "ScfEpin",
   "",
   sizeof(ScfEpin),
-  6,
+  7,
   scf_epin__field_descriptors,
   scf_epin__field_indices_by_name,
   1,  scf_epin__number_ranges,
diff --git a/scf_eda.pb-c.h b/scf_eda.pb-c.h
index 53b065e..81d6c72 100644
--- a/scf_eda.pb-c.h
+++ b/scf_eda.pb-c.h
@@ -46,6 +46,7 @@ struct  _ScfEpin
   size_t n_tos;
   uint64_t *tos;
   uint64_t id;
+  uint64_t cid;
   uint64_t flags;
   uint32_t x;
   uint32_t y;
@@ -54,7 +55,7 @@ struct  _ScfEpin
 };
 #define SCF_EPIN__INIT \
  { PROTOBUF_C_MESSAGE_INIT (&scf_epin__descriptor) \
-    , 0,NULL, 0, 0, 0, 0, 0,NULL }
+    , 0,NULL, 0, 0, 0, 0, 0, 0,NULL }
 
 
 struct  _ScfEcomponent
diff --git a/scf_eda.proto b/scf_eda.proto
index 78e95fb..d46b246 100644
--- a/scf_eda.proto
+++ b/scf_eda.proto
@@ -12,11 +12,12 @@ message scf_epin
 {
 	repeated uint64    tos   = 1;
 	required uint64    id    = 2;
-	required uint64    flags = 3;
+	required uint64    cid   = 3;
+	required uint64    flags = 4;
 
-	required uint32    x     = 4;
-	required uint32    y     = 5;
-	repeated scf_eline lines = 6;
+	required uint32    x     = 5;
+	required uint32    y     = 6;
+	repeated scf_eline lines = 7;
 }
 
 message scf_ecomponent
diff --git a/scf_eda_inst.c b/scf_eda_inst.c
new file mode 100644
index 0000000..bf7b376
--- /dev/null
+++ b/scf_eda_inst.c
@@ -0,0 +1,625 @@
+#include"scf_eda.h"
+
+#define EDA_INST_OP2_CHECK() \
+	if (!c->dsts || c->dsts->size != 1) \
+		return -EINVAL; \
+	\
+	if (!c->srcs || c->srcs->size != 1) \
+		return -EINVAL; \
+	\
+	scf_eda_context_t* eda  = ctx->priv; \
+	scf_function_t*    f    = eda->f; \
+	\
+	scf_3ac_operand_t* dst  = c->dsts->data[0]; \
+	scf_3ac_operand_t* src  = c->srcs->data[0]; \
+	\
+	if (!src || !src->dag_node) \
+		return -EINVAL; \
+	\
+	if (!dst || !dst->dag_node) \
+		return -EINVAL; \
+	\
+	if (src->dag_node->var->size != dst->dag_node->var->size) {\
+		scf_loge("size: %d, %d\n", src->dag_node->var->size, dst->dag_node->var->size); \
+		return -EINVAL; \
+	}
+
+#define EDA_INST_OP3_CHECK() \
+	if (!c->dsts || c->dsts->size != 1) \
+		return -EINVAL; \
+	\
+	if (!c->srcs || c->srcs->size != 2) \
+		return -EINVAL; \
+	\
+	scf_eda_context_t* eda  = ctx->priv; \
+	scf_function_t*    f    = eda->f; \
+	\
+	scf_3ac_operand_t* dst  = c->dsts->data[0]; \
+	scf_3ac_operand_t* src0 = c->srcs->data[0]; \
+	scf_3ac_operand_t* src1 = c->srcs->data[1]; \
+	\
+	if (!src0 || !src0->dag_node) \
+		return -EINVAL; \
+	\
+	if (!src1 || !src1->dag_node) \
+		return -EINVAL; \
+	\
+	if (!dst || !dst->dag_node) \
+		return -EINVAL; \
+	\
+	if (src0->dag_node->var->size != src1->dag_node->var->size) {\
+		scf_loge("size: %d, %d\n", src0->dag_node->var->size, src1->dag_node->var->size); \
+		return -EINVAL; \
+	}
+
+#define EDA_INST_IN_CHECK(_in, _N) \
+	do { \
+		int i; \
+		if (!(_in)->var->arg_flag) { \
+			if ((_in)->n_pins != _N) \
+				return -EINVAL; \
+			\
+			for (i = 0; i < N; i++) { \
+				if (!(_in)->pins[i]) \
+					return -EINVAL; \
+			} \
+		} \
+	} while (0)
+
+static int _eda_inst_bit_not_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	EDA_INST_OP2_CHECK()
+
+	scf_dag_node_t* in  = src->dag_node;
+	scf_dag_node_t* out = dst->dag_node;
+
+	ScfEcomponent*  T   = NULL;
+	ScfEcomponent*  R   = NULL;
+	ScfEcomponent*  B   = f->ef->components[0];
+
+	int i;
+	int N = eda_variable_size(in->var);
+
+	EDA_INST_IN_CHECK(in, N);
+
+	in ->n_pins = N;
+	out->n_pins = N;
+
+	for (i = 0; i < N; i++) {
+
+		EDA_INST_ADD_COMPONENT(f, T, SCF_EDA_Transistor);
+		EDA_INST_ADD_COMPONENT(f, R, SCF_EDA_Resistor);
+
+		in->pins[i] = T->pins[SCF_EDA_Transistor_B];
+
+		EDA_PIN_ADD_COMPONENT(T->pins[SCF_EDA_Transistor_C], R->id, 1);
+		EDA_PIN_ADD_COMPONENT(T->pins[SCF_EDA_Transistor_E], B->id, SCF_EDA_Battery_NEG);
+
+		EDA_PIN_ADD_COMPONENT(R->pins[0], B->id, SCF_EDA_Battery_POS);
+		EDA_PIN_ADD_COMPONENT(R->pins[1], T->id, SCF_EDA_Transistor_C);
+
+		out->pins[i] = T->pins[SCF_EDA_Transistor_C];
+	}
+
+	return 0;
+}
+
+static int _eda_inst_bit_and_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	EDA_INST_OP3_CHECK()
+
+	scf_dag_node_t* in0 = src0->dag_node;
+	scf_dag_node_t* in1 = src1->dag_node;
+	scf_dag_node_t* out = dst ->dag_node;
+
+	ScfEcomponent*  D0  = NULL;
+	ScfEcomponent*  D1  = NULL;
+	ScfEcomponent*  R   = NULL;
+	ScfEcomponent*  B   = f->ef->components[0];
+
+	int i;
+	int N = eda_variable_size(in0->var);
+
+	EDA_INST_IN_CHECK(in0, N);
+	EDA_INST_IN_CHECK(in1, N);
+
+	in0->n_pins = N;
+	in1->n_pins = N;
+	out->n_pins = N;
+
+	for (i = 0; i < N; i++) {
+
+		EDA_INST_ADD_COMPONENT(f, D0, SCF_EDA_Diode);
+		EDA_INST_ADD_COMPONENT(f, D1, SCF_EDA_Diode);
+		EDA_INST_ADD_COMPONENT(f, R,  SCF_EDA_Resistor);
+
+		in0->pins[i] = D0->pins[SCF_EDA_Diode_NEG];
+		in1->pins[i] = D1->pins[SCF_EDA_Diode_NEG];
+
+		EDA_PIN_ADD_COMPONENT(D0->pins[SCF_EDA_Diode_POS], D1->id, SCF_EDA_Diode_POS);
+		EDA_PIN_ADD_COMPONENT(D0->pins[SCF_EDA_Diode_POS], R ->id, 1);
+
+		EDA_PIN_ADD_COMPONENT(D1->pins[SCF_EDA_Diode_POS], D0->id, SCF_EDA_Diode_POS);
+		EDA_PIN_ADD_COMPONENT(D1->pins[SCF_EDA_Diode_POS], R ->id, 1);
+
+		EDA_PIN_ADD_COMPONENT(R->pins[1], D0->id, SCF_EDA_Diode_POS);
+		EDA_PIN_ADD_COMPONENT(R->pins[1], D1->id, SCF_EDA_Diode_POS);
+		EDA_PIN_ADD_COMPONENT(R->pins[0], B ->id, SCF_EDA_Battery_POS);
+
+		out->pins[i] = R ->pins[1];
+	}
+
+	return 0;
+}
+
+static int _eda_inst_bit_or_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	EDA_INST_OP3_CHECK()
+
+	scf_dag_node_t* in0 = src0->dag_node;
+	scf_dag_node_t* in1 = src1->dag_node;
+	scf_dag_node_t* out = dst ->dag_node;
+
+	ScfEcomponent*  D0  = NULL;
+	ScfEcomponent*  D1  = NULL;
+	ScfEcomponent*  R   = NULL;
+	ScfEcomponent*  B   = f->ef->components[0];
+
+	int i;
+	int N = eda_variable_size(in0->var);
+
+	EDA_INST_IN_CHECK(in0, N);
+	EDA_INST_IN_CHECK(in1, N);
+
+	in0->n_pins = N;
+	in1->n_pins = N;
+	out->n_pins = N;
+
+	for (i = 0; i < N; i++) {
+
+		EDA_INST_ADD_COMPONENT(f, D0, SCF_EDA_Diode);
+		EDA_INST_ADD_COMPONENT(f, D1, SCF_EDA_Diode);
+		EDA_INST_ADD_COMPONENT(f, R,  SCF_EDA_Resistor);
+
+		in0->pins[i] = D0->pins[SCF_EDA_Diode_POS];
+		in1->pins[i] = D1->pins[SCF_EDA_Diode_POS];
+
+		EDA_PIN_ADD_COMPONENT(D0->pins[SCF_EDA_Diode_NEG], D1->id, SCF_EDA_Diode_NEG);
+		EDA_PIN_ADD_COMPONENT(D0->pins[SCF_EDA_Diode_NEG], R ->id, 0);
+
+		EDA_PIN_ADD_COMPONENT(D1->pins[SCF_EDA_Diode_NEG], D0->id, SCF_EDA_Diode_NEG);
+		EDA_PIN_ADD_COMPONENT(D1->pins[SCF_EDA_Diode_NEG], R ->id, 0);
+
+		EDA_PIN_ADD_COMPONENT(R->pins[0], D0->id, SCF_EDA_Diode_NEG);
+		EDA_PIN_ADD_COMPONENT(R->pins[0], D1->id, SCF_EDA_Diode_NEG);
+		EDA_PIN_ADD_COMPONENT(R->pins[1], B ->id, SCF_EDA_Battery_NEG);
+
+		out->pins[i] = R ->pins[0];
+	}
+
+	return 0;
+}
+
+static int _eda_inst_inc_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_inc_post_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_dec_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_dec_post_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_assign_array_index_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	if (!c->srcs || c->srcs->size != 4)
+		return -EINVAL;
+
+	scf_eda_context_t*  eda    = ctx->priv;
+	scf_function_t*     f      = eda->f;
+
+	scf_3ac_operand_t*  base   = c->srcs->data[0];
+	scf_3ac_operand_t*  index  = c->srcs->data[1];
+	scf_3ac_operand_t*  scale  = c->srcs->data[2];
+	scf_3ac_operand_t*  src    = c->srcs->data[3];
+
+	if (!base || !base->dag_node)
+		return -EINVAL;
+
+	if (!index || !index->dag_node)
+		return -EINVAL;
+
+	if (!scale || !scale->dag_node)
+		return -EINVAL;
+
+	if (!src || !src->dag_node)
+		return -EINVAL;
+
+	return -EINVAL;
+}
+
+static int _eda_inst_and_assign_array_index_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	if (!c->srcs || c->srcs->size != 4)
+		return -EINVAL;
+
+	scf_eda_context_t*  eda    = ctx->priv;
+	scf_function_t*     f      = eda->f;
+
+	scf_3ac_operand_t*  base   = c->srcs->data[0];
+	scf_3ac_operand_t*  index  = c->srcs->data[1];
+	scf_3ac_operand_t*  scale  = c->srcs->data[2];
+	scf_3ac_operand_t*  src    = c->srcs->data[3];
+
+	if (!base || !base->dag_node)
+		return -EINVAL;
+
+	if (!index || !index->dag_node)
+		return -EINVAL;
+
+	if (!scale || !scale->dag_node)
+		return -EINVAL;
+
+	if (!src || !src->dag_node)
+		return -EINVAL;
+
+	return -EINVAL;
+}
+
+static int _eda_inst_or_assign_array_index_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	if (!c->srcs || c->srcs->size != 4)
+		return -EINVAL;
+
+	scf_eda_context_t*  eda    = ctx->priv;
+	scf_function_t*     f      = eda->f;
+
+	scf_3ac_operand_t*  base   = c->srcs->data[0];
+	scf_3ac_operand_t*  index  = c->srcs->data[1];
+	scf_3ac_operand_t*  scale  = c->srcs->data[2];
+	scf_3ac_operand_t*  src    = c->srcs->data[3];
+
+	if (!base || !base->dag_node)
+		return -EINVAL;
+
+	if (!index || !index->dag_node)
+		return -EINVAL;
+
+	if (!scale || !scale->dag_node)
+		return -EINVAL;
+
+	if (!src || !src->dag_node)
+		return -EINVAL;
+
+	return -EINVAL;
+}
+
+static int _eda_inst_array_index_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	if (!c->dsts || c->dsts->size != 1)
+		return -EINVAL;
+
+	if (!c->srcs || c->srcs->size != 3)
+		return -EINVAL;
+
+	scf_eda_context_t*  eda    = ctx->priv;
+	scf_function_t*     f      = eda->f;
+
+	scf_3ac_operand_t*  dst    = c->dsts->data[0];
+	scf_3ac_operand_t*  base   = c->srcs->data[0];
+	scf_3ac_operand_t*  index  = c->srcs->data[1];
+	scf_3ac_operand_t*  scale  = c->srcs->data[2];
+
+	if (!base || !base->dag_node)
+		return -EINVAL;
+
+	if (!index || !index->dag_node)
+		return -EINVAL;
+
+	if (!scale || !scale->dag_node)
+		return -EINVAL;
+
+	if (!c->instructions) {
+		c->instructions = scf_vector_alloc();
+		if (!c->instructions)
+			return -ENOMEM;
+	}
+
+	scf_variable_t*     vd  = dst  ->dag_node->var;
+	scf_variable_t*     vb  = base ->dag_node->var;
+	scf_variable_t*     vi  = index->dag_node->var;
+	scf_variable_t*     vs  = scale->dag_node->var;
+
+	return -EINVAL;
+}
+
+static int _eda_inst_teq_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_logic_not_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_cmp_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_setz_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_setnz_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_setgt_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_setge_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_setlt_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_setle_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_eq_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_ne_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_gt_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_ge_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_lt_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_le_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_cast_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	if (!c->dsts || c->dsts->size != 1)
+		return -EINVAL;
+
+	if (!c->srcs || c->srcs->size != 1)
+		return -EINVAL;
+
+	scf_eda_context_t* eda = ctx->priv;
+	scf_function_t*    f   = eda->f;
+	scf_3ac_operand_t* src = c->srcs->data[0];
+	scf_3ac_operand_t* dst = c->dsts->data[0];
+
+	if (!src || !src->dag_node)
+		return -EINVAL;
+
+	if (!dst || !dst->dag_node)
+		return -EINVAL;
+
+	if (0 == dst->dag_node->color)
+		return -EINVAL;
+
+	return -EINVAL;
+}
+
+static int _eda_inst_return_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	if (!c->srcs || c->srcs->size < 1)
+		return -EINVAL;
+
+	scf_eda_context_t*  eda  = ctx->priv;
+	scf_function_t*     f    = eda->f;
+	scf_3ac_operand_t*  src  = NULL;
+	scf_dag_node_t*     out  = NULL;
+
+	int i;
+	int j;
+
+	for (i  = 0; i < c->srcs->size; i++) {
+		src =        c->srcs->data[i];
+
+		out = src->dag_node;
+
+		if (out->n_pins <= 0) {
+			scf_loge("\n");
+			return -EINVAL;
+		}
+
+		for (j  = 0; j < out->n_pins; j++)
+			out->pins[j]->flags |= SCF_EDA_PIN_OUT;
+	}
+
+	return 0;
+}
+
+static int _eda_inst_nop_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return 0;
+}
+
+static int _eda_inst_end_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return 0;
+}
+
+static int _eda_inst_goto_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_jz_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_jnz_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_jgt_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_jge_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_jlt_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_jle_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return -EINVAL;
+}
+
+static int _eda_inst_load_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return 0;
+}
+
+static int _eda_inst_reload_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return 0;
+}
+
+static int _eda_inst_save_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return 0;
+}
+
+static int _eda_inst_assign_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return 0;
+}
+
+static int _eda_inst_and_assign_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return 0;
+}
+
+static int _eda_inst_or_assign_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+	return 0;
+}
+
+static eda_inst_handler_t eda_inst_handlers[] =
+{
+	{SCF_OP_ARRAY_INDEX, 	_eda_inst_array_index_handler},
+
+	{SCF_OP_TYPE_CAST,      _eda_inst_cast_handler},
+	{SCF_OP_LOGIC_NOT, 		_eda_inst_logic_not_handler},
+	{SCF_OP_BIT_NOT,        _eda_inst_bit_not_handler},
+
+	{SCF_OP_INC,            _eda_inst_inc_handler},
+	{SCF_OP_DEC,            _eda_inst_dec_handler},
+
+	{SCF_OP_INC_POST,       _eda_inst_inc_post_handler},
+	{SCF_OP_DEC_POST,       _eda_inst_dec_post_handler},
+
+	{SCF_OP_BIT_AND,        _eda_inst_bit_and_handler},
+	{SCF_OP_BIT_OR,         _eda_inst_bit_or_handler},
+
+	{SCF_OP_3AC_TEQ,        _eda_inst_teq_handler},
+	{SCF_OP_3AC_CMP,        _eda_inst_cmp_handler},
+
+	{SCF_OP_3AC_SETZ,       _eda_inst_setz_handler},
+	{SCF_OP_3AC_SETNZ,      _eda_inst_setnz_handler},
+	{SCF_OP_3AC_SETGT,      _eda_inst_setgt_handler},
+	{SCF_OP_3AC_SETGE,      _eda_inst_setge_handler},
+	{SCF_OP_3AC_SETLT,      _eda_inst_setlt_handler},
+	{SCF_OP_3AC_SETLE,      _eda_inst_setle_handler},
+
+	{SCF_OP_EQ, 			_eda_inst_eq_handler},
+	{SCF_OP_NE, 			_eda_inst_ne_handler},
+	{SCF_OP_GT, 			_eda_inst_gt_handler},
+	{SCF_OP_GE,             _eda_inst_ge_handler},
+	{SCF_OP_LT,             _eda_inst_lt_handler},
+	{SCF_OP_LE,             _eda_inst_le_handler},
+
+	{SCF_OP_ASSIGN, 		_eda_inst_assign_handler},
+
+	{SCF_OP_AND_ASSIGN,     _eda_inst_and_assign_handler},
+	{SCF_OP_OR_ASSIGN,      _eda_inst_or_assign_handler},
+
+	{SCF_OP_RETURN, 		_eda_inst_return_handler},
+	{SCF_OP_GOTO, 			_eda_inst_goto_handler},
+
+	{SCF_OP_3AC_JZ, 		_eda_inst_jz_handler},
+	{SCF_OP_3AC_JNZ, 		_eda_inst_jnz_handler},
+	{SCF_OP_3AC_JGT, 		_eda_inst_jgt_handler},
+	{SCF_OP_3AC_JGE, 		_eda_inst_jge_handler},
+	{SCF_OP_3AC_JLT, 		_eda_inst_jlt_handler},
+	{SCF_OP_3AC_JLE, 		_eda_inst_jle_handler},
+
+	{SCF_OP_3AC_NOP, 		_eda_inst_nop_handler},
+	{SCF_OP_3AC_END, 		_eda_inst_end_handler},
+
+	{SCF_OP_3AC_SAVE,       _eda_inst_save_handler},
+	{SCF_OP_3AC_LOAD,       _eda_inst_load_handler},
+
+	{SCF_OP_3AC_RESAVE,     _eda_inst_save_handler},
+	{SCF_OP_3AC_RELOAD,     _eda_inst_reload_handler},
+
+	{SCF_OP_3AC_ASSIGN_ARRAY_INDEX,     _eda_inst_assign_array_index_handler},
+	{SCF_OP_3AC_AND_ASSIGN_ARRAY_INDEX, _eda_inst_and_assign_array_index_handler},
+	{SCF_OP_3AC_OR_ASSIGN_ARRAY_INDEX,  _eda_inst_or_assign_array_index_handler},
+};
+
+eda_inst_handler_t* scf_eda_find_inst_handler(const int op_type)
+{
+	int i;
+	for (i = 0; i < sizeof(eda_inst_handlers) / sizeof(eda_inst_handlers[0]); i++) {
+
+		eda_inst_handler_t* h = &(eda_inst_handlers[i]);
+
+		if (op_type == h->type)
+			return h;
+	}
+	return NULL;
+}
diff --git a/scf_vector.h b/scf_vector.h
new file mode 100644
index 0000000..d4249ca
--- /dev/null
+++ b/scf_vector.h
@@ -0,0 +1,198 @@
+#ifndef SCF_VECTOR_H
+#define SCF_VECTOR_H
+
+#include"scf_def.h"
+
+typedef struct {
+	int		capacity;
+	int		size;
+	void**	data;
+} scf_vector_t;
+
+#undef  NB_MEMBER_INC
+#define NB_MEMBER_INC	16
+
+static inline scf_vector_t* scf_vector_alloc()
+{
+	scf_vector_t* v = calloc(1, sizeof(scf_vector_t));
+	if (!v)
+		return NULL;
+
+	v->data = calloc(NB_MEMBER_INC, sizeof(void*));
+	if (!v->data) {
+		free(v);
+		v = NULL;
+		return NULL;
+	}
+
+	v->capacity = NB_MEMBER_INC;
+	return v;
+}
+
+static inline scf_vector_t* scf_vector_clone(scf_vector_t* origin)
+{
+	scf_vector_t* clone = calloc(1, sizeof(scf_vector_t));
+	if (!clone)
+		return NULL;
+
+	clone->data = calloc(origin->capacity, sizeof(void*));
+	if (!clone->data) {
+		free(clone);
+		clone = NULL;
+		return NULL;
+	}
+
+	clone->capacity = origin->capacity;
+	clone->size		= origin->size;
+	memcpy(clone->data, origin->data, origin->size * sizeof(void*));
+	return clone;
+}
+
+static inline int scf_vector_cat(scf_vector_t* dst, scf_vector_t* src)
+{
+	if (!dst || !src)
+		return -EINVAL;
+
+	int size = dst->size + src->size;
+	if (size > dst->capacity) {
+
+		void* p = realloc(dst->data, sizeof(void*) * (size + NB_MEMBER_INC));
+		if (!p)
+			return -ENOMEM;
+
+		dst->data = p;
+		dst->capacity = size + NB_MEMBER_INC;
+	}
+
+	memcpy(dst->data + dst->size * sizeof(void*), src->data, src->size * sizeof(void*));
+	dst->size += src->size;
+	return 0;
+}
+
+static inline int scf_vector_add(scf_vector_t* v, void* node)
+{
+	if (!v || !v->data)
+		return -EINVAL;
+
+	assert(v->size <= v->capacity);
+
+	if (v->size == v->capacity) {
+		void* p = realloc(v->data, sizeof(void*) * (v->capacity + NB_MEMBER_INC));
+		if (!p)
+			return -ENOMEM;
+
+		v->data = p;
+		v->capacity += NB_MEMBER_INC;
+	}
+
+	v->data[v->size++] = node;
+	return 0;
+}
+
+static inline int scf_vector_del(scf_vector_t* v, void* node)
+{
+	if (!v || !v->data)
+		return -EINVAL;
+
+	assert(v->size <= v->capacity);
+
+	int i;
+	for (i = 0; i < v->size; i++) {
+
+		if (v->data[i] != node)
+			continue;
+
+		int j;
+		for (j = i + 1; j < v->size; j++)
+			v->data[j - 1] = v->data[j];
+
+		v->size--;
+
+		if (v->size + NB_MEMBER_INC * 2 < v->capacity) {
+			void* p = realloc(v->data, sizeof(void*) * (v->capacity - NB_MEMBER_INC));
+			if (p) {
+				v->data = p;
+				v->capacity -= NB_MEMBER_INC;
+			}
+		}
+		return 0;
+	}
+
+	return -1;
+}
+
+static inline void* scf_vector_find(const scf_vector_t* v, const void* node)
+{
+	int i;
+	for (i = 0; i < v->size; i++) {
+		if (node == v->data[i])
+			return v->data[i];
+	}
+	return NULL;
+}
+
+static inline int scf_vector_add_unique(scf_vector_t* v, void* node)
+{
+	if (!scf_vector_find(v, node))
+		return scf_vector_add(v, node);
+	return 0;
+}
+
+static inline void* scf_vector_find_cmp(const scf_vector_t* v, const void* node, int (*cmp)(const void*, const void*))
+{
+	int i;
+	for (i = 0; i < v->size; i++) {
+		if (0 == cmp(node, v->data[i]))
+			return v->data[i];
+	}
+	return NULL;
+}
+
+static inline int scf_vector_qsort(const scf_vector_t* v, int (*cmp)(const void*, const void*))
+{
+	if (!v || !v->data || 0 == v->size || !cmp)
+		return -EINVAL;
+
+	qsort(v->data, v->size, sizeof(void*), cmp);
+	return 0;
+}
+
+static inline void scf_vector_clear(scf_vector_t* v, void (*type_free)(void*))
+{
+	if (!v || !v->data)
+		return;
+
+	if (type_free) {
+		int i;
+		for (i = 0; i < v->size; i++) {
+			if (v->data[i]) {
+				type_free(v->data[i]);
+				v->data[i] = NULL;
+			}
+		}
+	}
+
+	v->size = 0;
+
+	if (v->capacity > NB_MEMBER_INC) {
+		void* p = realloc(v->data, sizeof(void*) * NB_MEMBER_INC);
+		if (p) {
+			v->data = p;
+			v->capacity = NB_MEMBER_INC;
+		}
+	}
+}
+
+static inline void scf_vector_free(scf_vector_t* v)
+{
+	if (v) {
+		if (v->data)
+			free(v->data);
+
+		free(v);
+		v = NULL;
+	}
+}
+
+#endif
+
diff --git a/ses_layout.c b/ses_layout.c
new file mode 100644
index 0000000..a802c5f
--- /dev/null
+++ b/ses_layout.c
@@ -0,0 +1,87 @@
+#include"ses_layout.h"
+
+int epin_cmp(const void* v0, const void* v1)
+{
+	const uint64_t* t0 = v0;
+	const uint64_t* t1 = v1;
+
+	if (t0[0] < t1[0])
+		return -1;
+
+	if (t0[0] > t1[0])
+		return 1;
+
+	if (t0[1] < t1[1])
+		return -1;
+
+	if (t0[1] > t1[1])
+		return 1;
+
+	return 0;
+}
+
+int ses_pins_same_line(ScfEfunction* f, scf_vector_t* lines)
+{
+	ScfEcomponent* c;
+	ScfEline*      l;
+	ScfEpin*       p;
+	ScfEpin*       p2;
+
+	scf_vector_t*  vec;
+
+	size_t i;
+	size_t j;
+	size_t k;
+	size_t m;
+
+	for (i = 0; i < f->n_components; i++) {
+		c  =        f->components[i];
+
+		for (j = 0; j < c->n_pins; j++) {
+			p  =        c->pins[j];
+
+			qsort(p->tos, p->n_tos / 2, sizeof(uint64_t) * 2, epin_cmp);
+
+			for (k = 0; k < lines->size; k++) {
+				vec       = lines->data[k];
+
+				for (m = 0; m < vec->size; m++) {
+					p2 =        vec->data[m];
+
+					if (p2->i)
+
+				}
+			}
+		}
+	}
+
+	return 0;
+}
+
+int ses_layout_board(ScfEboard* b, int x, int y, int w, int h)
+{
+	ScfEcomponent* c;
+	ScfEfunction*  f;
+	ScfEline*      l;
+	ScfEpin*       p;
+
+	scf_vector_t*  lines;
+
+	size_t i;
+	size_t j;
+	size_t k;
+
+	lines = scf_vector_alloc();
+	if (!lines)
+		return -ENOMEM;
+
+	for (i = 0; i < b->n_functions; i++) {
+		f  =        b->functions[i];
+
+		printf("f: %s\n", f->name);
+
+
+	}
+
+	return 0;
+}
diff --git a/ses_layout.h b/ses_layout.h
new file mode 100644
index 0000000..6dd16d7
--- /dev/null
+++ b/ses_layout.h
@@ -0,0 +1,8 @@
+#ifndef SES_LAYOUT_H
+#define SES_LAYOUT_H
+
+#include"scf_eda_pb.h"
+
+int ses_layout_board(ScfEboard* b, int x, int y, int w, int h);
+
+#endif