修改优化代码

Optimizer/Optimizer.py

@@ -1,95 +1,198 @@
-from block import *
+#  优化模块
+# 第一步: 常量传播
+def constant_propagation(quads):
+    #print("Running Constant Propagation")
+    value_map = {}
+    optimized = []
 
-def tp(sth):
+    for quad in quads:
-    if sth ==None:
+        op, arg1, arg2, dest = quad
-        return -1
+
-    if sth[0] >='0' and sth[0] <='9':
+        if op == '=' and arg1.isdigit():
-        return 2
+            # 常量赋值：如 (=, 32, _, _v0)
-    if sth[0] != '_':
+            value_map[dest] = arg1
-        return 0
+        elif op == '=':
-    return 1
+            # 变量赋值：如 (=, _v0, _, age)
-class DAGNode:
+            if arg1 in value_map:
-    cnt = 1
+                new_quad = ('=', value_map[arg1], '_', dest)
-    def __init__(self,tag=None,l=None,r=None,op=None):
+                optimized.append(new_quad)
-        self.cnt = DAGNode.cnt
+                value_map[dest] = value_map[arg1]
-        DAGNode.cnt += 1
+            else:
-        self.parents = []
+                optimized.append(quad)
-        self.lc = l
+                # 如果 dest 不再被使用，可以考虑删除该赋值
-        self.rc = r
+        else:
-        self.op = op
+            # 替换操作数中的变量为已知常量
-        self.main_tag = tag
+            new_arg1 = value_map.get(arg1, arg1)
-        self.other_tag = set()
+            new_arg2 = value_map.get(arg2, arg2) if arg2 != '_' else '_'
-        if tag is not None:
+            optimized.append((op, new_arg1, new_arg2, dest))
-            self.other_tag.add(tag)
+
-    def insert(self,tag):
+    return optimized
-        self.other_tag.add(tag)
+
-        if tp(tag) > tp(self.main_tag):
+# 第二步: 公共子表达式消除
-            self.main_tag = tag
+def common_subexpression_elimination(quads):
-    def has(self,tag):
+    #print("Running Common Subexpression Elimination")
-        return tag in self.other_tag
+    expr_map = {}
-class Optimizer:
+    optimized = []
-    def __init__(self):
+    temp_counter = 0
-        self.nodes = [""]
+
-        self.cnt = 0
+    for quad in quads:
-        self.ans= []
+        op, arg1, arg2, dest = quad
-    def cfind(self,tag):
+
-        for i in range(1,self.cnt+1)[::-1]:
+        if op in ['+', '-', '*', '/']:
-            if self.nodes[i].has(tag):
+            expr_key = f"{arg1} {op} {arg2}"
-                return self.nodes[i]
+            if expr_key in expr_map:
-        self.cnt += 1
+                # 复用已有结果
-        self.nodes.append(DAGNode(tag=tag))
+                reused_var = expr_map[expr_key]
-        return self.nodes[self.cnt]
+                optimized.append(('=', reused_var, '_', dest))
-    def cfind_op1(self,op,lc,rc):
+            else:
-        for i in range(1,self.cnt+1)[::-1]:
+                # 新表达式
-            if self.nodes[i].op==op and ((self.nodes[i].lc == lc and self.nodes[i].rc == rc) or (self.nodes[i].lc == rc and self.nodes[i].rc == lc)):
+                temp_var = f"_t{temp_counter}"
-                return self.nodes[i]
+                temp_counter += 1
-        self.cnt +=1
+                expr_map[expr_key] = temp_var
-        self.nodes.append(DAGNode(op=op,l=lc,r=rc))
+                optimized.append((op, arg1, arg2, temp_var))
-        return  self.nodes[self.cnt]
+                optimized.append(('=', temp_var, '_', dest))
-    def cfind_op2(self,op,lc,rc):
+        else:
-        for i in range(1, self.cnt + 1)[::-1]:
+            optimized.append(quad)
-            if self.nodes[i].op == op and self.nodes[i].lc == lc and self.nodes[i].rc == rc:
+
-                return self.nodes[i]
+    return optimized
-        self.cnt += 1
+
-        self.nodes.append(DAGNode(op=op, l=lc, r=rc))
+# 第三步: 死代码消除
-        return self.nodes[self.cnt]
+def dead_code_elimination(quads):
-    def build(self,lst):
+    #print("Running Dead Code Elimination")
-        self.ans = []
+    used_vars = set()
-        for _ in lst:
+    optimized = []
-            op,a,b,res = _.a,_.b,_.c,_.d
+
-            if op =='=':
+    # 第一遍找出所有被使用的变量
-                # 将ans插入到a的节点中
+    for quad in quads:
-                self.cfind(a).insert(res)
+        op, arg1, arg2, dest = quad
-            elif op =='+' or op=='*' or op=='&' or op=='^' or op =='|' or op =='&&' or op =='||' or op =='==' or op == '!=':
+        if arg1 != '_' and not arg1.isdigit():
-                # 首先找一下有没有a b节点 , 没有就自己造一个
+            used_vars.add(arg1)
-                aNode = self.cfind(a)
+        if arg2 != '_' and not arg2.isdigit():
-                bNode = self.cfind(b)
+            used_vars.add(arg2)
-                # 然后找一下有没有a op b 的节点 , 有的话插进去
+
-                # 这里并不能根据a ,b 来查找 , 因为昔人已乘黄鹤去 ,  你找到的或许只是曾经的ab
+    # 第二遍删除未使用变量的赋值语句
-                self.cfind_op1(op,aNode,bNode).insert(res)
+    for quad in quads:
-            elif op =='-' or op=='%' or op=='/':
+        op, arg1, arg2, dest = quad
-                # 这种不换的元素符
+        if op == '=' and dest.startswith('_v') and dest not in used_vars:
-                self.cfind_op2(op,self.cfind(a),self.cfind(b)).insert(ans)
+            continue  # 跳过无用的赋值语句
-                pass
+        optimized.append(quad)
-            # 剩下就是while end , if end , el等 , 不用管
+
-        for i in range(1,self.cnt+1)[::-1]:
+    return optimized
-            _ = self.nodes[i]
-            op = _.op
-            if op is not None:
-                self.ans.append(FourTuple(op,_.lc.main_tag,_.rc.main_tag,_.main_tag))
-                for __ in _.other_tag:
-                    if __ != _.main_tag:
-                        self.ans.append(FourTuple('=',_.main_tag,c='_',d=__))
-        self.ans = self.ans[::-1]
 
 
-if __name__ == '__main__':
+
-    divider = BlockDivider(l)
+# 第四步: 控制流优化
-    optimizer = Optimizer()
+def control_flow_simplification(quads):
-    ls = divider.run()
+    # print("Running Control Flow Simplification")
-    for l in ls:
+    optimized = []
-        optimizer.build(l)
+
-        for i in optimizer.ans:
+    for quad in quads:
-            print(i)
+        op, arg1, arg2, dest = quad
-        # print()
+        if op == 'if' and arg2 == 'goto':
+            if arg1.isdigit():
+                if arg1 == '1':
+                    optimized.append(('goto', '_', '_', dest))
+                elif arg1 == '0':
+                    continue  # 恒假，跳过该条件跳转
+            else:
+                optimized.append(quad)
+        else:
+            optimized.append(quad)
+
+    return optimized
+
+# 第五步: 寄存器重用
+def register_reuse(quads):
+    #print("Running Register Reuse (Improved)")
+    
+    # 计算活跃变量信息
+    live_info = compute_live_vars(quads)
+    
+    optimized = []
+    available_temps = []  # 可用于复用的临时变量池
+
+    for i, quad in enumerate(quads):
+        op, arg1, arg2, dest = quad
+        current_live = live_info[i]
+
+        if op == '=':
+            # 查看当前 dest 是否会被后续使用
+            is_dest_used_later = dest in current_live
+
+            # 如果 dest 不再使用，可以加入可用池
+            if not is_dest_used_later and dest.startswith('_'):
+                available_temps.append(dest)
+
+            # 尝试复用已死的临时变量
+            reused = False
+            for var in list(available_temps):
+                if var not in [arg1, arg2] and var not in current_live:
+                    # 安全复用
+                    optimized.append(('=', arg1, arg2, var))
+                    available_temps.remove(var)
+                    if var != dest:
+                        available_temps.append(dest)  # 原 dest 现在可回收
+                    reused = True
+                    break
+
+            if not reused:
+                optimized.append(quad)
+                if dest.startswith('_') and dest not in current_live:
+                    available_temps.append(dest)
+        else:
+            optimized.append(quad)
+
+    return optimized
+
+def compute_live_vars(quads):
+    """
+    活跃变量分析：从后往前推导每个 quad 之后仍会使用的变量
+    """
+    live_vars = set()
+    live_info = []
+
+    for quad in reversed(quads):
+        op, arg1, arg2, dest = quad
+
+        # 先移除 dest 的影响（因为 dest 被重新定义）
+        if dest in live_vars:
+            live_vars.remove(dest)
+
+        # 如果操作数是变量，则加入活跃集合
+        if arg1 != '_' and not arg1.isdigit():
+            live_vars.add(arg1)
+        if arg2 != '_' and not arg2.isdigit():
+            live_vars.add(arg2)
+
+        # 把当前活跃变量集合复制一份保存下来
+        live_info.append(live_vars.copy())
+
+    # 从后往前遍历，所以需要反转结果
+    live_info.reverse()
+    return live_info
+
+
+# 优化器整合
+def optimize(quads):
+    passes = [
+        ("Constant Propagation", constant_propagation),
+        ("Common Subexpression Elimination", common_subexpression_elimination),
+        ("Dead Code Elimination", dead_code_elimination),
+        ("Control Flow Simplification", control_flow_simplification),
+        ("Register Reuse", register_reuse),
+    ]
+
+    for name, opt_func in passes:
+        # print(f"Running optimization pass: {name}")
+        quads = opt_func(quads)
+
+    return quads
+
+def output_ir_str(quads):
+    lines = []
+    for i, quad in enumerate(quads):
+        op, arg1, arg2, dest = quad
+        quad = f"({op}, {arg1}, {arg2}, {dest})"
+        lines.append(f"{i}  {quad}")
+    return "\n".join(lines)
 

Optimizer/block.py

@@ -1,52 +0,0 @@
-l = [
-    "=,10,_,t1",
-    "=,20,_,t1",
-    "+,t1,t1,t2"
-]
-class FourTuple:
-    cnt =0
-    def __init__(self, a='_',b='_',c='_',d='_'):
-        self.a = a
-        self.b = b
-        self.c = c
-        self.d = d
-        self.cnt = FourTuple.cnt
-        FourTuple.cnt += 1
-        self.block_sign = set(['if','jmp','jmpf','el','ifend','while','fun','return','while','we','goto'])
-
-
-    def is_block_sign(self):
-        return self.a in self.block_sign
-    def __str__(self):
-        return f"({self.a} , {self.b} , {self.c} , {self.d})"
-class BlockDivider:
-    def __init__(self,lst):
-        self.ans = []
-        self.l =[]
-        for i in lst:
-            k = i.split(',')
-            obj = FourTuple(k[0].strip(),k[1].strip(),k[2].strip(),k[3].strip())
-            self.l.append(obj)
-            # print(obj)
-    def run(self):
-        lst = []
-        for i in self.l:
-            lst.append(i)
-            if i.is_block_sign():
-                self.ans.append(lst)
-                lst = []
-        if lst:
-            self.ans.append(lst)
-
-        return self.ans
-
-
-
-if __name__ == '__main__':
-
-    divider = BlockDivider(l)
-    ans = divider.run()
-    for i in ans:
-        for j in i:
-            print(j,end='\t')
-        print()

test0.hy

@@ -0,0 +1,3 @@
+fn main() {
+    
+}

test4.hy

@@ -1,7 +1,7 @@
 // test4：嵌套 if 判断（复杂控制流）
 
 fn max(x: i32, y: i32) -> i32 {
-    if x > y {
+    if x >= y {
         return x;
     } else {
         return y;

test8.hy

@@ -0,0 +1,4 @@
+fn main( :i32)
+{
+	a = 34 * 3;
+}

tk_ui.py

@@ -4,6 +4,7 @@ from lexical.lexical import Lexical
 from syntax.syntax import Syntax
 from semantic.rule import symbol_table_pool
 from syntax.syntax import LL1Generator
+from Optimizer.optimizer import optimize, output_ir_str
 
 def process_code(input_code):
     lexical = Lexical()
@@ -30,6 +31,14 @@ def process_code(input_code):
             for code in syntax.get_result().root.code:
                 i += 1
                 output.append(f"{i}  \t{code}")
+
+            quads = [tuple(map(str.strip, str(item).strip("()").split(","))) for item in syntax.get_result().root.code]
+
+            optimized_quads = optimize(quads)
+        
+            output.append('\n')
+            output.append(f"优化后的四元式:\t")
+            output.append(output_ir_str(optimized_quads))
             return '\n'.join(output), ''
         else:
             return '\n'.join(output), '错误原因:\t' + syntax.get_error().info
@@ -56,12 +65,27 @@ root.title("Hydrogen语言编译器前端演示")
 input_text = scrolledtext.ScrolledText(root, width=80, height=20)
 input_text.pack(padx=10, pady=5)
 
-# 提交按钮
+# 提交按钮和清空按钮在同一行
+button_frame = tk.Frame(root)
+def on_generate_ll1_table():
+    try:
+        obj = LL1Generator()
+        obj.compile()
+        obj.show_me_what_you_got("LL1_table.csv")
+        messagebox.showinfo("提示", "成功生成预测表")
+    except Exception as e:
+        messagebox.showerror("生成预测表异常", str(e))
+
+submit_btn = tk.Button(button_frame, text="生成产生式的预测表", command=on_generate_ll1_table)
+
+submit_btn.pack(side=tk.LEFT, padx=5)
+
+button_frame.pack(pady=5)
 submit_btn = tk.Button(root, text="提交", command=on_submit)
 submit_btn.pack(pady=5)
 
 # 输出框
-output_text = scrolledtext.ScrolledText(root, width=80, height=20, bg="#ffffff")
+output_text = scrolledtext.ScrolledText(root, width=80, height=20, bg="#000000")
 output_text.pack(padx=10, pady=5)
 
 # 错误信息框