From 950141bc7e672be06e88fb842f4beb1c5b894ff9 Mon Sep 17 00:00:00 2001
From: "yu.dongliang" <18588496441@163.com>
Date: Wed, 5 Nov 2025 14:39:21 +0800
Subject: [PATCH] js: fix 'teq' for 'js object' which is a return value of an
 function call(), for source code as 'if (obj)', 'if (!obj)', or 'if
 (Boolean(0))', etc.

---
 examples/js.html                     |   8 +-
 html/Makefile                        |   1 +
 js/core/scf_dag.c                    |  12 +-
 js/core/scf_operator_dag.c           |   2 +
 js/core/scf_optimizer.c              |   2 +
 js/core/scf_optimizer_auto_gc.c      |   6 +-
 js/core/scf_optimizer_auto_gc_find.c |   8 +-
 js/core/scf_optimizer_inline.c       |   6 +-
 js/core/scf_optimizer_js_teq.c       | 176 +++++++++++++++++++++++++++
 js/core/scf_optimizer_split_call.c   |   2 +-
 js/core/scf_variable.c               |   3 +
 js/core/scf_variable.h               |   1 +
 js/doc.c                             |  24 ++++
 js/parse/scf_dfa_var.c               |   4 +
 js/parse/scf_parse.c                 |   4 -
 ui/Makefile                          |   1 +
 16 files changed, 238 insertions(+), 22 deletions(-)
 create mode 100644 js/core/scf_optimizer_js_teq.c

diff --git a/examples/js.html b/examples/js.html
index be3e657..322c052 100644
--- a/examples/js.html
+++ b/examples/js.html
@@ -8,13 +8,7 @@
 
 <script>
 
-var s0 = "123";
-var s1 = "124";
-
-document.write(s0 == s1);
-document.write("<br>");
-
-if (s0 == s1)
+if (Boolean(0))
 	document.write(true);
 else
 	document.write(false);
diff --git a/html/Makefile b/html/Makefile
index 71e93d1..3890934 100644
--- a/html/Makefile
+++ b/html/Makefile
@@ -108,6 +108,7 @@ CFILES += ../js/core/scf_optimizer_dag.c
 CFILES += ../js/core/scf_optimizer_inline.c
 
 CFILES += ../js/core/scf_optimizer_js_array.c
+CFILES += ../js/core/scf_optimizer_js_teq.c
 CFILES += ../js/core/scf_optimizer_js_call.c
 
 CFILES += ../js/core/scf_optimizer_split_call.c
diff --git a/js/core/scf_dag.c b/js/core/scf_dag.c
index 9fa2005..54a58cb 100644
--- a/js/core/scf_dag.c
+++ b/js/core/scf_dag.c
@@ -583,6 +583,7 @@ int scf_dag_node_same(scf_dag_node_t* dn, const scf_node_t* node)
 	if (!dn->childs) {
 		if (SCF_OP_CALL == node->type /*&& 1 == node->nb_nodes*/) {
 			int ret = __dn_same_call(dn, node, split);
+			scf_logd("ret: %d\n", ret);
 			return ret;
 		}
 
@@ -638,8 +639,15 @@ int scf_dag_node_same(scf_dag_node_t* dn, const scf_node_t* node)
 		}
 	}
 
-	if (dn->childs->size != node->nb_nodes)
+	if (dn->childs->size != node->nb_nodes) {
+		if (SCF_OP_CALL == node->type /*&& 1 == node->nb_nodes*/) {
+			int ret = __dn_same_call(dn, node, split);
+			scf_logd("ret: %d\n", ret);
+			return ret;
+		}
+
 		return 0;
+	}
 
 cmp_childs:
 	for (i = 0; i < node->nb_nodes; i++) {
@@ -687,6 +695,7 @@ cmp_childs:
 
 	if (SCF_OP_CALL == dn->type) {
 		int ret = __dn_same_call(dn, node, split);
+		scf_logd("ret: %d\n", ret);
 		return ret;
 	}
 
@@ -724,7 +733,6 @@ int scf_dag_get_node(scf_list_t* h, const scf_node_t* node, scf_dag_node_t** pp)
 		node2 = node;
 
 	v  = _scf_operand_get((scf_node_t*)node2);
-
 	dn = scf_dag_find_node(h, node2);
 
 	if (!dn) {
diff --git a/js/core/scf_operator_dag.c b/js/core/scf_operator_dag.c
index cac9df1..103592e 100644
--- a/js/core/scf_operator_dag.c
+++ b/js/core/scf_operator_dag.c
@@ -373,6 +373,7 @@ static int _scf_dag_op_##name(scf_list_t* h, scf_dag_node_t* parent, scf_dag_nod
 }
 
 SCF_OP_CMP(eq, ==, SCF_OP_EQ)
+SCF_OP_CMP(ne, ==, SCF_OP_NE)
 SCF_OP_CMP(gt, >, SCF_OP_GT)
 SCF_OP_CMP(lt, <, SCF_OP_LT)
 
@@ -406,6 +407,7 @@ scf_dag_operator_t	dag_operators[] =
 	{SCF_OP_BIT_OR,         SCF_OP_ASSOCIATIVITY_LEFT, _scf_dag_op_or},
 
 	{SCF_OP_EQ,             SCF_OP_ASSOCIATIVITY_LEFT, _scf_dag_op_eq},
+	{SCF_OP_NE,             SCF_OP_ASSOCIATIVITY_LEFT, _scf_dag_op_ne},
 	{SCF_OP_GT,             SCF_OP_ASSOCIATIVITY_LEFT, _scf_dag_op_gt},
 	{SCF_OP_LT,             SCF_OP_ASSOCIATIVITY_LEFT, _scf_dag_op_lt},
 
diff --git a/js/core/scf_optimizer.c b/js/core/scf_optimizer.c
index 9cc3516..bf449f5 100644
--- a/js/core/scf_optimizer.c
+++ b/js/core/scf_optimizer.c
@@ -2,6 +2,7 @@
 
 extern scf_optimizer_t   scf_optimizer_inline;
 extern scf_optimizer_t   scf_optimizer_js_array;
+extern scf_optimizer_t   scf_optimizer_js_teq;
 extern scf_optimizer_t   scf_optimizer_js_call;
 
 extern scf_optimizer_t   scf_optimizer_split_call;
@@ -36,6 +37,7 @@ static scf_optimizer_t*  scf_optimizers[] =
 {
 	&scf_optimizer_inline, // global optimizer
 	&scf_optimizer_js_array,
+	&scf_optimizer_js_teq,
 	&scf_optimizer_js_call,
 
 	&scf_optimizer_split_call,
diff --git a/js/core/scf_optimizer_auto_gc.c b/js/core/scf_optimizer_auto_gc.c
index bdc2a93..afd61f2 100644
--- a/js/core/scf_optimizer_auto_gc.c
+++ b/js/core/scf_optimizer_auto_gc.c
@@ -439,9 +439,9 @@ static int _auto_gc_last_free(scf_ast_t* ast, scf_function_t* f)
 		dn = ds->dag_node;
 		v  = dn->var;
 
-		scf_logw("%s(), last free: v_%d_%d/%s, ds->ret_flag: %u\n",
-				f->node.w->text->data, v->w->line, v->w->pos, v->w->text->data, ds->ret_flag);
-		scf_dn_status_print(ds);
+//		scf_logw("%s(), last free: v_%d_%d/%s, ds->ret_flag: %u\n",
+//				f->node.w->text->data, v->w->line, v->w->pos, v->w->text->data, ds->ret_flag);
+//		scf_dn_status_print(ds);
 
 		if (ds->ret_flag)
 			continue;
diff --git a/js/core/scf_optimizer_auto_gc_find.c b/js/core/scf_optimizer_auto_gc_find.c
index 2c5cf66..53dc6a7 100644
--- a/js/core/scf_optimizer_auto_gc_find.c
+++ b/js/core/scf_optimizer_auto_gc_find.c
@@ -808,7 +808,7 @@ static int _auto_gc_function_find(scf_ast_t* ast, scf_function_t* f, scf_list_t*
 	int count = 0;
 	int ret;
 
-	scf_logw("--- %s() ---\n", f->node.w->text->data);
+	scf_logd("--- %s() ---\n", f->node.w->text->data);
 
 	do {
 		for (l = scf_list_head(bb_list_head); l != scf_list_sentinel(bb_list_head); ) {
@@ -848,7 +848,7 @@ static int _auto_gc_function_find(scf_ast_t* ast, scf_function_t* f, scf_list_t*
 
 		if (!ds->ret_flag)
 			continue;
-#if 1
+#if 0
 		scf_logi("ds: %#lx, ds->ret_flag: %u, ds->ret_index: %d, ds->dag_node->var->arg_flag: %u\n",
 				0xffff & (uintptr_t)ds, ds->ret_flag, ds->ret_index, ds->dag_node->var->arg_flag);
 		scf_dn_status_print(ds);
@@ -864,7 +864,7 @@ static int _auto_gc_function_find(scf_ast_t* ast, scf_function_t* f, scf_list_t*
 			_bb_find_ds_alias_leak(ds, c, bb, bb_list_head);
 		}
 	}
-	scf_logi("--- %s() ---\n\n", f->node.w->text->data);
+	scf_logd("--- %s() ---\n\n", f->node.w->text->data);
 
 	return total;
 }
@@ -913,7 +913,7 @@ static int _optimize_auto_gc_find(scf_ast_t* ast, scf_function_t* f, scf_vector_
 			total1 += ret;
 		}
 
-		scf_logi("total0: %d, total1: %d\n", total0, total1);
+		scf_logd("total0: %d, total1: %d\n", total0, total1);
 
 	} while (total0 != total1);
 
diff --git a/js/core/scf_optimizer_inline.c b/js/core/scf_optimizer_inline.c
index f710578..6900ea9 100644
--- a/js/core/scf_optimizer_inline.c
+++ b/js/core/scf_optimizer_inline.c
@@ -453,8 +453,12 @@ static int _optimize_inline(scf_ast_t* ast, scf_function_t* f, scf_vector_t* fun
 
 	int i;
 	for (i = 0; i < functions->size; i++) {
+		f  =        functions->data[i];
 
-		int ret = _optimize_inline2(ast, functions->data[i]);
+		if (f->js_flag)
+			continue;
+
+		int ret = _optimize_inline2(ast, f);
 		if (ret < 0) {
 			scf_loge("\n");
 			return ret;
diff --git a/js/core/scf_optimizer_js_teq.c b/js/core/scf_optimizer_js_teq.c
new file mode 100644
index 0000000..2d64d15
--- /dev/null
+++ b/js/core/scf_optimizer_js_teq.c
@@ -0,0 +1,176 @@
+#include"scf_optimizer.h"
+#include"scf_pointer_alias.h"
+
+static int __js_teq(scf_ast_t* ast, scf_3ac_code_t** pc, scf_node_t* node)
+{
+	scf_3ac_code_t*  c;
+	scf_variable_t*  v;
+	scf_function_t*  f = NULL;
+	scf_type_t*      t = NULL;
+	scf_node_t*      pf;
+	scf_node_t*      fret;
+
+	int ret = scf_ast_find_global_function(&f, ast, "Object_teq");
+	if (ret < 0)
+		return ret;
+
+	ret = scf_ast_find_type_type(&t, ast, SCF_FUNCTION_PTR);
+	if (ret < 0)
+		return ret;
+
+	v = SCF_VAR_ALLOC_BY_TYPE(f->node.w, t, 1, 1, f);
+	if (!v)
+		return -ENOMEM;
+	v->const_literal_flag = 1;
+
+	pf = scf_node_alloc(NULL, v->type, v);
+	scf_variable_free(v);
+	v = NULL;
+	if (!pf)
+		return -ENOMEM;
+
+	ret = scf_ast_find_type_type(&t, ast, SCF_VAR_BOOL);
+	if (ret < 0)
+		return ret;
+
+	v = SCF_VAR_ALLOC_BY_TYPE(f->node.w, t, 0, 0, NULL);
+	if (!v)
+		return -ENOMEM;
+	v->tmp_flag = 1;
+
+	fret = scf_node_alloc(f->node.w, SCF_OP_CALL, NULL);
+	if (!fret) {
+		scf_variable_free(v);
+		scf_node_free(pf);
+		return -ENOMEM;
+	}
+	fret->op     = scf_find_base_operator_by_type(SCF_OP_CALL);
+	fret->result = v;
+	v = NULL;
+
+	scf_node_t* srcs[] = {pf, node};
+
+	c = scf_3ac_code_NN(SCF_OP_CALL, &fret, 1, srcs, 2);
+	if (!c) {
+		scf_node_free(pf);
+		scf_node_free(fret);
+		return -ENOMEM;
+	}
+
+	*pc = c;
+	return 0;
+}
+
+static int _optimize_js_teq_bb(scf_ast_t* ast, scf_function_t* f, scf_basic_block_t* bb, scf_list_t* bb_list_head)
+{
+	scf_3ac_operand_t* src;
+	scf_3ac_operand_t* dst;
+	scf_3ac_code_t*    c;
+	scf_3ac_code_t*    c2;
+	scf_variable_t*    v;
+	scf_node_t*        node;
+	scf_type_t*        Object = NULL;
+	scf_list_t*        l;
+
+	int ret = scf_ast_find_global_type(&Object, ast, "Object");
+	if (ret < 0)
+		return ret;
+
+	for (l = scf_list_head(&bb->code_list_head); l != scf_list_sentinel(&bb->code_list_head); ) {
+
+		c  = scf_list_data(l, scf_3ac_code_t, list);
+		l  = scf_list_next(l);
+
+		if (SCF_OP_3AC_TEQ == c->op->type) {
+			src  = c->srcs->data[0];
+			node = src->node;
+
+			while (SCF_OP_EXPR == node->type)
+				node = node->nodes[0];
+
+			v = _scf_operand_get(node);
+
+			if (v->type != Object->type)
+				continue;
+
+			if (SCF_OP_CALL == node->type) {
+				assert(node->nb_nodes > 0);
+
+				scf_variable_t* v2 = _scf_operand_get(node->nodes[0]);
+				scf_function_t* f2 = v2->func_ptr;
+
+				if (!strcmp(f2->node.w->text->data, "scf__auto_malloc"))
+					continue;
+				scf_logd("f2: %s()\n", f2->node.w->text->data);
+			}
+
+			c2  = NULL;
+			ret = __js_teq(ast, &c2, node);
+			if (ret < 0)
+				return ret;
+
+			c2->basic_block            = c->basic_block;
+			c2->basic_block->call_flag = 1;
+
+			scf_list_add_tail(&c->list, &c2->list);
+
+			assert(1 == c2->dsts->size);
+			dst = c2->dsts->data[0];
+
+			src->node = scf_node_clone(dst->node);
+			if (!src->node)
+				return -ENOMEM;
+			src->node->result = dst->node->result;
+			src->node->op     = dst->node->op;
+		}
+	}
+
+	return 0;
+}
+
+static int _optimize_js_teq(scf_ast_t* ast, scf_function_t* f, scf_vector_t* functions)
+{
+	if (!f)
+		return -EINVAL;
+
+	if (strcmp(f->node.w->text->data, "__js_main")) {
+		scf_string_t* s = f->node.w->file;
+
+		if (!strncmp(s->data + s->len - 8, "js/doc.c", 8))
+			return 0;
+	}
+
+	printf("\n");
+	scf_logi("------- %s() ------ file: %s\n", f->node.w->text->data, f->node.w->file->data);
+
+	scf_list_t*        bb_list_head = &f->basic_block_list_head;
+	scf_list_t*        l;
+	scf_basic_block_t* bb;
+
+	if (scf_list_empty(bb_list_head))
+		return 0;
+
+	for (l = scf_list_head(bb_list_head); l != scf_list_sentinel(bb_list_head); ) {
+
+		bb = scf_list_data(l, scf_basic_block_t, list);
+		l  = scf_list_next(l);
+
+		if (bb->cmp_flag) {
+
+			int ret = _optimize_js_teq_bb(ast, f, bb, bb_list_head);
+			if (ret < 0)
+				return ret;
+		}
+	}
+
+	return 0;
+}
+
+scf_optimizer_t  scf_optimizer_js_teq =
+{
+	.name     =  "js_teq",
+
+	.optimize =  _optimize_js_teq,
+
+	.flags    = SCF_OPTIMIZER_LOCAL,
+};
diff --git a/js/core/scf_optimizer_split_call.c b/js/core/scf_optimizer_split_call.c
index 0fc10ca..1b0a324 100644
--- a/js/core/scf_optimizer_split_call.c
+++ b/js/core/scf_optimizer_split_call.c
@@ -81,7 +81,7 @@ static int _optimize_split_call(scf_ast_t* ast, scf_function_t* f, scf_vector_t*
 		bb = scf_list_data(l, scf_basic_block_t, list);
 		l  = scf_list_next(l);
 
-		if (bb->jmp_flag || bb->end_flag || bb->cmp_flag)
+		if (bb->jmp_flag || bb->end_flag)
 			continue;
 
 		if (!bb->call_flag)
diff --git a/js/core/scf_variable.c b/js/core/scf_variable.c
index 3c2fde5..469e896 100644
--- a/js/core/scf_variable.c
+++ b/js/core/scf_variable.c
@@ -134,6 +134,9 @@ scf_variable_t*	scf_variable_alloc(scf_lex_word_t* w, scf_type_t* t)
 				case SCF_LEX_WORD_CONST_CHAR:
 					v->data.u32 = w->data.u32;
 					break;
+				case SCF_LEX_WORD_CONST_BOOL:
+					v->data.u32 = w->data.u32;
+					break;
 
 				case SCF_LEX_WORD_CONST_STRING:
 					v->data.s = scf_string_clone(w->data.s);
diff --git a/js/core/scf_variable.h b/js/core/scf_variable.h
index 96e695d..b6a57eb 100644
--- a/js/core/scf_variable.h
+++ b/js/core/scf_variable.h
@@ -78,6 +78,7 @@ struct scf_variable_s {
 	uint32_t            global_flag :1;
 	uint32_t            member_flag :1;
 
+	uint32_t            js_flag     :1;
 	uint32_t            vla_flag    :1;
 	uint32_t            arg_flag    :1;
 	uint32_t            auto_gc_flag:1;
diff --git a/js/doc.c b/js/doc.c
index f509019..fb4ce0c 100644
--- a/js/doc.c
+++ b/js/doc.c
@@ -549,6 +549,30 @@ void Object_func_arguments(Object* this, int i, Object* arg)
 	}
 }
 
+bool Object_teq(Object* this)
+{
+	if (!this)
+		return 0;
+
+	switch (this->type) {
+		case JS_Number:
+			return 0.0 != this->d;
+			break;
+
+		case JS_Boolean:
+			return 0 != this->i64;
+			break;
+
+		case JS_String:
+			return '\0' != this->str[0];
+			break;
+		default:
+			break;
+	};
+
+	return 0;
+}
+
 int Object_array_realloc(Object* this, int i)
 {
 	if (JS_Object != this->type)
diff --git a/js/parse/scf_dfa_var.c b/js/parse/scf_dfa_var.c
index b59b044..ae9e017 100644
--- a/js/parse/scf_dfa_var.c
+++ b/js/parse/scf_dfa_var.c
@@ -68,6 +68,7 @@ static int _var_add_var(scf_dfa_t* dfa, dfa_data_t* d)
 		uint32_t global_flag;
 		uint32_t local_flag;
 		uint32_t member_flag;
+		uint32_t js_flag = 0;
 
 		if (!b) {
 			local_flag  = 0;
@@ -125,6 +126,8 @@ static int _var_add_var(scf_dfa_t* dfa, dfa_data_t* d)
 
 			if (scf_ast_find_type(&id0->type, parse->ast, "Object") < 0)
 				return SCF_DFA_ERROR;
+
+			js_flag = 1;
 		}
 
 		v = SCF_VAR_ALLOC_BY_TYPE(id->identity, id0->type, id0->const_flag, id0->nb_pointers, id0->func_ptr);
@@ -135,6 +138,7 @@ static int _var_add_var(scf_dfa_t* dfa, dfa_data_t* d)
 		v->local_flag  = local_flag;
 		v->global_flag = global_flag;
 		v->member_flag = member_flag;
+		v->js_flag     = js_flag;
 
 		v->static_flag = id0->static_flag;
 		v->extern_flag = id0->extern_flag;
diff --git a/js/parse/scf_parse.c b/js/parse/scf_parse.c
index bad9719..95efe61 100644
--- a/js/parse/scf_parse.c
+++ b/js/parse/scf_parse.c
@@ -1863,10 +1863,6 @@ int scf_parse_compile_functions(scf_parse_t* parse, scf_vector_t* functions)
 	for (i = 0; i < functions->size; i++) {
 		f  =        functions->data[i];
 
-		printf("%d, %p\n", i, f->node.w->text);
-		printf("argv: %p, define_flag: %d, inline_flag: %d\n",
-				f->argv, f->node.define_flag, f->inline_flag);
-
 		printf("%d, %s(), argv->size: %d, define_flag: %d, inline_flag: %d\n",
 				i, f->node.w->text->data, f->argv->size, f->node.define_flag, f->inline_flag);
 
diff --git a/ui/Makefile b/ui/Makefile
index 902c10f..229ff1d 100644
--- a/ui/Makefile
+++ b/ui/Makefile
@@ -158,6 +158,7 @@ CFILES += ../js/core/scf_optimizer.c
 CFILES += ../js/core/scf_optimizer_dag.c
 CFILES += ../js/core/scf_optimizer_inline.c
 CFILES += ../js/core/scf_optimizer_js_array.c
+CFILES += ../js/core/scf_optimizer_js_teq.c
 CFILES += ../js/core/scf_optimizer_js_call.c
 CFILES += ../js/core/scf_optimizer_split_call.c
 CFILES += ../js/core/scf_optimizer_call.c
-- 
2.25.1