├── test ├── test_2020 │ ├── 10_break.out │ ├── 11_while.out │ ├── 79_gcd.in │ ├── 79_gcd.out │ ├── 80_lcm.in │ ├── 80_lcm.out │ ├── 86_bin_search.in │ ├── 91_line_search.in │ ├── 94_lcm.in │ ├── 94_lcm.out │ ├── 99_bin_search.in │ ├── 02_arr_defn4.out │ ├── 03_var_defn2.out │ ├── 04_func_defn.out │ ├── 09_void_func.out │ ├── 11_continue.out │ ├── 18_cal_prio.out │ ├── 19_neg_expr.in │ ├── 19_neg_expr.out │ ├── 20_arr_sum.out │ ├── 22_if_test1.out │ ├── 23_if_test2.out │ ├── 24_if_test3.out │ ├── 25_if_test4.out │ ├── 26_if_test5.out │ ├── 33_func_test1.out │ ├── 70_multi.out │ ├── 81_jump_game.out │ ├── 85_multi.out │ ├── 90_insert_order.in │ ├── 95_jump_game.out │ ├── 06_var_defn_func.out │ ├── 12_array_traverse.out │ ├── 13_array_traverse2.out │ ├── 15_array_test3.out │ ├── 18_cal_prio.in │ ├── 21_suminput.out │ ├── 27_while_test1.out │ ├── 28_while_test2.out │ ├── 29_while_test3.out │ ├── 31_while_if_test2.out │ ├── 32_while_if_test3.out │ ├── 34_func_test2.out │ ├── 35_array_test.out │ ├── 36_domain_test.out │ ├── 46_and_prior_or.out │ ├── 47_minus_with_sub.out │ ├── 49_decl_in_defn.out │ ├── 60_while_fibonacci.in │ ├── 60_while_fibonacci.out │ ├── 61_rec_fibonacci.in │ ├── 65_word_count.out │ ├── 66_go_upstairs.out │ ├── 68_accumulate.out │ ├── 72_enum.out │ ├── 73_exchange_value.in │ ├── 75_max_container.out │ ├── 77_unique_path.out │ ├── 81_go_upstairs.out │ ├── 83_accumulate.out │ ├── 83_enc_dec.out │ ├── 87_enum.out │ ├── 88_exchange_value.in │ ├── 90_max_container.out │ ├── 92_unique_path.out │ ├── 97_enc_dec.out │ ├── 30_while_if_test1.out │ ├── 38_if_complex_expr.out │ ├── 40_index_complex_expr.out │ ├── 42_index_func_ret.out │ ├── 43_time_prior_plus.out │ ├── 44_add_prior_equal.out │ ├── 45_equal_prior_logic.out │ ├── 50_recursion_test1.out │ ├── 51_recursion_test2.out │ ├── 52_recursion_test3.out │ ├── 63_simple_atoi.in │ ├── 63_simple_atoi.out │ ├── 64_alpha_count.out │ ├── 69_last_word_length.out │ ├── 71_max_subsequence_sum.out │ ├── 74_itera_sqrt.out │ ├── 76_int_factor_sum.out │ ├── 84_last_word_length.out │ ├── 86_bin_search.out │ ├── 86_max_subsequence_sum.out │ ├── 89_itera_sqrt.out │ ├── 91_int_factor_sum.out │ ├── 91_line_search.out │ ├── 99_bin_search.out │ ├── 99_register_realloc.out │ ├── 21_suminput.in │ ├── 39_assign_complex_expr.out │ ├── 41_index_arithmetic_expr.out │ ├── 61_rec_fibonacci.out │ ├── 67_remove_duplicate_element.out │ ├── 78_decbinoct.out │ ├── 82_remove_duplicate_element.out │ ├── 88_array_concat.out │ ├── 93_decbinoct.out │ ├── 20_arr_sum.in │ ├── 73_exchange_value.out │ ├── 82_int_split.out │ ├── 84_palindrome_number.out │ ├── 88_exchange_value.out │ ├── 96_int_split.out │ ├── 98_palindrome_number.out │ ├── 53_sort_test1.out │ ├── 54_sort_test2.out │ ├── 55_sort_test3.out │ ├── 56_sort_test4.out │ ├── 57_sort_test5.out │ ├── 58_sort_test6.out │ ├── 59_sort_test7.out │ ├── 90_insert_order.out │ ├── 03_var_defn2.sy │ ├── 06_var_defn_func.sy │ ├── 49_decl_in_defn.sy │ ├── 10_break.sy │ ├── 11_while.sy │ ├── 02_arr_defn4.sy │ ├── 04_func_defn.sy │ ├── 18_cal_prio.sy │ ├── 19_neg_expr.sy │ ├── 46_and_prior_or.ll │ ├── 09_void_func.sy │ ├── 45_equal_prior_logic.ll │ ├── 11_continue.sy │ ├── 47_minus_with_sub.sy │ ├── 50_recursion_test1.sy │ ├── 22_if_test1.sy │ ├── 47_minus_with_sub.ll │ ├── 49_decl_in_defn.ll │ ├── 43_time_prior_plus.ll │ ├── 52_recursion_test3.sy │ ├── 51_recursion_test2.sy │ ├── 43_time_prior_plus.sy │ ├── 24_if_test3.sy │ ├── 39_assign_complex_expr.ll │ ├── 70_multi.sy │ ├── 85_multi.sy │ ├── 25_if_test4.sy │ ├── 26_if_test5.sy │ ├── 68_accumulate.sy │ ├── 83_accumulate.sy │ ├── 27_while_test1.sy │ ├── 20_arr_sum.sy │ ├── 03_var_defn2.ll │ ├── 33_func_test1.sy │ ├── 41_index_arithmetic_expr.sy │ ├── 23_if_test2.sy │ ├── 46_and_prior_or.sy │ ├── 36_domain_test.sy │ ├── 64_alpha_count.in │ ├── 65_word_count.in │ ├── 12_array_traverse.sy │ ├── 38_if_complex_expr.ll │ ├── 44_add_prior_equal.ll │ ├── 15_array_test3.sy │ ├── 31_while_if_test2.sy │ ├── 35_array_test.sy │ ├── 44_add_prior_equal.sy │ ├── 13_array_traverse2.sy │ ├── 61_rec_fibonacci.sy │ ├── 06_var_defn_func.ll │ ├── 22_if_test1.ll │ ├── 24_if_test3.ll │ ├── 21_suminput.sy │ ├── 25_if_test4.ll │ ├── 26_if_test5.ll │ ├── 30_while_if_test1.sy │ ├── 23_if_test2.ll │ ├── 60_while_fibonacci.sy │ ├── 73_exchange_value.sy │ ├── 88_exchange_value.sy │ ├── 74_itera_sqrt.sy │ ├── 89_itera_sqrt.sy │ ├── 66_go_upstairs.sy │ ├── 81_go_upstairs.sy │ ├── 45_equal_prior_logic.sy │ ├── 39_assign_complex_expr.sy │ ├── 64_alpha_count.sy │ ├── 32_while_if_test3.sy │ ├── 79_gcd.sy │ ├── 76_int_factor_sum.sy │ ├── 91_int_factor_sum.sy │ ├── 04_func_defn.ll │ ├── 38_if_complex_expr.sy │ ├── 80_lcm.sy │ ├── 94_lcm.sy │ ├── 78_decbinoct.sy │ ├── 93_decbinoct.sy │ ├── 62_long_code.out │ ├── 83_enc_dec.sy │ ├── 97_enc_dec.sy │ ├── 72_enum.sy │ ├── 87_enum.sy │ ├── 73_exchange_value.ll │ ├── 88_exchange_value.ll │ ├── 28_while_test2.sy │ ├── 40_index_complex_expr.sy │ ├── 34_func_test2.sy │ ├── 67_remove_duplicate_element.sy │ ├── 82_remove_duplicate_element.sy │ ├── 42_index_func_ret.sy │ ├── 82_int_split.sy │ ├── 96_int_split.sy │ ├── 19_neg_expr.ll │ ├── 41_index_arithmetic_expr.ll │ ├── 69_last_word_length.sy │ ├── 84_last_word_length.sy │ ├── 09_void_func.ll │ ├── 18_cal_prio.ll │ ├── 84_palindrome_number.sy │ ├── 98_palindrome_number.sy │ ├── 71_max_subsequence_sum.sy │ ├── 86_max_subsequence_sum.sy │ ├── 77_unique_path.sy │ ├── 92_unique_path.sy │ ├── 75_max_container.sy │ ├── 90_max_container.sy │ ├── 54_sort_test2.sy │ ├── 70_multi.ll │ ├── 85_multi.ll │ ├── 65_word_count.sy │ ├── 68_accumulate.ll │ ├── 83_accumulate.ll │ ├── 50_recursion_test1.ll │ ├── 31_while_if_test2.ll │ ├── 90_insert_order.sy │ ├── 40_index_complex_expr.ll │ ├── 81_jump_game.sy │ ├── 86_bin_search.sy │ ├── 95_jump_game.sy │ ├── 99_bin_search.sy │ ├── 88_array_concat.sy │ ├── 11_while.ll │ ├── 53_sort_test1.sy │ ├── 91_line_search.sy │ ├── 10_break.ll │ ├── 11_continue.ll │ ├── 56_sort_test4.sy │ ├── 63_simple_atoi.sy │ ├── 33_func_test1.ll │ ├── 36_domain_test.ll │ ├── 29_while_test3.sy │ ├── 52_recursion_test3.ll │ ├── 74_itera_sqrt.ll │ ├── 89_itera_sqrt.ll │ ├── 78_decbinoct.ll │ ├── 93_decbinoct.ll │ ├── 58_sort_test6.sy │ ├── 34_func_test2.ll │ └── 51_recursion_test2.ll └── test_2021 │ ├── 005_func.out │ ├── 028_if_test1.out │ ├── 030_if_test3.out │ ├── 031_if_test4.out │ ├── 032_if_test5.out │ ├── 037_break.out │ ├── 038_continue.out │ ├── 049_unary_op.out │ ├── 054_hex_defn.out │ ├── 101_insert_order.in │ ├── 006_array_initialize.out │ ├── 007_arr_defn4.out │ ├── 012_func_defn.out │ ├── 013_var_defn_func.out │ ├── 034_while_test1.out │ ├── 035_while_test2.out │ ├── 036_while_test3.out │ ├── 042_arr_expr_len.out │ ├── 043_op_priority1.out │ ├── 044_op_priority2.out │ ├── 045_op_priority3.out │ ├── 046_op_priority4.out │ ├── 051_logi_assign.in │ ├── 051_logi_assign.out │ ├── 055_hex_oct_add.out │ ├── 060_scope.out │ ├── 071_accumulate.out │ ├── 071_exchange_array.out │ ├── 080_go_upstairs.out │ ├── 081_exgcd.out │ ├── 091_kmp.out │ ├── 095_empty_stmt.out │ ├── 099_skip_spaces.out │ ├── 100_int_literal.out │ ├── 107_long_code2.out │ ├── 113_many_locals2.in │ ├── 115_nested_calls.out │ ├── 117_nested_loops.out │ ├── 009_const_var_defn2.out │ ├── 010_const_var_defn3.out │ ├── 029_if_test2.out │ ├── 033_while_if.out │ ├── 039_while_if_test1.out │ ├── 040_while_if_test2.out │ ├── 041_while_if_test3.out │ ├── 046_op_priority4.in │ ├── 047_op_priority5.out │ ├── 048_stmt_expr.out │ ├── 050_unary_op2.out │ ├── 072_percolation.out │ ├── 073_backpack.out │ ├── 079_calculator.out │ ├── 080_color.out │ ├── 092_max_flow.out │ ├── 093_n_queens.in │ ├── 094_substr.out │ ├── 101_scope2.out │ ├── 105_long_array2.out │ ├── 110_many_params3.out │ ├── 112_many_locals.out │ ├── 116_nested_calls2.out │ ├── 057_if_complex_expr.out │ ├── 059_short_circuit2.out │ ├── 070_remove_duplicate_element.out │ ├── 100_array_concat.out │ ├── 108_many_params.out │ ├── 111_many_globals.out │ ├── 114_register_alloc.out │ ├── 056_assign_complex_expr.out │ ├── 058_short_circuit.out │ ├── 069_greatest_common_divisor.in │ ├── 085_dijkstra.out │ ├── 088_hanoi.in │ ├── 114_register_alloc.in │ ├── 058_short_circuit.in │ ├── 069_greatest_common_divisor.out │ ├── 070_multiplication_puzzle.out │ ├── 074_matrix_add.out │ ├── 075_matrix_sub.out │ ├── 076_matrix_mul.out │ ├── 117_nested_loops.in │ ├── 068_genealogical_tree.in │ ├── 077_matrix_tran.out │ ├── 068_genealogical_tree.out │ ├── 089_hidden_var.out │ ├── 079_calculator.in │ ├── 102_short_circuit3.out │ ├── 115_nested_calls.in │ ├── 086_full_conn.out │ ├── 090_int_io.out │ ├── 091_kmp.in │ ├── 084_expr_eval.out │ ├── 113_many_locals2.out │ ├── 095_empty_stmt.sy │ ├── 061_bubble_sort.out │ ├── 109_many_params2.out │ ├── 101_insert_order.out │ ├── 054_hex_defn.sy │ ├── 072_percolation.in │ ├── 087_gcd.out │ ├── 099_skip_spaces.in │ ├── 096_side_effect.out │ ├── 085_dijkstra.in │ ├── 084_expr_eval.in │ ├── 078_big_int_mul.out │ ├── 055_hex_oct_add.sy │ ├── 090_int_io.in │ ├── 108_many_params.in │ ├── 092_max_flow.in │ ├── 103_long_func.out │ ├── 104_long_array.out │ ├── 045_op_priority3.sy │ ├── 097_var_name.out │ ├── 012_func_defn.sy │ ├── 043_op_priority1.sy │ ├── 049_unary_op.ll │ ├── 049_unary_op.sy │ ├── 054_hex_defn.ll │ ├── 095_empty_stmt.ll │ ├── 006_array_initialize.sy │ ├── 043_op_priority1.ll │ ├── 044_op_priority2.ll │ ├── 044_op_priority2.sy │ ├── 045_op_priority3.ll │ ├── 055_hex_oct_add.ll │ ├── 087_gcd.in │ ├── 009_const_var_defn2.sy │ ├── 051_logi_assign.sy │ ├── 048_stmt_expr.sy │ ├── 083_brainfk.out │ ├── 013_var_defn_func.sy │ ├── 010_const_var_defn3.sy │ ├── 028_if_test1.sy │ ├── 042_arr_expr_len.sy │ ├── 050_unary_op2.sy │ ├── 116_nested_calls2.sy │ ├── 037_break.sy │ ├── 047_op_priority5.sy │ ├── 005_func.sy │ ├── 030_if_test3.sy │ ├── 082_reverse_output.sy │ ├── 031_if_test4.sy │ ├── 032_if_test5.sy │ ├── 046_op_priority4.sy │ ├── 056_assign_complex_expr.ll │ ├── 071_accumulate.sy │ ├── 034_while_test1.sy │ ├── 038_continue.sy │ ├── 069_greatest_common_divisor.sy │ ├── 050_unary_op2.ll │ ├── 087_gcd.sy │ ├── 057_if_complex_expr.ll │ ├── 071_exchange_array.sy │ ├── 007_arr_defn4.sy │ ├── 040_while_if_test2.sy │ ├── 105_long_array2.sy │ ├── 028_if_test1.ll │ ├── 030_if_test3.ll │ ├── 031_if_test4.ll │ ├── 032_if_test5.ll │ ├── 039_while_if_test1.sy │ ├── 029_if_test2.sy │ ├── 060_scope.sy │ ├── 080_go_upstairs.sy │ ├── 099_skip_spaces.sy │ ├── 056_assign_complex_expr.sy │ ├── 081_exgcd.sy │ ├── 059_short_circuit2.sy │ ├── 041_while_if_test3.sy │ ├── 029_if_test2.ll │ ├── 101_scope2.sy │ ├── 057_if_complex_expr.sy │ ├── 058_short_circuit.sy │ ├── 070_multiplication_puzzle.sy │ ├── 106_long_code.out │ ├── 033_while_if.sy │ ├── 035_while_test2.sy │ ├── 082_reverse_output.out │ ├── 070_remove_duplicate_element.sy │ ├── 088_hanoi.sy │ ├── 096_side_effect.sy │ ├── 086_full_conn.in │ ├── 012_func_defn.ll │ ├── 009_const_var_defn2.ll │ ├── 071_accumulate.ll │ ├── 042_arr_expr_len.ll │ ├── 040_while_if_test2.ll │ ├── 101_insert_order.sy │ ├── 100_array_concat.sy │ ├── 061_bubble_sort.sy │ ├── 068_genealogical_tree.sy │ ├── 038_continue.ll │ ├── 037_break.ll │ ├── 090_int_io.sy │ ├── 109_many_params2.sy │ ├── 069_greatest_common_divisor.ll │ ├── 082_reverse_output.ll │ ├── 112_many_locals.sy │ ├── 048_stmt_expr.ll │ ├── 036_while_test3.sy │ ├── 093_n_queens.sy │ ├── 089_hidden_var.sy │ ├── 051_logi_assign.ll │ ├── 098_chaos_token.out │ ├── 116_nested_calls2.ll │ ├── 073_backpack.sy │ ├── 078_big_int_mul.sy │ └── 102_short_circuit3.sy ├── src ├── Optimize │ ├── Pass.cpp │ └── CMakeLists.txt ├── Checker │ └── CMakeLists.txt ├── ASTBuilder │ └── CMakeLists.txt ├── ASTPrinter │ └── CMakeLists.txt ├── ErrorReporter │ ├── CMakeLists.txt │ └── ErrorReporter.cpp ├── SysYFIRBuilder │ └── CMakeLists.txt ├── SysYFIR │ ├── CMakeLists.txt │ ├── Value.cpp │ └── GlobalVariable.cpp └── Frontend │ └── CMakeLists.txt ├── .gitignore ├── doc ├── Dominance.pdf ├── SysYF语言定义.pdf └── DeadCodeEli.pdf ├── include ├── Frontend │ ├── stack.hh │ └── position.hh ├── SysYFIR │ ├── IRPrinter.h │ ├── GlobalVariable.h │ └── User.h ├── Optimize │ ├── ActiveVar.h │ ├── DeadCodeEli.h │ ├── Pass.h │ ├── DominateTree.h │ └── RDominateTree.h └── ErrorReporter │ └── ErrorReporter.h ├── report └── Checker.md └── lib └── lib.c /test/test_2020/10_break.out: -------------------------------------------------------------------------------- 1 | 5 2 | -------------------------------------------------------------------------------- /test/test_2020/11_while.out: -------------------------------------------------------------------------------- 1 | 6 2 | -------------------------------------------------------------------------------- /test/test_2020/79_gcd.in: -------------------------------------------------------------------------------- 1 | 4 2 | 20 -------------------------------------------------------------------------------- /test/test_2020/79_gcd.out: -------------------------------------------------------------------------------- 1 | 4 2 | -------------------------------------------------------------------------------- /test/test_2020/80_lcm.in: -------------------------------------------------------------------------------- 1 | 4 2 | 20 -------------------------------------------------------------------------------- /test/test_2020/80_lcm.out: -------------------------------------------------------------------------------- 1 | 20 2 | -------------------------------------------------------------------------------- /test/test_2020/86_bin_search.in: -------------------------------------------------------------------------------- 1 | 6 -------------------------------------------------------------------------------- /test/test_2020/91_line_search.in: -------------------------------------------------------------------------------- 1 | 7 -------------------------------------------------------------------------------- /test/test_2020/94_lcm.in: -------------------------------------------------------------------------------- 1 | 4 2 | 20 -------------------------------------------------------------------------------- /test/test_2020/94_lcm.out: -------------------------------------------------------------------------------- 1 | 20 2 | -------------------------------------------------------------------------------- /test/test_2020/99_bin_search.in: -------------------------------------------------------------------------------- 1 | 6 -------------------------------------------------------------------------------- /test/test_2021/005_func.out: -------------------------------------------------------------------------------- 1 | 17 -------------------------------------------------------------------------------- /test/test_2020/02_arr_defn4.out: -------------------------------------------------------------------------------- 1 | 9 2 | -------------------------------------------------------------------------------- /test/test_2020/03_var_defn2.out: -------------------------------------------------------------------------------- 1 | 28 2 | -------------------------------------------------------------------------------- /test/test_2020/04_func_defn.out: -------------------------------------------------------------------------------- 1 | 9 2 | -------------------------------------------------------------------------------- /test/test_2020/09_void_func.out: -------------------------------------------------------------------------------- 1 | 5 2 | -------------------------------------------------------------------------------- /test/test_2020/11_continue.out: -------------------------------------------------------------------------------- 1 | 5 2 | -------------------------------------------------------------------------------- /test/test_2020/18_cal_prio.out: -------------------------------------------------------------------------------- 1 | 7 2 | -------------------------------------------------------------------------------- /test/test_2020/19_neg_expr.in: -------------------------------------------------------------------------------- 1 | 2 3 2 | -------------------------------------------------------------------------------- /test/test_2020/19_neg_expr.out: -------------------------------------------------------------------------------- 1 | -5 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/20_arr_sum.out: -------------------------------------------------------------------------------- 1 | 12 2 | -------------------------------------------------------------------------------- /test/test_2020/22_if_test1.out: -------------------------------------------------------------------------------- 1 | 25 2 | -------------------------------------------------------------------------------- /test/test_2020/23_if_test2.out: -------------------------------------------------------------------------------- 1 | 132 2 | -------------------------------------------------------------------------------- /test/test_2020/24_if_test3.out: -------------------------------------------------------------------------------- 1 | 25 2 | -------------------------------------------------------------------------------- /test/test_2020/25_if_test4.out: -------------------------------------------------------------------------------- 1 | 25 2 | -------------------------------------------------------------------------------- /test/test_2020/26_if_test5.out: -------------------------------------------------------------------------------- 1 | 25 2 | -------------------------------------------------------------------------------- /test/test_2020/33_func_test1.out: -------------------------------------------------------------------------------- 1 | 5 2 | -------------------------------------------------------------------------------- /test/test_2020/70_multi.out: -------------------------------------------------------------------------------- 1 | 0 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/81_jump_game.out: -------------------------------------------------------------------------------- 1 | 1 2 | -------------------------------------------------------------------------------- /test/test_2020/85_multi.out: -------------------------------------------------------------------------------- 1 | 0 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/90_insert_order.in: -------------------------------------------------------------------------------- 1 | 50 -------------------------------------------------------------------------------- /test/test_2020/95_jump_game.out: -------------------------------------------------------------------------------- 1 | 1 2 | -------------------------------------------------------------------------------- /test/test_2021/028_if_test1.out: -------------------------------------------------------------------------------- 1 | 25 2 | -------------------------------------------------------------------------------- /test/test_2021/030_if_test3.out: -------------------------------------------------------------------------------- 1 | 25 2 | -------------------------------------------------------------------------------- /test/test_2021/031_if_test4.out: -------------------------------------------------------------------------------- 1 | 25 2 | -------------------------------------------------------------------------------- /test/test_2021/032_if_test5.out: -------------------------------------------------------------------------------- 1 | 25 2 | -------------------------------------------------------------------------------- /test/test_2021/037_break.out: -------------------------------------------------------------------------------- 1 | 201 2 | -------------------------------------------------------------------------------- /test/test_2021/038_continue.out: -------------------------------------------------------------------------------- 1 | 36 2 | -------------------------------------------------------------------------------- /test/test_2021/049_unary_op.out: -------------------------------------------------------------------------------- 1 | 0 2 | -------------------------------------------------------------------------------- /test/test_2021/054_hex_defn.out: -------------------------------------------------------------------------------- 1 | 15 2 | -------------------------------------------------------------------------------- /test/test_2021/101_insert_order.in: -------------------------------------------------------------------------------- 1 | 50 -------------------------------------------------------------------------------- /test/test_2020/06_var_defn_func.out: -------------------------------------------------------------------------------- 1 | 4 2 | -------------------------------------------------------------------------------- /test/test_2020/12_array_traverse.out: -------------------------------------------------------------------------------- 1 | 0 2 | -------------------------------------------------------------------------------- /test/test_2020/13_array_traverse2.out: -------------------------------------------------------------------------------- 1 | 0 2 | -------------------------------------------------------------------------------- /test/test_2020/15_array_test3.out: -------------------------------------------------------------------------------- 1 | 15 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/18_cal_prio.in: -------------------------------------------------------------------------------- 1 | 1 2 3 2 | -------------------------------------------------------------------------------- /test/test_2020/21_suminput.out: -------------------------------------------------------------------------------- 1 | 6 2 | 6 3 | -------------------------------------------------------------------------------- /test/test_2020/27_while_test1.out: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /test/test_2020/28_while_test2.out: -------------------------------------------------------------------------------- 1 | 54 2 | -------------------------------------------------------------------------------- /test/test_2020/29_while_test3.out: -------------------------------------------------------------------------------- 1 | 23 2 | -------------------------------------------------------------------------------- /test/test_2020/31_while_if_test2.out: -------------------------------------------------------------------------------- 1 | 96 2 | -------------------------------------------------------------------------------- /test/test_2020/32_while_if_test3.out: -------------------------------------------------------------------------------- 1 | 88 2 | -------------------------------------------------------------------------------- /test/test_2020/34_func_test2.out: -------------------------------------------------------------------------------- 1 | 127 2 | -------------------------------------------------------------------------------- /test/test_2020/35_array_test.out: -------------------------------------------------------------------------------- 1 | 15 2 | -------------------------------------------------------------------------------- /test/test_2020/36_domain_test.out: -------------------------------------------------------------------------------- 1 | 12 2 | -------------------------------------------------------------------------------- /test/test_2020/46_and_prior_or.out: -------------------------------------------------------------------------------- 1 | 0 2 | -------------------------------------------------------------------------------- /test/test_2020/47_minus_with_sub.out: -------------------------------------------------------------------------------- 1 | 0 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/49_decl_in_defn.out: -------------------------------------------------------------------------------- 1 | 12 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/60_while_fibonacci.in: -------------------------------------------------------------------------------- 1 | 4 2 | -------------------------------------------------------------------------------- /test/test_2020/60_while_fibonacci.out: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /test/test_2020/61_rec_fibonacci.in: -------------------------------------------------------------------------------- 1 | 10 2 | -------------------------------------------------------------------------------- /test/test_2020/65_word_count.out: -------------------------------------------------------------------------------- 1 | 56 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/66_go_upstairs.out: -------------------------------------------------------------------------------- 1 | 8 2 | -------------------------------------------------------------------------------- /test/test_2020/68_accumulate.out: -------------------------------------------------------------------------------- 1 | 210 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/72_enum.out: -------------------------------------------------------------------------------- 1 | 01000 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2020/73_exchange_value.in: -------------------------------------------------------------------------------- 1 | 4 2 | 20 -------------------------------------------------------------------------------- /test/test_2020/75_max_container.out: -------------------------------------------------------------------------------- 1 | 56 2 | -------------------------------------------------------------------------------- /test/test_2020/77_unique_path.out: -------------------------------------------------------------------------------- 1 | 6 2 | -------------------------------------------------------------------------------- /test/test_2020/81_go_upstairs.out: -------------------------------------------------------------------------------- 1 | 8 2 | -------------------------------------------------------------------------------- /test/test_2020/83_accumulate.out: -------------------------------------------------------------------------------- 1 | 210 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/83_enc_dec.out: -------------------------------------------------------------------------------- 1 | 401 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2020/87_enum.out: -------------------------------------------------------------------------------- 1 | 01000 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2020/88_exchange_value.in: -------------------------------------------------------------------------------- 1 | 4 2 | 20 -------------------------------------------------------------------------------- /test/test_2020/90_max_container.out: -------------------------------------------------------------------------------- 1 | 56 2 | -------------------------------------------------------------------------------- /test/test_2020/92_unique_path.out: -------------------------------------------------------------------------------- 1 | 6 2 | -------------------------------------------------------------------------------- /test/test_2020/97_enc_dec.out: -------------------------------------------------------------------------------- 1 | 401 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/006_array_initialize.out: -------------------------------------------------------------------------------- 1 | 9 -------------------------------------------------------------------------------- /test/test_2021/007_arr_defn4.out: -------------------------------------------------------------------------------- 1 | 21 2 | -------------------------------------------------------------------------------- /test/test_2021/012_func_defn.out: -------------------------------------------------------------------------------- 1 | 90 2 | -------------------------------------------------------------------------------- /test/test_2021/013_var_defn_func.out: -------------------------------------------------------------------------------- 1 | 15 2 | -------------------------------------------------------------------------------- /test/test_2021/034_while_test1.out: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /test/test_2021/035_while_test2.out: -------------------------------------------------------------------------------- 1 | 54 2 | -------------------------------------------------------------------------------- /test/test_2021/036_while_test3.out: -------------------------------------------------------------------------------- 1 | 23 2 | -------------------------------------------------------------------------------- /test/test_2021/042_arr_expr_len.out: -------------------------------------------------------------------------------- 1 | 51 2 | -------------------------------------------------------------------------------- /test/test_2021/043_op_priority1.out: -------------------------------------------------------------------------------- 1 | 40 2 | -------------------------------------------------------------------------------- /test/test_2021/044_op_priority2.out: -------------------------------------------------------------------------------- 1 | 24 2 | -------------------------------------------------------------------------------- /test/test_2021/045_op_priority3.out: -------------------------------------------------------------------------------- 1 | 40 2 | -------------------------------------------------------------------------------- /test/test_2021/046_op_priority4.out: -------------------------------------------------------------------------------- 1 | 1 2 | -------------------------------------------------------------------------------- /test/test_2021/051_logi_assign.in: -------------------------------------------------------------------------------- 1 | 4 4 2 | -------------------------------------------------------------------------------- /test/test_2021/051_logi_assign.out: -------------------------------------------------------------------------------- 1 | 1 2 | -------------------------------------------------------------------------------- /test/test_2021/055_hex_oct_add.out: -------------------------------------------------------------------------------- 1 | 88 2 | -------------------------------------------------------------------------------- /test/test_2021/060_scope.out: -------------------------------------------------------------------------------- 1 | 1 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/071_accumulate.out: -------------------------------------------------------------------------------- 1 | 210 2 | 0 -------------------------------------------------------------------------------- /test/test_2021/071_exchange_array.out: -------------------------------------------------------------------------------- 1 | 2 2 | -------------------------------------------------------------------------------- /test/test_2021/080_go_upstairs.out: -------------------------------------------------------------------------------- 1 | 8 2 | -------------------------------------------------------------------------------- /test/test_2021/081_exgcd.out: -------------------------------------------------------------------------------- 1 | 13 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/091_kmp.out: -------------------------------------------------------------------------------- 1 | 23 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/095_empty_stmt.out: -------------------------------------------------------------------------------- 1 | 21 2 | -------------------------------------------------------------------------------- /test/test_2021/099_skip_spaces.out: -------------------------------------------------------------------------------- 1 | 55 2 | -------------------------------------------------------------------------------- /test/test_2021/100_int_literal.out: -------------------------------------------------------------------------------- 1 | 230 2 | -------------------------------------------------------------------------------- /test/test_2021/107_long_code2.out: -------------------------------------------------------------------------------- 1 | 160 2 | -------------------------------------------------------------------------------- /test/test_2021/113_many_locals2.in: -------------------------------------------------------------------------------- 1 | 5 2 | -------------------------------------------------------------------------------- /test/test_2021/115_nested_calls.out: -------------------------------------------------------------------------------- 1 | 250 2 | -------------------------------------------------------------------------------- /test/test_2021/117_nested_loops.out: -------------------------------------------------------------------------------- 1 | 38 2 | -------------------------------------------------------------------------------- /src/Optimize/Pass.cpp: -------------------------------------------------------------------------------- 1 | #include "Pass.h" 2 | 3 | -------------------------------------------------------------------------------- /test/test_2020/30_while_if_test1.out: -------------------------------------------------------------------------------- 1 | 198 2 | -------------------------------------------------------------------------------- /test/test_2020/38_if_complex_expr.out: -------------------------------------------------------------------------------- 1 | 2 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/40_index_complex_expr.out: -------------------------------------------------------------------------------- 1 | 45 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/42_index_func_ret.out: -------------------------------------------------------------------------------- 1 | -7 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/43_time_prior_plus.out: -------------------------------------------------------------------------------- 1 | -4 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/44_add_prior_equal.out: -------------------------------------------------------------------------------- 1 | 0 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/45_equal_prior_logic.out: -------------------------------------------------------------------------------- 1 | 0 2 | -------------------------------------------------------------------------------- /test/test_2020/50_recursion_test1.out: -------------------------------------------------------------------------------- 1 | 24 2 | -------------------------------------------------------------------------------- /test/test_2020/51_recursion_test2.out: -------------------------------------------------------------------------------- 1 | 55 2 | -------------------------------------------------------------------------------- /test/test_2020/52_recursion_test3.out: -------------------------------------------------------------------------------- 1 | 120 2 | -------------------------------------------------------------------------------- /test/test_2020/63_simple_atoi.in: -------------------------------------------------------------------------------- 1 | -0258425 2 | -------------------------------------------------------------------------------- /test/test_2020/63_simple_atoi.out: -------------------------------------------------------------------------------- 1 | -258425 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/64_alpha_count.out: -------------------------------------------------------------------------------- 1 | 299 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2020/69_last_word_length.out: -------------------------------------------------------------------------------- 1 | 5 2 | -------------------------------------------------------------------------------- /test/test_2020/71_max_subsequence_sum.out: -------------------------------------------------------------------------------- 1 | 25 2 | -------------------------------------------------------------------------------- /test/test_2020/74_itera_sqrt.out: -------------------------------------------------------------------------------- 1 | 20 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2020/76_int_factor_sum.out: -------------------------------------------------------------------------------- 1 | 172 2 | -------------------------------------------------------------------------------- /test/test_2020/84_last_word_length.out: -------------------------------------------------------------------------------- 1 | 5 2 | -------------------------------------------------------------------------------- /test/test_2020/86_bin_search.out: -------------------------------------------------------------------------------- 1 | 6 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2020/86_max_subsequence_sum.out: -------------------------------------------------------------------------------- 1 | 25 2 | -------------------------------------------------------------------------------- /test/test_2020/89_itera_sqrt.out: -------------------------------------------------------------------------------- 1 | 20 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2020/91_int_factor_sum.out: -------------------------------------------------------------------------------- 1 | 172 2 | -------------------------------------------------------------------------------- /test/test_2020/91_line_search.out: -------------------------------------------------------------------------------- 1 | 6 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2020/99_bin_search.out: -------------------------------------------------------------------------------- 1 | 6 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2020/99_register_realloc.out: -------------------------------------------------------------------------------- 1 | 132 2 | -------------------------------------------------------------------------------- /test/test_2021/009_const_var_defn2.out: -------------------------------------------------------------------------------- 1 | 14 2 | -------------------------------------------------------------------------------- /test/test_2021/010_const_var_defn3.out: -------------------------------------------------------------------------------- 1 | 5 2 | -------------------------------------------------------------------------------- /test/test_2021/029_if_test2.out: -------------------------------------------------------------------------------- 1 | -5 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/033_while_if.out: -------------------------------------------------------------------------------- 1 | 88 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/039_while_if_test1.out: -------------------------------------------------------------------------------- 1 | 198 2 | -------------------------------------------------------------------------------- /test/test_2021/040_while_if_test2.out: -------------------------------------------------------------------------------- 1 | 96 2 | -------------------------------------------------------------------------------- /test/test_2021/041_while_if_test3.out: -------------------------------------------------------------------------------- 1 | 88 2 | -------------------------------------------------------------------------------- /test/test_2021/046_op_priority4.in: -------------------------------------------------------------------------------- 1 | 0 1 1 1 1 2 | -------------------------------------------------------------------------------- /test/test_2021/047_op_priority5.out: -------------------------------------------------------------------------------- 1 | 1 2 | 1 3 | -------------------------------------------------------------------------------- /test/test_2021/048_stmt_expr.out: -------------------------------------------------------------------------------- 1 | 1024 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/050_unary_op2.out: -------------------------------------------------------------------------------- 1 | 4 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/072_percolation.out: -------------------------------------------------------------------------------- 1 | 8 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/073_backpack.out: -------------------------------------------------------------------------------- 1 | 15 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/079_calculator.out: -------------------------------------------------------------------------------- 1 | 2 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/080_color.out: -------------------------------------------------------------------------------- 1 | 39480 2 | 56 3 | -------------------------------------------------------------------------------- /test/test_2021/092_max_flow.out: -------------------------------------------------------------------------------- 1 | 77 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/093_n_queens.in: -------------------------------------------------------------------------------- 1 | 4 2 | 1 5 6 8 3 | -------------------------------------------------------------------------------- /test/test_2021/094_substr.out: -------------------------------------------------------------------------------- 1 | 43 2 | 6 3 | 0 4 | -------------------------------------------------------------------------------- /test/test_2021/101_scope2.out: -------------------------------------------------------------------------------- 1 | -40 2 | 62 3 | -------------------------------------------------------------------------------- /test/test_2021/105_long_array2.out: -------------------------------------------------------------------------------- 1 | 3 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/110_many_params3.out: -------------------------------------------------------------------------------- 1 | 83 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/112_many_locals.out: -------------------------------------------------------------------------------- 1 | 254 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/116_nested_calls2.out: -------------------------------------------------------------------------------- 1 | 4 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2020/21_suminput.in: -------------------------------------------------------------------------------- 1 | 3 2 | 1 3 | 2 4 | 3 5 | -------------------------------------------------------------------------------- /test/test_2020/39_assign_complex_expr.out: -------------------------------------------------------------------------------- 1 | -171 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/41_index_arithmetic_expr.out: -------------------------------------------------------------------------------- 1 | 3 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/61_rec_fibonacci.out: -------------------------------------------------------------------------------- 1 | 55 2 | 55 3 | -------------------------------------------------------------------------------- /test/test_2020/67_remove_duplicate_element.out: -------------------------------------------------------------------------------- 1 | 8 2 | -------------------------------------------------------------------------------- /test/test_2020/78_decbinoct.out: -------------------------------------------------------------------------------- 1 | 110010000 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2020/82_remove_duplicate_element.out: -------------------------------------------------------------------------------- 1 | 8 2 | -------------------------------------------------------------------------------- /test/test_2020/88_array_concat.out: -------------------------------------------------------------------------------- 1 | 012012 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2020/93_decbinoct.out: -------------------------------------------------------------------------------- 1 | 110010000 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/057_if_complex_expr.out: -------------------------------------------------------------------------------- 1 | 2 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/059_short_circuit2.out: -------------------------------------------------------------------------------- 1 | 05040 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/070_remove_duplicate_element.out: -------------------------------------------------------------------------------- 1 | 8 2 | -------------------------------------------------------------------------------- /test/test_2021/100_array_concat.out: -------------------------------------------------------------------------------- 1 | 012012 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/108_many_params.out: -------------------------------------------------------------------------------- 1 | 331024 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/111_many_globals.out: -------------------------------------------------------------------------------- 1 | 2822118 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/114_register_alloc.out: -------------------------------------------------------------------------------- 1 | 194 2 | 194 3 | -------------------------------------------------------------------------------- /test/test_2020/20_arr_sum.in: -------------------------------------------------------------------------------- 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | -------------------------------------------------------------------------------- /test/test_2020/73_exchange_value.out: -------------------------------------------------------------------------------- 1 | 20 2 | 4 3 | 0 4 | -------------------------------------------------------------------------------- /test/test_2020/82_int_split.out: -------------------------------------------------------------------------------- 1 | 1 2 | 4 3 | 7 4 | 8 5 | 0 -------------------------------------------------------------------------------- /test/test_2020/84_palindrome_number.out: -------------------------------------------------------------------------------- 1 | 1221 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2020/88_exchange_value.out: -------------------------------------------------------------------------------- 1 | 20 2 | 4 3 | 0 4 | -------------------------------------------------------------------------------- /test/test_2020/96_int_split.out: -------------------------------------------------------------------------------- 1 | 1 2 | 4 3 | 7 4 | 8 5 | 0 -------------------------------------------------------------------------------- /test/test_2020/98_palindrome_number.out: -------------------------------------------------------------------------------- 1 | 1221 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/056_assign_complex_expr.out: -------------------------------------------------------------------------------- 1 | -171 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/058_short_circuit.out: -------------------------------------------------------------------------------- 1 | 11111210 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/069_greatest_common_divisor.in: -------------------------------------------------------------------------------- 1 | 91 39 2 | -------------------------------------------------------------------------------- /test/test_2021/085_dijkstra.out: -------------------------------------------------------------------------------- 1 | 0 1 8 4 13 17 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/088_hanoi.in: -------------------------------------------------------------------------------- 1 | 4 2 | 4 3 | 7 4 | 3 5 | 9 6 | -------------------------------------------------------------------------------- /test/test_2021/114_register_alloc.in: -------------------------------------------------------------------------------- 1 | 1 2 | 1 2 3 4 3 | -------------------------------------------------------------------------------- /test/test_2021/058_short_circuit.in: -------------------------------------------------------------------------------- 1 | 11 2 | 10 3 | 100 4 | 99 -------------------------------------------------------------------------------- /test/test_2021/069_greatest_common_divisor.out: -------------------------------------------------------------------------------- 1 | 13 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/070_multiplication_puzzle.out: -------------------------------------------------------------------------------- 1 | 3650 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/074_matrix_add.out: -------------------------------------------------------------------------------- 1 | 024 2 | 024 3 | 024 4 | 0 5 | -------------------------------------------------------------------------------- /test/test_2021/075_matrix_sub.out: -------------------------------------------------------------------------------- 1 | 000 2 | 000 3 | 000 4 | 0 5 | -------------------------------------------------------------------------------- /test/test_2021/076_matrix_mul.out: -------------------------------------------------------------------------------- 1 | 036 2 | 036 3 | 036 4 | 0 5 | -------------------------------------------------------------------------------- /test/test_2021/117_nested_loops.in: -------------------------------------------------------------------------------- 1 | 12 10 2 | 2 2 3 2 3 2 2 3 | -------------------------------------------------------------------------------- /test/test_2021/068_genealogical_tree.in: -------------------------------------------------------------------------------- 1 | 0 4 5 1 0 1 0 5 3 0 3 0 2 | -------------------------------------------------------------------------------- /test/test_2021/077_matrix_tran.out: -------------------------------------------------------------------------------- 1 | 000 2 | 111 3 | 222 4 | 0 5 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | build 2 | cmake-build-debug 3 | .idea 4 | .vscode 5 | .cache 6 | -------------------------------------------------------------------------------- /test/test_2021/068_genealogical_tree.out: -------------------------------------------------------------------------------- 1 | 2 2 | 4 3 | 5 4 | 3 5 | 1 6 | 0 7 | -------------------------------------------------------------------------------- /test/test_2021/089_hidden_var.out: -------------------------------------------------------------------------------- 1 | 331 2 | 1 3 | 218 4 | 5 5 | 6719 6 | 0 7 | -------------------------------------------------------------------------------- /test/test_2021/079_calculator.in: -------------------------------------------------------------------------------- 1 | (4 - (3 - 5) * 2 + 100) % (2^3 - 1) / 2 + 1 2 | -------------------------------------------------------------------------------- /test/test_2021/102_short_circuit3.out: -------------------------------------------------------------------------------- 1 | 0 3 0 3 2 | 3 3 3 | ADF 4 | CIJK 5 | 0 6 | -------------------------------------------------------------------------------- /test/test_2021/115_nested_calls.in: -------------------------------------------------------------------------------- 1 | 1 2 3 4 5 2 | 6 7 8 9 10 3 | 11 12 13 14 4 | -------------------------------------------------------------------------------- /test/test_2021/086_full_conn.out: -------------------------------------------------------------------------------- 1 | dog 2 | cat 3 | dog 4 | dog 5 | cat 6 | cat 7 | 0 8 | -------------------------------------------------------------------------------- /test/test_2021/090_int_io.out: -------------------------------------------------------------------------------- 1 | 4006571 2 | 9900 3 | 1504379 4 | 758219 5 | 99336677 6 | 0 7 | -------------------------------------------------------------------------------- /test/test_2021/091_kmp.in: -------------------------------------------------------------------------------- 1 | abcabdbca 2 | aababcabdabdababcabdbcadceadbcababcdcbaabsbda 3 | -------------------------------------------------------------------------------- /doc/Dominance.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Komorebi660/SysYF-Compiler/HEAD/doc/Dominance.pdf -------------------------------------------------------------------------------- /doc/SysYF语言定义.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Komorebi660/SysYF-Compiler/HEAD/doc/SysYF语言定义.pdf -------------------------------------------------------------------------------- /src/Checker/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library( 2 | Checker STATIC 3 | SyntaxTreeChecker.cpp 4 | ) -------------------------------------------------------------------------------- /doc/DeadCodeEli.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Komorebi660/SysYF-Compiler/HEAD/doc/DeadCodeEli.pdf -------------------------------------------------------------------------------- /src/ASTBuilder/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library( 2 | ASTLib STATIC 3 | SyntaxTree.cpp 4 | ) 5 | -------------------------------------------------------------------------------- /test/test_2021/084_expr_eval.out: -------------------------------------------------------------------------------- 1 | -820 2 | 696 3 | 1220 4 | panic! 5 | -1 6 | panic! 7 | -1 8 | 0 9 | -------------------------------------------------------------------------------- /test/test_2021/113_many_locals2.out: -------------------------------------------------------------------------------- 1 | 01234567891011121314151617181920212223242526272829 2 | 6 3 | 25 4 | -------------------------------------------------------------------------------- /src/ASTPrinter/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library( 2 | ASTPrinter 3 | SyntaxTreePrinter.cpp 4 | ) 5 | -------------------------------------------------------------------------------- /src/ErrorReporter/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library( 2 | ErrReporter 3 | ErrorReporter.cpp 4 | ) 5 | -------------------------------------------------------------------------------- /test/test_2021/095_empty_stmt.sy: -------------------------------------------------------------------------------- 1 | int main() { 2 | int a = 10; 3 | ; 4 | return a * 2 + 1; 5 | } 6 | -------------------------------------------------------------------------------- /src/SysYFIRBuilder/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library( 2 | SysYFIRBuilder STATIC 3 | IRBuilder.cpp 4 | ) 5 | -------------------------------------------------------------------------------- /test/test_2020/53_sort_test1.out: -------------------------------------------------------------------------------- 1 | 0 2 | 1 3 | 2 4 | 3 5 | 4 6 | 5 7 | 6 8 | 7 9 | 8 10 | 9 11 | 0 12 | -------------------------------------------------------------------------------- /test/test_2020/54_sort_test2.out: -------------------------------------------------------------------------------- 1 | 0 2 | 1 3 | 2 4 | 3 5 | 4 6 | 5 7 | 6 8 | 7 9 | 8 10 | 9 11 | 0 12 | -------------------------------------------------------------------------------- /test/test_2020/55_sort_test3.out: -------------------------------------------------------------------------------- 1 | 0 2 | 1 3 | 2 4 | 3 5 | 4 6 | 5 7 | 6 8 | 7 9 | 8 10 | 9 11 | 0 12 | -------------------------------------------------------------------------------- /test/test_2020/56_sort_test4.out: -------------------------------------------------------------------------------- 1 | 0 2 | 1 3 | 2 4 | 3 5 | 4 6 | 5 7 | 6 8 | 7 9 | 8 10 | 9 11 | 0 12 | -------------------------------------------------------------------------------- /test/test_2020/57_sort_test5.out: -------------------------------------------------------------------------------- 1 | 0 2 | 1 3 | 2 4 | 3 5 | 4 6 | 5 7 | 6 8 | 7 9 | 8 10 | 9 11 | 0 12 | -------------------------------------------------------------------------------- /test/test_2020/58_sort_test6.out: -------------------------------------------------------------------------------- 1 | 0 2 | 1 3 | 2 4 | 3 5 | 4 6 | 5 7 | 6 8 | 7 9 | 8 10 | 9 11 | 0 12 | -------------------------------------------------------------------------------- /test/test_2020/59_sort_test7.out: -------------------------------------------------------------------------------- 1 | 0 2 | 1 3 | 2 4 | 3 5 | 4 6 | 5 7 | 6 8 | 7 9 | 8 10 | 9 11 | 0 12 | -------------------------------------------------------------------------------- /test/test_2021/061_bubble_sort.out: -------------------------------------------------------------------------------- 1 | 0 2 | 1 3 | 2 4 | 3 5 | 4 6 | 5 7 | 6 8 | 7 9 | 8 10 | 9 11 | 0 12 | -------------------------------------------------------------------------------- /test/test_2021/109_many_params2.out: -------------------------------------------------------------------------------- 1 | 0123000009 2 | 9 3 | 805 3612 2695 1778 861 3668 2751 1834 917 0 4 | 0 5 | -------------------------------------------------------------------------------- /test/test_2020/90_insert_order.out: -------------------------------------------------------------------------------- 1 | 1 2 | 3 3 | 4 4 | 7 5 | 8 6 | 11 7 | 13 8 | 18 9 | 50 10 | 50 11 | 0 12 | -------------------------------------------------------------------------------- /test/test_2021/101_insert_order.out: -------------------------------------------------------------------------------- 1 | 1 2 | 3 3 | 4 4 | 7 5 | 8 6 | 11 7 | 13 8 | 18 9 | 50 10 | 50 11 | 0 12 | -------------------------------------------------------------------------------- /test/test_2021/054_hex_defn.sy: -------------------------------------------------------------------------------- 1 | // test hexadecimal define 2 | int main(){ 3 | int a; 4 | a = 0xf; 5 | return a; 6 | } -------------------------------------------------------------------------------- /test/test_2021/072_percolation.in: -------------------------------------------------------------------------------- 1 | 2 2 2 | 3 1 3 | 4 2 4 | 4 4 5 | 1 2 6 | 2 3 7 | 2 1 8 | 3 2 9 | 3 4 10 | 3 1 11 | -------------------------------------------------------------------------------- /test/test_2021/087_gcd.out: -------------------------------------------------------------------------------- 1 | 20 2 | 1 3 | 1 4 | 1 5 | 2 6 | 2 7 | 4 8 | 1 9 | 1 10 | 1 11 | 7 12 | 1 13 | 4 14 | 0 15 | -------------------------------------------------------------------------------- /test/test_2021/099_skip_spaces.in: -------------------------------------------------------------------------------- 1 | 1 2 3 4 5 6 7 8 9 10 2 | 11 12 13 14 15 16 17 18 19 20 3 | 23 233 2333 23333 233333 0 0 4 | -------------------------------------------------------------------------------- /test/test_2020/03_var_defn2.sy: -------------------------------------------------------------------------------- 1 | int a,b; 2 | 3 | int main(){ 4 | a=10; 5 | b=5; 6 | int c=a*2+b+3; 7 | return c; 8 | } -------------------------------------------------------------------------------- /test/test_2021/096_side_effect.out: -------------------------------------------------------------------------------- 1 | 1 2 | 4 2 3 | 5 4 | 8 4 5 | 9 6 | 12 8 7 | 13 8 | 16 16 9 | 24 16 10 | 29 16 11 | 29 12 | -------------------------------------------------------------------------------- /test/test_2020/06_var_defn_func.sy: -------------------------------------------------------------------------------- 1 | int defn(){ 2 | return 4; 3 | } 4 | 5 | int main(){ 6 | int a=defn(); 7 | return a; 8 | } -------------------------------------------------------------------------------- /test/test_2020/49_decl_in_defn.sy: -------------------------------------------------------------------------------- 1 | int main () { 2 | int a; 3 | a = 12; 4 | int t; 5 | putint(a); 6 | return 0; 7 | } 8 | -------------------------------------------------------------------------------- /test/test_2021/085_dijkstra.in: -------------------------------------------------------------------------------- 1 | 6 9 2 | 1 2 1 3 | 2 3 9 4 | 1 3 12 5 | 2 4 3 6 | 4 3 4 7 | 3 5 5 8 | 4 5 13 9 | 5 6 4 10 | 4 6 15 11 | -------------------------------------------------------------------------------- /test/test_2021/084_expr_eval.in: -------------------------------------------------------------------------------- 1 | 5 2 | 1+2* 3/4- 2 *411 ; 3 | 0 -1+10*1329000/ 22219 +99 ; 4 | 1199+ 98888/2227 %112-23; 5 | * 2; 6 | ; 7 | -------------------------------------------------------------------------------- /test/test_2021/078_big_int_mul.out: -------------------------------------------------------------------------------- 1 | 3102343761271952753654505476597868729361003112012671299112096683775968059149440439438030623917912792644636180 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2021/055_hex_oct_add.sy: -------------------------------------------------------------------------------- 1 | //test add of hex and oct 2 | int main(){ 3 | int a, b; 4 | a = 0xf; 5 | b = 0xc; 6 | return a + b + 075; 7 | } -------------------------------------------------------------------------------- /test/test_2021/090_int_io.in: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 4 | 4006571 5 | 6 | 9900 7 | 1504379 8 | 9 | 10 | 758219 11 | 99336677 12 | 13 | 14 | -------------------------------------------------------------------------------- /test/test_2021/108_many_params.in: -------------------------------------------------------------------------------- 1 | 17 2 | 13 3 | 80 4 | 55 5 | 81 6 | 91 7 | 95 8 | 58 9 | 13 10 | 5 11 | 63 12 | 19 13 | 54 14 | 45 15 | 67 16 | 63 17 | -------------------------------------------------------------------------------- /test/test_2020/10_break.sy: -------------------------------------------------------------------------------- 1 | int main(){ 2 | int a=10; 3 | while(a>0){ 4 | a=a-1; 5 | if(a==5) 6 | break; 7 | } 8 | return a; 9 | } -------------------------------------------------------------------------------- /test/test_2020/11_while.sy: -------------------------------------------------------------------------------- 1 | int a; 2 | int b; 3 | int main(){ 4 | b=0; 5 | a=3; 6 | while(a>0){ 7 | b = b+a; 8 | a = a-1; 9 | } 10 | return b; 11 | } 12 | -------------------------------------------------------------------------------- /test/test_2021/092_max_flow.in: -------------------------------------------------------------------------------- 1 | 7 11 2 | 1 6 22 3 | 1 3 10 4 | 1 4 56 5 | 3 7 15 6 | 3 5 11 7 | 5 7 45 8 | 4 5 100 9 | 6 3 34 10 | 2 3 9 11 | 6 7 68 12 | 6 2 6 13 | -------------------------------------------------------------------------------- /test/test_2020/02_arr_defn4.sy: -------------------------------------------------------------------------------- 1 | int main(){ 2 | int a[4][2]={1,2,3,4,5,6,7,8}; 3 | int b[4][2]={{a[0][0],a[0][1]},{3,4},{5,6},{7,8}}; 4 | return b[0][0]+b[3][1]; 5 | } -------------------------------------------------------------------------------- /test/test_2021/103_long_func.out: -------------------------------------------------------------------------------- 1 | 1 2 | 2 3 | 4 4 | 8 5 | 16 6 | 32 7 | 64 8 | 128 9 | 256 10 | 512 11 | 1024 12 | 2048 13 | 4096 14 | 8192 15 | 16384 16 | 32768 17 | 0 18 | -------------------------------------------------------------------------------- /test/test_2020/04_func_defn.sy: -------------------------------------------------------------------------------- 1 | int a; 2 | int func(int p){ 3 | p = p - 1; 4 | return p; 5 | } 6 | int main(){ 7 | int b; 8 | a = 10; 9 | b = func(a); 10 | return b; 11 | } 12 | -------------------------------------------------------------------------------- /test/test_2021/104_long_array.out: -------------------------------------------------------------------------------- 1 | 02425294124166176216218-22282-34782142718170218357718485218672718700218877718865218842718825218832718815218822718825218832718815218822718805218 2 | 216 3 | -------------------------------------------------------------------------------- /test/test_2020/18_cal_prio.sy: -------------------------------------------------------------------------------- 1 | int a; 2 | int b; 3 | int c; 4 | int main(){ 5 | a = getint(); 6 | b = getint(); 7 | c = getint(); 8 | int d; 9 | d = a+b*c; 10 | return d; 11 | } 12 | -------------------------------------------------------------------------------- /test/test_2021/045_op_priority3.sy: -------------------------------------------------------------------------------- 1 | //test the priority of unary operator and binary operator 2 | int main(){ 3 | int a, b; 4 | a = 10; 5 | b = 30; 6 | return a - -5 + b + -5; 7 | } -------------------------------------------------------------------------------- /test/test_2021/097_var_name.out: -------------------------------------------------------------------------------- 1 | 3 2 | 5 3 | 8 4 | 13 5 | 21 6 | 34 7 | 55 8 | 89 9 | 144 10 | 233 11 | 377 12 | 610 13 | 987 14 | 1597 15 | 2584 16 | 4181 17 | 6765 18 | 10946 19 | 236 20 | -------------------------------------------------------------------------------- /test/test_2020/19_neg_expr.sy: -------------------------------------------------------------------------------- 1 | int a; 2 | int b; 3 | int main(){ 4 | a = getint(); 5 | b = getint(); 6 | int c; 7 | c = -(a + b); 8 | putint(c); 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /test/test_2021/012_func_defn.sy: -------------------------------------------------------------------------------- 1 | int a; 2 | float b=100; 3 | int func(int p, int q){ 4 | p = b+p-q; 5 | return p; 6 | } 7 | int main(){ 8 | const int b=10; 9 | return func(a,b); 10 | } 11 | -------------------------------------------------------------------------------- /test/test_2020/46_and_prior_or.ll: -------------------------------------------------------------------------------- 1 | define i32 @main() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 0 6 | } 7 | -------------------------------------------------------------------------------- /test/test_2021/043_op_priority1.sy: -------------------------------------------------------------------------------- 1 | //test the priority of add and mul 2 | int main(){ 3 | int a, b, c, d; 4 | a = 10; 5 | b = 4; 6 | c = 2; 7 | d = 2; 8 | return c + a * b - d; 9 | } -------------------------------------------------------------------------------- /test/test_2021/049_unary_op.ll: -------------------------------------------------------------------------------- 1 | define i32 @main() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 0 6 | } 7 | -------------------------------------------------------------------------------- /test/test_2021/049_unary_op.sy: -------------------------------------------------------------------------------- 1 | int main() { 2 | int a; 3 | a = 10; 4 | if (+-!!!a) { 5 | a = - - -1; 6 | } 7 | else { 8 | a = 0; 9 | } 10 | return a; 11 | } -------------------------------------------------------------------------------- /test/test_2021/054_hex_defn.ll: -------------------------------------------------------------------------------- 1 | define i32 @main() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 15 6 | } 7 | -------------------------------------------------------------------------------- /test/test_2021/095_empty_stmt.ll: -------------------------------------------------------------------------------- 1 | define i32 @main() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 21 6 | } 7 | -------------------------------------------------------------------------------- /test/test_2020/09_void_func.sy: -------------------------------------------------------------------------------- 1 | int a,b,c; 2 | 3 | void add(int a,int b){ 4 | c=a+b; 5 | return; 6 | } 7 | 8 | int main(){ 9 | a=3; 10 | b=2; 11 | add(a,b); 12 | return c; 13 | } -------------------------------------------------------------------------------- /test/test_2020/45_equal_prior_logic.ll: -------------------------------------------------------------------------------- 1 | define i32 @main() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 0 6 | } 7 | -------------------------------------------------------------------------------- /test/test_2021/006_array_initialize.sy: -------------------------------------------------------------------------------- 1 | const int c[10][10][2]={2}; 2 | 3 | int main() 4 | { 5 | const int b[5][5]={1,2}; 6 | int a[c[0][0][0]][b[0][1]] = {{4+1.0,2}, 7.1+2}; 7 | return a[1][0]+a[1][1]; 8 | } -------------------------------------------------------------------------------- /test/test_2021/043_op_priority1.ll: -------------------------------------------------------------------------------- 1 | define i32 @main() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 40 6 | } 7 | -------------------------------------------------------------------------------- /test/test_2021/044_op_priority2.ll: -------------------------------------------------------------------------------- 1 | define i32 @main() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 24 6 | } 7 | -------------------------------------------------------------------------------- /test/test_2021/044_op_priority2.sy: -------------------------------------------------------------------------------- 1 | //test the priority of add and mul 2 | int main(){ 3 | int a, b, c, d; 4 | a = 10; 5 | b = 4; 6 | c = 2; 7 | d = 2; 8 | return (c + a) * (b - d); 9 | } -------------------------------------------------------------------------------- /test/test_2021/045_op_priority3.ll: -------------------------------------------------------------------------------- 1 | define i32 @main() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 40 6 | } 7 | -------------------------------------------------------------------------------- /test/test_2021/055_hex_oct_add.ll: -------------------------------------------------------------------------------- 1 | define i32 @main() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 88 6 | } 7 | -------------------------------------------------------------------------------- /test/test_2021/087_gcd.in: -------------------------------------------------------------------------------- 1 | 13 2 | 32860 47240 3 | 34234 9291 4 | 3243 821 5 | 984201 892342 6 | 842 102 7 | 32 918 8 | 4 8 9 | 255 1087 10 | 44 229 11 | 5423 260 12 | 35 7 13 | 4269 4213 14 | 556 208 15 | -------------------------------------------------------------------------------- /test/test_2021/009_const_var_defn2.sy: -------------------------------------------------------------------------------- 1 | const int a[5]={2,11,3,13,14}; 2 | 3 | int func(int a[]) 4 | { 5 | return a[1]; 6 | } 7 | 8 | int main() 9 | { 10 | int b[a[a[0]]]={0,0,a[4]}; 11 | return b[2]; 12 | } -------------------------------------------------------------------------------- /test/test_2020/11_continue.sy: -------------------------------------------------------------------------------- 1 | int main(){ 2 | int a=10; 3 | while(a>0){ 4 | if(a>5){ 5 | a=a-1; 6 | continue; 7 | } 8 | return a; 9 | } 10 | return a; 11 | } -------------------------------------------------------------------------------- /test/test_2021/051_logi_assign.sy: -------------------------------------------------------------------------------- 1 | int a; 2 | int b; 3 | int main() 4 | { 5 | a=getint(); 6 | b=getint(); 7 | int c; 8 | if (a==b&&a!=3) { 9 | c = 1; 10 | } 11 | else { 12 | c = 0; 13 | } 14 | return c; 15 | } 16 | -------------------------------------------------------------------------------- /test/test_2021/048_stmt_expr.sy: -------------------------------------------------------------------------------- 1 | int k; 2 | const int n = 10; 3 | int main () { 4 | int i = 0; 5 | k = 1; 6 | while (i <= n - 1) { 7 | i = i + 1; 8 | k + 1; 9 | k = k + k; 10 | } 11 | putint(k); 12 | return k; 13 | } 14 | -------------------------------------------------------------------------------- /test/test_2020/47_minus_with_sub.sy: -------------------------------------------------------------------------------- 1 | // Use minus with sub in one expr 2 | int main () { 3 | int a; 4 | int b; 5 | a = -2; 6 | b = 1; 7 | a = a - -b + -(a + b) % -(a - b); 8 | putint(a); 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /test/test_2021/083_brainfk.out: -------------------------------------------------------------------------------- 1 | I'm Suzumiya Haruhi from the East Junior High School, and I'm not interested in ordinary humans. If there were an alien, a time traveller, an otherworlder or a superhero among you, please come to meet me! That's all. 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2020/50_recursion_test1.sy: -------------------------------------------------------------------------------- 1 | int fact(int n) { 2 | if (n == 0) { 3 | return 1; 4 | } 5 | int nn; 6 | nn = n-1; 7 | return (n * fact(nn)); 8 | } 9 | 10 | int main() { 11 | int n; 12 | n = 4; 13 | return fact(n); 14 | } 15 | -------------------------------------------------------------------------------- /test/test_2021/013_var_defn_func.sy: -------------------------------------------------------------------------------- 1 | const int a[10]={1,2,3,4,5,6,7,8,9,10}; 2 | int b[5]={1,2,3,4,5}; 3 | 4 | int func(int a[],int b[5]){ 5 | return a[0]+a[1]+a[2]+b[3]+b[4]; 6 | } 7 | 8 | int main(){ 9 | float c=func(a,b); 10 | return c; 11 | } -------------------------------------------------------------------------------- /test/test_2021/010_const_var_defn3.sy: -------------------------------------------------------------------------------- 1 | const int a[5]={2,11,3,13,14}; 2 | 3 | int func(int a[]) 4 | { 5 | return a[3]; 6 | } 7 | 8 | int main() 9 | { 10 | const int b=0; 11 | int c[a[a[b]]+1]={0,0,0,a[b]+a[a[b]]}; 12 | return func(c); 13 | } -------------------------------------------------------------------------------- /test/test_2020/22_if_test1.sy: -------------------------------------------------------------------------------- 1 | // test if-else 2 | int ifElse() { 3 | int a; 4 | a = 5; 5 | if (a == 5) { 6 | a = 25; 7 | } else { 8 | a = a * 2; 9 | } 10 | return (a); 11 | } 12 | 13 | 14 | int main() { 15 | return (ifElse()); 16 | } 17 | -------------------------------------------------------------------------------- /test/test_2021/028_if_test1.sy: -------------------------------------------------------------------------------- 1 | // test if-else 2 | int ifElse() { 3 | int a; 4 | a = 5; 5 | if (a == 5) { 6 | a = 25; 7 | } else { 8 | a = a * 2; 9 | } 10 | return (a); 11 | } 12 | 13 | 14 | int main() { 15 | return (ifElse()); 16 | } 17 | -------------------------------------------------------------------------------- /test/test_2021/042_arr_expr_len.sy: -------------------------------------------------------------------------------- 1 | const int N = -1; 2 | int arr[N + 2 * 4 - 99 / 99] = {1, 2, 33, 4, 5, 6}; 3 | 4 | int main() { 5 | int i = 0, sum = 0; 6 | while (i < 6) { 7 | sum = sum + arr[i]; 8 | i = i + 1; 9 | } 10 | return sum; 11 | } 12 | -------------------------------------------------------------------------------- /test/test_2020/47_minus_with_sub.ll: -------------------------------------------------------------------------------- 1 | declare void @put_int(i32) 2 | 3 | define i32 @main() { 4 | label_entry: 5 | call void @put_int(i32 0) 6 | br label %label_ret 7 | label_ret: ; preds = %label_entry 8 | ret i32 0 9 | } 10 | -------------------------------------------------------------------------------- /test/test_2020/49_decl_in_defn.ll: -------------------------------------------------------------------------------- 1 | declare void @put_int(i32) 2 | 3 | define i32 @main() { 4 | label_entry: 5 | call void @put_int(i32 12) 6 | br label %label_ret 7 | label_ret: ; preds = %label_entry 8 | ret i32 0 9 | } 10 | -------------------------------------------------------------------------------- /test/test_2021/050_unary_op2.sy: -------------------------------------------------------------------------------- 1 | int main() { 2 | int a, b; 3 | a = 070; 4 | b = 0x4; 5 | a = a - - 4 + + b; 6 | if (+-!!!a) { 7 | a = - - -1; 8 | } 9 | else { 10 | a = 0 + + b; 11 | } 12 | putint(a); 13 | return 0; 14 | } -------------------------------------------------------------------------------- /test/test_2020/43_time_prior_plus.ll: -------------------------------------------------------------------------------- 1 | declare void @put_int(i32) 2 | 3 | define i32 @main() { 4 | label_entry: 5 | call void @put_int(i32 -4) 6 | br label %label_ret 7 | label_ret: ; preds = %label_entry 8 | ret i32 0 9 | } 10 | -------------------------------------------------------------------------------- /test/test_2020/52_recursion_test3.sy: -------------------------------------------------------------------------------- 1 | // factorial number 2 | int a; 3 | int r; 4 | int fac(int x) 5 | { 6 | if (x <2) 7 | return 1; 8 | a = x - 1; 9 | r = fac(a); 10 | r = x * r; 11 | return r; 12 | } 13 | 14 | int main(){ 15 | int a; 16 | a = 5; 17 | return fac(a); 18 | } -------------------------------------------------------------------------------- /test/test_2021/116_nested_calls2.sy: -------------------------------------------------------------------------------- 1 | int f(int a, int b) { 2 | return a * b; 3 | } 4 | 5 | int g(int a, int b) { 6 | return a % b; 7 | } 8 | 9 | int h(int a, int b) { 10 | return f(f(2, g(a, b)), g(f(a, b), 4)); 11 | } 12 | 13 | int main () { 14 | putint(h(11, 3)); 15 | return 0; 16 | } -------------------------------------------------------------------------------- /test/test_2020/51_recursion_test2.sy: -------------------------------------------------------------------------------- 1 | int fib(int n) { 2 | if (n == 0) 3 | return 0; 4 | if (n == 1) 5 | return 1; 6 | int p; 7 | p = n - 1; 8 | int q; 9 | q = n - 2; 10 | return fib(p) + fib(q); 11 | } 12 | 13 | int main() { 14 | int tmp; 15 | tmp = 10; 16 | return fib(tmp); 17 | } -------------------------------------------------------------------------------- /test/test_2021/037_break.sy: -------------------------------------------------------------------------------- 1 | //test break 2 | int main(){ 3 | int i; 4 | i = 0; 5 | int sum; 6 | sum = 0; 7 | while(i < 100){ 8 | if(i == 50){ 9 | break; 10 | } 11 | sum = sum + i; 12 | i = i + 1; 13 | } 14 | return sum; 15 | } -------------------------------------------------------------------------------- /src/Optimize/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library( 2 | SysYFPass STATIC 3 | Pass.cpp 4 | ComSubExprEli.cpp 5 | DominateTree.cpp 6 | RDominateTree.cpp 7 | Mem2Reg.cpp 8 | ConstPropagation.cpp 9 | DeadCodeEli.cpp 10 | ActiveVar.cpp 11 | ) 12 | -------------------------------------------------------------------------------- /test/test_2021/047_op_priority5.sy: -------------------------------------------------------------------------------- 1 | int a = 1; 2 | int b = 0; 3 | int c = 1; 4 | int d = 2; 5 | int e = 4; 6 | int main() 7 | { 8 | int flag=0; 9 | if(a * b / c == e + d && a * (a + b) + c <= d + e || a - (b * c) == d - a / c) 10 | { 11 | flag=1; 12 | } 13 | putint(flag); 14 | return flag; 15 | } -------------------------------------------------------------------------------- /test/test_2020/43_time_prior_plus.sy: -------------------------------------------------------------------------------- 1 | // Check the priority between time and plus 2 | int main() { 3 | int a; 4 | a = 20; 5 | int b; 6 | b = 5; 7 | int c; 8 | c = 6; 9 | int d; 10 | d = -4; 11 | a = a + c * d - b % (a + d) / a; 12 | putint(a); 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /test/test_2021/005_func.sy: -------------------------------------------------------------------------------- 1 | void f1(int a[][5][6]){ 2 | a[3][1][2] = 7; 3 | } 4 | 5 | void f2(int a[2][3][4][5][6]){ 6 | a[0][1][3][1][2] = 10; 7 | } 8 | 9 | int main() 10 | { 11 | int a[2][3][4][5][6]; 12 | f1(a[1][2]); 13 | f2(a); 14 | return a[1][2][3][1][2]+a[0][1][3][1][2]; 15 | } -------------------------------------------------------------------------------- /test/test_2020/24_if_test3.sy: -------------------------------------------------------------------------------- 1 | // test if-if-else 2 | int ififElse() { 3 | int a; 4 | a = 5; 5 | int b; 6 | b = 10; 7 | if(a == 5) 8 | if (b == 10) 9 | a = 25; 10 | else 11 | a = a + 15; 12 | 13 | return (a); 14 | } 15 | 16 | int main(){ 17 | return (ififElse()); 18 | } 19 | -------------------------------------------------------------------------------- /test/test_2020/39_assign_complex_expr.ll: -------------------------------------------------------------------------------- 1 | declare void @put_int(i32) 2 | 3 | define i32 @main() { 4 | label_entry: 5 | call void @put_int(i32 -1) 6 | call void @put_int(i32 71) 7 | br label %label_ret 8 | label_ret: ; preds = %label_entry 9 | ret i32 0 10 | } 11 | -------------------------------------------------------------------------------- /test/test_2020/70_multi.sy: -------------------------------------------------------------------------------- 1 | int main() 2 | { 3 | //newline=10; 4 | int i; 5 | int sum; 6 | sum=0; 7 | //m = 1478; 8 | //int t; 9 | i=0; 10 | while(i<21) 11 | { 12 | sum=sum*i; 13 | i=i+1; 14 | } 15 | 16 | putint(sum); 17 | 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /test/test_2020/85_multi.sy: -------------------------------------------------------------------------------- 1 | int main() 2 | { 3 | //newline=10; 4 | int i; 5 | int sum; 6 | sum=0; 7 | //m = 1478; 8 | //int t; 9 | i=0; 10 | while(i<21) 11 | { 12 | sum=sum*i; 13 | i=i+1; 14 | } 15 | 16 | putint(sum); 17 | 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /test/test_2021/030_if_test3.sy: -------------------------------------------------------------------------------- 1 | // test if-if-else 2 | int ififElse() { 3 | int a; 4 | a = 5; 5 | int b; 6 | b = 10; 7 | if(a == 5) 8 | if (b == 10) 9 | a = 25; 10 | else 11 | a = a + 15; 12 | 13 | return (a); 14 | } 15 | 16 | int main(){ 17 | return (ififElse()); 18 | } 19 | -------------------------------------------------------------------------------- /test/test_2021/082_reverse_output.sy: -------------------------------------------------------------------------------- 1 | void reverse(int n) { 2 | int next; 3 | if (n <= 1) { 4 | next=getint(); 5 | putint(next); 6 | } 7 | else { 8 | next=getint(); 9 | reverse(n-1); 10 | putint(next); 11 | } 12 | } 13 | 14 | int main() { 15 | int i=200; 16 | reverse(i); 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /test/test_2020/25_if_test4.sy: -------------------------------------------------------------------------------- 1 | // test if-{if-else} 2 | int if_ifElse_() { 3 | int a; 4 | a = 5; 5 | int b; 6 | b = 10; 7 | if(a == 5){ 8 | if (b == 10) 9 | a = 25; 10 | else 11 | a = a + 15; 12 | } 13 | return (a); 14 | } 15 | 16 | int main(){ 17 | return (if_ifElse_()); 18 | } 19 | -------------------------------------------------------------------------------- /test/test_2020/26_if_test5.sy: -------------------------------------------------------------------------------- 1 | // test if-{if}-else 2 | int if_if_Else() { 3 | int a; 4 | a = 5; 5 | int b; 6 | b = 10; 7 | if(a == 5){ 8 | if (b == 10) 9 | a = 25; 10 | } 11 | else 12 | a = a + 15; 13 | return (a); 14 | } 15 | 16 | int main(){ 17 | return (if_if_Else()); 18 | } 19 | -------------------------------------------------------------------------------- /test/test_2020/68_accumulate.sy: -------------------------------------------------------------------------------- 1 | 2 | int main() 3 | { 4 | //newline=10; 5 | int i; 6 | int sum; 7 | sum=0; 8 | //m = 1478; 9 | //int t; 10 | i=0; 11 | while(i<21) 12 | { 13 | sum=sum+i; 14 | i=i+1; 15 | } 16 | 17 | putint(sum); 18 | 19 | return 0; 20 | } -------------------------------------------------------------------------------- /test/test_2020/83_accumulate.sy: -------------------------------------------------------------------------------- 1 | 2 | int main() 3 | { 4 | //newline=10; 5 | int i; 6 | int sum; 7 | sum=0; 8 | //m = 1478; 9 | //int t; 10 | i=0; 11 | while(i<21) 12 | { 13 | sum=sum+i; 14 | i=i+1; 15 | } 16 | 17 | putint(sum); 18 | 19 | return 0; 20 | } -------------------------------------------------------------------------------- /test/test_2021/031_if_test4.sy: -------------------------------------------------------------------------------- 1 | // test if-{if-else} 2 | int if_ifElse_() { 3 | int a; 4 | a = 5; 5 | int b; 6 | b = 10; 7 | if(a == 5){ 8 | if (b == 10) 9 | a = 25; 10 | else 11 | a = a + 15; 12 | } 13 | return (a); 14 | } 15 | 16 | int main(){ 17 | return (if_ifElse_()); 18 | } 19 | -------------------------------------------------------------------------------- /test/test_2021/032_if_test5.sy: -------------------------------------------------------------------------------- 1 | // test if-{if}-else 2 | int if_if_Else() { 3 | int a; 4 | a = 5; 5 | int b; 6 | b = 10; 7 | if(a == 5){ 8 | if (b == 10) 9 | a = 25; 10 | } 11 | else 12 | a = a + 15; 13 | return (a); 14 | } 15 | 16 | int main(){ 17 | return (if_if_Else()); 18 | } 19 | -------------------------------------------------------------------------------- /test/test_2021/046_op_priority4.sy: -------------------------------------------------------------------------------- 1 | int a; 2 | int b; 3 | int c; 4 | int d; 5 | int e; 6 | int main() 7 | { 8 | a=getint(); 9 | b=getint(); 10 | c=getint(); 11 | d=getint(); 12 | e=getint(); 13 | int flag=0; 14 | if(a-b*c!=d-a/c||a*b/c==e+d||a+b+c==d+e) 15 | { 16 | flag=1; 17 | } 18 | return flag; 19 | } 20 | -------------------------------------------------------------------------------- /test/test_2021/056_assign_complex_expr.ll: -------------------------------------------------------------------------------- 1 | declare void @put_int(i32) 2 | 3 | define i32 @main() { 4 | label_entry: 5 | call void @put_int(i32 -1) 6 | call void @put_int(i32 71) 7 | br label %label_ret 8 | label_ret: ; preds = %label_entry 9 | ret i32 0 10 | } 11 | -------------------------------------------------------------------------------- /test/test_2021/071_accumulate.sy: -------------------------------------------------------------------------------- 1 | 2 | int main() 3 | { 4 | //newline=10; 5 | int i; 6 | int sum; 7 | sum=0; 8 | //m = 1478; 9 | //int t; 10 | i=0; 11 | while(i<21) 12 | { 13 | sum=sum+i; 14 | i=i+1; 15 | } 16 | 17 | putint(sum); 18 | 19 | return 0; 20 | } -------------------------------------------------------------------------------- /test/test_2020/27_while_test1.sy: -------------------------------------------------------------------------------- 1 | int doubleWhile() { 2 | int i; 3 | i = 5; 4 | int j; 5 | j = 7; 6 | while (i < 100) { 7 | i = i + 30; 8 | while(j < 100){ 9 | j = j + 6; 10 | } 11 | j = j - 100; 12 | } 13 | return (j); 14 | } 15 | 16 | int main() { 17 | return doubleWhile(); 18 | } 19 | -------------------------------------------------------------------------------- /test/test_2021/034_while_test1.sy: -------------------------------------------------------------------------------- 1 | int doubleWhile() { 2 | int i; 3 | i = 5; 4 | int j; 5 | j = 7; 6 | while (i < 100) { 7 | i = i + 30; 8 | while(j < 100){ 9 | j = j + 6; 10 | } 11 | j = j - 100; 12 | } 13 | return (j); 14 | } 15 | 16 | int main() { 17 | return doubleWhile(); 18 | } 19 | -------------------------------------------------------------------------------- /test/test_2020/20_arr_sum.sy: -------------------------------------------------------------------------------- 1 | int a[5]; 2 | int main(){ 3 | a[0] = getint(); 4 | a[1] = getint(); 5 | a[2] = getint(); 6 | a[3] = getint(); 7 | a[4] = getint(); 8 | int cnt; 9 | cnt = 4; 10 | int sum; 11 | sum = 0; 12 | while( cnt > 1 ){ 13 | sum = sum + a[cnt]; 14 | cnt = cnt - 1; 15 | } 16 | return sum; 17 | } 18 | -------------------------------------------------------------------------------- /test/test_2021/038_continue.sy: -------------------------------------------------------------------------------- 1 | //test continue 2 | int main(){ 3 | int i; 4 | i = 0; 5 | int sum; 6 | sum = 0; 7 | while(i < 100){ 8 | if(i == 50){ 9 | i = i + 1; 10 | continue; 11 | } 12 | sum = sum + i; 13 | i = i + 1; 14 | } 15 | return sum; 16 | } -------------------------------------------------------------------------------- /test/test_2020/03_var_defn2.ll: -------------------------------------------------------------------------------- 1 | @a = global i32 zeroinitializer 2 | @b = global i32 zeroinitializer 3 | define i32 @main() { 4 | label_entry: 5 | store i32 10, i32* @a 6 | store i32 5, i32* @b 7 | br label %label_ret 8 | label_ret: ; preds = %label_entry 9 | ret i32 28 10 | } 11 | -------------------------------------------------------------------------------- /test/test_2021/069_greatest_common_divisor.sy: -------------------------------------------------------------------------------- 1 | int fun(int m,int n){ 2 | int rem; 3 | while(n > 0){ 4 | rem = m % n; 5 | m = n; 6 | n = rem; 7 | } 8 | return m; 9 | } 10 | int main(){ 11 | int n,m; 12 | int num; 13 | m=getint(); 14 | n=getint(); 15 | num=fun(m,n); 16 | putint(num); 17 | 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /src/SysYFIR/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library( 2 | IRLib STATIC 3 | Type.cpp 4 | User.cpp 5 | Value.cpp 6 | BasicBlock.cpp 7 | Constant.cpp 8 | Function.cpp 9 | GlobalVariable.cpp 10 | Instruction.cpp 11 | Module.cpp 12 | IRPrinter.cpp 13 | ) 14 | -------------------------------------------------------------------------------- /test/test_2020/33_func_test1.sy: -------------------------------------------------------------------------------- 1 | int a; 2 | 3 | int myFunc(int a, int b, int c) { 4 | a = 2; 5 | { 6 | int c; 7 | c = 0; 8 | if (c != 0) { 9 | return 0; 10 | } 11 | } 12 | while (b > 0) { 13 | b = b - 1; 14 | } 15 | return (a)+(b); 16 | } 17 | 18 | int main() { 19 | a = (3); 20 | int b; 21 | b = myFunc(1, 2, 1); 22 | return ((a+b)); 23 | } -------------------------------------------------------------------------------- /include/Frontend/stack.hh: -------------------------------------------------------------------------------- 1 | // A Bison parser, made by GNU Bison 3.7.6. 2 | 3 | // Starting with Bison 3.2, this file is useless: the structure it 4 | // used to define is now defined with the parser itself. 5 | // 6 | // To get rid of this file: 7 | // 1. add '%require "3.2"' (or newer) to your grammar file 8 | // 2. remove references to this file from your build system. 9 | -------------------------------------------------------------------------------- /test/test_2020/41_index_arithmetic_expr.sy: -------------------------------------------------------------------------------- 1 | // Use arithmetic expression as array's index 2 | int main() { 3 | int a; 4 | int b; 5 | int result[3]; 6 | a = 56; 7 | b = 12; 8 | result[0] = 1; 9 | result[1] = 2; 10 | result[2] = 3; 11 | int t; 12 | t = result[(a % b + b) / 5 - 2]; 13 | putint(t); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /test/test_2020/23_if_test2.sy: -------------------------------------------------------------------------------- 1 | // test if-else else-if 2 | int ifElseElseIf() { 3 | int a; 4 | a = 66; 5 | int b; 6 | b = 8923; 7 | if (a == 5) { 8 | b = 25; 9 | } 10 | else if (a == 10) { 11 | b = 42; 12 | } 13 | else { 14 | b = a * 2; 15 | } 16 | return (b); 17 | } 18 | 19 | int main() { 20 | return (ifElseElseIf()); 21 | } 22 | -------------------------------------------------------------------------------- /test/test_2020/46_and_prior_or.sy: -------------------------------------------------------------------------------- 1 | // And is prior to or 2 | int main () { 3 | int a; 4 | int b; 5 | int c; 6 | int d; 7 | a = 3; 8 | b = 8; 9 | c = -4; 10 | d = 15; 11 | int t; 12 | if (d % (b - a) != 0 && a > 0 || d % 3 == 0 && c > 0) { 13 | t = d + c - -b; 14 | putint(t); 15 | } 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /test/test_2020/36_domain_test.sy: -------------------------------------------------------------------------------- 1 | // duplicate names with global array variables and local int variable 2 | int a[2]; 3 | 4 | int func(int array[]) { 5 | a[0] = 1; 6 | return array[3 - a[0]]; 7 | } 8 | 9 | int main() { 10 | int a; 11 | int array[3]; 12 | array[0] = (-1); 13 | array[1] = 4; 14 | array[2] = 8; 15 | a = func(array); 16 | return (a + array[1]); 17 | } -------------------------------------------------------------------------------- /src/Frontend/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library( 2 | Driver STATIC 3 | SysYFDriver.cpp 4 | ) 5 | 6 | add_library( 7 | Scanner STATIC 8 | SysYFScanner.cpp 9 | ) 10 | 11 | add_library( 12 | Parser STATIC 13 | SysYFParser.cpp 14 | ) 15 | 16 | target_link_libraries( 17 | Driver 18 | Scanner 19 | Parser 20 | ASTLib 21 | ) 22 | -------------------------------------------------------------------------------- /test/test_2020/64_alpha_count.in: -------------------------------------------------------------------------------- 1 | Around the world, people gather to explore their emotions through dance. the dances are created as part of celebrations, as religious services, as preparation for challenging hunts and warfare and to express sorrow. indeed, dance does play an important role within a culture and reveals a wide range of information about the characteristics of a culture. 2 | -------------------------------------------------------------------------------- /test/test_2020/65_word_count.in: -------------------------------------------------------------------------------- 1 | Around the world, people gather to explore their emotions through dance. the dances are created as part of celebrations, as religious services, as preparation for challenging hunts and warfare and to express sorrow. indeed, dance does play an important role within a culture and reveals a wide range of information about the characteristics of a culture. 2 | -------------------------------------------------------------------------------- /test/test_2021/050_unary_op2.ll: -------------------------------------------------------------------------------- 1 | declare void @put_int(i32) 2 | 3 | define i32 @main() { 4 | label_entry: 5 | br label %label_3 6 | label_ret: ; preds = %label_3 7 | ret i32 0 8 | label_3: ; preds = %label_entry 9 | call void @put_int(i32 4) 10 | br label %label_ret 11 | } 12 | -------------------------------------------------------------------------------- /test/test_2021/087_gcd.sy: -------------------------------------------------------------------------------- 1 | 2 | int gcd(int m, int n) 3 | { 4 | if (n == 0) { 5 | return m; 6 | } 7 | return gcd(n, m % n); 8 | } 9 | 10 | int main() 11 | { 12 | int k = getint(); 13 | while (k > 0) { 14 | int a = getint(), b = getint(); 15 | putint(gcd(a, b)); putch(10); 16 | k = k - 1; 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /test/test_2020/12_array_traverse.sy: -------------------------------------------------------------------------------- 1 | int a[3][4]; 2 | 3 | int main(){ 4 | int i=0; 5 | int cnt=0; 6 | while(i<=3+4-2){ 7 | int j=i; 8 | while(j>=0){ 9 | if(j<4&&i-j<3){ 10 | a[i-j][j]=cnt; 11 | cnt=1; 12 | } 13 | j=j-1; 14 | } 15 | i=i+1; 16 | } 17 | return 0; 18 | } -------------------------------------------------------------------------------- /test/test_2020/38_if_complex_expr.ll: -------------------------------------------------------------------------------- 1 | declare void @put_int(i32) 2 | 3 | define i32 @main() { 4 | label_entry: 5 | br label %label_1 6 | label_ret: ; preds = %label_1 7 | ret i32 0 8 | label_1: ; preds = %label_entry 9 | call void @put_int(i32 2) 10 | br label %label_ret 11 | } 12 | -------------------------------------------------------------------------------- /test/test_2020/44_add_prior_equal.ll: -------------------------------------------------------------------------------- 1 | declare void @put_int(i32) 2 | 3 | define i32 @main() { 4 | label_entry: 5 | br label %label_1 6 | label_ret: ; preds = %label_1 7 | ret i32 0 8 | label_1: ; preds = %label_entry 9 | call void @put_int(i32 0) 10 | br label %label_ret 11 | } 12 | -------------------------------------------------------------------------------- /test/test_2021/057_if_complex_expr.ll: -------------------------------------------------------------------------------- 1 | declare void @put_int(i32) 2 | 3 | define i32 @main() { 4 | label_entry: 5 | br label %label_1 6 | label_ret: ; preds = %label_1 7 | ret i32 0 8 | label_1: ; preds = %label_entry 9 | call void @put_int(i32 2) 10 | br label %label_ret 11 | } 12 | -------------------------------------------------------------------------------- /test/test_2020/15_array_test3.sy: -------------------------------------------------------------------------------- 1 | int a[5][5]={1,2,3,4,5}; 2 | 3 | int func(int a[][5]){ 4 | int i=0; 5 | int j=0; 6 | int sum=0; 7 | while(i<5){ 8 | while(j<5){ 9 | sum=sum+a[i][j]; 10 | j=j+1; 11 | } 12 | i=i+1; 13 | } 14 | return sum; 15 | } 16 | 17 | int main(){ 18 | putint(func(a)); 19 | return 0; 20 | } -------------------------------------------------------------------------------- /test/test_2020/31_while_if_test2.sy: -------------------------------------------------------------------------------- 1 | int ifWhile() { 2 | int a; 3 | a = 0; 4 | int b; 5 | b = 3; 6 | if (a == 5) { 7 | while(b == 2){ 8 | b = b + 2; 9 | } 10 | b = b + 25; 11 | } 12 | else 13 | while (a < 5) { 14 | b = b * 2; 15 | a = a + 1; 16 | } 17 | return (b); 18 | } 19 | 20 | 21 | int main(){ 22 | return (ifWhile()); 23 | } 24 | -------------------------------------------------------------------------------- /test/test_2021/071_exchange_array.sy: -------------------------------------------------------------------------------- 1 | int main(){ 2 | int a[5][5] = {1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5}; 3 | int m, n, i, j; 4 | m = 2; 5 | n = 3; 6 | j = 0; 7 | while(j < 5){ 8 | i = a[m-1][j]; 9 | a[m-1][j] = a[n-1][j]; 10 | a[n-1][j] = i; 11 | j = j + 1; 12 | } 13 | return a[2][0]; 14 | } -------------------------------------------------------------------------------- /test/test_2021/007_arr_defn4.sy: -------------------------------------------------------------------------------- 1 | int main(){ 2 | const int a[4][2] = {{1, 2}, {3, 4}, {}, 7}; 3 | const int N = 3; 4 | int b[4][2] = {}; 5 | int c[4][2] = {1, 2, 3, 4, 5, 6, 7, 8}; 6 | int d[N + 1][2] = {1, 2, {3}, {5}, a[3][0], 8}; 7 | int e[4][2][1] = {{d[2][1], {c[2][1]}}, {3, 4}, {5, 6}, {7, 8}}; 8 | return e[3][1][0] + e[0][0][0] + e[0][1][0] + d[3][0]; 9 | } 10 | -------------------------------------------------------------------------------- /test/test_2021/040_while_if_test2.sy: -------------------------------------------------------------------------------- 1 | int ifWhile() { 2 | int a; 3 | a = 0; 4 | int b; 5 | b = 3; 6 | if (a == 5) { 7 | while(b == 2){ 8 | b = b + 2; 9 | } 10 | b = b + 25; 11 | } 12 | else 13 | while (a < 5) { 14 | b = b * 2; 15 | a = a + 1; 16 | } 17 | return (b); 18 | } 19 | 20 | 21 | int main(){ 22 | return (ifWhile()); 23 | } 24 | -------------------------------------------------------------------------------- /test/test_2020/35_array_test.sy: -------------------------------------------------------------------------------- 1 | // array as parameter of a function 2 | int field[2]; 3 | 4 | int func(int array[]) { 5 | return array[3 - field[0]]; 6 | } 7 | 8 | int main() { 9 | int i[1]; 10 | int j[3]; 11 | int k; 12 | 13 | field[0] = 1; 14 | field[1] = 2; 15 | 16 | 17 | j[0 + 0] = -1; 18 | j[1] = j[0] - 2; 19 | k = j[1]; 20 | j[2] = 16; 21 | 22 | return func(j) + 2 + k; 23 | } -------------------------------------------------------------------------------- /test/test_2020/44_add_prior_equal.sy: -------------------------------------------------------------------------------- 1 | // Add is prior than equal and not equal 2 | int main () { 3 | int a; 4 | int b; 5 | int c; 6 | a = 1; 7 | b = 4; 8 | c = 28; 9 | int t; 10 | if (c + a != b) { 11 | t = c % -b; 12 | putint(t); 13 | } 14 | if (b - c == a) { 15 | t = c%b+b; 16 | putint(t); 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /test/test_2021/105_long_array2.sy: -------------------------------------------------------------------------------- 1 | int a[4096]; 2 | 3 | int f1(int b[]) 4 | { 5 | a[5] = 4000; 6 | a[4000] = 3; 7 | a[4095] = 7; 8 | b[a[4095]] = a[2216] + 9; 9 | return a[a[5]]; 10 | } 11 | 12 | int main() 13 | { 14 | int b[4][1024] = {{}, {1}, {2, 3}, {4, 5, 6}}; 15 | int c[1024][4] = {{1, 2}, {3, 4}}; 16 | putint(f1(c[0])); 17 | putch(10); 18 | return c[2][0]; 19 | } -------------------------------------------------------------------------------- /test/test_2020/13_array_traverse2.sy: -------------------------------------------------------------------------------- 1 | int a[3][3][3]; 2 | 3 | int main(){ 4 | int i,j,k; 5 | i=0;j=0;k=0; 6 | int cnt=0; 7 | while(i<3){ 8 | while(j<3){ 9 | while(k<3){ 10 | a[i][j][k]=cnt; 11 | cnt=cnt+1; 12 | k=k+1; 13 | } 14 | j=j+1; 15 | } 16 | i=i+1; 17 | } 18 | return 0; 19 | } -------------------------------------------------------------------------------- /test/test_2020/61_rec_fibonacci.sy: -------------------------------------------------------------------------------- 1 | int n; 2 | int f(int x) 3 | { 4 | if(x==1) 5 | return 1; 6 | if(x==2) 7 | return 1; 8 | int a; 9 | int b; 10 | a=x-1; 11 | b=x-2; 12 | int c; 13 | c = f(a)+f(b); 14 | return c; 15 | } 16 | int main() 17 | { 18 | n=getint(); 19 | int t; 20 | int xx; 21 | t=f(n); 22 | putint(t); 23 | int newline; 24 | newline = 10; 25 | putch(newline); 26 | return t; 27 | } 28 | -------------------------------------------------------------------------------- /test/test_2020/06_var_defn_func.ll: -------------------------------------------------------------------------------- 1 | define i32 @defn() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 4 6 | } 7 | define i32 @main() { 8 | label_entry: 9 | %op2 = call i32 @defn() 10 | br label %label_ret 11 | label_ret: ; preds = %label_entry 12 | ret i32 %op2 13 | } 14 | -------------------------------------------------------------------------------- /test/test_2020/22_if_test1.ll: -------------------------------------------------------------------------------- 1 | define i32 @ifElse() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 25 6 | } 7 | define i32 @main() { 8 | label_entry: 9 | %op1 = call i32 @ifElse() 10 | br label %label_ret 11 | label_ret: ; preds = %label_entry 12 | ret i32 %op1 13 | } 14 | -------------------------------------------------------------------------------- /test/test_2021/028_if_test1.ll: -------------------------------------------------------------------------------- 1 | define i32 @ifElse() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 25 6 | } 7 | define i32 @main() { 8 | label_entry: 9 | %op1 = call i32 @ifElse() 10 | br label %label_ret 11 | label_ret: ; preds = %label_entry 12 | ret i32 %op1 13 | } 14 | -------------------------------------------------------------------------------- /test/test_2020/24_if_test3.ll: -------------------------------------------------------------------------------- 1 | define i32 @ififElse() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 25 6 | } 7 | define i32 @main() { 8 | label_entry: 9 | %op1 = call i32 @ififElse() 10 | br label %label_ret 11 | label_ret: ; preds = %label_entry 12 | ret i32 %op1 13 | } 14 | -------------------------------------------------------------------------------- /test/test_2021/030_if_test3.ll: -------------------------------------------------------------------------------- 1 | define i32 @ififElse() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 25 6 | } 7 | define i32 @main() { 8 | label_entry: 9 | %op1 = call i32 @ififElse() 10 | br label %label_ret 11 | label_ret: ; preds = %label_entry 12 | ret i32 %op1 13 | } 14 | -------------------------------------------------------------------------------- /test/test_2020/21_suminput.sy: -------------------------------------------------------------------------------- 1 | //sample:input n numbers,then print the sum of them; 2 | int n; 3 | int a[10]; 4 | int main() 5 | { 6 | n = getint(); 7 | if (n > 10) 8 | return 1; 9 | int s; 10 | int i; 11 | i = 0; 12 | s = i; 13 | while (i < n) { 14 | a[i] = getint(); 15 | s = s + a[i]; 16 | i=i+1; 17 | } 18 | putint(s); 19 | int newline; 20 | newline = 10; 21 | putch(newline); 22 | return s; 23 | } 24 | -------------------------------------------------------------------------------- /test/test_2020/25_if_test4.ll: -------------------------------------------------------------------------------- 1 | define i32 @if_ifElse_() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 25 6 | } 7 | define i32 @main() { 8 | label_entry: 9 | %op1 = call i32 @if_ifElse_() 10 | br label %label_ret 11 | label_ret: ; preds = %label_entry 12 | ret i32 %op1 13 | } 14 | -------------------------------------------------------------------------------- /test/test_2020/26_if_test5.ll: -------------------------------------------------------------------------------- 1 | define i32 @if_if_Else() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 25 6 | } 7 | define i32 @main() { 8 | label_entry: 9 | %op1 = call i32 @if_if_Else() 10 | br label %label_ret 11 | label_ret: ; preds = %label_entry 12 | ret i32 %op1 13 | } 14 | -------------------------------------------------------------------------------- /test/test_2020/30_while_if_test1.sy: -------------------------------------------------------------------------------- 1 | // test while-if 2 | int whileIf() { 3 | int a; 4 | a = 0; 5 | int b; 6 | b = 0; 7 | while (a < 100) { 8 | if (a == 5) { 9 | b = 25; 10 | } 11 | else if (a == 10) { 12 | b = 42; 13 | } 14 | else { 15 | b = a * 2; 16 | } 17 | a = a + 1; 18 | } 19 | return (b); 20 | } 21 | 22 | 23 | int main(){ 24 | return (whileIf()); 25 | } 26 | -------------------------------------------------------------------------------- /test/test_2021/031_if_test4.ll: -------------------------------------------------------------------------------- 1 | define i32 @if_ifElse_() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 25 6 | } 7 | define i32 @main() { 8 | label_entry: 9 | %op1 = call i32 @if_ifElse_() 10 | br label %label_ret 11 | label_ret: ; preds = %label_entry 12 | ret i32 %op1 13 | } 14 | -------------------------------------------------------------------------------- /test/test_2021/032_if_test5.ll: -------------------------------------------------------------------------------- 1 | define i32 @if_if_Else() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 25 6 | } 7 | define i32 @main() { 8 | label_entry: 9 | %op1 = call i32 @if_if_Else() 10 | br label %label_ret 11 | label_ret: ; preds = %label_entry 12 | ret i32 %op1 13 | } 14 | -------------------------------------------------------------------------------- /test/test_2021/039_while_if_test1.sy: -------------------------------------------------------------------------------- 1 | // test while-if 2 | int whileIf() { 3 | int a; 4 | a = 0; 5 | int b; 6 | b = 0; 7 | while (a < 100) { 8 | if (a == 5) { 9 | b = 25; 10 | } 11 | else if (a == 10) { 12 | b = 42; 13 | } 14 | else { 15 | b = a * 2; 16 | } 17 | a = a + 1; 18 | } 19 | return (b); 20 | } 21 | 22 | 23 | int main(){ 24 | return (whileIf()); 25 | } 26 | -------------------------------------------------------------------------------- /include/SysYFIR/IRPrinter.h: -------------------------------------------------------------------------------- 1 | #include "Value.h" 2 | #include "Module.h" 3 | #include "Function.h" 4 | #include "GlobalVariable.h" 5 | #include "Constant.h" 6 | #include "BasicBlock.h" 7 | #include "Instruction.h" 8 | #include "User.h" 9 | #include "Type.h" 10 | 11 | std::string print_as_op( Value *v, bool print_ty ); 12 | std::string print_cmp_type( CmpInst::CmpOp op); 13 | std::string print_fcmp_type( FCmpInst::CmpOp op); -------------------------------------------------------------------------------- /test/test_2020/23_if_test2.ll: -------------------------------------------------------------------------------- 1 | define i32 @ifElseElseIf() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 132 6 | } 7 | define i32 @main() { 8 | label_entry: 9 | %op1 = call i32 @ifElseElseIf() 10 | br label %label_ret 11 | label_ret: ; preds = %label_entry 12 | ret i32 %op1 13 | } 14 | -------------------------------------------------------------------------------- /test/test_2020/60_while_fibonacci.sy: -------------------------------------------------------------------------------- 1 | int n; 2 | int fib(int p){ 3 | int a; 4 | int b; 5 | int c; 6 | a = 0; 7 | b = 1; 8 | if ( p == 0 ){ 9 | return 0; 10 | } 11 | if ( p == 1 ){ 12 | return 1; 13 | } 14 | while ( p > 1 ){ 15 | c = a + b; 16 | a = b; 17 | b = c; 18 | p = p - 1; 19 | } 20 | return c; 21 | } 22 | int main(){ 23 | n = getint(); 24 | int res; 25 | res = fib( n ); 26 | return res; 27 | } 28 | -------------------------------------------------------------------------------- /test/test_2020/73_exchange_value.sy: -------------------------------------------------------------------------------- 1 | int n; 2 | 3 | int main() 4 | { 5 | //newline=10; 6 | int i; 7 | int j; 8 | //m = 1478; 9 | //int t; 10 | i=getint(); 11 | j=getint(); 12 | int temp; 13 | temp=i; 14 | i=j; 15 | j=temp; 16 | 17 | putint(i); 18 | temp = 10; 19 | putch(temp); 20 | putint(j); 21 | temp = 10; 22 | putch(temp); 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /test/test_2020/88_exchange_value.sy: -------------------------------------------------------------------------------- 1 | int n; 2 | 3 | int main() 4 | { 5 | //newline=10; 6 | int i; 7 | int j; 8 | //m = 1478; 9 | //int t; 10 | i=getint(); 11 | j=getint(); 12 | int temp; 13 | temp=i; 14 | i=j; 15 | j=temp; 16 | 17 | putint(i); 18 | temp = 10; 19 | putch(temp); 20 | putint(j); 21 | temp = 10; 22 | putch(temp); 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /test/test_2020/74_itera_sqrt.sy: -------------------------------------------------------------------------------- 1 | int fsqrt(int a) 2 | { 3 | int x0=0; 4 | int x1; 5 | x1=a/2; 6 | while(x0-x1!=0) 7 | { 8 | x0=x1; 9 | x1=(x0+a/x0); 10 | x1=x1/2; 11 | } 12 | 13 | return x1; 14 | 15 | } 16 | 17 | int main() 18 | { 19 | int a; 20 | a=400; 21 | int res; 22 | res=fsqrt(a); 23 | putint(res); 24 | res = 10; 25 | putch(res); 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /test/test_2020/89_itera_sqrt.sy: -------------------------------------------------------------------------------- 1 | int fsqrt(int a) 2 | { 3 | int x0=0; 4 | int x1; 5 | x1=a/2; 6 | while(x0-x1!=0) 7 | { 8 | x0=x1; 9 | x1=(x0+a/x0); 10 | x1=x1/2; 11 | } 12 | 13 | return x1; 14 | 15 | } 16 | 17 | int main() 18 | { 19 | int a; 20 | a=400; 21 | int res; 22 | res=fsqrt(a); 23 | putint(res); 24 | res = 10; 25 | putch(res); 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /test/test_2021/029_if_test2.sy: -------------------------------------------------------------------------------- 1 | // test if-else-if 2 | int ifElseIf() { 3 | int a; 4 | a = 5; 5 | int b; 6 | b = 10; 7 | if(a == 6 || b == 0xb) { 8 | return a; 9 | } 10 | else { 11 | if (b == 10 && a == 1) 12 | a = 25; 13 | else if (b == 10 && a == -5) 14 | a = a + 15; 15 | else 16 | a = -+a; 17 | } 18 | 19 | return a; 20 | } 21 | 22 | int main(){ 23 | putint(ifElseIf()); 24 | return 0; 25 | } -------------------------------------------------------------------------------- /test/test_2021/060_scope.sy: -------------------------------------------------------------------------------- 1 | int a = 7; 2 | 3 | int func() { 4 | int b = a; 5 | int a = 1; 6 | if (a == b) { 7 | a = a + 1; 8 | return 1; 9 | } 10 | else 11 | return 0; 12 | } 13 | 14 | int main() { 15 | int result = 0; 16 | int i = 0; 17 | while (i < 100) { 18 | if (func() == 1) 19 | result = result + 1; 20 | i = i + 1; 21 | } 22 | if (result < 100) 23 | putint(1); 24 | else 25 | putint(0); 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /test/test_2020/66_go_upstairs.sy: -------------------------------------------------------------------------------- 1 | int climbStairs(int n) { 2 | if(n < 4) 3 | return n; 4 | int dp[10]; 5 | dp[0] = 0; 6 | dp[1] = 1; 7 | dp[2] = 2; 8 | int i; 9 | i = 3; 10 | while(i 40 && temp < 91 || temp > 96 && temp < 123) { 13 | count = count + 1; 14 | } 15 | i = i + 1; 16 | } 17 | putint(count); 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /test/test_2021/059_short_circuit2.sy: -------------------------------------------------------------------------------- 1 | int func(int n) { 2 | if (n <= 50) { 3 | putint(n); 4 | return 1; 5 | } 6 | else { 7 | putint(n); 8 | return 0; 9 | } 10 | } 11 | 12 | int main() { 13 | int i; 14 | 15 | if (func(0) == 1 || func(50) == 1 && func(100) == 0) 16 | i = 0; 17 | else 18 | i = 1; 19 | 20 | if (func(50) == 1 && func(40) == 1 || func(1) == 1 ) 21 | i = 0; 22 | else 23 | i = 1; 24 | 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /test/test_2020/32_while_if_test3.sy: -------------------------------------------------------------------------------- 1 | int deepWhileBr(int a, int b) { 2 | int c; 3 | c = a + b; 4 | while (c < 75) { 5 | int d; 6 | d = 42; 7 | if (c < 100) { 8 | c = c + d; 9 | if (c > 99) { 10 | int e; 11 | e = d * 2; 12 | if (1 == 1) { 13 | c = e * 2; 14 | } 15 | } 16 | } 17 | } 18 | return (c); 19 | } 20 | 21 | int main() { 22 | int p; 23 | p = 2; 24 | return deepWhileBr(p, p); 25 | } 26 | -------------------------------------------------------------------------------- /test/test_2021/041_while_if_test3.sy: -------------------------------------------------------------------------------- 1 | int deepWhileBr(int a, int b) { 2 | int c; 3 | c = a + b; 4 | while (c < 75) { 5 | int d; 6 | d = 42; 7 | if (c < 100) { 8 | c = c + d; 9 | if (c > 99) { 10 | int e; 11 | e = d * 2; 12 | if (1 == 1) { 13 | c = e * 2; 14 | } 15 | } 16 | } 17 | } 18 | return (c); 19 | } 20 | 21 | int main() { 22 | int p; 23 | p = 2; 24 | return deepWhileBr(p, p); 25 | } 26 | -------------------------------------------------------------------------------- /test/test_2021/029_if_test2.ll: -------------------------------------------------------------------------------- 1 | declare void @put_int(i32) 2 | 3 | define i32 @ifElseIf() { 4 | label_entry: 5 | br label %label_ret 6 | label_ret: ; preds = %label_entry 7 | ret i32 -5 8 | } 9 | define i32 @main() { 10 | label_entry: 11 | %op1 = call i32 @ifElseIf() 12 | call void @put_int(i32 %op1) 13 | br label %label_ret 14 | label_ret: ; preds = %label_entry 15 | ret i32 0 16 | } 17 | -------------------------------------------------------------------------------- /test/test_2020/79_gcd.sy: -------------------------------------------------------------------------------- 1 | int n; 2 | 3 | int gcd(int m,int n) 4 | { 5 | int t; 6 | int r; 7 | 8 | if(m 10) { 9 | k = k - 88; 10 | if (k < 1000) { 11 | int g = 9; 12 | { 13 | int l = 11; 14 | { 15 | g = 10; 16 | k = k - g; 17 | int g = 11; 18 | k = k + g + l; 19 | } 20 | } 21 | } 22 | } 23 | putint(k); 24 | } 25 | return k; 26 | } 27 | -------------------------------------------------------------------------------- /test/test_2020/04_func_defn.ll: -------------------------------------------------------------------------------- 1 | @a = global i32 zeroinitializer 2 | define i32 @func(i32 %arg0) { 3 | label_entry: 4 | %op4 = sub i32 %arg0, 1 5 | br label %label_ret 6 | label_ret: ; preds = %label_entry 7 | ret i32 %op4 8 | } 9 | define i32 @main() { 10 | label_entry: 11 | store i32 10, i32* @a 12 | %op3 = call i32 @func(i32 10) 13 | br label %label_ret 14 | label_ret: ; preds = %label_entry 15 | ret i32 %op3 16 | } 17 | -------------------------------------------------------------------------------- /test/test_2020/38_if_complex_expr.sy: -------------------------------------------------------------------------------- 1 | // Use complex expression in if structure 2 | int main () { 3 | int a; 4 | int b; 5 | int c; 6 | int d; 7 | int result; 8 | a = 5; 9 | b = 5; 10 | c = 1; 11 | d = -2; 12 | result = 2; 13 | if ((d * 1 / 2) < 0 || (a - b) != 0 && (c + 3) % 2 != 0) { 14 | putint(result); 15 | } 16 | if ((d % 2 + 67) < 0 || (a - b) != 0 && (c + 2) % 2 != 0) { 17 | result = 4; 18 | putint(result); 19 | } 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /test/test_2020/80_lcm.sy: -------------------------------------------------------------------------------- 1 | int n; 2 | 3 | int gcd(int m,int n) 4 | { 5 | int a; 6 | int b; 7 | a=m; 8 | b=n; 9 | 10 | int t; 11 | int r; 12 | 13 | if(m 10 && func(i)) i = 1; else i = 0; 13 | i = getint(); 14 | if (i > 11 && func(i)) i = 1; else i = 0; 15 | i = getint(); 16 | if (i <= 99 || func(i)) i = 1; else i = 0; 17 | i = getint(); 18 | if (i <= 100 || func(i)) i = 1; else i = 0; 19 | if (!func(99) && func(100)) i = 1; else i = 0; 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /test/test_2020/78_decbinoct.sy: -------------------------------------------------------------------------------- 1 | int dec2bin(int a) 2 | { 3 | int res; 4 | int k; 5 | int i; 6 | int temp; 7 | res=0; 8 | k=1; 9 | temp=a; 10 | while(temp!=0) 11 | { 12 | i=temp%2; 13 | res=k*i+res; 14 | k=k*10; 15 | temp=temp/2; 16 | } 17 | return res; 18 | 19 | } 20 | 21 | int main() 22 | { 23 | int a; 24 | a=400; 25 | int res; 26 | res=dec2bin(a); 27 | putint(res); 28 | res = 10; 29 | putch(res); 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /test/test_2020/93_decbinoct.sy: -------------------------------------------------------------------------------- 1 | int dec2bin(int a) 2 | { 3 | int res; 4 | int k; 5 | int i; 6 | int temp; 7 | res=0; 8 | k=1; 9 | temp=a; 10 | while(temp!=0) 11 | { 12 | i=temp%2; 13 | res=k*i+res; 14 | k=k*10; 15 | temp=temp/2; 16 | } 17 | return res; 18 | 19 | } 20 | 21 | int main() 22 | { 23 | int a; 24 | a=400; 25 | int res; 26 | res=dec2bin(a); 27 | putint(res); 28 | res = 10; 29 | putch(res); 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /test/test_2020/62_long_code.out: -------------------------------------------------------------------------------- 1 | 7238926282254275832735749053546579352646394592968929756452279588796363928129015723262728293639586883878996254264273279282290354452459574639657756905929935175115723262728293639586883878996254264273279282290354452459574639657756905929935157232627282936395868838789962542642732792822903544524595746396577569059299351572326272829363958688387899625426427327928229035445245957463965775690592993500014500056800018350002210000119500024160002770003581016102157158658902805545816096195895834243461553125546824662331115043274-77600 2 | 0 -------------------------------------------------------------------------------- /test/test_2020/83_enc_dec.sy: -------------------------------------------------------------------------------- 1 | int enc(int a) 2 | { 3 | if(a>25) 4 | a=a+60; 5 | else 6 | { 7 | a=a-15; 8 | } 9 | 10 | return a; 11 | 12 | } 13 | 14 | int dec(int a) 15 | { 16 | if (a>85) 17 | a=a-59; 18 | else 19 | { 20 | a=a+14; 21 | } 22 | 23 | return a; 24 | 25 | } 26 | 27 | int main() 28 | { 29 | int a; 30 | a=400; 31 | int res; 32 | res=enc(a); 33 | res=dec(res); 34 | putint(res); 35 | res = 10; 36 | putch(res); 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /test/test_2020/97_enc_dec.sy: -------------------------------------------------------------------------------- 1 | int enc(int a) 2 | { 3 | if(a>25) 4 | a=a+60; 5 | else 6 | { 7 | a=a-15; 8 | } 9 | 10 | return a; 11 | 12 | } 13 | 14 | int dec(int a) 15 | { 16 | if (a>85) 17 | a=a-59; 18 | else 19 | { 20 | a=a+14; 21 | } 22 | 23 | return a; 24 | 25 | } 26 | 27 | int main() 28 | { 29 | int a; 30 | a=400; 31 | int res; 32 | res=enc(a); 33 | res=dec(res); 34 | putint(res); 35 | res = 10; 36 | putch(res); 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /test/test_2021/070_multiplication_puzzle.sy: -------------------------------------------------------------------------------- 1 | int a[6]={10,1,50,50,20,5}; 2 | int dp[10][10]; 3 | int main() 4 | { 5 | int n; 6 | n=6; 7 | 8 | int k,i,t,j,aa; 9 | k=3; 10 | while(k<=n) 11 | { 12 | i=0; 13 | while(i 99) { 14 | int e; 15 | e = d * 2; 16 | if (get_one(0) == 1) { 17 | c = e * 2; 18 | } 19 | } 20 | } 21 | } 22 | return (c); 23 | } 24 | 25 | int main() { 26 | int p; 27 | p = 2; 28 | p = deepWhileBr(p, p); 29 | putint(p); 30 | return 0; 31 | } -------------------------------------------------------------------------------- /test/test_2021/035_while_test2.sy: -------------------------------------------------------------------------------- 1 | int FourWhile() { 2 | int a; 3 | a = 5; 4 | int b; 5 | int c; 6 | b = 6; 7 | c = 7; 8 | int d; 9 | d = 10; 10 | while (a < 20) { 11 | a = a + 3; 12 | while(b < 10){ 13 | b = b + 1; 14 | while(c == 7){ 15 | c = c - 1; 16 | while(d < 20){ 17 | d = d + 3; 18 | } 19 | d = d - 1; 20 | } 21 | c = c + 1; 22 | } 23 | b = b - 2; 24 | } 25 | 26 | return (a + (b + d) + c); 27 | } 28 | 29 | int main() { 30 | return FourWhile(); 31 | } 32 | -------------------------------------------------------------------------------- /test/test_2020/40_index_complex_expr.sy: -------------------------------------------------------------------------------- 1 | // Use complex expression in assign structure 2 | int main () { 3 | int a; 4 | int b; 5 | int c; 6 | int d; 7 | int result[5]; 8 | a = 5; 9 | b = 5; 10 | c = 1; 11 | d = -2; 12 | result[0] = 1; 13 | result[1] = 2; 14 | result[2] = 3; 15 | result[3] = 4; 16 | result[4] = 5; 17 | int t; 18 | t = result[((d * 1 / 2) + 4 + (a - b) - -(c + 3) % 2) % 5]; 19 | putint(t); 20 | t = result[(((c % 2 + 67) + a - b) - -((c + 2) % 2)) % 5]; 21 | putint(t); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /src/ErrorReporter/ErrorReporter.cpp: -------------------------------------------------------------------------------- 1 | #include "ErrorReporter.h" 2 | 3 | ErrorReporter::ErrorReporter(std::ostream &error_stream) : err(error_stream) {} 4 | 5 | void ErrorReporter::error(Position pos, const std::string &msg) 6 | { 7 | report(pos, msg, "Error"); 8 | } 9 | 10 | void ErrorReporter::warn(Position pos, const std::string &msg) 11 | { 12 | report(pos, msg, "Warning"); 13 | } 14 | 15 | void ErrorReporter::report(Position pos, const std::string &msg, const std::string &prefix) 16 | { 17 | err << prefix << " at position " << pos << ": " << msg << std::endl; 18 | } 19 | -------------------------------------------------------------------------------- /test/test_2020/34_func_test2.sy: -------------------------------------------------------------------------------- 1 | int func1() { 2 | int a; 3 | a = 1; 4 | return a; 5 | } 6 | 7 | int func2() { 8 | int a; 9 | a = 2; 10 | return a; 11 | } 12 | 13 | int func3() { 14 | int a; 15 | a = 4; 16 | return a; 17 | } 18 | 19 | int func4() { 20 | int a; 21 | { 22 | int b; 23 | b = 8; 24 | a = b; 25 | } 26 | { 27 | int b; 28 | b = 16; 29 | a = a + b; 30 | } 31 | return a; 32 | } 33 | 34 | int main() { 35 | int a; 36 | int b; 37 | int c; 38 | a = 32; 39 | b = 32; 40 | c = 32; 41 | 42 | return func1() + func2() + func3() + func4() 43 | + a + b + c; 44 | } -------------------------------------------------------------------------------- /test/test_2021/082_reverse_output.out: -------------------------------------------------------------------------------- 1 | 5975945915885855825795765735705675645615585555525495465435405375345315285255225195165135105075045014984954924894864834804774744714684654624594564534504474444414384354324294264234204174144114084054023993963933903873843813783753723693663633603573543513483453423393363333303273243213183153123093063033002972942912882852822792762732702672642612582552522492462432402372342312282252222192162132102072042011981951921891861831801771741711681651621591561531501471441411381351321291261231201171141111081051029996939087848178757269666360575451484542393633302724211815129630 2 | 0 3 | -------------------------------------------------------------------------------- /test/test_2020/67_remove_duplicate_element.sy: -------------------------------------------------------------------------------- 1 | int removeElement(int nums[], int n, int val) { 2 | int i; 3 | i = 0; 4 | while (i < n) { 5 | if (nums[i] == val) { 6 | nums[i] = nums[n - 1]; 7 | n = n - 1; 8 | } else { 9 | i = i + 1; 10 | } 11 | } 12 | return n; 13 | } 14 | int main(){ 15 | int res; 16 | int a[10]; 17 | a[0]=3;a[1]=3;a[2]=9;a[3]=0;a[4]=0; 18 | a[5]=1;a[6]=1;a[7]=5;a[8]=7;a[9]=8; 19 | res = 10; 20 | int val; 21 | val = 3; 22 | res = removeElement(a, res, val); 23 | return res; 24 | } -------------------------------------------------------------------------------- /test/test_2020/82_remove_duplicate_element.sy: -------------------------------------------------------------------------------- 1 | int removeElement(int nums[], int n, int val) { 2 | int i; 3 | i = 0; 4 | while (i < n) { 5 | if (nums[i] == val) { 6 | nums[i] = nums[n - 1]; 7 | n = n - 1; 8 | } else { 9 | i = i + 1; 10 | } 11 | } 12 | return n; 13 | } 14 | int main(){ 15 | int res; 16 | int a[10]; 17 | a[0]=3;a[1]=3;a[2]=9;a[3]=0;a[4]=0; 18 | a[5]=1;a[6]=1;a[7]=5;a[8]=7;a[9]=8; 19 | res = 10; 20 | int val; 21 | val = 3; 22 | res = removeElement(a, res, val); 23 | return res; 24 | } -------------------------------------------------------------------------------- /test/test_2021/070_remove_duplicate_element.sy: -------------------------------------------------------------------------------- 1 | int removeElement(int nums[], int n, int val) { 2 | int i; 3 | i = 0; 4 | while (i < n) { 5 | if (nums[i] == val) { 6 | nums[i] = nums[n - 1]; 7 | n = n - 1; 8 | } else { 9 | i = i + 1; 10 | } 11 | } 12 | return n; 13 | } 14 | int main(){ 15 | int res; 16 | int a[10]; 17 | a[0]=3;a[1]=3;a[2]=9;a[3]=0;a[4]=0; 18 | a[5]=1;a[6]=1;a[7]=5;a[8]=7;a[9]=8; 19 | res = 10; 20 | int val; 21 | val = 3; 22 | res = removeElement(a, res, val); 23 | return res; 24 | } -------------------------------------------------------------------------------- /test/test_2020/42_index_func_ret.sy: -------------------------------------------------------------------------------- 1 | // Use return value of a function as array's index 2 | int _getMaxOfAll(int result[], int size) { 3 | int maxNum; 4 | maxNum = -999999; 5 | size = size - 1; 6 | while(size > -1) { 7 | if (result[size] > maxNum) { 8 | maxNum = result[size]; 9 | } 10 | size = size - 1; 11 | } 12 | return maxNum; 13 | } 14 | 15 | int main() { 16 | int result[3]; 17 | result[0] = -2; 18 | result[1] = 2; 19 | result[2] = -7; 20 | int x; 21 | x = result[_getMaxOfAll(result, 3)]; 22 | putint(x); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /test/test_2021/088_hanoi.sy: -------------------------------------------------------------------------------- 1 | 2 | void move(int x, int y) 3 | { 4 | putint(x); putch(32); putint(y); putch(44); putch(32); 5 | } 6 | 7 | void hanoi(int n, int one, int two, int three) 8 | { 9 | if (n == 1) 10 | move(one, three); 11 | else { 12 | hanoi(n - 1, one, three, two); 13 | move(one, three); 14 | hanoi(n - 1, two, one, three); 15 | } 16 | } 17 | 18 | int main() 19 | { 20 | int n = getint(); 21 | while (n > 0) { 22 | int x = getint(); 23 | hanoi(x, 1, 2, 3); 24 | putch(10); 25 | n = n - 1; 26 | } 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /test/test_2020/82_int_split.sy: -------------------------------------------------------------------------------- 1 | int N; 2 | 3 | int newline; 4 | 5 | int split(int n ,int a[]) 6 | { 7 | int i; 8 | i=N-1; 9 | while(i!=-1) 10 | { 11 | a[i]=n%10; 12 | n=n/10; 13 | i=i-1; 14 | 15 | } 16 | 17 | return 0; 18 | } 19 | 20 | int main() 21 | { 22 | N=4; 23 | newline=10; 24 | int i; 25 | int m; 26 | int b[4]; 27 | m = 1478; 28 | m = split(m,b); 29 | int t; 30 | i=0; 31 | while(i<4) 32 | { 33 | t=b[i]; 34 | putint(t); 35 | putch(newline); 36 | i=i+1; 37 | 38 | } 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /test/test_2020/96_int_split.sy: -------------------------------------------------------------------------------- 1 | int N; 2 | 3 | int newline; 4 | 5 | int split(int n ,int a[]) 6 | { 7 | int i; 8 | i=N-1; 9 | while(i!=-1) 10 | { 11 | a[i]=n%10; 12 | n=n/10; 13 | i=i-1; 14 | 15 | } 16 | 17 | return 0; 18 | } 19 | 20 | int main() 21 | { 22 | N=4; 23 | newline=10; 24 | int i; 25 | int m; 26 | int b[4]; 27 | m = 1478; 28 | m = split(m,b); 29 | int t; 30 | i=0; 31 | while(i<4) 32 | { 33 | t=b[i]; 34 | putint(t); 35 | putch(newline); 36 | i=i+1; 37 | 38 | } 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /test/test_2020/19_neg_expr.ll: -------------------------------------------------------------------------------- 1 | @a = global i32 zeroinitializer 2 | @b = global i32 zeroinitializer 3 | declare i32 @get_int() 4 | 5 | declare void @put_int(i32) 6 | 7 | define i32 @main() { 8 | label_entry: 9 | %op1 = call i32 @get_int() 10 | store i32 %op1, i32* @a 11 | %op2 = call i32 @get_int() 12 | store i32 %op2, i32* @b 13 | %op4 = load i32, i32* @a 14 | %op5 = load i32, i32* @b 15 | %op6 = add i32 %op4, %op5 16 | %op7 = mul i32 %op6, -1 17 | call void @put_int(i32 %op7) 18 | br label %label_ret 19 | label_ret: ; preds = %label_entry 20 | ret i32 0 21 | } 22 | -------------------------------------------------------------------------------- /test/test_2020/41_index_arithmetic_expr.ll: -------------------------------------------------------------------------------- 1 | declare void @put_int(i32) 2 | 3 | define i32 @main() { 4 | label_entry: 5 | %op3 = alloca [3 x i32] 6 | %op4 = getelementptr [3 x i32], [3 x i32]* %op3, i32 0, i32 0 7 | store i32 1, i32* %op4 8 | %op5 = getelementptr [3 x i32], [3 x i32]* %op3, i32 0, i32 1 9 | store i32 2, i32* %op5 10 | %op6 = getelementptr [3 x i32], [3 x i32]* %op3, i32 0, i32 2 11 | store i32 3, i32* %op6 12 | %op16 = load i32, i32* %op6 13 | call void @put_int(i32 %op16) 14 | br label %label_ret 15 | label_ret: ; preds = %label_entry 16 | ret i32 0 17 | } 18 | -------------------------------------------------------------------------------- /include/Optimize/DeadCodeEli.h: -------------------------------------------------------------------------------- 1 | #ifndef SYSYF_DEADCODEELI_H 2 | #define SYSYF_DEADCODEELI_H 3 | 4 | #include "Pass.h" 5 | #include "Module.h" 6 | 7 | class DeadCodeEli : public Pass 8 | { 9 | public: 10 | DeadCodeEli(Module *module) : Pass(module) {} 11 | void execute() final; 12 | 13 | const std::string get_name() const override { return name; } 14 | 15 | private: 16 | Function *func_; 17 | const std::string name = "DeadCodeElimination"; 18 | void preparemark(); 19 | void mark(); 20 | void sweep(); 21 | void deleteunusedbb(); 22 | void DeleteUnusedJump(Function *func); //删除多余分支指令 23 | }; 24 | 25 | #endif // SYSYF_DEADCODEELI_H 26 | -------------------------------------------------------------------------------- /test/test_2021/096_side_effect.sy: -------------------------------------------------------------------------------- 1 | 2 | int a = -1, b = 1; 3 | 4 | int inc_a() 5 | { 6 | int b = a; 7 | b = b + 1; 8 | a = b; 9 | return a; 10 | } 11 | 12 | int main() 13 | { 14 | int k = 5; 15 | while (k >= 0) { 16 | if (inc_a() && inc_a() && inc_a()) { 17 | putint(a); putch(32); putint(b); putch(10); 18 | } 19 | if (inc_a() < 14 || inc_a() && inc_a() - inc_a() + 1) { 20 | putint(a); putch(10); 21 | b = b * 2; 22 | } else { 23 | inc_a(); 24 | } 25 | k = k - 1; 26 | } 27 | putint(a); putch(32); putint(b); putch(10); 28 | return a; 29 | } 30 | -------------------------------------------------------------------------------- /test/test_2020/69_last_word_length.sy: -------------------------------------------------------------------------------- 1 | int lengthOfLastWord(int s[], int n) { 2 | if(n == 0) 3 | return 0; 4 | int c; 5 | c = n - 1; 6 | while(c > -1 && s[c] == 0){ 7 | c = c - 1; 8 | } 9 | if(c == -1) 10 | return 0; 11 | int i; 12 | i = c; 13 | while(i > -1){ 14 | if(s[i] == 0) 15 | return n - i - 1 - (n - 1 - c); 16 | i = i - 1; 17 | } 18 | return c - i; 19 | } 20 | int main(){ 21 | int res; 22 | int a[10]; 23 | a[0]=-4;a[1]=3;a[2]=9;a[3]=-2;a[4]=0; 24 | a[5]=1;a[6]=-6;a[7]=5;a[8]=7;a[9]=8; 25 | res = 10; 26 | res = lengthOfLastWord(a, res); 27 | return res; 28 | } -------------------------------------------------------------------------------- /test/test_2020/84_last_word_length.sy: -------------------------------------------------------------------------------- 1 | int lengthOfLastWord(int s[], int n) { 2 | if(n == 0) 3 | return 0; 4 | int c; 5 | c = n - 1; 6 | while(c > -1 && s[c] == 0){ 7 | c = c - 1; 8 | } 9 | if(c == -1) 10 | return 0; 11 | int i; 12 | i = c; 13 | while(i > -1){ 14 | if(s[i] == 0) 15 | return n - i - 1 - (n - 1 - c); 16 | i = i - 1; 17 | } 18 | return c - i; 19 | } 20 | int main(){ 21 | int res; 22 | int a[10]; 23 | a[0]=-4;a[1]=3;a[2]=9;a[3]=-2;a[4]=0; 24 | a[5]=1;a[6]=-6;a[7]=5;a[8]=7;a[9]=8; 25 | res = 10; 26 | res = lengthOfLastWord(a, res); 27 | return res; 28 | } -------------------------------------------------------------------------------- /test/test_2020/09_void_func.ll: -------------------------------------------------------------------------------- 1 | @a = global i32 zeroinitializer 2 | @b = global i32 zeroinitializer 3 | @c = global i32 zeroinitializer 4 | define void @add(i32 %arg0, i32 %arg1) { 5 | label_entry: 6 | %op6 = add i32 %arg0, %arg1 7 | store i32 %op6, i32* @c 8 | br label %label_ret 9 | label_ret: ; preds = %label_entry 10 | ret void 11 | } 12 | define i32 @main() { 13 | label_entry: 14 | store i32 3, i32* @a 15 | store i32 2, i32* @b 16 | call void @add(i32 3, i32 2) 17 | %op3 = load i32, i32* @c 18 | br label %label_ret 19 | label_ret: ; preds = %label_entry 20 | ret i32 %op3 21 | } 22 | -------------------------------------------------------------------------------- /test/test_2020/18_cal_prio.ll: -------------------------------------------------------------------------------- 1 | @a = global i32 zeroinitializer 2 | @b = global i32 zeroinitializer 3 | @c = global i32 zeroinitializer 4 | declare i32 @get_int() 5 | 6 | define i32 @main() { 7 | label_entry: 8 | %op1 = call i32 @get_int() 9 | store i32 %op1, i32* @a 10 | %op2 = call i32 @get_int() 11 | store i32 %op2, i32* @b 12 | %op3 = call i32 @get_int() 13 | store i32 %op3, i32* @c 14 | %op5 = load i32, i32* @a 15 | %op6 = load i32, i32* @b 16 | %op7 = load i32, i32* @c 17 | %op8 = mul i32 %op6, %op7 18 | %op9 = add i32 %op5, %op8 19 | br label %label_ret 20 | label_ret: ; preds = %label_entry 21 | ret i32 %op9 22 | } 23 | -------------------------------------------------------------------------------- /test/test_2020/84_palindrome_number.sy: -------------------------------------------------------------------------------- 1 | int palindrome(int n) 2 | { 3 | int a[4]; 4 | int j; 5 | int flag; 6 | j=0; 7 | while(j<4) 8 | { 9 | a[j]=n%10; 10 | n=n/10; 11 | j=j+1; 12 | } 13 | 14 | if(a[0]==a[3] && a[1]==a[2]) 15 | { 16 | flag=1; 17 | }else{ 18 | flag=0; 19 | } 20 | return flag; 21 | } 22 | 23 | int main() 24 | { 25 | int test; 26 | test=1221; 27 | int flag; 28 | flag=palindrome(test); 29 | if(flag==1) 30 | putint(test); 31 | else 32 | { 33 | flag = 0; 34 | putint(flag); 35 | } 36 | 37 | flag = 10; 38 | putch(flag); 39 | 40 | return 0; 41 | 42 | } 43 | -------------------------------------------------------------------------------- /test/test_2020/98_palindrome_number.sy: -------------------------------------------------------------------------------- 1 | int palindrome(int n) 2 | { 3 | int a[4]; 4 | int j; 5 | int flag; 6 | j=0; 7 | while(j<4) 8 | { 9 | a[j]=n%10; 10 | n=n/10; 11 | j=j+1; 12 | } 13 | 14 | if(a[0]==a[3] && a[1]==a[2]) 15 | { 16 | flag=1; 17 | }else{ 18 | flag=0; 19 | } 20 | return flag; 21 | } 22 | 23 | int main() 24 | { 25 | int test; 26 | test=1221; 27 | int flag; 28 | flag=palindrome(test); 29 | if(flag==1) 30 | putint(test); 31 | else 32 | { 33 | flag = 0; 34 | putint(flag); 35 | } 36 | 37 | flag = 10; 38 | putch(flag); 39 | 40 | return 0; 41 | 42 | } 43 | -------------------------------------------------------------------------------- /test/test_2020/71_max_subsequence_sum.sy: -------------------------------------------------------------------------------- 1 | int maxSubArray(int nums[], int n) { 2 | if(n == 0) 3 | return 0; 4 | if(n == 1) 5 | return nums[0]; 6 | int sum; 7 | sum = nums[0]; 8 | int max; 9 | max = sum; 10 | int i; 11 | i = 1; 12 | while(i < n){ 13 | if(sum < 0) 14 | sum = 0; 15 | sum = sum + nums[i]; 16 | if(max < sum) 17 | max = sum; 18 | i = i + 1; 19 | } 20 | return max; 21 | } 22 | int main(){ 23 | int res; 24 | int a[10]; 25 | a[0]=-4;a[1]=3;a[2]=9;a[3]=-2;a[4]=0; 26 | a[5]=1;a[6]=-6;a[7]=5;a[8]=7;a[9]=8; 27 | res = 10; 28 | res = maxSubArray(a, res); 29 | return res; 30 | } -------------------------------------------------------------------------------- /test/test_2020/86_max_subsequence_sum.sy: -------------------------------------------------------------------------------- 1 | int maxSubArray(int nums[], int n) { 2 | if(n == 0) 3 | return 0; 4 | if(n == 1) 5 | return nums[0]; 6 | int sum; 7 | sum = nums[0]; 8 | int max; 9 | max = sum; 10 | int i; 11 | i = 1; 12 | while(i < n){ 13 | if(sum < 0) 14 | sum = 0; 15 | sum = sum + nums[i]; 16 | if(max < sum) 17 | max = sum; 18 | i = i + 1; 19 | } 20 | return max; 21 | } 22 | int main(){ 23 | int res; 24 | int a[10]; 25 | a[0]=-4;a[1]=3;a[2]=9;a[3]=-2;a[4]=0; 26 | a[5]=1;a[6]=-6;a[7]=5;a[8]=7;a[9]=8; 27 | res = 10; 28 | res = maxSubArray(a, res); 29 | return res; 30 | } -------------------------------------------------------------------------------- /include/ErrorReporter/ErrorReporter.h: -------------------------------------------------------------------------------- 1 | #ifndef _SYSYF_ERROR_REPORTER_H_ 2 | #define _SYSYF_ERROR_REPORTER_H_ 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include "SyntaxTree.h" 9 | 10 | class ErrorReporter 11 | { 12 | public: 13 | using Position = SyntaxTree::Position; 14 | explicit ErrorReporter(std::ostream &error_stream); 15 | 16 | void error(Position pos, const std::string &msg); 17 | void warn(Position pos, const std::string &msg); 18 | 19 | protected: 20 | virtual void report(Position pos, const std::string &msg, const std::string &prefix); 21 | 22 | private: 23 | std::ostream &err; 24 | }; 25 | 26 | #endif // _SYSYF_ERROR_REPORTER_H_ 27 | -------------------------------------------------------------------------------- /test/test_2020/77_unique_path.sy: -------------------------------------------------------------------------------- 1 | int uniquePaths(int m, int n) { 2 | if(m == 1 || n == 1) 3 | return 1; 4 | 5 | int dp[9]; 6 | int i; 7 | int j; 8 | i = 0; 9 | while(i -1){ 20 | j=n-2; 21 | while(j > -1){ 22 | dp[i*3+j] = dp[(i+1)*3+j] + dp[i*3+j+1]; 23 | j = j - 1; 24 | } 25 | i = i - 1; 26 | } 27 | return dp[0]; 28 | } 29 | int main(){ 30 | int res; 31 | int n; 32 | n=3; 33 | res = uniquePaths(n, n); 34 | return res; 35 | } -------------------------------------------------------------------------------- /test/test_2020/92_unique_path.sy: -------------------------------------------------------------------------------- 1 | int uniquePaths(int m, int n) { 2 | if(m == 1 || n == 1) 3 | return 1; 4 | 5 | int dp[9]; 6 | int i; 7 | int j; 8 | i = 0; 9 | while(i -1){ 20 | j=n-2; 21 | while(j > -1){ 22 | dp[i*3+j] = dp[(i+1)*3+j] + dp[i*3+j+1]; 23 | j = j - 1; 24 | } 25 | i = i - 1; 26 | } 27 | return dp[0]; 28 | } 29 | int main(){ 30 | int res; 31 | int n; 32 | n=3; 33 | res = uniquePaths(n, n); 34 | return res; 35 | } -------------------------------------------------------------------------------- /test/test_2021/086_full_conn.in: -------------------------------------------------------------------------------- 1 | 6 2 | 3 | 233 95 179 178 105 4 | 115 190 92 216 21 5 | 48 252 184 148 36 6 | 252 20 92 99 18 7 | 61 245 40 190 16 8 | 9 | 61 197 150 246 225 10 | 27 99 197 227 206 11 | 130 134 172 149 52 12 | 147 246 171 52 84 13 | 174 42 90 23 42 14 | 15 | 130 207 209 104 168 16 | 139 248 84 142 225 17 | 127 242 45 62 7 18 | 102 191 119 168 190 19 | 14 249 239 188 118 20 | 21 | 159 29 212 96 189 22 | 159 220 97 71 180 23 | 202 131 217 165 138 24 | 94 98 86 68 140 25 | 132 92 247 99 110 26 | 27 | 228 10 119 127 21 28 | 247 8 230 81 251 29 | 216 213 24 114 68 30 | 83 188 240 196 231 31 | 90 206 224 49 28 32 | 33 | 158 252 95 171 239 34 | 90 66 22 221 10 35 | 177 32 38 24 93 36 | 227 55 4 59 211 37 | 80 92 38 238 42 38 | -------------------------------------------------------------------------------- /include/SysYFIR/GlobalVariable.h: -------------------------------------------------------------------------------- 1 | #ifndef _SYSYF_GLOBALVARIABLE_H_ 2 | #define _SYSYF_GLOBALVARIABLE_H_ 3 | 4 | #include "Module.h" 5 | #include "User.h" 6 | #include "Constant.h" 7 | 8 | class GlobalVariable : public User 9 | { 10 | private: 11 | bool is_const_ ; 12 | Constant* init_val_; 13 | GlobalVariable(std::string name, Module *m, Type* ty, bool is_const, Constant* init = nullptr); 14 | public: 15 | static GlobalVariable *create(std::string name, Module *m, Type* ty, bool is_const, 16 | Constant* init ); 17 | 18 | Constant *get_init() { return init_val_; } 19 | bool is_const() { return is_const_; } 20 | std::string print(); 21 | }; 22 | #endif //_SYSYF_GLOBALVARIABLE_H_ 23 | -------------------------------------------------------------------------------- /report/Checker.md: -------------------------------------------------------------------------------- 1 | 整体实现思路如下： 2 | 3 | 首先定义符号表，使用`C++`的`map`类，它通过变量名索引，元素的值为类型结构体`Entry`，由于不同作用域的符号表不同，所以对不同作用域的符号表使用`C++`的`list`类按顺序串联起来，每次进入一个新的作用域(如函数定义、语句块)时，在`list`的头部插入新的符号表，当离开作用域时，则删去`list`的头部元素。在查找符号表时，从`list`的头部开始查起，往后遍历，直到找到元素，这样的查找方式正好符合作用域由小到大的查找方式。 4 | 5 | 在原来的代码基础上，对所有的节点展开，也即调用`accept()`函数，保证语义检查覆盖所有可能的语句。 6 | 7 | - 取模的语义检查基本同助教提供的代码的思路； 8 | - 对于变量检查，主要使用了符号表，在`VarDef`节点作插入符号表的操作，同时检查是否重定义；在`LVal`节点作查询符号表操作，同时检查是否出现变量未定义的情况； 9 | - 函数声明与定义的检查方法与变量相同； 10 | - 在比较形参与实参的一致性时，在`visitor`类的内部定义了一个私有变量`current_type`，用于保存当前分析的元素的变量类型，在`FuncCallStmt`节点，查询符号表找函数的定义，之后对`FuncCallStmt`的`params`中的每一个元素与查符号表得到的函数定义时的参数列表中的每一个元素逐一对比，完成一致性检查。 11 | 12 | 主要的实现亮点我认为是数据结构的选用，通过链表的方式组织不同作用域的符号表，而没有使用课本上的栈的方式，使得遍历(`lookup`)更为方便，除此以外，我还将插入符号表以及`lookup`的操作封装在`visitor`类当中，这样，在重写`visit()`函数时可以更加简洁。 -------------------------------------------------------------------------------- /test/test_2021/012_func_defn.ll: -------------------------------------------------------------------------------- 1 | @a = global i32 zeroinitializer 2 | @b = global float 0x4059000000000000 3 | define i32 @func(i32 %arg0, i32 %arg1) { 4 | label_entry: 5 | %op5 = load float, float* @b 6 | %op7 = sitofp i32 %arg0 to float 7 | %op8 = fadd float %op5, %op7 8 | %op10 = sitofp i32 %arg1 to float 9 | %op11 = fsub float %op8, %op10 10 | %op12 = fptosi float %op11 to i32 11 | br label %label_ret 12 | label_ret: ; preds = %label_entry 13 | ret i32 %op12 14 | } 15 | define i32 @main() { 16 | label_entry: 17 | %op2 = load i32, i32* @a 18 | %op4 = call i32 @func(i32 %op2, i32 10) 19 | br label %label_ret 20 | label_ret: ; preds = %label_entry 21 | ret i32 %op4 22 | } 23 | -------------------------------------------------------------------------------- /test/test_2020/75_max_container.sy: -------------------------------------------------------------------------------- 1 | int maxArea(int height[], int n) { 2 | int i; 3 | int j; 4 | i = 0; 5 | j = n - 1; 6 | int max_val; 7 | max_val = -1; 8 | while(i < j){ 9 | int area; 10 | if(height[i] < height[j]) 11 | area = (j - i) * height[i]; 12 | else 13 | area = (j - i) * height[j]; 14 | if(area > max_val){ 15 | max_val = area; 16 | } 17 | if(height[i] > height[j]) 18 | j = j - 1; 19 | else 20 | i = i + 1; 21 | } 22 | return max_val; 23 | } 24 | 25 | int main(){ 26 | int res; 27 | int a[10]; 28 | a[0]=3;a[1]=3;a[2]=9;a[3]=0;a[4]=0; 29 | a[5]=1;a[6]=1;a[7]=5;a[8]=7;a[9]=8; 30 | res = 10; 31 | res = maxArea(a, res); 32 | return res; 33 | } -------------------------------------------------------------------------------- /test/test_2020/90_max_container.sy: -------------------------------------------------------------------------------- 1 | int maxArea(int height[], int n) { 2 | int i; 3 | int j; 4 | i = 0; 5 | j = n - 1; 6 | int max_val; 7 | max_val = -1; 8 | while(i < j){ 9 | int area; 10 | if(height[i] < height[j]) 11 | area = (j - i) * height[i]; 12 | else 13 | area = (j - i) * height[j]; 14 | if(area > max_val){ 15 | max_val = area; 16 | } 17 | if(height[i] > height[j]) 18 | j = j - 1; 19 | else 20 | i = i + 1; 21 | } 22 | return max_val; 23 | } 24 | 25 | int main(){ 26 | int res; 27 | int a[10]; 28 | a[0]=3;a[1]=3;a[2]=9;a[3]=0;a[4]=0; 29 | a[5]=1;a[6]=1;a[7]=5;a[8]=7;a[9]=8; 30 | res = 10; 31 | res = maxArea(a, res); 32 | return res; 33 | } -------------------------------------------------------------------------------- /test/test_2021/009_const_var_defn2.ll: -------------------------------------------------------------------------------- 1 | @a = constant [5 x i32] [i32 2, i32 11, i32 3, i32 13, i32 14] 2 | define i32 @main() { 3 | label_entry: 4 | %op1 = alloca [3 x i32] 5 | %op2 = getelementptr [5 x i32], [5 x i32]* @a, i32 0, i32 4 6 | %op3 = load i32, i32* %op2 7 | %op4 = getelementptr [3 x i32], [3 x i32]* %op1, i32 0, i32 0 8 | store i32 0, i32* %op4 9 | %op5 = getelementptr [3 x i32], [3 x i32]* %op1, i32 0, i32 1 10 | store i32 0, i32* %op5 11 | %op6 = getelementptr [3 x i32], [3 x i32]* %op1, i32 0, i32 2 12 | store i32 0, i32* %op6 13 | store i32 0, i32* %op4 14 | store i32 0, i32* %op5 15 | store i32 %op3, i32* %op6 16 | %op11 = load i32, i32* %op6 17 | br label %label_ret 18 | label_ret: ; preds = %label_entry 19 | ret i32 %op11 20 | } 21 | -------------------------------------------------------------------------------- /test/test_2020/54_sort_test2.sy: -------------------------------------------------------------------------------- 1 | int n; 2 | int insertsort(int a[]) 3 | { 4 | int i; 5 | i = 1; 6 | while(i-1&&temp 6 | #include 7 | #include "Module.h" 8 | 9 | 10 | class Pass{ 11 | public: 12 | explicit Pass(Module* m){module = m;} 13 | virtual void execute() = 0; 14 | virtual const std::string get_name() const = 0; 15 | protected: 16 | Module* module; 17 | }; 18 | 19 | template 20 | using PassList = std::list; 21 | 22 | class PassMgr{ 23 | public: 24 | explicit PassMgr(Module* m){module = m;pass_list = PassList();} 25 | template void addPass(){pass_list.push_back(new PassTy(module));} 26 | void execute() { 27 | for (auto pass : pass_list) { 28 | pass->execute(); 29 | } 30 | } 31 | private: 32 | Module* module; 33 | PassList pass_list; 34 | }; 35 | 36 | 37 | #endif // SYSYF_PASS_H -------------------------------------------------------------------------------- /test/test_2020/31_while_if_test2.ll: -------------------------------------------------------------------------------- 1 | define i32 @ifWhile() { 2 | label_entry: 3 | br label %label_7 4 | label_ret: ; preds = %label_7 5 | ret i32 %op22 6 | label_7: ; preds = %label_8, %label_entry 7 | %op22 = phi i32 [ %op16, %label_8 ], [ 3, %label_entry ] 8 | %op23 = phi i32 [ %op18, %label_8 ], [ 0, %label_entry ] 9 | %op14 = icmp slt i32 %op23, 5 10 | br i1 %op14, label %label_8, label %label_ret 11 | label_8: ; preds = %label_7 12 | %op16 = mul i32 %op22, 2 13 | %op18 = add i32 %op23, 1 14 | br label %label_7 15 | } 16 | define i32 @main() { 17 | label_entry: 18 | %op1 = call i32 @ifWhile() 19 | br label %label_ret 20 | label_ret: ; preds = %label_entry 21 | ret i32 %op1 22 | } 23 | -------------------------------------------------------------------------------- /test/test_2020/90_insert_order.sy: -------------------------------------------------------------------------------- 1 | //int n; 2 | int N; 3 | int insert(int a[],int x) 4 | { 5 | int p; 6 | int i; 7 | p=0; 8 | 9 | while(x>a[p]&&pp) 14 | { 15 | a[i]=a[i-1]; 16 | a[p]=x; 17 | i=i-1; 18 | 19 | } 20 | 21 | return 0; 22 | } 23 | 24 | int main() 25 | { 26 | N=10; 27 | int a[11]; 28 | //a[0]=1; 29 | a[0]=1; 30 | a[1]=3; 31 | a[2]=4; 32 | a[3]=7; 33 | a[4]=8; 34 | a[5]=11; 35 | a[6]=13; 36 | a[7]=18; 37 | a[8]=56; 38 | a[9]=78; 39 | int x; 40 | int i; 41 | i=0; 42 | x=getint(); 43 | x=insert(a,x); 44 | //while() 45 | while(ia[p]&&pp) 14 | { 15 | a[i]=a[i-1]; 16 | a[p]=x; 17 | i=i-1; 18 | 19 | } 20 | 21 | return 0; 22 | } 23 | 24 | int main() 25 | { 26 | N=10; 27 | int a[11]; 28 | //a[0]=1; 29 | a[0]=1; 30 | a[1]=3; 31 | a[2]=4; 32 | a[3]=7; 33 | a[4]=8; 34 | a[5]=11; 35 | a[6]=13; 36 | a[7]=18; 37 | a[8]=56; 38 | a[9]=78; 39 | int x; 40 | int i; 41 | i=0; 42 | x=getint(); 43 | x=insert(a,x); 44 | //while() 45 | while(i 2 | /* Input & output functions */ 3 | int get_int(){int t; scanf("%d",&t); return t; } 4 | int get_float(){float t; scanf("%f",&t); return t; } 5 | int get_char(){char c; scanf("%c",&c); return (int)c; } 6 | int get_int_array(int a[]){ 7 | int n; 8 | scanf("%d",&n); 9 | for(int i=0;i n - 2) 5 | return 1; 6 | int dp[10]; 7 | int i; 8 | i = 0; 9 | while(i -1){ 16 | int j; 17 | if(nums[i] < n - 1 - i){ 18 | j = nums[i]; 19 | } 20 | else 21 | j = n - 1 - i; 22 | while(j > -1){ 23 | if(dp[i+j] != 0){ 24 | dp[i] = 1; 25 | } 26 | j = j - 1; 27 | } 28 | i = i - 1; 29 | } 30 | 31 | return dp[0]; 32 | } 33 | int main(){ 34 | int res; 35 | int a[10]; 36 | a[0]=3;a[1]=3;a[2]=9;a[3]=0;a[4]=0; 37 | a[5]=1;a[6]=1;a[7]=5;a[8]=7;a[9]=8; 38 | res = 10; 39 | res = canJump(a, res); 40 | return res; 41 | } -------------------------------------------------------------------------------- /test/test_2020/86_bin_search.sy: -------------------------------------------------------------------------------- 1 | 2 | int main() 3 | { 4 | //newline=10; 5 | int i; 6 | int sum; 7 | int a[10]; 8 | sum=0; 9 | //m = 1478; 10 | //int t; 11 | i=0; 12 | while(i<10) 13 | { 14 | a[i]=i+1; 15 | i=i+1; 16 | } 17 | int x; 18 | int high; 19 | int low; 20 | int mid; 21 | int n; 22 | n=10; 23 | x=getint(); 24 | high=n-1; 25 | low=0; 26 | mid=(high+low)/2; 27 | while(a[mid]!=x && low < high) 28 | { 29 | mid=(high+low)/2; 30 | if(x n - 2) 5 | return 1; 6 | int dp[10]; 7 | int i; 8 | i = 0; 9 | while(i -1){ 16 | int j; 17 | if(nums[i] < n - 1 - i){ 18 | j = nums[i]; 19 | } 20 | else 21 | j = n - 1 - i; 22 | while(j > -1){ 23 | if(dp[i+j] != 0){ 24 | dp[i] = 1; 25 | } 26 | j = j - 1; 27 | } 28 | i = i - 1; 29 | } 30 | 31 | return dp[0]; 32 | } 33 | int main(){ 34 | int res; 35 | int a[10]; 36 | a[0]=3;a[1]=3;a[2]=9;a[3]=0;a[4]=0; 37 | a[5]=1;a[6]=1;a[7]=5;a[8]=7;a[9]=8; 38 | res = 10; 39 | res = canJump(a, res); 40 | return res; 41 | } -------------------------------------------------------------------------------- /test/test_2020/99_bin_search.sy: -------------------------------------------------------------------------------- 1 | 2 | int main() 3 | { 4 | //newline=10; 5 | int i; 6 | int sum; 7 | int a[10]; 8 | sum=0; 9 | //m = 1478; 10 | //int t; 11 | i=0; 12 | while(i<10) 13 | { 14 | a[i]=i+1; 15 | i=i+1; 16 | } 17 | int x; 18 | int high; 19 | int low; 20 | int mid; 21 | int n; 22 | n=10; 23 | x=getint(); 24 | high=n-1; 25 | low=0; 26 | mid=(high+low)/2; 27 | while(a[mid]!=x && low < high) 28 | { 29 | mid=(high+low)/2; 30 | if(x 6 | #endif 7 | 8 | Value::Value(Type *ty, const std::string &name ) 9 | : type_(ty), name_(name) 10 | { 11 | 12 | } 13 | 14 | void Value::add_use(Value *val, unsigned arg_no ) 15 | { 16 | use_list_.push_back(Use(val, arg_no)); 17 | } 18 | 19 | std::string Value::get_name() const 20 | { 21 | return name_; 22 | } 23 | 24 | void Value::replace_all_use_with(Value *new_val) 25 | { 26 | for (auto use : use_list_) { 27 | auto val = dynamic_cast(use.val_); 28 | #ifdef DEBUG 29 | assert(val && "new_val is not a user"); 30 | #endif 31 | val->set_operand(use.arg_no_, new_val); 32 | } 33 | } 34 | 35 | void Value::remove_use(Value *val) 36 | { 37 | auto is_val = [val] (const Use &use) { return use.val_ == val; }; 38 | use_list_.remove_if(is_val); 39 | } -------------------------------------------------------------------------------- /include/SysYFIR/User.h: -------------------------------------------------------------------------------- 1 | #ifndef _SYSYF_USER_H_ 2 | #define _SYSYF_USER_H_ 3 | 4 | #include "Value.h" 5 | #include 6 | // #include 7 | 8 | class User : public Value 9 | { 10 | public: 11 | User(Type *ty, const std::string &name = "", unsigned num_ops = 0); 12 | ~User() = default; 13 | 14 | std::vector& get_operands(); 15 | 16 | // start from 0 17 | Value *get_operand(unsigned i) const; 18 | 19 | // start from 0 20 | void set_operand(unsigned i, Value *v); 21 | void add_operand( Value *v); 22 | 23 | unsigned get_num_operand() const; 24 | 25 | void remove_use_of_ops(); 26 | void remove_operands(int index1,int index2); 27 | 28 | private: 29 | // std::unique_ptr< std::list > operands_; // operands of this value 30 | std::vector operands_; // operands of this value 31 | unsigned num_ops_; 32 | }; 33 | 34 | #endif // _SYSYF_USER_H_ 35 | -------------------------------------------------------------------------------- /test/test_2020/11_while.ll: -------------------------------------------------------------------------------- 1 | @a = global i32 zeroinitializer 2 | @b = global i32 zeroinitializer 3 | define i32 @main() { 4 | label_entry: 5 | store i32 0, i32* @b 6 | store i32 3, i32* @a 7 | br label %label_1 8 | label_ret: ; preds = %label_3 9 | ret i32 %op9 10 | label_1: ; preds = %label_entry, %label_2 11 | %op2 = load i32, i32* @a 12 | %op3 = icmp sgt i32 %op2, 0 13 | br i1 %op3, label %label_2, label %label_3 14 | label_2: ; preds = %label_1 15 | %op4 = load i32, i32* @b 16 | %op5 = load i32, i32* @a 17 | %op6 = add i32 %op4, %op5 18 | store i32 %op6, i32* @b 19 | %op7 = load i32, i32* @a 20 | %op8 = sub i32 %op7, 1 21 | store i32 %op8, i32* @a 22 | br label %label_1 23 | label_3: ; preds = %label_1 24 | %op9 = load i32, i32* @b 25 | br label %label_ret 26 | } 27 | -------------------------------------------------------------------------------- /test/test_2020/53_sort_test1.sy: -------------------------------------------------------------------------------- 1 | int n; 2 | int bubblesort(int arr[]) 3 | { 4 | int i; 5 | int j; 6 | i =0; 7 | while(i < n-1){ 8 | // Last i elements are already in place 9 | j = 0; 10 | while(j < n-i-1){ 11 | if (arr[j] > arr[j+1]) { 12 | // swap(&arr[j], &arr[j+1]); 13 | int tmp; 14 | tmp = arr[j+1]; 15 | arr[j+1] = arr[j]; 16 | arr[j] = tmp; 17 | } 18 | j = j + 1; 19 | } 20 | i = i + 1; 21 | } 22 | return 0; 23 | } 24 | 25 | int main(){ 26 | n = 10; 27 | int a[10]; 28 | a[0]=4;a[1]=3;a[2]=9;a[3]=2;a[4]=0; 29 | a[5]=1;a[6]=6;a[7]=5;a[8]=7;a[9]=8; 30 | int i; 31 | i = bubblesort(a); 32 | while (i < n) { 33 | int tmp; 34 | tmp = a[i]; 35 | putint(tmp); 36 | tmp = 10; 37 | putch(tmp); 38 | i = i + 1; 39 | } 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /test/test_2021/061_bubble_sort.sy: -------------------------------------------------------------------------------- 1 | int n; 2 | int bubblesort(int arr[]) 3 | { 4 | int i; 5 | int j; 6 | i =0; 7 | while(i < n-1){ 8 | // Last i elements are already in place 9 | j = 0; 10 | while(j < n-i-1){ 11 | if (arr[j] > arr[j+1]) { 12 | // swap(&arr[j], &arr[j+1]); 13 | int tmp; 14 | tmp = arr[j+1]; 15 | arr[j+1] = arr[j]; 16 | arr[j] = tmp; 17 | } 18 | j = j + 1; 19 | } 20 | i = i + 1; 21 | } 22 | return 0; 23 | } 24 | 25 | int main(){ 26 | n = 10; 27 | int a[10]; 28 | a[0]=4;a[1]=3;a[2]=9;a[3]=2;a[4]=0; 29 | a[5]=1;a[6]=6;a[7]=5;a[8]=7;a[9]=8; 30 | int i; 31 | i = bubblesort(a); 32 | while (i < n) { 33 | int tmp; 34 | tmp = a[i]; 35 | putint(tmp); 36 | tmp = 10; 37 | putch(tmp); 38 | i = i + 1; 39 | } 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /test/test_2020/91_line_search.sy: -------------------------------------------------------------------------------- 1 | 2 | int main() 3 | { 4 | //newline=10; 5 | int i; 6 | int sum; 7 | int a[10]; 8 | sum=0; 9 | //m = 1478; 10 | //int t; 11 | i=0; 12 | while(i<10) 13 | { 14 | a[i]=i+1; 15 | i=i+1; 16 | } 17 | int x; 18 | int high; 19 | int low; 20 | int mid; 21 | int n; 22 | n=10; 23 | x=getint(); 24 | high=n-1; 25 | low=0; 26 | mid=(high+low)/2; 27 | int flag; 28 | flag=0; 29 | //int i; 30 | i=0; 31 | int j; 32 | j=0; 33 | while(i<10 && flag==0) 34 | { 35 | if(a[i]==x) 36 | { 37 | flag=1; 38 | j=i; 39 | } 40 | 41 | i=i+1; 42 | 43 | } 44 | 45 | if(flag==1) 46 | putint(j); 47 | else 48 | { 49 | x = 0; 50 | putint(x); 51 | } 52 | 53 | 54 | 55 | x= 10; 56 | putch(x); 57 | 58 | return 0; 59 | } 60 | -------------------------------------------------------------------------------- /test/test_2021/068_genealogical_tree.sy: -------------------------------------------------------------------------------- 1 | int map[10][10]; 2 | int indegree[10]; 3 | int queue[10]; 4 | void topo(int n) 5 | { 6 | int m=0; 7 | int t=0; 8 | int i,j; 9 | i=1; 10 | j=1; 11 | while(i<=n) 12 | { 13 | j=1; 14 | while(j<=n) 15 | { 16 | if(indegree[j]==0) 17 | { 18 | 19 | m=j; 20 | break; 21 | } 22 | j=j+1; 23 | } 24 | queue[t]=m; 25 | t=t+1; 26 | indegree[m]=-1; 27 | j=1; 28 | while(j<=n) 29 | 30 | { 31 | if(map[m][j]) 32 | { 33 | indegree[j]=indegree[j]-1; 34 | } 35 | j=j+1; 36 | } 37 | i=i+1; 38 | } 39 | i=0; 40 | while(i 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include "Pass.h" 10 | #include "BasicBlock.h" 11 | #include "Module.h" 12 | 13 | class DominateTree : public Pass{ 14 | public: 15 | explicit DominateTree(Module* module): Pass(module){} 16 | void execute()final; 17 | void get_revserse_post_order(Function* f); 18 | void get_post_order(BasicBlock* bb,std::set& visited); 19 | void get_bb_idom(Function* f); 20 | void get_bb_dom_front(Function* f); 21 | BasicBlock* intersect(BasicBlock* b1, BasicBlock* b2); 22 | const std::string get_name() const override {return name;} 23 | private: 24 | std::list reverse_post_order; 25 | std::map bb2int; 26 | std::vector doms; 27 | const std::string name = "DominateTree"; 28 | }; 29 | 30 | #endif // SYSYF_DOMINATETREE_H 31 | -------------------------------------------------------------------------------- /test/test_2020/10_break.ll: -------------------------------------------------------------------------------- 1 | define i32 @main() { 2 | label_entry: 3 | br label %label_1 4 | label_ret: ; preds = %label_3 5 | ret i32 %op11 6 | label_1: ; preds = %label_entry, %label_5 7 | %op10 = phi i32 [ 10, %label_entry ], [ %op6, %label_5 ] 8 | %op4 = icmp sgt i32 %op10, 0 9 | br i1 %op4, label %label_2, label %label_3 10 | label_2: ; preds = %label_1 11 | %op6 = sub i32 %op10, 1 12 | %op8 = icmp eq i32 %op6, 5 13 | br i1 %op8, label %label_4, label %label_5 14 | label_3: ; preds = %label_1, %label_4 15 | %op11 = phi i32 [ %op10, %label_1 ], [ %op6, %label_4 ] 16 | br label %label_ret 17 | label_4: ; preds = %label_2 18 | br label %label_3 19 | label_5: ; preds = %label_2 20 | br label %label_1 21 | } 22 | -------------------------------------------------------------------------------- /test/test_2020/11_continue.ll: -------------------------------------------------------------------------------- 1 | define i32 @main() { 2 | label_entry: 3 | br label %label_1 4 | label_ret: ; preds = %label_5, %label_3 5 | %op11 = phi i32 [ %op12, %label_3 ], [ %op12, %label_5 ] 6 | ret i32 %op11 7 | label_1: ; preds = %label_entry, %label_4 8 | %op12 = phi i32 [ 10, %label_entry ], [ %op9, %label_4 ] 9 | %op4 = icmp sgt i32 %op12, 0 10 | br i1 %op4, label %label_2, label %label_3 11 | label_2: ; preds = %label_1 12 | %op6 = icmp sgt i32 %op12, 5 13 | br i1 %op6, label %label_4, label %label_5 14 | label_3: ; preds = %label_1 15 | br label %label_ret 16 | label_4: ; preds = %label_2 17 | %op9 = sub i32 %op12, 1 18 | br label %label_1 19 | label_5: ; preds = %label_2 20 | br label %label_ret 21 | } 22 | -------------------------------------------------------------------------------- /test/test_2021/038_continue.ll: -------------------------------------------------------------------------------- 1 | define i32 @main() { 2 | label_entry: 3 | br label %label_1 4 | label_ret: ; preds = %label_1 5 | ret i32 %op16 6 | label_1: ; preds = %label_entry, %label_4, %label_5 7 | %op16 = phi i32 [ 0, %label_entry ], [ %op13, %label_5 ], [ %op16, %label_4 ] 8 | %op17 = phi i32 [ 0, %label_entry ], [ %op15, %label_5 ], [ %op10, %label_4 ] 9 | %op5 = icmp slt i32 %op17, 100 10 | br i1 %op5, label %label_2, label %label_ret 11 | label_2: ; preds = %label_1 12 | %op7 = icmp eq i32 %op17, 50 13 | br i1 %op7, label %label_4, label %label_5 14 | label_4: ; preds = %label_2 15 | %op10 = add i32 %op17, 1 16 | br label %label_1 17 | label_5: ; preds = %label_2 18 | %op13 = add i32 %op16, %op17 19 | %op15 = add i32 %op17, 1 20 | br label %label_1 21 | } 22 | -------------------------------------------------------------------------------- /test/test_2020/56_sort_test4.sy: -------------------------------------------------------------------------------- 1 | int n; 2 | int select_sort(int A[],int n) 3 | { 4 | int i; 5 | int j; 6 | int min; 7 | i =0; 8 | while(i < n-1) 9 | { 10 | min=i;// 11 | j = i + 1; 12 | while(j < n) 13 | { 14 | if(A[min]>A[j]) 15 | { 16 | min=j; 17 | } 18 | j=j+1; 19 | } 20 | if(min!=i) 21 | { 22 | int tmp; 23 | tmp = A[min]; 24 | A[min] = A[i]; 25 | A[i] = tmp; 26 | } 27 | i = i + 1; 28 | } 29 | return 0; 30 | } 31 | 32 | int main(){ 33 | n = 10; 34 | int a[10]; 35 | a[0]=4;a[1]=3;a[2]=9;a[3]=2;a[4]=0; 36 | a[5]=1;a[6]=6;a[7]=5;a[8]=7;a[9]=8; 37 | int i; 38 | i = 0; 39 | i = select_sort(a, n); 40 | while (i < n) { 41 | int tmp; 42 | tmp = a[i]; 43 | putint(tmp); 44 | tmp = 10; 45 | putch(tmp); 46 | i = i + 1; 47 | } 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /test/test_2021/037_break.ll: -------------------------------------------------------------------------------- 1 | define i32 @main() { 2 | label_entry: 3 | br label %label_1 4 | label_ret: ; preds = %label_3 5 | ret i32 %op14 6 | label_1: ; preds = %label_entry, %label_5 7 | %op14 = phi i32 [ 0, %label_entry ], [ %op11, %label_5 ] 8 | %op15 = phi i32 [ 0, %label_entry ], [ %op13, %label_5 ] 9 | %op5 = icmp slt i32 %op15, 100 10 | br i1 %op5, label %label_2, label %label_3 11 | label_2: ; preds = %label_1 12 | %op7 = icmp eq i32 %op15, 50 13 | br i1 %op7, label %label_4, label %label_5 14 | label_3: ; preds = %label_1, %label_4 15 | br label %label_ret 16 | label_4: ; preds = %label_2 17 | br label %label_3 18 | label_5: ; preds = %label_2 19 | %op11 = add i32 %op14, %op15 20 | %op13 = add i32 %op15, 1 21 | br label %label_1 22 | } 23 | -------------------------------------------------------------------------------- /test/test_2021/090_int_io.sy: -------------------------------------------------------------------------------- 1 | const int ascii_0 = 48; 2 | 3 | int my_getint() 4 | { 5 | int sum = 0, c; 6 | 7 | while (1) { 8 | c = getch() - ascii_0; 9 | if (c < 0 || c > 9) { 10 | continue; 11 | } else { 12 | break; 13 | } 14 | } 15 | sum = c; 16 | 17 | while (1) { 18 | c = getch() - ascii_0; 19 | if (c >= 0 && c <= 9) { 20 | sum = sum * 10 + c; 21 | } else { 22 | break; 23 | } 24 | } 25 | 26 | return sum; 27 | } 28 | 29 | void my_putint(int a) 30 | { 31 | int b[16], i = 0; 32 | while (a > 0) { 33 | b[i] = a % 10 + ascii_0; 34 | a = a / 10; 35 | i = i + 1; 36 | } 37 | while (i > 0) { 38 | i = i - 1; 39 | putch(b[i]); 40 | } 41 | } 42 | 43 | int main() 44 | { 45 | int n = my_getint(); 46 | while (n > 0) { 47 | int m = my_getint(); 48 | my_putint(m); putch(10); 49 | n = n - 1; 50 | } 51 | return 0; 52 | } 53 | -------------------------------------------------------------------------------- /test/test_2021/109_many_params2.sy: -------------------------------------------------------------------------------- 1 | 2 | int func(int a, int b[][59], int c, int d[], int e, int f, int g[], int h, int i) 3 | { 4 | int index = 0; 5 | while (index < 10) { 6 | putint(b[a][index]); 7 | index = index + 1; 8 | } 9 | putch(10); 10 | 11 | putint(d[c]); 12 | putch(10); 13 | 14 | while (i < 10) { 15 | g[i] = h * 128875 % 3724; 16 | i = i + 1; 17 | h = h + 7; 18 | } 19 | 20 | return e + f; 21 | } 22 | 23 | int main() 24 | { 25 | int a[61][67] = {}; 26 | int b[53][59] = {}; 27 | 28 | a[17][1] = 6; 29 | a[17][3] = 7; 30 | a[17][4] = 4; 31 | a[17][7] = 9; 32 | a[17][11] = 11; 33 | 34 | b[6][1] = 1; 35 | b[6][2] = 2; 36 | b[6][3] = 3; 37 | b[6][9] = 9; 38 | 39 | int ret; 40 | ret = func(a[17][1], b, a[17][3], a[17], b[6][3], b[6][0], b[6], b[34][4], b[51][18]) * 3; 41 | 42 | while (ret >= 0) { 43 | putint(b[6][ret]); putch(32); 44 | ret = ret - 1; 45 | } 46 | putch(10); 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /test/test_2020/63_simple_atoi.sy: -------------------------------------------------------------------------------- 1 | // Simple atoi program 2 | int atoi_(int src[]) { 3 | int s; 4 | s = 0; 5 | int isMinus; 6 | isMinus = 1; 7 | int i; 8 | i = 0; 9 | while(src[i] == 32) { // 跳过空白符 10 | i = i + 1; 11 | } 12 | 13 | if(src[i] == 43 || src[i] == 45) { 14 | if(src[i] == 45) { 15 | isMinus = -1; 16 | } 17 | i = i + 1; 18 | } else if (src[i] < 48 || src[i] > 57) { 19 | //如果第一位既不是符号也不是数字，直接返回异常值 20 | s = 2147483647; 21 | return s; 22 | } 23 | 24 | while (src[i] != 0 && src[i] > 47 && src[i] < 58) { 25 | s = s * 10 + src[i] - 48; 26 | i = i + 1; 27 | } 28 | return s * isMinus; 29 | } 30 | 31 | int main () { 32 | int string[500]; 33 | int temp; 34 | temp = 0; 35 | int i; 36 | i = 0; 37 | while (temp != 10) { 38 | temp = getch(); 39 | string[i] = temp; 40 | i = i + 1; 41 | } 42 | string[i] = 0; 43 | i = atoi_(string); 44 | putint(i); 45 | return 0; 46 | } 47 | 48 | -------------------------------------------------------------------------------- /test/test_2021/069_greatest_common_divisor.ll: -------------------------------------------------------------------------------- 1 | declare i32 @get_int() 2 | 3 | declare void @put_int(i32) 4 | 5 | define i32 @fun(i32 %arg0, i32 %arg1) { 6 | label_entry: 7 | br label %label_1 8 | label_ret: ; preds = %label_1 9 | ret i32 %op15 10 | label_1: ; preds = %label_entry, %label_2 11 | %op15 = phi i32 [ %arg0, %label_entry ], [ %op16, %label_2 ] 12 | %op16 = phi i32 [ %arg1, %label_entry ], [ %op11, %label_2 ] 13 | %op8 = icmp sgt i32 %op16, 0 14 | br i1 %op8, label %label_2, label %label_ret 15 | label_2: ; preds = %label_1 16 | %op11 = srem i32 %op15, %op16 17 | br label %label_1 18 | } 19 | define i32 @main() { 20 | label_entry: 21 | %op4 = call i32 @get_int() 22 | %op5 = call i32 @get_int() 23 | %op8 = call i32 @fun(i32 %op4, i32 %op5) 24 | call void @put_int(i32 %op8) 25 | br label %label_ret 26 | label_ret: ; preds = %label_entry 27 | ret i32 0 28 | } 29 | -------------------------------------------------------------------------------- /test/test_2021/082_reverse_output.ll: -------------------------------------------------------------------------------- 1 | declare i32 @get_int() 2 | 3 | declare void @put_int(i32) 4 | 5 | define void @reverse(i32 %arg0) { 6 | label_entry: 7 | %op4 = icmp sle i32 %arg0, 1 8 | br i1 %op4, label %label_1, label %label_2 9 | label_ret: ; preds = %label_3 10 | ret void 11 | label_1: ; preds = %label_entry 12 | %op5 = call i32 @get_int() 13 | call void @put_int(i32 %op5) 14 | br label %label_3 15 | label_2: ; preds = %label_entry 16 | %op7 = call i32 @get_int() 17 | %op9 = sub i32 %arg0, 1 18 | call void @reverse(i32 %op9) 19 | call void @put_int(i32 %op7) 20 | br label %label_3 21 | label_3: ; preds = %label_1, %label_2 22 | br label %label_ret 23 | } 24 | define i32 @main() { 25 | label_entry: 26 | call void @reverse(i32 200) 27 | br label %label_ret 28 | label_ret: ; preds = %label_entry 29 | ret i32 0 30 | } 31 | -------------------------------------------------------------------------------- /test/test_2021/112_many_locals.sy: -------------------------------------------------------------------------------- 1 | 2 | int foo() 3 | { 4 | int arr[16] = {0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3}; 5 | 6 | int a = 3, b = 7, c = 5, d = 6, e = 1, f = 0, g = 3, h = 5, 7 | i = 4, j = 2, k = 7, l = 9, m = 8, n = 1, o = 4, p = 6; 8 | 9 | int sum1 = a + b + c + d + e + f + g + h; 10 | int sum2 = i + j + k + l + m + n + o + p; 11 | 12 | return sum1 + sum2 + arr[a]; 13 | } 14 | 15 | int main() 16 | { 17 | int a = 3, b = 7, c = 5, d = 6, e = 1, f = 0, g = 3, h = 5, 18 | i = 4, j = 2, k = 7, l = 9, m = 8, n = 1, o = 4, p = 6; 19 | 20 | int sum1 = a + b + c + d + e + f + g + h; 21 | int sum2 = i + j + k + l + m + n + o + p; 22 | 23 | sum1 = sum1 + foo(); 24 | 25 | int q = 4, r = 7, s = 2, t = 5, u = 8, v = 0, w = 6, x = 3; 26 | 27 | sum2 = sum2 + foo(); 28 | 29 | a = i; b = j; c = k; d = l; 30 | e = m; f = n; g = o; h = p; 31 | 32 | int sum3 = q + r + s + t + u + v + w + x; 33 | 34 | int sum = sum1 + sum2 + sum3; 35 | 36 | putint(sum); 37 | putch(10); 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /include/Optimize/RDominateTree.h: -------------------------------------------------------------------------------- 1 | #ifndef SYSYF_RDOMINATETREE_H 2 | #define SYSYF_RDOMINATETREE_H 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include "Pass.h" 9 | #include "BasicBlock.h" 10 | #include "Module.h" 11 | 12 | class RDominateTree : public Pass{//reverse dominate tree 13 | public: 14 | explicit RDominateTree(Module* module): Pass(module){} 15 | void execute()final; 16 | void get_revserse_post_order(Function* f); 17 | void get_post_order(BasicBlock* bb,std::set& visited); 18 | void get_bb_irdom(Function* f); 19 | void get_bb_rdoms(Function* f); 20 | void get_bb_rdom_front(Function* f); 21 | const std::string get_name() const override {return name;} 22 | BasicBlock* intersect(BasicBlock* b1, BasicBlock* b2); 23 | private: 24 | BasicBlock* exit_block = nullptr; 25 | std::list reverse_post_order; 26 | std::map bb2int; 27 | std::vector rdoms; 28 | const std::string name = "RDominateTree"; 29 | }; 30 | 31 | #endif //SYSYF_RDOMINATETREE_H -------------------------------------------------------------------------------- /test/test_2021/048_stmt_expr.ll: -------------------------------------------------------------------------------- 1 | @k = global i32 zeroinitializer 2 | @n = constant i32 10 3 | declare void @put_int(i32) 4 | 5 | define i32 @main() { 6 | label_entry: 7 | store i32 1, i32* @k 8 | br label %label_1 9 | label_ret: ; preds = %label_3 10 | ret i32 %op15 11 | label_1: ; preds = %label_entry, %label_2 12 | %op16 = phi i32 [ 0, %label_entry ], [ %op8, %label_2 ] 13 | %op4 = load i32, i32* @n 14 | %op5 = sub i32 %op4, 1 15 | %op6 = icmp sle i32 %op16, %op5 16 | br i1 %op6, label %label_2, label %label_3 17 | label_2: ; preds = %label_1 18 | %op8 = add i32 %op16, 1 19 | %op11 = load i32, i32* @k 20 | %op12 = load i32, i32* @k 21 | %op13 = add i32 %op11, %op12 22 | store i32 %op13, i32* @k 23 | br label %label_1 24 | label_3: ; preds = %label_1 25 | %op14 = load i32, i32* @k 26 | call void @put_int(i32 %op14) 27 | %op15 = load i32, i32* @k 28 | br label %label_ret 29 | } 30 | -------------------------------------------------------------------------------- /test/test_2020/33_func_test1.ll: -------------------------------------------------------------------------------- 1 | @a = global i32 zeroinitializer 2 | define i32 @myFunc(i32 %arg0, i32 %arg1, i32 %arg2) { 3 | label_entry: 4 | br label %label_3 5 | label_ret: ; preds = %label_5 6 | ret i32 %op17 7 | label_3: ; preds = %label_4, %label_entry 8 | %op20 = phi i32 [ %op14, %label_4 ], [ %arg1, %label_entry ] 9 | %op12 = icmp sgt i32 %op20, 0 10 | br i1 %op12, label %label_4, label %label_5 11 | label_4: ; preds = %label_3 12 | %op14 = sub i32 %op20, 1 13 | br label %label_3 14 | label_5: ; preds = %label_3 15 | %op17 = add i32 2, %op20 16 | br label %label_ret 17 | } 18 | define i32 @main() { 19 | label_entry: 20 | store i32 3, i32* @a 21 | %op2 = call i32 @myFunc(i32 1, i32 2, i32 1) 22 | %op3 = load i32, i32* @a 23 | %op5 = add i32 %op3, %op2 24 | br label %label_ret 25 | label_ret: ; preds = %label_entry 26 | ret i32 %op5 27 | } 28 | -------------------------------------------------------------------------------- /test/test_2020/36_domain_test.ll: -------------------------------------------------------------------------------- 1 | @a = global [2 x i32] zeroinitializer 2 | define i32 @func(i32* %arg0) { 3 | label_entry: 4 | %op3 = getelementptr [2 x i32], [2 x i32]* @a, i32 0, i32 0 5 | store i32 1, i32* %op3 6 | %op5 = load i32, i32* %op3 7 | %op6 = sub i32 3, %op5 8 | %op8 = getelementptr i32, i32* %arg0, i32 %op6 9 | %op9 = load i32, i32* %op8 10 | br label %label_ret 11 | label_ret: ; preds = %label_entry 12 | ret i32 %op9 13 | } 14 | define i32 @main() { 15 | label_entry: 16 | %op2 = alloca [3 x i32] 17 | %op3 = getelementptr [3 x i32], [3 x i32]* %op2, i32 0, i32 0 18 | store i32 -1, i32* %op3 19 | %op4 = getelementptr [3 x i32], [3 x i32]* %op2, i32 0, i32 1 20 | store i32 4, i32* %op4 21 | %op5 = getelementptr [3 x i32], [3 x i32]* %op2, i32 0, i32 2 22 | store i32 8, i32* %op5 23 | %op7 = call i32 @func(i32* %op3) 24 | %op10 = load i32, i32* %op4 25 | %op11 = add i32 %op7, %op10 26 | br label %label_ret 27 | label_ret: ; preds = %label_entry 28 | ret i32 %op11 29 | } 30 | -------------------------------------------------------------------------------- /test/test_2020/29_while_test3.sy: -------------------------------------------------------------------------------- 1 | int g; 2 | int h; 3 | int f; 4 | int e; 5 | int EightWhile() { 6 | int a; 7 | a = 5; 8 | int b; 9 | int c; 10 | b = 6; 11 | c = 7; 12 | int d; 13 | d = 10; 14 | while (a < 20) { 15 | a = a + 3; 16 | while(b < 10){ 17 | b = b + 1; 18 | while(c == 7){ 19 | c = c - 1; 20 | while(d < 20){ 21 | d = d + 3; 22 | while(e > 1){ 23 | e = e-1; 24 | while(f > 2){ 25 | f = f -2; 26 | while(g < 3){ 27 | g = g +10; 28 | while(h < 10){ 29 | h = h + 8; 30 | } 31 | h = h-1; 32 | } 33 | g = g- 8; 34 | } 35 | f = f + 1; 36 | } 37 | e = e + 1; 38 | } 39 | d = d - 1; 40 | } 41 | c = c + 1; 42 | } 43 | b = b - 2; 44 | } 45 | 46 | return (a + (b + d) + c)-(e + d - g + h); 47 | } 48 | 49 | int main() { 50 | g = 1; 51 | h = 2; 52 | e = 4; 53 | f = 6; 54 | return EightWhile(); 55 | } 56 | -------------------------------------------------------------------------------- /test/test_2021/036_while_test3.sy: -------------------------------------------------------------------------------- 1 | int g; 2 | int h; 3 | int f; 4 | int e; 5 | int EightWhile() { 6 | int a; 7 | a = 5; 8 | int b; 9 | int c; 10 | b = 6; 11 | c = 7; 12 | int d; 13 | d = 10; 14 | while (a < 20) { 15 | a = a + 3; 16 | while(b < 10){ 17 | b = b + 1; 18 | while(c == 7){ 19 | c = c - 1; 20 | while(d < 20){ 21 | d = d + 3; 22 | while(e > 1){ 23 | e = e-1; 24 | while(f > 2){ 25 | f = f -2; 26 | while(g < 3){ 27 | g = g +10; 28 | while(h < 10){ 29 | h = h + 8; 30 | } 31 | h = h-1; 32 | } 33 | g = g- 8; 34 | } 35 | f = f + 1; 36 | } 37 | e = e + 1; 38 | } 39 | d = d - 1; 40 | } 41 | c = c + 1; 42 | } 43 | b = b - 2; 44 | } 45 | 46 | return (a + (b + d) + c)-(e + d - g + h); 47 | } 48 | 49 | int main() { 50 | g = 1; 51 | h = 2; 52 | e = 4; 53 | f = 6; 54 | return EightWhile(); 55 | } 56 | -------------------------------------------------------------------------------- /test/test_2020/52_recursion_test3.ll: -------------------------------------------------------------------------------- 1 | @a = global i32 zeroinitializer 2 | @r = global i32 zeroinitializer 3 | define i32 @fac(i32 %arg0) { 4 | label_entry: 5 | %op4 = icmp slt i32 %arg0, 2 6 | br i1 %op4, label %label_1, label %label_2 7 | label_ret: ; preds = %label_1, %label_2 8 | %op14 = phi i32 [ %op13, %label_2 ], [ 1, %label_1 ] 9 | ret i32 %op14 10 | label_1: ; preds = %label_entry 11 | br label %label_ret 12 | label_2: ; preds = %label_entry 13 | %op7 = sub i32 %arg0, 1 14 | store i32 %op7, i32* @a 15 | %op8 = load i32, i32* @a 16 | %op9 = call i32 @fac(i32 %op8) 17 | store i32 %op9, i32* @r 18 | %op11 = load i32, i32* @r 19 | %op12 = mul i32 %arg0, %op11 20 | store i32 %op12, i32* @r 21 | %op13 = load i32, i32* @r 22 | br label %label_ret 23 | } 24 | define i32 @main() { 25 | label_entry: 26 | %op3 = call i32 @fac(i32 5) 27 | br label %label_ret 28 | label_ret: ; preds = %label_entry 29 | ret i32 %op3 30 | } 31 | -------------------------------------------------------------------------------- /test/test_2021/093_n_queens.sy: -------------------------------------------------------------------------------- 1 | int ans[50], sum = 0, n; 2 | 3 | int row[50], line1[50], line2[100]; 4 | 5 | void printans() 6 | { 7 | sum = sum + 1; 8 | int i = 1; 9 | while (i <= n) { 10 | putint(ans[i]); 11 | if (i == n) { 12 | putch(10); 13 | return; 14 | } else 15 | putch(32); 16 | i = i + 1; 17 | } 18 | } 19 | 20 | void f(int step) 21 | { 22 | int i = 1; 23 | while (i <= n) { 24 | if (row[i] != 1 && line1[step + i] == 0 && !line2[n + step - i]) { 25 | ans[step] = i; 26 | if (step == n) 27 | printans(); 28 | row[i] = 1; 29 | line1[step + i] = 1; 30 | line2[n + step - i] = 1; 31 | f(step + 1); 32 | row[i] = 0; 33 | line1[step + i] = 0; 34 | line2[n + step - i] = 0; 35 | } 36 | i = i + 1; 37 | } 38 | } 39 | 40 | int main() 41 | { 42 | int N = getint(); 43 | while (N > 0) { 44 | n = getint(); 45 | f(1); 46 | N = N - 1; 47 | } 48 | return sum; 49 | } 50 | -------------------------------------------------------------------------------- /src/SysYFIR/GlobalVariable.cpp: -------------------------------------------------------------------------------- 1 | #include "GlobalVariable.h" 2 | #include "IRPrinter.h" 3 | 4 | GlobalVariable::GlobalVariable( std::string name, Module *m, Type* ty, bool is_const, Constant* init) 5 | : User(ty, name, init != nullptr), is_const_(is_const), init_val_(init) 6 | { 7 | m->add_global_variable(this); 8 | if (init) { 9 | this->set_operand(0, init); 10 | } 11 | }//global操作数为initval 12 | 13 | GlobalVariable *GlobalVariable::create(std::string name, Module *m, Type* ty, bool is_const, 14 | Constant* init = nullptr) 15 | { 16 | return new GlobalVariable(name, m, PointerType::get(ty), is_const, init); 17 | } 18 | 19 | std::string GlobalVariable::print() 20 | { 21 | std::string global_val_ir; 22 | global_val_ir += print_as_op(this, false); 23 | global_val_ir += " = "; 24 | global_val_ir += (this->is_const() ? "constant " : "global "); 25 | global_val_ir += this->get_type()->get_pointer_element_type()->print(); 26 | global_val_ir += " "; 27 | global_val_ir += this->get_init()->print(); 28 | return global_val_ir; 29 | } -------------------------------------------------------------------------------- /test/test_2021/089_hidden_var.sy: -------------------------------------------------------------------------------- 1 | 2 | int b = 5; 3 | int c[4] = {6, 7, 8, 9}; 4 | 5 | int main() 6 | { 7 | int a; 8 | a = 1; 9 | { 10 | int a; 11 | a = 2; 12 | { 13 | a = 3; 14 | putint(a); 15 | } 16 | putint(a); 17 | } 18 | putint(a); putch(10); 19 | 20 | while (a < 5) { 21 | int a = 0; 22 | a = a + 1; 23 | if (a) 24 | break; 25 | } 26 | putint(a); putch(10); 27 | 28 | { 29 | { 30 | { 31 | {} 32 | } 33 | c[2] = 1; 34 | { 35 | int c[2][8] = {{0, 9}, 8, 3}; 36 | } 37 | } 38 | } 39 | 40 | { 41 | int b = 2; 42 | if (c[2]) { 43 | int c[7][1][5] = {{}, {}, {2, 1, 8}, {{}}}; 44 | putint(c[b][0][0]); 45 | putint(c[b][0][1]); 46 | putint(c[b][0][2]); 47 | } 48 | } 49 | putch(10); 50 | 51 | putint(b); putch(10); 52 | putint(c[0]); putint(c[1]); putint(c[2]); putint(c[3]); putch(10); 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /test/test_2021/051_logi_assign.ll: -------------------------------------------------------------------------------- 1 | @a = global i32 zeroinitializer 2 | @b = global i32 zeroinitializer 3 | declare i32 @get_int() 4 | 5 | define i32 @main() { 6 | label_entry: 7 | %op1 = call i32 @get_int() 8 | store i32 %op1, i32* @a 9 | %op2 = call i32 @get_int() 10 | store i32 %op2, i32* @b 11 | %op4 = load i32, i32* @a 12 | %op5 = load i32, i32* @b 13 | %op6 = icmp eq i32 %op4, %op5 14 | br i1 %op6, label %label_4, label %label_2 15 | label_ret: ; preds = %label_3 16 | ret i32 %op11 17 | label_1: ; preds = %label_4 18 | br label %label_3 19 | label_2: ; preds = %label_entry, %label_4 20 | br label %label_3 21 | label_3: ; preds = %label_1, %label_2 22 | %op11 = phi i32 [ 0, %label_2 ], [ 1, %label_1 ] 23 | br label %label_ret 24 | label_4: ; preds = %label_entry 25 | %op9 = load i32, i32* @a 26 | %op10 = icmp ne i32 %op9, 3 27 | br i1 %op10, label %label_1, label %label_2 28 | } 29 | -------------------------------------------------------------------------------- /test/test_2020/74_itera_sqrt.ll: -------------------------------------------------------------------------------- 1 | declare void @put_int(i32) 2 | 3 | declare void @put_char(i32) 4 | 5 | define i32 @fsqrt(i32 %arg0) { 6 | label_entry: 7 | %op6 = sdiv i32 %arg0, 2 8 | br label %label_1 9 | label_ret: ; preds = %label_1 10 | ret i32 %op21 11 | label_1: ; preds = %label_entry, %label_2 12 | %op21 = phi i32 [ %op6, %label_entry ], [ %op19, %label_2 ] 13 | %op22 = phi i32 [ 0, %label_entry ], [ %op21, %label_2 ] 14 | %op10 = sub i32 %op22, %op21 15 | %op11 = icmp ne i32 %op10, 0 16 | br i1 %op11, label %label_2, label %label_ret 17 | label_2: ; preds = %label_1 18 | %op16 = sdiv i32 %arg0, %op21 19 | %op17 = add i32 %op21, %op16 20 | %op19 = sdiv i32 %op17, 2 21 | br label %label_1 22 | } 23 | define i32 @main() { 24 | label_entry: 25 | %op4 = call i32 @fsqrt(i32 400) 26 | call void @put_int(i32 %op4) 27 | call void @put_char(i32 10) 28 | br label %label_ret 29 | label_ret: ; preds = %label_entry 30 | ret i32 0 31 | } 32 | -------------------------------------------------------------------------------- /test/test_2020/89_itera_sqrt.ll: -------------------------------------------------------------------------------- 1 | declare void @put_int(i32) 2 | 3 | declare void @put_char(i32) 4 | 5 | define i32 @fsqrt(i32 %arg0) { 6 | label_entry: 7 | %op6 = sdiv i32 %arg0, 2 8 | br label %label_1 9 | label_ret: ; preds = %label_1 10 | ret i32 %op21 11 | label_1: ; preds = %label_entry, %label_2 12 | %op21 = phi i32 [ %op6, %label_entry ], [ %op19, %label_2 ] 13 | %op22 = phi i32 [ 0, %label_entry ], [ %op21, %label_2 ] 14 | %op10 = sub i32 %op22, %op21 15 | %op11 = icmp ne i32 %op10, 0 16 | br i1 %op11, label %label_2, label %label_ret 17 | label_2: ; preds = %label_1 18 | %op16 = sdiv i32 %arg0, %op21 19 | %op17 = add i32 %op21, %op16 20 | %op19 = sdiv i32 %op17, 2 21 | br label %label_1 22 | } 23 | define i32 @main() { 24 | label_entry: 25 | %op4 = call i32 @fsqrt(i32 400) 26 | call void @put_int(i32 %op4) 27 | call void @put_char(i32 10) 28 | br label %label_ret 29 | label_ret: ; preds = %label_entry 30 | ret i32 0 31 | } 32 | -------------------------------------------------------------------------------- /test/test_2021/098_chaos_token.out: -------------------------------------------------------------------------------- 1 | Welcome to the Japari Park! 2 | Araiguma says hello to Tairiku Ookami 3 | Tairiku Ookami says hello to Saabaru 4 | Araiguma says hello to Kaban 5 | Hunboruto Pengin says hello to Hashibirokou 6 | Hashibirokou says hello to Tairiku Ookami 7 | Hunboruto Pengin says hello to Saabaru 8 | Hashibirokou says hello to Araiguma 9 | Araiguma says hello to Hunboruto Pengin 10 | Hashibirokou says hello to Kaban 11 | Araiguma says hello to Hashibirokou 12 | Kaban says hello to Tairiku Ookami 13 | Araiguma says hello to Saabaru 14 | Kaban says hello to Araiguma 15 | Hashibirokou says hello to Hunboruto Pengin 16 | Saabaru says hello to Tairiku Ookami 17 | Hashibirokou says hello to Saabaru 18 | Saabaru says hello to Araiguma 19 | Kaban says hello to Hunboruto Pengin 20 | Saabaru says hello to Kaban 21 | Kaban says hello to Hashibirokou 22 | Tairiku Ookami says hello to Kaban 23 | Kaban says hello to Saabaru 24 | Hunboruto Pengin says hello to Tairiku Ookami 25 | Saabaru says hello to Hunboruto Pengin 26 | Hunboruto Pengin says hello to Araiguma 27 | Saabaru says hello to Hashibirokou 28 | Hunboruto Pengin says hello to Kaban 29 | 0 30 | -------------------------------------------------------------------------------- /test/test_2021/116_nested_calls2.ll: -------------------------------------------------------------------------------- 1 | declare void @put_int(i32) 2 | 3 | define i32 @f(i32 %arg0, i32 %arg1) { 4 | label_entry: 5 | %op7 = mul i32 %arg0, %arg1 6 | br label %label_ret 7 | label_ret: ; preds = %label_entry 8 | ret i32 %op7 9 | } 10 | define i32 @g(i32 %arg0, i32 %arg1) { 11 | label_entry: 12 | %op7 = srem i32 %arg0, %arg1 13 | br label %label_ret 14 | label_ret: ; preds = %label_entry 15 | ret i32 %op7 16 | } 17 | define i32 @h(i32 %arg0, i32 %arg1) { 18 | label_entry: 19 | %op7 = call i32 @g(i32 %arg0, i32 %arg1) 20 | %op8 = call i32 @f(i32 2, i32 %op7) 21 | %op11 = call i32 @f(i32 %arg0, i32 %arg1) 22 | %op12 = call i32 @g(i32 %op11, i32 4) 23 | %op13 = call i32 @f(i32 %op8, i32 %op12) 24 | br label %label_ret 25 | label_ret: ; preds = %label_entry 26 | ret i32 %op13 27 | } 28 | define i32 @main() { 29 | label_entry: 30 | %op1 = call i32 @h(i32 11, i32 3) 31 | call void @put_int(i32 %op1) 32 | br label %label_ret 33 | label_ret: ; preds = %label_entry 34 | ret i32 0 35 | } 36 | -------------------------------------------------------------------------------- /test/test_2020/78_decbinoct.ll: -------------------------------------------------------------------------------- 1 | declare void @put_int(i32) 2 | 3 | declare void @put_char(i32) 4 | 5 | define i32 @dec2bin(i32 %arg0) { 6 | label_entry: 7 | br label %label_1 8 | label_ret: ; preds = %label_1 9 | ret i32 %op25 10 | label_1: ; preds = %label_entry, %label_2 11 | %op23 = phi i32 [ %arg0, %label_entry ], [ %op21, %label_2 ] 12 | %op24 = phi i32 [ 1, %label_entry ], [ %op19, %label_2 ] 13 | %op25 = phi i32 [ 0, %label_entry ], [ %op17, %label_2 ] 14 | %op10 = icmp ne i32 %op23, 0 15 | br i1 %op10, label %label_2, label %label_ret 16 | label_2: ; preds = %label_1 17 | %op12 = srem i32 %op23, 2 18 | %op15 = mul i32 %op24, %op12 19 | %op17 = add i32 %op15, %op25 20 | %op19 = mul i32 %op24, 10 21 | %op21 = sdiv i32 %op23, 2 22 | br label %label_1 23 | } 24 | define i32 @main() { 25 | label_entry: 26 | %op4 = call i32 @dec2bin(i32 400) 27 | call void @put_int(i32 %op4) 28 | call void @put_char(i32 10) 29 | br label %label_ret 30 | label_ret: ; preds = %label_entry 31 | ret i32 0 32 | } 33 | -------------------------------------------------------------------------------- /test/test_2020/93_decbinoct.ll: -------------------------------------------------------------------------------- 1 | declare void @put_int(i32) 2 | 3 | declare void @put_char(i32) 4 | 5 | define i32 @dec2bin(i32 %arg0) { 6 | label_entry: 7 | br label %label_1 8 | label_ret: ; preds = %label_1 9 | ret i32 %op25 10 | label_1: ; preds = %label_entry, %label_2 11 | %op23 = phi i32 [ %arg0, %label_entry ], [ %op21, %label_2 ] 12 | %op24 = phi i32 [ 1, %label_entry ], [ %op19, %label_2 ] 13 | %op25 = phi i32 [ 0, %label_entry ], [ %op17, %label_2 ] 14 | %op10 = icmp ne i32 %op23, 0 15 | br i1 %op10, label %label_2, label %label_ret 16 | label_2: ; preds = %label_1 17 | %op12 = srem i32 %op23, 2 18 | %op15 = mul i32 %op24, %op12 19 | %op17 = add i32 %op15, %op25 20 | %op19 = mul i32 %op24, 10 21 | %op21 = sdiv i32 %op23, 2 22 | br label %label_1 23 | } 24 | define i32 @main() { 25 | label_entry: 26 | %op4 = call i32 @dec2bin(i32 400) 27 | call void @put_int(i32 %op4) 28 | call void @put_char(i32 10) 29 | br label %label_ret 30 | label_ret: ; preds = %label_entry 31 | ret i32 0 32 | } 33 | -------------------------------------------------------------------------------- /test/test_2020/58_sort_test6.sy: -------------------------------------------------------------------------------- 1 | int n; 2 | 3 | int counting_sort(int ini_arr[], int sorted_arr[], int n) { 4 | int count_arr[10]; 5 | int i; 6 | int j; 7 | int k; 8 | k = 0; 9 | i = 0; 10 | j = 0; 11 | while(k < 10){ 12 | count_arr[k] = 0; 13 | k = k + 1; 14 | } 15 | while(i < n) 16 | { 17 | count_arr[ini_arr[i]] = count_arr[ini_arr[i]] + 1; 18 | i = i + 1; 19 | } 20 | k = 1; 21 | while(k < 10){ 22 | count_arr[k] = count_arr[k] + count_arr[k - 1]; 23 | k = k + 1; 24 | } 25 | j = n; 26 | while( j > 0){ 27 | count_arr[ini_arr[j - 1]] = count_arr[ini_arr[j - 1]] - 1; 28 | sorted_arr[count_arr[ini_arr[j - 1]]] = ini_arr[j - 1]; 29 | j = j - 1; 30 | } 31 | return 0; 32 | } 33 | 34 | 35 | int main(){ 36 | n = 10; 37 | int a[10]; 38 | a[0]=4;a[1]=3;a[2]=9;a[3]=2;a[4]=0; 39 | a[5]=1;a[6]=6;a[7]=5;a[8]=7;a[9]=8; 40 | int i; 41 | i = 0; 42 | int b[10]; 43 | i = counting_sort(a, b, n); 44 | while (i < n) { 45 | int tmp; 46 | tmp = b[i]; 47 | putint(tmp); 48 | tmp = 10; 49 | putch(tmp); 50 | i = i + 1; 51 | } 52 | return 0; 53 | } 54 | -------------------------------------------------------------------------------- /test/test_2020/34_func_test2.ll: -------------------------------------------------------------------------------- 1 | define i32 @func1() { 2 | label_entry: 3 | br label %label_ret 4 | label_ret: ; preds = %label_entry 5 | ret i32 1 6 | } 7 | define i32 @func2() { 8 | label_entry: 9 | br label %label_ret 10 | label_ret: ; preds = %label_entry 11 | ret i32 2 12 | } 13 | define i32 @func3() { 14 | label_entry: 15 | br label %label_ret 16 | label_ret: ; preds = %label_entry 17 | ret i32 4 18 | } 19 | define i32 @func4() { 20 | label_entry: 21 | br label %label_ret 22 | label_ret: ; preds = %label_entry 23 | ret i32 24 24 | } 25 | define i32 @main() { 26 | label_entry: 27 | %op4 = call i32 @func1() 28 | %op5 = call i32 @func2() 29 | %op6 = add i32 %op4, %op5 30 | %op7 = call i32 @func3() 31 | %op8 = add i32 %op6, %op7 32 | %op9 = call i32 @func4() 33 | %op10 = add i32 %op8, %op9 34 | %op12 = add i32 %op10, 32 35 | %op14 = add i32 %op12, 32 36 | %op16 = add i32 %op14, 32 37 | br label %label_ret 38 | label_ret: ; preds = %label_entry 39 | ret i32 %op16 40 | } 41 | -------------------------------------------------------------------------------- /test/test_2020/51_recursion_test2.ll: -------------------------------------------------------------------------------- 1 | define i32 @fib(i32 %arg0) { 2 | label_entry: 3 | %op4 = icmp eq i32 %arg0, 0 4 | br i1 %op4, label %label_1, label %label_2 5 | label_ret: ; preds = %label_1, %label_3, %label_4 6 | %op19 = phi i32 [ %op18, %label_4 ], [ 1, %label_3 ], [ 0, %label_1 ] 7 | ret i32 %op19 8 | label_1: ; preds = %label_entry 9 | br label %label_ret 10 | label_2: ; preds = %label_entry 11 | %op7 = icmp eq i32 %arg0, 1 12 | br i1 %op7, label %label_3, label %label_4 13 | label_3: ; preds = %label_2 14 | br label %label_ret 15 | label_4: ; preds = %label_2 16 | %op10 = sub i32 %arg0, 1 17 | %op13 = sub i32 %arg0, 2 18 | %op15 = call i32 @fib(i32 %op10) 19 | %op17 = call i32 @fib(i32 %op13) 20 | %op18 = add i32 %op15, %op17 21 | br label %label_ret 22 | } 23 | define i32 @main() { 24 | label_entry: 25 | %op3 = call i32 @fib(i32 10) 26 | br label %label_ret 27 | label_ret: ; preds = %label_entry 28 | ret i32 %op3 29 | } 30 | -------------------------------------------------------------------------------- /test/test_2021/073_backpack.sy: -------------------------------------------------------------------------------- 1 | int V[200][200]={}; 2 | int KnapSack(int n, int w[], int v[], int x[], int C) 3 | { 4 | int i, j; 5 | i=1; 6 | while(i<=n) 7 | { 8 | j=0; 9 | while(jtmp2) 18 | { 19 | V[i][j] = tmp1; 20 | } 21 | else 22 | { 23 | V[i][j] = tmp2; 24 | } 25 | 26 | } 27 | j=j+1; 28 | } 29 | i=i+1; 30 | } 31 | 32 | j = C; 33 | i=n; 34 | while(i>=1) 35 | { 36 | if (V[i][j]>V[i - 1][j]) 37 | { 38 | x[i] = 1; 39 | j = j - w[i]; 40 | } 41 | else 42 | { 43 | 44 | x[i] = 0; 45 | } 46 | i=i-1; 47 | } 48 | return V[n][C]; 49 | } 50 | 51 | int main() 52 | { 53 | int s; 54 | int w[6] = {0,2,2,6,5,4}; 55 | int v[6] = {0,6,3,5,4,6}; 56 | int x[6]; 57 | int n = 5; 58 | int C=10; 59 | s = KnapSack(n, w, v, x, C); 60 | putint(s); 61 | return 0; 62 | 63 | } 64 | -------------------------------------------------------------------------------- /test/test_2021/078_big_int_mul.sy: -------------------------------------------------------------------------------- 1 | const int len = 20; 2 | 3 | int main() 4 | { 5 | int i, j, t, n, temp; 6 | int mult1[len] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0}; 7 | int mult2[len] = {2, 3, 4, 2, 5, 7 ,9 ,9, 0, 1, 9, 8, 7, 6, 4, 3, 2, 1, 2, 2}; 8 | int len1 = len; 9 | int len2 = len; 10 | int c1[len + 5]; 11 | int c2[len + 5]; 12 | int result[len * 2] = {}; 13 | 14 | i = 0; 15 | while (i < len1) { 16 | c1[i] = mult1[i]; 17 | i = i + 1; 18 | } 19 | 20 | i = 0; 21 | while (i < len2) { 22 | c2[i] = mult2[i]; 23 | i = i + 1; 24 | } 25 | 26 | n = len1 + len2 - 1; 27 | 28 | i = 0; 29 | while (i <= n) { 30 | result[i]=0; 31 | i = i + 1; 32 | } 33 | 34 | temp=0; 35 | 36 | i = len2 - 1; 37 | while (i > -1) { 38 | t = c2[i]; 39 | j = len1 - 1; 40 | while (j > -1) { 41 | temp = result[n] + t * c1[j]; 42 | if(temp >= 10) { 43 | result[n] = (temp); 44 | result[n-1] = result[n-1] + temp / 10; 45 | } 46 | else 47 | result[n] = temp; 48 | j = j - 1; 49 | n = n - 1; 50 | } 51 | n = n + len1 - 1; 52 | i = i - 1; 53 | } 54 | 55 | if(result[0] != 0) 56 | putint(result[0]); 57 | 58 | i = 1; 59 | while (i <= len1 + len2 - 1) { 60 | putint(result[i]); 61 | i = i + 1; 62 | } 63 | 64 | return 0; 65 | } -------------------------------------------------------------------------------- /test/test_2021/102_short_circuit3.sy: -------------------------------------------------------------------------------- 1 | int a, b, d; 2 | 3 | int set_a(int val) { a = val; return a; } 4 | int set_b(int val) { b = val; return b; } 5 | int set_d(int val) { d = val; return d; } 6 | 7 | int main() 8 | { 9 | a = 2; b = 3; 10 | if (set_a(0) && set_b(1)) {} 11 | putint(a); putch(32); 12 | putint(b); putch(32); 13 | 14 | a = 2; b = 3; 15 | if (set_a(0) && set_b(1)) ; 16 | putint(a); putch(32); 17 | putint(b); putch(10); 18 | 19 | const int c = 1; 20 | d = 2; 21 | if (c >= 1 && set_d(3)) ; 22 | putint(d); putch(32); 23 | if (c <= 1 || set_d(4)) {} 24 | putint(d); putch(10); 25 | 26 | if (16 >= (3 - (2 + 1))) { putch(65); } 27 | if ((25 - 7) != (36 - 6 * 3)) putch(66); 28 | if (1 < 8 != 7 % 2) { putch(67); } 29 | if (3 > 4 == 0) { putch(68); } 30 | if (1 == 0x66 <= 077) putch(69); 31 | if (5 - 6 == -!0) putch(70); 32 | putch(10); 33 | 34 | int i0 = 0, i1 = 1, i2 = 2, i3 = 3, i4 = 4; 35 | while (i0 && i1) putch(32); 36 | if (i0 || i1) putch(67); 37 | if (i0 >= i1 || i1 <= i0) putch(72); 38 | if (i2 >= i1 && i4 != i3) { putch(73); } 39 | if (i0 == !i1 && i3 < i3 || i4 >= i4) { putch(74); } 40 | if (i0 == !i1 || i3 < i3 && i4 >= i4) putch(75); 41 | putch(10); 42 | 43 | return 0; 44 | } 45 | --------------------------------------------------------------------------------