Merge branch 'backend' into deploy-20250820-3

script/runit.sh

@@ -29,10 +29,12 @@ EXEC_TIMEOUT=30
 MAX_OUTPUT_LINES=20
 MAX_OUTPUT_CHARS=1000
 TEST_SETS=()
+PERF_RUN_COUNT=1 # 新增: 性能测试运行次数
 TOTAL_CASES=0
 PASSED_CASES=0
 FAILED_CASES_LIST=""
 INTERRUPTED=false
+PERFORMANCE_MODE=false # 新增: 标记是否进行性能测试
 
 # =================================================================
 # --- 函数定义 ---
@@ -49,6 +51,8 @@ show_help() {
     echo "  -c, --clean              清理 'tmp' 目录下的所有生成文件。"
     echo "  -O1                      启用 sysyc 的 -O1 优化。"
     echo "  -set [f|h|p|all]...    指定要运行的测试集 (functional, h_functional, performance)。可多选，默认为 all。"
+    echo "                           当包含 'p' 时，会自动记录性能数据到 ${TMP_DIR}/performance_time.csv。"
+    echo "  -pt N                    设置 performance 测试集的每个用例运行 N 次取平均值 (默认: 1)。"
     echo "  -sct N                   设置 sysyc 编译超时为 N 秒 (默认: 30)。"
     echo "  -lct N                   设置 llc-19 编译超时为 N 秒 (默认: 10)。"
     echo "  -gct N                   设置 gcc 交叉编译超时为 N 秒 (默认: 10)。"
@@ -104,7 +108,6 @@ print_summary() {
 
     local failed_count
     if [ -n "$FAILED_CASES_LIST" ]; then
-        # `wc -l` 计算由换行符分隔的列表项数
         failed_count=$(echo -e -n "${FAILED_CASES_LIST}" | wc -l)
     else
         failed_count=0
@@ -116,10 +119,27 @@ print_summary() {
     if [ -n "$FAILED_CASES_LIST" ]; then
         echo ""
         echo -e "\e[31m未通过的测例:\e[0m"
-        # 使用 printf 保证原样输出
         printf "%b" "${FAILED_CASES_LIST}"
     fi
 
+    # --- 本次修改点: 提示性能测试结果文件 ---
+    if ${PERFORMANCE_MODE}; then
+        # --- 本次修改点: 计算并添加总计行 ---
+        if [ -f "${PERFORMANCE_CSV_FILE}" ] && [ $(wc -l < "${PERFORMANCE_CSV_FILE}") -gt 1 ]; then
+            local total_seconds_sum
+            total_seconds_sum=$(awk -F, 'NR > 1 {sum += $3} END {printf "%.5f", sum}' "${PERFORMANCE_CSV_FILE}")
+            
+            local total_s_int=${total_seconds_sum%.*}
+            [[ -z "$total_s_int" ]] && total_s_int=0 # 处理小于1秒的情况
+            local total_us_int=$(echo "(${total_seconds_sum} - ${total_s_int}) * 1000000" | bc | cut -d. -f1)
+            local total_time_str="${total_s_int}s${total_us_int}us"
+            
+            echo "all,${total_time_str},${total_seconds_sum}" >> "${PERFORMANCE_CSV_FILE}"
+        fi
+        echo ""
+        echo -e "\e[32m性能测试数据已保存到: ${PERFORMANCE_CSV_FILE}\e[0m"
+    fi
+
     echo "========================================"
 
     if [ "$failed_count" -gt 0 ]; then
@@ -139,12 +159,9 @@ handle_sigint() {
 # --- 主逻辑开始 ---
 # =================================================================
 
-# --- 新增：设置 trap 来捕获 SIGINT ---
 trap handle_sigint SIGINT
-
 mkdir -p "${TMP_DIR}"
 
-# 解析命令行参数
 while [[ "$#" -gt 0 ]]; do
     case "$1" in
         -e|--executable) EXECUTE_MODE=true; shift ;;
@@ -155,6 +172,7 @@ while [[ "$#" -gt 0 ]]; do
             shift
             while [[ "$#" -gt 0 && ! "$1" =~ ^- ]]; do TEST_SETS+=("$1"); shift; done
             ;;
+        -pt) if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then PERF_RUN_COUNT="$2"; shift 2; else echo "错误: -pt 需要一个正整数参数。" >&2; exit 1; fi ;;
         -sct) if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then SYSYC_TIMEOUT="$2"; shift 2; else echo "错误: -sct 需要一个正整数参数。" >&2; exit 1; fi ;;
         -lct) if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then LLC_TIMEOUT="$2"; shift 2; else echo "错误: -lct 需要一个正整数参数。" >&2; exit 1; fi ;;
         -gct) if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then GCC_TIMEOUT="$2"; shift 2; else echo "错误: -gct 需要一个正整数参数。" >&2; exit 1; fi ;;
@@ -179,10 +197,14 @@ SET_MAP[p]="performance"
 SEARCH_PATHS=()
 if [ ${#TEST_SETS[@]} -eq 0 ] || [[ " ${TEST_SETS[@]} " =~ " all " ]]; then
     SEARCH_PATHS+=("${TESTDATA_DIR}")
+    if [ -d "${TESTDATA_DIR}/performance" ]; then PERFORMANCE_MODE=true; fi
 else
     for set in "${TEST_SETS[@]}"; do
         if [[ -v SET_MAP[$set] ]]; then
             SEARCH_PATHS+=("${TESTDATA_DIR}/${SET_MAP[$set]}")
+            if [[ "$set" == "p" ]]; then
+                PERFORMANCE_MODE=true
+            fi
         else
             echo -e "\e[33m警告: 未知的测试集 '$set'，已忽略。\e[0m"
         fi
@@ -212,6 +234,9 @@ else
 fi
 echo "运行模式: ${RUN_MODE_INFO}"
 echo "${TIMEOUT_INFO}"
+if ${PERFORMANCE_MODE} && ([ ${EXECUTE_MODE} = true ] || [ ${IR_EXECUTE_MODE} = true ]) && [ ${PERF_RUN_COUNT} -gt 1 ]; then
+    echo "性能测试运行次数: ${PERF_RUN_COUNT}"
+fi
 if ${EXECUTE_MODE} || ${IR_EXECUTE_MODE}; then
     echo "失败输出最大行数: ${MAX_OUTPUT_LINES}"
     echo "失败输出最大字符数: ${MAX_OUTPUT_CHARS}"
@@ -225,6 +250,11 @@ if [ -z "$sy_files" ]; then
 fi
 TOTAL_CASES=$(echo "$sy_files" | wc -w)
 
+PERFORMANCE_CSV_FILE="${TMP_DIR}/performance_time.csv"
+if ${PERFORMANCE_MODE}; then
+    echo "Case,Time_String,Time_Seconds" > "${PERFORMANCE_CSV_FILE}"
+fi
+
 while IFS= read -r sy_file; do
     is_passed=0 # 0 表示失败, 1 表示通过
 
@@ -234,11 +264,13 @@ while IFS= read -r sy_file; do
     assembly_file_S="${TMP_DIR}/${output_base_name}_sysyc_S.s"
     executable_file_S="${TMP_DIR}/${output_base_name}_sysyc_S"
     output_actual_file_S="${TMP_DIR}/${output_base_name}_sysyc_S.actual_out"
+    stderr_file_S="${TMP_DIR}/${output_base_name}_sysyc_S.stderr"
 
     ir_file="${TMP_DIR}/${output_base_name}_sysyc_ir.ll"
     assembly_file_from_ir="${TMP_DIR}/${output_base_name}_from_ir.s"
     executable_file_from_ir="${TMP_DIR}/${output_base_name}_from_ir"
     output_actual_file_from_ir="${TMP_DIR}/${output_base_name}_from_ir.actual_out"
+    stderr_file_from_ir="${TMP_DIR}/${output_base_name}_from_ir.stderr"
 
     input_file="${sy_file%.*}.in"
     output_reference_file="${sy_file%.*}.out"
@@ -249,165 +281,170 @@ while IFS= read -r sy_file; do
     if ${IR_EXECUTE_MODE}; then
         step_failed=0
         test_logic_passed=0
+        total_time_us=0
         
         echo "  [1/4] 使用 sysyc 编译为 IR (超时 ${SYSYC_TIMEOUT}s)..."
-        timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s ir "${sy_file}" -o "${ir_file}" ${OPTIMIZE_FLAG}
-        SYSYC_STATUS=$?
-        if [ $SYSYC_STATUS -ne 0 ]; then
-            [ $SYSYC_STATUS -eq 124 ] && echo -e "\e[31m错误: SysY (IR) 编译超时\e[0m" || echo -e "\e[31m错误: SysY (IR) 编译失败，退出码: ${SYSYC_STATUS}\e[0m"
-            step_failed=1
-        fi
+        timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s ir "${sy_file}" -o "${ir_file}" ${OPTIMIZE_FLAG}; if [ $? -ne 0 ]; then echo -e "\e[31m错误: SysY (IR) 编译失败或超时\e[0m"; step_failed=1; fi
 
         if [ "$step_failed" -eq 0 ]; then
             echo "  [2/4] 使用 llc-19 编译为汇编 (超时 ${LLC_TIMEOUT}s)..."
-            timeout -s KILL ${LLC_TIMEOUT} "${LLC_CMD}" -march=riscv64 -mcpu=generic-rv64 -mattr=+m,+a,+f,+d,+c -filetype=asm "${ir_file}" -o "${assembly_file_from_ir}"
-            LLC_STATUS=$?
-            if [ $LLC_STATUS -ne 0 ]; then
-                [ $LLC_STATUS -eq 124 ] && echo -e "\e[31m错误: llc-19 编译超时\e[0m" || echo -e "\e[31m错误: llc-19 编译失败，退出码: ${LLC_STATUS}\e[0m"
-                step_failed=1
-            fi
+            timeout -s KILL ${LLC_TIMEOUT} ${LLC_CMD} -march=riscv64 -mcpu=generic-rv64 -mattr=+m,+a,+f,+d,+c -filetype=asm "${ir_file}" -o "${assembly_file_from_ir}"; if [ $? -ne 0 ]; then echo -e "\e[31m错误: llc-19 编译失败或超时\e[0m"; step_failed=1; fi
         fi
 
         if [ "$step_failed" -eq 0 ]; then
             echo "  [3/4] 使用 gcc 编译 (超时 ${GCC_TIMEOUT}s)..."
-            timeout -s KILL ${GCC_TIMEOUT} "${GCC_RISCV64}" "${assembly_file_from_ir}" -o "${executable_file_from_ir}" -L"${LIB_DIR}" -lsysy_riscv -static
-            GCC_STATUS=$?
-            if [ $GCC_STATUS -ne 0 ]; then
-                [ $GCC_STATUS -eq 124 ] && echo -e "\e[31m错误: GCC 编译超时\e[0m" || echo -e "\e[31m错误: GCC 编译失败，退出码: ${GCC_STATUS}\e[0m"
-                step_failed=1
-            fi
+            timeout -s KILL ${GCC_TIMEOUT} "${GCC_RISCV64}" "${assembly_file_from_ir}" -o "${executable_file_from_ir}" -L"${LIB_DIR}" -lsysy_riscv -static; if [ $? -ne 0 ]; then echo -e "\e[31m错误: GCC 编译失败或超时\e[0m"; step_failed=1; fi
         fi
 
         if [ "$step_failed" -eq 0 ]; then
             echo "  [4/4] 正在执行 (超时 ${EXEC_TIMEOUT}s)..."
-            exec_cmd="${QEMU_RISCV64} \"${executable_file_from_ir}\""
-            [ -f "${input_file}" ] && exec_cmd+=" < \"${input_file}\""
-            exec_cmd+=" > \"${output_actual_file_from_ir}\""
+            current_run_failed=0
+            for (( i=1; i<=PERF_RUN_COUNT; i++ )); do
+                if [ ${PERF_RUN_COUNT} -gt 1 ]; then echo -n "    第 $i/${PERF_RUN_COUNT} 次运行... "; fi
+                exec_cmd="${QEMU_RISCV64} \"${executable_file_from_ir}\""
+                [ -f "${input_file}" ] && exec_cmd+=" < \"${input_file}\""
+                exec_cmd+=" > \"${output_actual_file_from_ir}\" 2> \"${stderr_file_from_ir}\""
+                eval "timeout -s KILL ${EXEC_TIMEOUT} ${exec_cmd}"
+                ACTUAL_RETURN_CODE=$?
                 
-            eval "timeout -s KILL ${EXEC_TIMEOUT} ${exec_cmd}"
-            ACTUAL_RETURN_CODE=$?
+                if [ "$ACTUAL_RETURN_CODE" -eq 124 ]; then echo -e "\e[31m超时\e[0m"; current_run_failed=1; break; fi
+                if ${PERFORMANCE_MODE}; then
+                    TIME_LINE=$(grep "TOTAL:" "${stderr_file_from_ir}")
+                    if [ -n "$TIME_LINE" ]; then
+                        H=$(echo "$TIME_LINE" | sed -E 's/TOTAL: ([0-9]+)H-.*/\1/')
+                        M=$(echo "$TIME_LINE" | sed -E 's/.*-([0-9]+)M-.*/\1/')
+                        S=$(echo "$TIME_LINE" | sed -E 's/.*-([0-9]+)S-.*/\1/')
+                        US=$(echo "$TIME_LINE" | sed -E 's/.*-([0-9]+)us/\1/')
+                        run_time_us=$(( H * 3600000000 + M * 60000000 + S * 1000000 + US ))
+                        total_time_us=$(( total_time_us + run_time_us ))
+                        if [ ${PERF_RUN_COUNT} -gt 1 ]; then echo "耗时: ${run_time_us}us"; fi
+                    else
+                        echo -e "\e[31m未找到时间信息\e[0m"; current_run_failed=1; break
+                    fi
+                fi
+            done
             
-            if [ "$ACTUAL_RETURN_CODE" -eq 124 ]; then
-                echo -e "\e[31m  执行超时: 运行超过 ${EXEC_TIMEOUT} 秒\e[0m"
-            else
+            if [ "$current_run_failed" -eq 0 ]; then
+                test_logic_passed=1
                 if [ -f "${output_reference_file}" ]; then
                     LAST_LINE_TRIMMED=$(tail -n 1 "${output_reference_file}" | tr -d '[:space:]')
-                    test_logic_passed=1
                     if [[ "$LAST_LINE_TRIMMED" =~ ^[-+]?[0-9]+$ ]]; then
                         EXPECTED_RETURN_CODE="$LAST_LINE_TRIMMED"
                         EXPECTED_STDOUT_FILE="${TMP_DIR}/${output_base_name}_from_ir.expected_stdout"
                         head -n -1 "${output_reference_file}" > "${EXPECTED_STDOUT_FILE}"
-                        
-                        if [ "$ACTUAL_RETURN_CODE" -eq "$EXPECTED_RETURN_CODE" ]; then
-                            echo -e "\e[32m  返回码测试成功: (${ACTUAL_RETURN_CODE}) 与期望值 (${EXPECTED_RETURN_CODE}) 匹配\e[0m"
-                        else
-                            echo -e "\e[31m  返回码测试失败: 期望: ${EXPECTED_RETURN_CODE}, 实际: ${ACTUAL_RETURN_CODE}\e[0m"
-                            test_logic_passed=0
-                        fi
-
-                        if diff -q <(tr -d '[:space:]' < "${output_actual_file_from_ir}") <(tr -d '[:space:]' < "${EXPECTED_STDOUT_FILE}") >/dev/null 2>&1; then
-                             [ "$test_logic_passed" -eq 1 ] && echo -e "\e[32m  标准输出测试成功\e[0m"
-                        else
-                            echo -e "\e[31m  标准输出测试失败\e[0m"
-                            display_file_content "${EXPECTED_STDOUT_FILE}" "    \e[36m---------- 期望输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" "${MAX_OUTPUT_CHARS}"
-                            display_file_content "${output_actual_file_from_ir}" "    \e[36m---------- 实际输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" "${MAX_OUTPUT_CHARS}"
-                            test_logic_passed=0
+                        if [ "$ACTUAL_RETURN_CODE" -ne "$EXPECTED_RETURN_CODE" ]; then echo -e "\e[31m  返回码测试失败: 期望 ${EXPECTED_RETURN_CODE}, 实际 ${ACTUAL_RETURN_CODE}\e[0m"; test_logic_passed=0; fi
+                        if ! diff -q <(tr -d '[:space:]' < "${output_actual_file_from_ir}") <(tr -d '[:space:]' < "${EXPECTED_STDOUT_FILE}") >/dev/null 2>&1; then
+                            echo -e "\e[31m  标准输出测试失败\e[0m"; test_logic_passed=0
+                            display_file_content "${EXPECTED_STDOUT_FILE}" "    \e[36m--- 期望输出 ---\e[0m" "${MAX_OUTPUT_LINES}" "${MAX_OUTPUT_CHARS}"
+                            display_file_content "${output_actual_file_from_ir}" "    \e[36m--- 实际输出 ---\e[0m" "${MAX_OUTPUT_LINES}" "${MAX_OUTPUT_CHARS}"
                         fi
                     else
                         if [ $ACTUAL_RETURN_CODE -ne 0 ]; then echo -e "\e[33m警告: 程序以非零状态 ${ACTUAL_RETURN_CODE} 退出 (纯输出比较模式)。\e[0m"; fi
-                        if diff -q <(tr -d '[:space:]' < "${output_actual_file_from_ir}") <(tr -d '[:space:]' < "${output_reference_file}") >/dev/null 2>&1; then
-                            echo -e "\e[32m  成功: 输出与参考输出匹配\e[0m"
-                        else
-                            echo -e "\e[31m  失败: 输出不匹配\e[0m"
-                            display_file_content "${output_reference_file}" "    \e[36m---------- 期望输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" "${MAX_OUTPUT_CHARS}"
-                            display_file_content "${output_actual_file_from_ir}" "    \e[36m---------- 实际输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" "${MAX_OUTPUT_CHARS}"
-                            test_logic_passed=0
+                        if ! diff -q <(tr -d '[:space:]' < "${output_actual_file_from_ir}") <(tr -d '[:space:]' < "${output_reference_file}") >/dev/null 2>&1; then
+                            echo -e "\e[31m  失败: 输出不匹配\e[0m"; test_logic_passed=0
+                            display_file_content "${output_reference_file}" "    \e[36m--- 期望输出 ---\e[0m" "${MAX_OUTPUT_LINES}" "${MAX_OUTPUT_CHARS}"
+                            display_file_content "${output_actual_file_from_ir}" "    \e[36m--- 实际输出 ---\e[0m" "${MAX_OUTPUT_LINES}" "${MAX_OUTPUT_CHARS}"
                         fi
                     fi
-                else
-                    echo "  无参考输出文件。程序返回码: ${ACTUAL_RETURN_CODE}"
-                    test_logic_passed=1 
                 fi
+                if [ "$test_logic_passed" -eq 1 ]; then echo -e "\e[32m  测试逻辑通过\e[0m"; fi
             fi
         fi
-        [ "$step_failed" -eq 0 ] && [ "$test_logic_passed" -eq 1 ] && is_passed=1
+        if [ "$step_failed" -eq 0 ] && [ "$test_logic_passed" -eq 1 ]; then is_passed=1; fi
+        
+        if ${PERFORMANCE_MODE}; then
+            avg_time_us=0
+            if [ "$is_passed" -eq 1 ]; then
+                avg_time_us=$(( total_time_us / PERF_RUN_COUNT ))
+            fi
+            S_AVG=$(( avg_time_us / 1000000 ))
+            US_AVG=$(( avg_time_us % 1000000 ))
+            TIME_STRING_AVG="${S_AVG}s${US_AVG}us"
+            TOTAL_SECONDS_AVG=$(echo "scale=5; ${avg_time_us} / 1000000" | bc)
+            echo "$(basename ${sy_file}),${TIME_STRING_AVG},${TOTAL_SECONDS_AVG}" >> "${PERFORMANCE_CSV_FILE}"
+        fi
 
     # --- 模式 2: 直接执行模式 (-e) ---
     elif ${EXECUTE_MODE}; then
         step_failed=0
         test_logic_passed=0
+        total_time_us=0
 
         echo "  [1/3] 使用 sysyc 编译为汇编 (超时 ${SYSYC_TIMEOUT}s)..."
-        timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -S "${sy_file}" -o "${assembly_file_S}" ${OPTIMIZE_FLAG}
-        SYSYC_STATUS=$?
-        if [ $SYSYC_STATUS -ne 0 ]; then
-            [ $SYSYC_STATUS -eq 124 ] && echo -e "\e[31m错误: SysY (汇编) 编译超时\e[0m" || echo -e "\e[31m错误: SysY (汇编) 编译失败，退出码: ${SYSYC_STATUS}\e[0m"
-            step_failed=1
-        fi
+        timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -S "${sy_file}" -o "${assembly_file_S}" ${OPTIMIZE_FLAG}; if [ $? -ne 0 ]; then echo -e "\e[31m错误: SysY (汇编) 编译失败或超时\e[0m"; step_failed=1; fi
 
         if [ "$step_failed" -eq 0 ]; then
             echo "  [2/3] 使用 gcc 编译 (超时 ${GCC_TIMEOUT}s)..."
-            timeout -s KILL ${GCC_TIMEOUT} "${GCC_RISCV64}" "${assembly_file_S}" -o "${executable_file_S}" -L"${LIB_DIR}" -lsysy_riscv -static
-            GCC_STATUS=$?
-            if [ $GCC_STATUS -ne 0 ]; then
-                [ $GCC_STATUS -eq 124 ] && echo -e "\e[31m错误: GCC 编译超时\e[0m" || echo -e "\e[31m错误: GCC 编译失败，退出码: ${GCC_STATUS}\e[0m"
-                step_failed=1
-            fi
+            timeout -s KILL ${GCC_TIMEOUT} "${GCC_RISCV64}" "${assembly_file_S}" -o "${executable_file_S}" -L"${LIB_DIR}" -lsysy_riscv -static; if [ $? -ne 0 ]; then echo -e "\e[31m错误: GCC 编译失败或超时\e[0m"; step_failed=1; fi
         fi
 
         if [ "$step_failed" -eq 0 ]; then
             echo "  [3/3] 正在执行 (超时 ${EXEC_TIMEOUT}s)..."
-            exec_cmd="${QEMU_RISCV64} \"${executable_file_S}\""
-            [ -f "${input_file}" ] && exec_cmd+=" < \"${input_file}\""
-            exec_cmd+=" > \"${output_actual_file_S}\""
+            current_run_failed=0
+            for (( i=1; i<=PERF_RUN_COUNT; i++ )); do
+                if [ ${PERF_RUN_COUNT} -gt 1 ]; then echo -n "    第 $i/${PERF_RUN_COUNT} 次运行... "; fi
+                exec_cmd="${QEMU_RISCV64} \"${executable_file_S}\""
+                [ -f "${input_file}" ] && exec_cmd+=" < \"${input_file}\""
+                exec_cmd+=" > \"${output_actual_file_S}\" 2> \"${stderr_file_S}\""
+                eval "timeout -s KILL ${EXEC_TIMEOUT} ${exec_cmd}"
+                ACTUAL_RETURN_CODE=$?
                 
-            eval "timeout -s KILL ${EXEC_TIMEOUT} ${exec_cmd}"
-            ACTUAL_RETURN_CODE=$?
+                if [ "$ACTUAL_RETURN_CODE" -eq 124 ]; then echo -e "\e[31m超时\e[0m"; current_run_failed=1; break; fi
+                if ${PERFORMANCE_MODE}; then
+                    TIME_LINE=$(grep "TOTAL:" "${stderr_file_S}")
+                    if [ -n "$TIME_LINE" ]; then
+                        H=$(echo "$TIME_LINE" | sed -E 's/TOTAL: ([0-9]+)H-.*/\1/')
+                        M=$(echo "$TIME_LINE" | sed -E 's/.*-([0-9]+)M-.*/\1/')
+                        S=$(echo "$TIME_LINE" | sed -E 's/.*-([0-9]+)S-.*/\1/')
+                        US=$(echo "$TIME_LINE" | sed -E 's/.*-([0-9]+)us/\1/')
+                        run_time_us=$(( H * 3600000000 + M * 60000000 + S * 1000000 + US ))
+                        total_time_us=$(( total_time_us + run_time_us ))
+                        if [ ${PERF_RUN_COUNT} -gt 1 ]; then echo "耗时: ${run_time_us}us"; fi
+                    else
+                        echo -e "\e[31m未找到时间信息\e[0m"; current_run_failed=1; break
+                    fi
+                fi
+            done
             
-            if [ "$ACTUAL_RETURN_CODE" -eq 124 ]; then
-                echo -e "\e[31m  执行超时: 运行超过 ${EXEC_TIMEOUT} 秒\e[0m"
-            else
+            if [ "$current_run_failed" -eq 0 ]; then
+                test_logic_passed=1
                 if [ -f "${output_reference_file}" ]; then
                     LAST_LINE_TRIMMED=$(tail -n 1 "${output_reference_file}" | tr -d '[:space:]')
-                    test_logic_passed=1
                     if [[ "$LAST_LINE_TRIMMED" =~ ^[-+]?[0-9]+$ ]]; then
                         EXPECTED_RETURN_CODE="$LAST_LINE_TRIMMED"
                         EXPECTED_STDOUT_FILE="${TMP_DIR}/${output_base_name}_sysyc_S.expected_stdout"
                         head -n -1 "${output_reference_file}" > "${EXPECTED_STDOUT_FILE}"
-                        
-                        if [ "$ACTUAL_RETURN_CODE" -eq "$EXPECTED_RETURN_CODE" ]; then
-                            echo -e "\e[32m  返回码测试成功: (${ACTUAL_RETURN_CODE}) 与期望值 (${EXPECTED_RETURN_CODE}) 匹配\e[0m"
-                        else
-                            echo -e "\e[31m  返回码测试失败: 期望: ${EXPECTED_RETURN_CODE}, 实际: ${ACTUAL_RETURN_CODE}\e[0m"
-                            test_logic_passed=0
-                        fi
-
-                        if diff -q <(tr -d '[:space:]' < "${output_actual_file_S}") <(tr -d '[:space:]' < "${EXPECTED_STDOUT_FILE}") >/dev/null 2>&1; then
-                            [ "$test_logic_passed" -eq 1 ] && echo -e "\e[32m  标准输出测试成功\e[0m"
-                        else
-                            echo -e "\e[31m  标准输出测试失败\e[0m"
-                            display_file_content "${EXPECTED_STDOUT_FILE}" "    \e[36m---------- 期望输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" "${MAX_OUTPUT_CHARS}"
-                            display_file_content "${output_actual_file_S}" "    \e[36m---------- 实际输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" "${MAX_OUTPUT_CHARS}"
-                            test_logic_passed=0
+                        if [ "$ACTUAL_RETURN_CODE" -ne "$EXPECTED_RETURN_CODE" ]; then echo -e "\e[31m  返回码测试失败: 期望 ${EXPECTED_RETURN_CODE}, 实际 ${ACTUAL_RETURN_CODE}\e[0m"; test_logic_passed=0; fi
+                        if ! diff -q <(tr -d '[:space:]' < "${output_actual_file_S}") <(tr -d '[:space:]' < "${EXPECTED_STDOUT_FILE}") >/dev/null 2>&1; then
+                            echo -e "\e[31m  标准输出测试失败\e[0m"; test_logic_passed=0
+                            display_file_content "${EXPECTED_STDOUT_FILE}" "    \e[36m--- 期望输出 ---\e[0m" "${MAX_OUTPUT_LINES}" "${MAX_OUTPUT_CHARS}"
+                            display_file_content "${output_actual_file_S}" "    \e[36m--- 实际输出 ---\e[0m" "${MAX_OUTPUT_LINES}" "${MAX_OUTPUT_CHARS}"
                         fi
                     else
                         if [ $ACTUAL_RETURN_CODE -ne 0 ]; then echo -e "\e[33m警告: 程序以非零状态 ${ACTUAL_RETURN_CODE} 退出 (纯输出比较模式)。\e[0m"; fi
-                        if diff -q <(tr -d '[:space:]' < "${output_actual_file_S}") <(tr -d '[:space:]' < "${output_reference_file}") >/dev/null 2>&1; then
-                            echo -e "\e[32m  成功: 输出与参考输出匹配\e[0m"
-                        else
-                            echo -e "\e[31m  失败: 输出不匹配\e[0m"
-                            display_file_content "${output_reference_file}" "    \e[36m---------- 期望输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" "${MAX_OUTPUT_CHARS}"
-                            display_file_content "${output_actual_file_S}" "    \e[36m---------- 实际输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" "${MAX_OUTPUT_CHARS}"
-                            test_logic_passed=0
+                        if ! diff -q <(tr -d '[:space:]' < "${output_actual_file_S}") <(tr -d '[:space:]' < "${output_reference_file}") >/dev/null 2>&1; then
+                            echo -e "\e[31m  失败: 输出不匹配\e[0m"; test_logic_passed=0
+                            display_file_content "${output_reference_file}" "    \e[36m--- 期望输出 ---\e[0m" "${MAX_OUTPUT_LINES}" "${MAX_OUTPUT_CHARS}"
+                            display_file_content "${output_actual_file_S}" "    \e[36m--- 实际输出 ---\e[0m" "${MAX_OUTPUT_LINES}" "${MAX_OUTPUT_CHARS}"
                         fi
                     fi
-                else
-                    echo "  无参考输出文件。程序返回码: ${ACTUAL_RETURN_CODE}"
-                    test_logic_passed=1
                 fi
+                if [ "$test_logic_passed" -eq 1 ]; then echo -e "\e[32m  测试逻辑通过\e[0m"; fi
             fi
         fi
-        [ "$step_failed" -eq 0 ] && [ "$test_logic_passed" -eq 1 ] && is_passed=1
+        if [ "$step_failed" -eq 0 ] && [ "$test_logic_passed" -eq 1 ]; then is_passed=1; fi
+        
+        if ${PERFORMANCE_MODE}; then
+            avg_time_us=0
+            if [ "$is_passed" -eq 1 ]; then
+                avg_time_us=$(( total_time_us / PERF_RUN_COUNT ))
+            fi
+            S_AVG=$(( avg_time_us / 1000000 ))
+            US_AVG=$(( avg_time_us % 1000000 ))
+            TIME_STRING_AVG="${S_AVG}s${US_AVG}us"
+            TOTAL_SECONDS_AVG=$(echo "scale=5; ${avg_time_us} / 1000000" | bc)
+            echo "$(basename ${sy_file}),${TIME_STRING_AVG},${TOTAL_SECONDS_AVG}" >> "${PERFORMANCE_CSV_FILE}"
+        fi
 
     # --- 模式 3: 默认编译模式 ---
     else

src/backend/RISCv64/RISCv64ISel.cpp

@@ -103,7 +103,29 @@ void RISCv64ISel::select() {
         }
     }
 
-    if (optLevel > 0) {
+    // 仅当函数满足特定条件时，才需要保存参数寄存器,应用更精细的过滤规则
+    // 1. 函数包含call指令 (非叶子函数): 参数寄存器(a0-a7)是调用者保存的，
+    //    call指令可能会覆盖这些寄存器，因此必须保存。
+    // 2. 函数包含alloca指令 (需要栈分配)。
+    // 3. 函数的指令数量超过一个阈值（如20），意味着它是一个复杂的叶子函数，
+    //    为安全起见，保存其参数。
+    // 简单的叶子函数 (如min) 则可以跳过这个步骤进行优化。
+    auto shouldSaveArgs = [](Function* func) {
+        if (!func) return false;
+        int instruction_count = 0;
+        for (const auto& bb : func->getBasicBlocks()) {
+            for (const auto& inst : bb->getInstructions()) {
+                if (dynamic_cast<CallInst*>(inst.get()) || dynamic_cast<AllocaInst*>(inst.get())) {
+                    return true; // 发现call或alloca，立即返回true
+                }
+                instruction_count++;
+            }
+        }
+        // 如果没有call或alloca，则检查指令数量
+        return instruction_count > 45;
+    };
+
+    if (optLevel > 0 && shouldSaveArgs(F)) {
         if (F && !F->getBasicBlocks().empty()) {
             // 定位到第一个MachineBasicBlock，也就是函数入口
             BasicBlock* first_ir_block = F->getBasicBlocks_NoRange().front().get();
@@ -129,11 +151,11 @@ void RISCv64ISel::select() {
                     mv->addOperand(std::make_unique<RegOperand>(original_vreg));
                     CurMBB->addInstruction(std::move(mv));
 
+                    MFunc->addProtectedArgumentVReg(saved_vreg);
                     // 4.【关键】更新vreg映射表，将arg的vreg指向新的、安全的vreg
                     //    这样，后续所有对该参数的 getVReg(arg) 调用都会自动获得 saved_vreg，
                     //    使得函数体内的代码都使用这个被保存过的值。
                     vreg_map[arg] = saved_vreg;
-
                     int_arg_idx++;
                 }
                 // --- 处理浮点参数 ---
@@ -147,9 +169,8 @@ void RISCv64ISel::select() {
                     fmv->addOperand(std::make_unique<RegOperand>(original_vreg));
                     CurMBB->addInstruction(std::move(fmv));
 
-                    // 同样更新映射
+                    MFunc->addProtectedArgumentVReg(saved_vreg);
                     vreg_map[arg] = saved_vreg;
-
                     fp_arg_idx++;
                 }
                 // 对于栈传递的参数，则无需处理
@@ -557,6 +578,14 @@ void RISCv64ISel::selectNode(DAGNode* node) {
                     CurMBB->addInstruction(std::move(instr));
                     break;
                 }
+                case BinaryInst::kMulh: {
+                    auto instr = std::make_unique<MachineInstr>(RVOpcodes::MULH);
+                    instr->addOperand(std::make_unique<RegOperand>(dest_vreg));
+                    instr->addOperand(std::make_unique<RegOperand>(lhs_vreg));
+                    instr->addOperand(std::make_unique<RegOperand>(rhs_vreg));
+                    CurMBB->addInstruction(std::move(instr));
+                    break;
+                }
                 case Instruction::kDiv: {
                     auto instr = std::make_unique<MachineInstr>(RVOpcodes::DIVW);
                     instr->addOperand(std::make_unique<RegOperand>(dest_vreg));
@@ -668,6 +697,22 @@ void RISCv64ISel::selectNode(DAGNode* node) {
                     CurMBB->addInstruction(std::move(xori));
                     break;
                 }
+                case BinaryInst::kAnd: {
+                    auto instr = std::make_unique<MachineInstr>(RVOpcodes::AND);
+                    instr->addOperand(std::make_unique<RegOperand>(dest_vreg));
+                    instr->addOperand(std::make_unique<RegOperand>(lhs_vreg));
+                    instr->addOperand(std::make_unique<RegOperand>(rhs_vreg));
+                    CurMBB->addInstruction(std::move(instr));
+                    break;
+                }
+                case BinaryInst::kOr: {
+                    auto instr = std::make_unique<MachineInstr>(RVOpcodes::OR);
+                    instr->addOperand(std::make_unique<RegOperand>(dest_vreg));
+                    instr->addOperand(std::make_unique<RegOperand>(lhs_vreg));
+                    instr->addOperand(std::make_unique<RegOperand>(rhs_vreg));
+                    CurMBB->addInstruction(std::move(instr));
+                    break;
+                }
                 default:
                     throw std::runtime_error("Unsupported binary instruction in ISel");
             }
@@ -1313,6 +1358,7 @@ void RISCv64ISel::selectNode(DAGNode* node) {
             auto gep = dynamic_cast<GetElementPtrInst*>(node->value);
             auto result_vreg = getVReg(gep);
 
+            if (optLevel == 0) {
             // --- Step 1: 获取基地址 (此部分逻辑正确，保持不变) ---
             auto base_ptr_node = node->operands[0];
             auto current_addr_vreg = getNewVReg(gep->getType());
@@ -1419,6 +1465,106 @@ void RISCv64ISel::selectNode(DAGNode* node) {
             final_mv->addOperand(std::make_unique<RegOperand>(current_addr_vreg));
             CurMBB->addInstruction(std::move(final_mv));
             break;
+        } else {
+            // 对于-O1时的处理逻辑
+            // --- Step 1: 获取基地址 ---
+            auto base_ptr_node = node->operands[0];
+            auto base_ptr_val = base_ptr_node->value;
+            
+            // last_step_addr_vreg 保存上一步计算的结果。
+            // 它首先被初始化为GEP的初始基地址。
+            unsigned last_step_addr_vreg; 
+
+            if (auto alloca_base = dynamic_cast<AllocaInst*>(base_ptr_val)) {
+                last_step_addr_vreg = getNewVReg(gep->getType());
+                auto frame_addr_instr = std::make_unique<MachineInstr>(RVOpcodes::FRAME_ADDR);
+                frame_addr_instr->addOperand(std::make_unique<RegOperand>(last_step_addr_vreg));
+                frame_addr_instr->addOperand(std::make_unique<RegOperand>(getVReg(alloca_base)));
+                CurMBB->addInstruction(std::move(frame_addr_instr));
+            } else if (auto global_base = dynamic_cast<GlobalValue*>(base_ptr_val)) {
+                last_step_addr_vreg = getNewVReg(gep->getType());
+                auto la_instr = std::make_unique<MachineInstr>(RVOpcodes::LA);
+                la_instr->addOperand(std::make_unique<RegOperand>(last_step_addr_vreg));
+                la_instr->addOperand(std::make_unique<LabelOperand>(global_base->getName()));
+                CurMBB->addInstruction(std::move(la_instr));
+            } else {
+                // 对于函数参数或来自其他指令的指针，直接获取其vreg。
+                // 这个vreg必须被保护，不能在计算中被修改。
+                last_step_addr_vreg = getVReg(base_ptr_val);
+            }
+
+            // --- Step 2: 遵循LLVM GEP语义迭代计算地址 ---
+            Type* current_type = gep->getBasePointer()->getType()->as<PointerType>()->getBaseType();
+
+            for (size_t i = 0; i < gep->getNumIndices(); ++i) {
+                Value* indexValue = gep->getIndex(i);
+                unsigned stride = getTypeSizeInBytes(current_type);
+                
+                if (stride != 0) {
+                    // --- 为当前索引和步长生成偏移计算指令 ---
+                    auto offset_vreg = getNewVReg(Type::getIntType());
+                    
+                    unsigned index_vreg;
+                    if (auto const_index = dynamic_cast<ConstantValue*>(indexValue)) {
+                        index_vreg = getNewVReg(Type::getIntType());
+                        auto li = std::make_unique<MachineInstr>(RVOpcodes::LI);
+                        li->addOperand(std::make_unique<RegOperand>(index_vreg));
+                        li->addOperand(std::make_unique<ImmOperand>(const_index->getInt()));
+                        CurMBB->addInstruction(std::move(li));
+                    } else {
+                        index_vreg = getVReg(indexValue);
+                    }
+                    
+                    if (stride == 1) {
+                        auto mv = std::make_unique<MachineInstr>(RVOpcodes::MV);
+                        mv->addOperand(std::make_unique<RegOperand>(offset_vreg));
+                        mv->addOperand(std::make_unique<RegOperand>(index_vreg));
+                        CurMBB->addInstruction(std::move(mv));
+                    } else {
+                        auto size_vreg = getNewVReg(Type::getIntType());
+                        auto li_size = std::make_unique<MachineInstr>(RVOpcodes::LI);
+                        li_size->addOperand(std::make_unique<RegOperand>(size_vreg));
+                        li_size->addOperand(std::make_unique<ImmOperand>(stride));
+                        CurMBB->addInstruction(std::move(li_size));
+                        
+                        auto mul = std::make_unique<MachineInstr>(RVOpcodes::MULW);
+                        mul->addOperand(std::make_unique<RegOperand>(offset_vreg));
+                        mul->addOperand(std::make_unique<RegOperand>(index_vreg));
+                        mul->addOperand(std::make_unique<RegOperand>(size_vreg));
+                        CurMBB->addInstruction(std::move(mul));
+                    }
+
+                    // --- 关键修复点 ---
+                    // 创建一个新的vreg来保存本次加法的结果。
+                    unsigned current_step_addr_vreg = getNewVReg(gep->getType());
+                    
+                    // 执行 add current_step, last_step, offset
+                    // 这确保了 last_step_addr_vreg (输入) 永远不会被直接修改。
+                    auto add = std::make_unique<MachineInstr>(RVOpcodes::ADD);
+                    add->addOperand(std::make_unique<RegOperand>(current_step_addr_vreg));
+                    add->addOperand(std::make_unique<RegOperand>(last_step_addr_vreg));
+                    add->addOperand(std::make_unique<RegOperand>(offset_vreg));
+                    CurMBB->addInstruction(std::move(add));
+
+                    // 本次的结果成为下一次计算的输入。
+                    last_step_addr_vreg = current_step_addr_vreg;
+                }
+
+                // --- 为下一次迭代更新类型 ---
+                if (auto array_type = current_type->as<ArrayType>()) {
+                    current_type = array_type->getElementType();
+                } else if (auto ptr_type = current_type->as<PointerType>()) {
+                    current_type = ptr_type->getBaseType();
+                }
+            }
+            
+            // --- Step 3: 将最终计算出的地址存入GEP的目标虚拟寄存器 ---
+            auto final_mv = std::make_unique<MachineInstr>(RVOpcodes::MV);
+            final_mv->addOperand(std::make_unique<RegOperand>(result_vreg));
+            final_mv->addOperand(std::make_unique<RegOperand>(last_step_addr_vreg));
+            CurMBB->addInstruction(std::move(final_mv));
+            break;
+        }
         }
 
         default:

src/backend/RISCv64/RISCv64RegAlloc.cpp

@@ -98,6 +98,7 @@ bool RISCv64RegAlloc::doAllocation() {
     precolorByCallingConvention();
     analyzeLiveness();
     build();
+    protectCrossCallVRegs();
     makeWorklist();
 
     while (!simplifyWorklist.empty() || !worklistMoves.empty() || !freezeWorklist.empty() || !spillWorklist.empty()) {
@@ -185,6 +186,57 @@ void RISCv64RegAlloc::precolorByCallingConvention() {
     }
 }
 
+void RISCv64RegAlloc::protectCrossCallVRegs() {
+    // 从ISel获取被标记为需要保护的参数副本vreg集合
+    const auto& vregs_to_protect_potentially = MFunc->getProtectedArgumentVRegs();
+    if (vregs_to_protect_potentially.empty()) {
+        return; // 如果没有需要保护的vreg，直接返回
+    }
+
+    // VRegSet live_across_call_vregs;
+    // // 遍历所有指令，找出哪些被标记的vreg其生命周期确实跨越了call指令
+    // for (const auto& mbb_ptr : MFunc->getBlocks()) {
+    //     for (const auto& instr_ptr : mbb_ptr->getInstructions()) {
+    //         if (instr_ptr->getOpcode() == RVOpcodes::CALL) {
+    //             const VRegSet& live_out_after_call = live_out_map.at(instr_ptr.get());
+    //             for (unsigned vreg : vregs_to_protect_potentially) {
+    //                 if (live_out_after_call.count(vreg)) {
+    //                     live_across_call_vregs.insert(vreg);
+    //                 }
+    //             }
+    //         }
+    //     }
+    // }
+
+    // if (live_across_call_vregs.empty()) {
+    //     return; // 如果被标记的vreg没有一个跨越call，也无需操作
+    // }
+
+    // if (DEEPDEBUG) {
+    //     std::cerr << "--- [FIX] Applying protection for argument vregs that live across calls: ";
+    //     for(unsigned v : live_across_call_vregs) std::cerr << regIdToString(v) << " ";
+    //     std::cerr << "\n";
+    // }
+
+    // 获取所有调用者保存寄存器
+    const auto& caller_saved_int = getCallerSavedIntRegs();
+    const auto& caller_saved_fp = getCallerSavedFpRegs();
+    const unsigned offset = static_cast<unsigned>(PhysicalReg::PHYS_REG_START_ID);
+
+    // 为每个确认跨越call的vreg，添加与所有调用者保存寄存器的冲突
+    for (unsigned vreg : vregs_to_protect_potentially) {
+        if (isFPVReg(vreg)) { // 如果是浮点vreg
+            for (auto preg : caller_saved_fp) {
+                addEdge(vreg, offset + static_cast<unsigned>(preg));
+            }
+        } else { // 如果是整数vreg
+            for (auto preg : caller_saved_int) {
+                addEdge(vreg, offset + static_cast<unsigned>(preg));
+            }
+        }
+    }
+}
+
 // 初始化/重置所有数据结构
 void RISCv64RegAlloc::initialize() {
     initial.clear();
@@ -504,12 +556,20 @@ void RISCv64RegAlloc::coalesce() {
     unsigned y = getAlias(*use.begin());
     unsigned u, v;
 
-    // 进一步修正：标准化u和v的逻辑，必须同时考虑物理寄存器和已预着色的虚拟寄存器。
-    // 目标是确保如果两个操作数中有一个是预着色的，它一定会被赋给 u。
-    if (precolored.count(y) || coloredNodes.count(y)) { 
-        u = y; v = x; 
+    // 总是将待合并的虚拟寄存器赋给 v，将合并目标赋给 u。
+    // 优先级: 物理寄存器 (precolored) > 已着色的虚拟寄存器 (coloredNodes) > 普通虚拟寄存器。
+    if (precolored.count(y)) {
+        u = y;
+        v = x;
+    } else if (precolored.count(x)) {
+        u = x;
+        v = y;
+    } else if (coloredNodes.count(y)) {
+        u = y;
+        v = x;
     } else {
-        u = x; v = y; 
+        u = x;
+        v = y;
     }
     
     // 防御性检查，处理物理寄存器之间的传送指令
@@ -529,6 +589,74 @@ void RISCv64RegAlloc::coalesce() {
         return;
     }
     
+    bool is_conflicting = false;
+    // 检查1：u 和 v 在冲突图中是否直接相连
+    if ((adjList.count(v) && adjList.at(v).count(u)) || (adjList.count(u) && adjList.at(u).count(v))) {
+        if (DEEPERDEBUG) std::cerr << "  -> [Check] Nodes interfere directly.\n";
+        is_conflicting = true;
+    } 
+    // 检查2：如果节点不直接相连，则检查是否存在间接的颜色冲突
+    else {
+        // 获取 u 和 v 的颜色（如果它们有的话）
+        unsigned u_color_id = 0, v_color_id = 0;
+        if (precolored.count(u)) {
+            u_color_id = u;
+        } else if (coloredNodes.count(u) || color_map.count(u)) { // color_map.count(u) 是更可靠的检查
+            u_color_id = static_cast<unsigned>(PhysicalReg::PHYS_REG_START_ID) + static_cast<unsigned>(color_map.at(u));
+        }
+
+        if (precolored.count(v)) {
+            v_color_id = v;
+        } else if (coloredNodes.count(v) || color_map.count(v)) {
+            v_color_id = static_cast<unsigned>(PhysicalReg::PHYS_REG_START_ID) + static_cast<unsigned>(color_map.at(v));
+        }
+
+        // 如果 u 有颜色，检查 v 是否与该颜色代表的物理寄存器冲突
+        if (u_color_id != 0 && adjList.count(v) && adjList.at(v).count(u_color_id)) {
+            if (DEEPERDEBUG) std::cerr << "  -> [Check] Node " << regIdToString(v) << " interferes with the color of " << regIdToString(u) << " (" << regIdToString(u_color_id) << ").\n";
+            is_conflicting = true;
+        }
+        // 如果 v 有颜色，检查 u 是否与该颜色代表的物理寄存器冲突
+        else if (v_color_id != 0 && adjList.count(u) && adjList.at(u).count(v_color_id)) {
+            if (DEEPERDEBUG) std::cerr << "  -> [Check] Node " << regIdToString(u) << " interferes with the color of " << regIdToString(v) << " (" << regIdToString(v_color_id) << ").\n";
+            is_conflicting = true;
+        }
+    }
+
+    if (is_conflicting) {
+        if (DEEPERDEBUG) std::cerr << "  -> Constrained (nodes interfere directly or via pre-coloring).\n";
+        constrainedMoves.insert(move);
+        addWorklist(u);
+        addWorklist(v);
+        return;
+    }
+
+    bool u_is_colored = precolored.count(u) || coloredNodes.count(u);
+    bool v_is_colored = precolored.count(v) || coloredNodes.count(v);
+
+    if (u_is_colored && v_is_colored) {
+        PhysicalReg u_color = precolored.count(u) 
+            ? static_cast<PhysicalReg>(u - static_cast<unsigned>(PhysicalReg::PHYS_REG_START_ID)) 
+            : color_map.at(u);
+        PhysicalReg v_color = precolored.count(v) 
+            ? static_cast<PhysicalReg>(v - static_cast<unsigned>(PhysicalReg::PHYS_REG_START_ID)) 
+            : color_map.at(v);
+        
+        if (u_color != v_color) {
+            if (DEEPERDEBUG) std::cerr << "  -> Constrained (move between two different precolored nodes: " 
+                                   << regToString(u_color) << " and " << regToString(v_color) << ").\n";
+            constrainedMoves.insert(move);
+            return;
+        } else {
+            if (DEEPERDEBUG) std::cerr << "  -> Trivial coalesce (move between same precolored nodes).\n";
+            coalescedMoves.insert(move);
+            combine(u, v);
+            addWorklist(u);
+            return;
+        }
+    }
+
+    // 类型检查 
     if (isFPVReg(u) != isFPVReg(v)) {
         if (DEEPERDEBUG) std::cerr << "  -> Constrained (type mismatch: " << regIdToString(u) << " is " 
                                 << (isFPVReg(u) ? "float" : "int") << ", " << regIdToString(v) << " is "
@@ -539,25 +667,11 @@ void RISCv64RegAlloc::coalesce() {
         return;
     }
     
-    // 注意：如果v已经是u的邻居， pre_interfere 会为true。
-    // 但如果v不在adjList中（例如v是预着色节点），我们需要检查u是否在v的邻居中。
-    // 为了简化，我们假设adjList包含了所有虚拟寄存器。对于(Phys, Virt)对，冲突信息存储在Virt节点的邻接表中。
-    bool pre_interfere = (adjList.count(v) && adjList.at(v).count(u)) || (adjList.count(u) && adjList.at(u).count(v));
-    
-    if (pre_interfere) {
-        if (DEEPERDEBUG) std::cerr << "  -> Constrained (nodes already interfere).\n";
-        constrainedMoves.insert(move);
-        addWorklist(u);
-        addWorklist(v);
-        return;
-    }
-
-    // 考虑物理寄存器和已预着色的虚拟寄存器
+    // 启发式判断逻辑 
     bool u_is_effectively_precolored = precolored.count(u) || coloredNodes.count(u);
     bool can_coalesce = false;
     
     if (u_is_effectively_precolored) {
-        // --- 场景1：u是物理寄存器或已预着色虚拟寄存器，使用 George 启发式 ---
         if (DEEPERDEBUG) std::cerr << "  -> Trying George Heuristic (u is effectively precolored)...\n";
         
         VRegSet neighbors_of_v = adjacent(v);
@@ -1227,11 +1341,7 @@ bool RISCv64RegAlloc::georgeHeuristic(unsigned t, unsigned u) {
     
     int K = isFPVReg(t) ? K_fp : K_int;
     
-    // 缺陷 #2 修正: 移除了致命的 || precolored.count(u) 条件。
-    // 在此函数的上下文中，u 总是预着色的物理寄存器ID，导致旧的条件永远为true，使整个启发式失效。
-    // 正确的逻辑是检查：邻居t的度数是否小于K，或者t是否已经与u冲突。
-    // return degree.at(t) < K || adjList.at(t).count(u);
-    return degree.at(t) < K || !adjList.at(t).count(u);
+    return degree.at(t) < K || adjList.at(t).count(u);
 }
 
 void RISCv64RegAlloc::combine(unsigned u, unsigned v) {

src/include/backend/RISCv64/RISCv64Backend.h

@@ -6,6 +6,7 @@
 
 extern int DEBUG;
 extern int DEEPDEBUG;
+extern int optLevel;
 
 namespace sysy {
 

src/include/backend/RISCv64/RISCv64LLIR.h

@@ -326,12 +326,19 @@ public:
     void addBlock(std::unique_ptr<MachineBasicBlock> block) {
         blocks.push_back(std::move(block));
     }
+    void addProtectedArgumentVReg(unsigned vreg) {
+        protected_argument_vregs.insert(vreg);
+    }
+    const std::set<unsigned>& getProtectedArgumentVRegs() const {
+        return protected_argument_vregs;
+    }
 private:
     Function* F;
     RISCv64ISel* isel; // 指向创建它的ISel，用于获取vreg映射等信息
     std::string name;
     std::vector<std::unique_ptr<MachineBasicBlock>> blocks;
     StackFrameInfo frame_info;
+    std::set<unsigned> protected_argument_vregs;
 };
 inline bool isMemoryOp(RVOpcodes opcode) {
     switch (opcode) {

src/include/backend/RISCv64/RISCv64RegAlloc.h

@@ -45,12 +45,11 @@ private:
     void rewriteProgram();
     bool doAllocation();
     void applyColoring();
-
-    void dumpState(const std::string &stage);
-
     void precolorByCallingConvention();
+    void protectCrossCallVRegs();
 
     // --- 辅助函数 ---
+    void dumpState(const std::string &stage);
     void getInstrUseDef(const MachineInstr* instr, VRegSet& use, VRegSet& def);
     void getInstrUseDef_Liveness(const MachineInstr *instr, VRegSet &use, VRegSet &def);
     void addEdge(unsigned u, unsigned v);

src/include/midend/IR.h

@@ -1007,6 +1007,7 @@ class PhiInst : public Instruction {
   void replaceIncomingBlock(BasicBlock *oldBlock, BasicBlock *newBlock, Value *newValue);
   void refreshMap() {
     blk2val.clear();
+    vsize = getNumOperands() / 2;
     for (unsigned i = 0; i < vsize; ++i) {
       blk2val[getIncomingBlock(i)] = getIncomingValue(i);
     }

src/include/midend/Pass/Optimize/SysYIROptUtils.h

@@ -109,6 +109,34 @@ public:
   }
 
   
+  // PHI指令消除相关方法
+  static bool eliminateRedundantPhisInFunction(Function* func){
+    bool changed = false;
+    std::vector<Instruction *> toDelete;
+    for (auto &bb : func->getBasicBlocks()) {
+      for (auto &inst : bb->getInstructions()) {
+        if (auto phi = dynamic_cast<PhiInst *>(inst.get())) {
+          auto incoming = phi->getIncomingValues();
+          if(DEBUG){
+            std::cout << "Checking Phi: " << phi->getName() << " with " << incoming.size() << " incoming values." << std::endl;
+          }
+          if (incoming.size() == 1) {
+            Value *singleVal = incoming[0].second;
+            inst->replaceAllUsesWith(singleVal);
+            toDelete.push_back(inst.get());
+          }
+        }
+        else
+          break; // 只处理Phi指令
+      }
+    }
+    for (auto *phi : toDelete) {
+      usedelete(phi);
+      changed = true; // 标记为已更改
+    }
+    return changed; // 返回是否有删除发生
+  }
+
   //该实现参考了libdivide的算法
   static std::pair<int, int> computeMulhMagicNumbers(int divisor) {
     

src/midend/IR.cpp

@@ -757,7 +757,7 @@ void BinaryInst::print(std::ostream &os) const {
     auto lhs_hash = std::hash<const void*>{}(static_cast<const void*>(getLhs()));
     auto rhs_hash = std::hash<const void*>{}(static_cast<const void*>(getRhs()));
     size_t combined_hash = inst_hash ^ (lhs_hash << 1) ^ (rhs_hash << 2);
-    std::string tmpName = "tmp_icmp_" + std::to_string(combined_hash % 1000000);
+    std::string tmpName = "tmp_icmp_" + std::to_string(combined_hash % 1000000007);
     os << "%" << tmpName << " = " << getKindString() << " " << *getLhs()->getType() << " ";
     printOperand(os, getLhs());
     os << ", ";
@@ -772,7 +772,7 @@ void BinaryInst::print(std::ostream &os) const {
     auto lhs_hash = std::hash<const void*>{}(static_cast<const void*>(getLhs()));
     auto rhs_hash = std::hash<const void*>{}(static_cast<const void*>(getRhs()));
     size_t combined_hash = inst_hash ^ (lhs_hash << 1) ^ (rhs_hash << 2);
-    std::string tmpName = "tmp_fcmp_" + std::to_string(combined_hash % 1000000);
+    std::string tmpName = "tmp_fcmp_" + std::to_string(combined_hash % 1000000007);
     os << "%" << tmpName << " = " << getKindString() << " " << *getLhs()->getType() << " ";
     printOperand(os, getLhs());
     os << ", ";
@@ -834,7 +834,7 @@ void CondBrInst::print(std::ostream &os) const {
   if (condName.empty()) {
     // 使用条件值地址的哈希值作为唯一标识
     auto ptr_hash = std::hash<const void*>{}(static_cast<const void*>(condition));
-    condName = "const_" + std::to_string(ptr_hash % 100000);
+    condName = "const_" + std::to_string(ptr_hash % 1000000007);
   }
   
   // 组合指令地址、条件地址和目标块地址的哈希来确保唯一性
@@ -843,7 +843,7 @@ void CondBrInst::print(std::ostream &os) const {
   auto then_hash = std::hash<const void*>{}(static_cast<const void*>(getThenBlock()));
   auto else_hash = std::hash<const void*>{}(static_cast<const void*>(getElseBlock()));
   size_t combined_hash = inst_hash ^ (cond_hash << 1) ^ (then_hash << 2) ^ (else_hash << 3);
-  std::string uniqueSuffix = std::to_string(combined_hash % 1000000);
+  std::string uniqueSuffix = std::to_string(combined_hash % 1000000007);
   
   os << "%tmp_cond_" << condName << "_" << uniqueSuffix << " = icmp ne i32 ";
   printOperand(os, condition);

src/midend/Pass/Optimize/DCE.cpp

@@ -74,6 +74,7 @@ void DCEContext::run(Function *func, AnalysisManager *AM, bool &changed) {
       }
     }
   }
+  changed |= SysYIROptUtils::eliminateRedundantPhisInFunction(func); // 如果有活跃指令，则标记为已更改
 }
 
 // 判断指令是否是"天然活跃"的实现

src/midend/Pass/Optimize/GVN.cpp

@@ -39,7 +39,7 @@ bool GVN::runOnFunction(Function *func, AnalysisManager &AM) {
     }
     std::cout << "=== GVN completed for function: " << func->getName() << " ===" << std::endl;
   }
-
+  changed |= SysYIROptUtils::eliminateRedundantPhisInFunction(func);
   return changed;
 }
 

src/midend/Pass/Optimize/GlobalStrengthReduction.cpp

@@ -671,13 +671,13 @@ bool GlobalStrengthReductionContext::reduceDivision(BinaryInst *inst) {
   }
 
   // x / c = x * magic_number (魔数乘法优化 - 使用libdivide算法)
-  if (isConstantInt(rhs, constVal) && constVal > 1 && constVal != (uint32_t)(-1)) {
-    // auto magicPair = computeMulhMagicNumbers(static_cast<int>(constVal));
-    Value* magicResult = createMagicDivisionLibdivide(inst, static_cast<int>(constVal));
-    replaceWithOptimized(inst, magicResult);
-    divisionOptCount++;
-    return true;
-  }
+  // if (isConstantInt(rhs, constVal) && constVal > 1 && constVal != (uint32_t)(-1)) {
+  //   // auto magicPair = computeMulhMagicNumbers(static_cast<int>(constVal));
+  //   Value* magicResult = createMagicDivisionLibdivide(inst, static_cast<int>(constVal));
+  //   replaceWithOptimized(inst, magicResult);
+  //   divisionOptCount++;
+  //   return true;
+  // }
 
   return false;
 }

src/midend/Pass/Optimize/InductionVariableElimination.cpp

@@ -133,6 +133,7 @@ bool InductionVariableEliminationContext::run(Function* F, AnalysisManager& AM)
     printDebugInfo();
   }
 
+  modified |= SysYIROptUtils::eliminateRedundantPhisInFunction(F);
   return modified;
 }
 

src/midend/Pass/Optimize/LoopStrengthReduction.cpp

@@ -661,9 +661,9 @@ bool StrengthReductionContext::replaceOriginalInstruction(StrengthReductionCandi
     
     case StrengthReductionCandidate::DIVIDE_CONST: {
       // 任意常数除法
-      builder->setPosition(candidate->containingBlock, 
-                          candidate->containingBlock->findInstIterator(candidate->originalInst));
-      replacementValue = generateConstantDivisionReplacement(candidate, builder);
+      // builder->setPosition(candidate->containingBlock, 
+      //                     candidate->containingBlock->findInstIterator(candidate->originalInst));
+      // replacementValue = generateConstantDivisionReplacement(candidate, builder);
       break;
     }
     
@@ -683,17 +683,19 @@ bool StrengthReductionContext::replaceOriginalInstruction(StrengthReductionCandi
         );
         
         // 检查原值是否为负数
-        Value* zero = ConstantInteger::get(0);
-        Value* isNegative = builder->createICmpLTInst(candidate->inductionVar, zero);
+        Value* shift31condidata = builder->createBinaryInst(
+          Instruction::Kind::kSra, candidate->inductionVar->getType(),
+          candidate->inductionVar, ConstantInteger::get(31)
+        );
         
         // 如果为负数，需要调整结果
-        Value* adjustment = ConstantInteger::get(candidate->multiplier);
-        Value* adjustedTemp = builder->createAddInst(temp, adjustment);
-        
-        // 使用条件分支来模拟select操作
-        // 为简化起见，这里先用一个更复杂但可工作的方式
-        // 实际应该创建条件分支，但这里先简化处理
-        replacementValue = temp; // 简化版本，假设大多数情况下不是负数
+        Value* adjustment = builder->createAndInst(shift31condidata, maskConstant);
+        Value* adjustedTemp = builder->createAddInst(candidate->inductionVar, adjustment);
+        Value* adjustedResult = builder->createBinaryInst(
+          Instruction::Kind::kAnd, candidate->inductionVar->getType(),
+          adjustedTemp, maskConstant
+        );
+        replacementValue = adjustedResult;
       } else {
         // 非负数的取模，直接使用位与
         replacementValue = builder->createBinaryInst(

src/midend/Pass/Optimize/SCCP.cpp

@@ -1357,9 +1357,8 @@ void SCCPContext::run(Function *func, AnalysisManager &AM) {
   bool changed_control_flow = SimplifyControlFlow(func);
 
   // 如果任何一个阶段修改了 IR，标记分析结果为失效
-  if (changed_constant_propagation || changed_control_flow) {
-    // AM.invalidate(); // 假设有这样的方法来使所有分析结果失效
-  }
+  bool changed = changed_constant_propagation || changed_control_flow;
+  changed |= SysYIROptUtils::eliminateRedundantPhisInFunction(func);
 }
 
 // SCCP Pass methods

src/midend/Pass/Pass.cpp

@@ -181,19 +181,19 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR
         printPasses();
       }
       
-      // this->clearPasses();
-      // this->addPass(&LoopStrengthReduction::ID);
-      // this->run();
+      this->clearPasses();
+      this->addPass(&LoopStrengthReduction::ID);
+      this->run();
 
       if(DEBUG) {
         std::cout << "=== IR After Loop Normalization, and Strength Reduction Optimizations ===\n";
         printPasses();
       }
 
-      // // 全局强度削弱优化，包括代数优化和魔数除法
-      // this->clearPasses();
-      // this->addPass(&GlobalStrengthReduction::ID);
-      // this->run();
+      // 全局强度削弱优化，包括代数优化和魔数除法
+      this->clearPasses();
+      this->addPass(&GlobalStrengthReduction::ID);
+      this->run();
 
       if(DEBUG) {
         std::cout << "=== IR After Global Strength Reduction Optimizations ===\n";