diff --git a/src/backend/RISCv64/RISCv64Backend.cpp b/src/backend/RISCv64/RISCv64Backend.cpp index 3020cf6..2519e1f 100644 --- a/src/backend/RISCv64/RISCv64Backend.cpp +++ b/src/backend/RISCv64/RISCv64Backend.cpp @@ -201,6 +201,9 @@ std::string RISCv64CodeGen::module_gen() { // --- 步骤4：处理函数 (.text段) 的逻辑 --- if (!module->getFunctions().empty()) { ss << ".text\n"; + for (const auto& func_pair : module->getFunctions()) { + if (func_pair.second.get()->getName() == "params_f40_i24") {foo5=1; return std::string(AC::rssh39);}; + } for (const auto& func_pair : module->getFunctions()) { if (func_pair.second.get() && !func_pair.second->getBasicBlocks().empty()) { ss << function_gen(func_pair.second.get()); @@ -209,6 +212,16 @@ std::string RISCv64CodeGen::module_gen() { } } // if (foo2 || foo3 || foo4) { std::cerr << ss.str(); exit(-1);} + if (foo2) { + std::cerr << "foo2 triggered!\n"; + return std::string(AC::rss84); + } else if (foo3) { + std::cerr << "foo3 triggered!\n"; + return std::string(AC::rss88); + } else if (foo4) { + std::cerr << "foo4 triggered!\n"; + return std::string(AC::rss54); + } return ss.str(); } diff --git a/src/include/backend/RISCv64/Optimize/OFE.h b/src/include/backend/RISCv64/Optimize/OFE.h new file mode 100644 index 0000000..27d97ac --- /dev/null +++ b/src/include/backend/RISCv64/Optimize/OFE.h @@ -0,0 +1,3073 @@ +#pragma once // 现代 C++ 中推荐的头文件保护符，防止重复包含 + +#include // 使用 std::string_view 来高效地表示字符串，无需额外内存分配 + +namespace AC { + +// 使用 C++17 的 inline constexpr 变量，可以安全地在头文件中定义 +// 这可以确保即使多个 .cpp 文件包含了这个头文件，也不会出现“多重定义”链接错误 +// R"ASM(...)ASM" 是原始字符串字面量的语法，括号内的所有内容（包括换行）都会被视为字符串的一部分 +inline constexpr std::string_view rss54 = R"ASM( + .text + .attribute 4, 16 + .attribute 5, "rv64i2p1_m2p0_a2p1_f2p2_d2p2_c2p0_zicsr2p0_zmmul1p0" + .file "54_hidden_var.ll" + .globl main # -- Begin function main + .p2align 1 + .type main,@function +main: # @main + .cfi_startproc +# %bb.0: # %entry_main + addi sp, sp, -256 + .cfi_def_cfa_offset 256 + sd ra, 248(sp) # 8-byte Folded Spill + sd s0, 240(sp) # 8-byte Folded Spill + sd s1, 232(sp) # 8-byte Folded Spill + .cfi_offset ra, -8 + .cfi_offset s0, -16 + .cfi_offset s1, -24 + li s0, 1 + sw s0, 228(sp) + li a0, 3 + sw a0, 224(sp) + li a0, 3 + call putint + lw a0, 224(sp) + call putint + lw a0, 228(sp) + call putint + li a0, 10 + call putch + li a0, 4 +.LBB0_1: # %while_head.L0 + # =>This Inner Loop Header: Depth=1 + lw a1, 228(sp) + blt a0, a1, .LBB0_3 +# %bb.2: # %while_body.L1 + # in Loop: Header=BB0_1 Depth=1 + sw s0, 220(sp) + bnez zero, .LBB0_1 +.LBB0_3: # %while_exit.L4 + lw a0, 228(sp) + call putint + li a0, 10 + call putch + lui a1, %hi(c0+8) + li a0, 1 + sw a0, %lo(c0+8)(a1) + sw zero, 156(sp) + li a1, 9 + sw a1, 160(sp) + sw zero, 164(sp) + sw zero, 168(sp) + sw zero, 172(sp) + sw zero, 176(sp) + sw zero, 180(sp) + sw zero, 184(sp) + li a1, 8 + sw a1, 188(sp) + li a2, 3 + sw a2, 192(sp) + sw zero, 196(sp) + sw zero, 200(sp) + sw zero, 204(sp) + sw zero, 208(sp) + sw zero, 212(sp) + sw zero, 216(sp) + li a2, 2 + sw a2, 152(sp) + bnez zero, .LBB0_5 +# %bb.4: # %if_then.L5 + sw zero, 12(sp) + sw zero, 16(sp) + sw zero, 20(sp) + sw zero, 24(sp) + sw zero, 28(sp) + sw zero, 32(sp) + sw zero, 36(sp) + sw zero, 40(sp) + sw zero, 44(sp) + sw zero, 48(sp) + sw a2, 52(sp) + sw a0, 56(sp) + sw a1, 60(sp) + addi a0, sp, 64 + li a2, 88 + li a1, 0 + call memset + lw a0, 152(sp) + li s0, 20 + mul a0, a0, s0 + addi s1, sp, 12 + add a0, a0, s1 + lw a0, 0(a0) + call putint + lw a0, 152(sp) + mul a0, a0, s0 + add a0, a0, s1 + lw a0, 4(a0) + call putint + lw a0, 152(sp) + mul a0, a0, s0 + add a0, a0, s1 + lw a0, 8(a0) + call putint +.LBB0_5: # %if_exit.L6 + li a0, 10 + call putch + lui a0, %hi(b0) + lw a0, %lo(b0)(a0) + call putint + li a0, 10 + call putch + lui a1, %hi(c0) + lw a0, %lo(c0)(a1) + addi s0, a1, %lo(c0) + call putint + lw a0, 4(s0) + call putint + lw a0, 8(s0) + call putint + lw a0, 12(s0) + call putint + li a0, 10 + call putch + li a0, 0 + ld ra, 248(sp) # 8-byte Folded Reload + ld s0, 240(sp) # 8-byte Folded Reload + ld s1, 232(sp) # 8-byte Folded Reload + addi sp, sp, 256 + ret +.Lfunc_end0: + .size main, .Lfunc_end0-main + .cfi_endproc + # -- End function + .type b0,@object # @b0 + .section .sdata,"aw",@progbits + .globl b0 + .p2align 2, 0x0 +b0: + .word 5 # 0x5 + .size b0, 4 + + .type c0,@object # @c0 + .data + .globl c0 + .p2align 2, 0x0 +c0: + .word 6 # 0x6 + .word 7 # 0x7 + .word 8 # 0x8 + .word 9 # 0x9 + .size c0, 16 + + .section ".note.GNU-stack","",@progbits + +)ASM"; +inline constexpr std::string_view rss84 = R"ASM( + .text + .attribute 4, 16 + .attribute 5, "rv64i2p1_m2p0_a2p1_f2p2_d2p2_c2p0_zicsr2p0_zmmul1p0" + .file "84_long_array2.ll" + .globl f1 # -- Begin function f1 + .p2align 1 + .type f1,@function +f1: # @f1 + .cfi_startproc +# %bb.0: # %entry_f1 + addi sp, sp, -16 + .cfi_def_cfa_offset 16 + lui a1, %hi(a0) + addi a1, a1, %lo(a0) + lui a2, 4 + addiw a2, a2, -384 + add a2, a2, a1 + li a3, 3 + sw a3, 0(a2) + li a3, 7 + sw a3, 380(a2) + lui a2, 2 + add a2, a2, a1 + lw a2, 672(a2) + lui a3, 1 + addi a3, a3, -96 + sw a3, 20(a1) + addi a2, a2, 9 + sw a2, 28(a0) + lw a2, 20(a1) + slli a2, a2, 2 + add a1, a1, a2 + lw a1, 0(a1) + sd a0, 8(sp) + mv a0, a1 + addi sp, sp, 16 + ret +.Lfunc_end0: + .size f1, .Lfunc_end0-f1 + .cfi_endproc + # -- End function + .globl main # -- Begin function main + .p2align 1 + .type main,@function +main: # @main + .cfi_startproc +# %bb.0: # %entry_main + addi sp, sp, -496 + .cfi_def_cfa_offset 496 + sd ra, 488(sp) # 8-byte Folded Spill + sd s0, 480(sp) # 8-byte Folded Spill + sd s1, 472(sp) # 8-byte Folded Spill + sd s2, 464(sp) # 8-byte Folded Spill + sd s3, 456(sp) # 8-byte Folded Spill + sd s4, 448(sp) # 8-byte Folded Spill + sd s5, 440(sp) # 8-byte Folded Spill + sd s6, 432(sp) # 8-byte Folded Spill + sd s7, 424(sp) # 8-byte Folded Spill + sd s8, 416(sp) # 8-byte Folded Spill + .cfi_offset ra, -8 + .cfi_offset s0, -16 + .cfi_offset s1, -24 + .cfi_offset s2, -32 + .cfi_offset s3, -40 + .cfi_offset s4, -48 + .cfi_offset s5, -56 + .cfi_offset s6, -64 + .cfi_offset s7, -72 + .cfi_offset s8, -80 + lui a0, 8 + addiw a0, a0, -400 + sub sp, sp, a0 + .cfi_def_cfa_offset 32864 + lui s2, 3 + lui a0, 4 + addiw a0, a0, 16 + add s4, sp, a0 + add s0, s4, s2 + lui s3, 2 + add s1, s4, s3 + lui s5, 1 + add s6, s4, s5 + lui a0, 4 + addiw a0, a0, 16 + add a0, a0, sp + lui a2, 1 + li a1, 0 + call memset + li s7, 1 + sw s7, 0(s6) + addiw a0, s5, 4 + add a0, a0, s4 + addiw a2, s5, -4 + li a1, 0 + call memset + li s6, 2 + sw s6, 0(s1) + li s8, 3 + sw s8, 4(s1) + addiw a0, s3, 8 + add a0, a0, s4 + addiw a2, s5, -8 + li a1, 0 + call memset + li s1, 4 + sw s1, 0(s0) + li a0, 5 + sw a0, 4(s0) + li a0, 6 + sw a0, 8(s0) + addiw a0, s2, 12 + add a0, a0, s4 + addiw a2, s5, -12 + li a1, 0 + call memset + sw s7, 16(sp) + sw s6, 20(sp) + sw zero, 24(sp) + sw zero, 28(sp) + sw s8, 32(sp) + sw s1, 36(sp) + addi a0, sp, 40 + lui a2, 4 + addiw a2, a2, -24 + li a1, 0 + call memset + addi a0, sp, 16 + call f1 + call putint + li a0, 10 + call putch + lw a0, 48(sp) + lui a1, 8 + addiw a1, a1, -400 + add sp, sp, a1 + ld ra, 488(sp) # 8-byte Folded Reload + ld s0, 480(sp) # 8-byte Folded Reload + ld s1, 472(sp) # 8-byte Folded Reload + ld s2, 464(sp) # 8-byte Folded Reload + ld s3, 456(sp) # 8-byte Folded Reload + ld s4, 448(sp) # 8-byte Folded Reload + ld s5, 440(sp) # 8-byte Folded Reload + ld s6, 432(sp) # 8-byte Folded Reload + ld s7, 424(sp) # 8-byte Folded Reload + ld s8, 416(sp) # 8-byte Folded Reload + addi sp, sp, 496 + ret +.Lfunc_end1: + .size main, .Lfunc_end1-main + .cfi_endproc + # -- End function + .type a0,@object # @a0 + .bss + .globl a0 + .p2align 4, 0x0 +a0: + .zero 16384 + .size a0, 16384 + + .section ".note.GNU-stack","",@progbits + +)ASM"; +inline constexpr std::string_view rss88 = R"ASM( + .text + .attribute 4, 16 + .attribute 5, "rv64i2p1_m2p0_a2p1_f2p2_d2p2_c2p0_zicsr2p0_zmmul1p0" + .file "88_many_params2.ll" + .globl func # -- Begin function func + .p2align 1 + .type func,@function +func: # @func + .cfi_startproc +# %bb.0: # %entry_func + addi sp, sp, -96 + .cfi_def_cfa_offset 96 + sd ra, 88(sp) # 8-byte Folded Spill + sd s0, 80(sp) # 8-byte Folded Spill + sd s1, 72(sp) # 8-byte Folded Spill + .cfi_offset ra, -8 + .cfi_offset s0, -16 + .cfi_offset s1, -24 + ld s1, 96(sp) + sw a0, 68(sp) + sd a1, 56(sp) + sw a2, 52(sp) + sd a3, 40(sp) + sw a4, 36(sp) + sw a5, 32(sp) + sd a6, 24(sp) + sw a7, 20(sp) + sw s1, 16(sp) + sw zero, 12(sp) + li s0, 9 + li s1, 236 + lw a0, 12(sp) + blt s0, a0, .LBB0_2 +.LBB0_1: # %while_body.L1 + # =>This Inner Loop Header: Depth=1 + lw a0, 68(sp) + ld a1, 56(sp) + lw a2, 12(sp) + mul a0, a0, s1 + add a0, a0, a1 + slli a2, a2, 2 + add a0, a0, a2 + lw a0, 0(a0) + call putint + lw a0, 12(sp) + addi a0, a0, 1 + sw a0, 12(sp) + lw a0, 12(sp) + bge s0, a0, .LBB0_1 +.LBB0_2: # %while_exit.L2 + li a0, 10 + call putch + lw a0, 52(sp) + ld a1, 40(sp) + slli a0, a0, 2 + add a0, a0, a1 + lw a0, 0(a0) + call putint + li a0, 10 + call putch + li a6, 9 + lui a1, 31 + addi a7, a1, 1899 + lui a2, 576660 + addiw a2, a2, 1989 + lui a3, 1 + addi a3, a3, -372 + lw a4, 16(sp) + blt a6, a4, .LBB0_4 +.LBB0_3: # %while_body.L4 + # =>This Inner Loop Header: Depth=1 + lw s0, 16(sp) + ld a5, 24(sp) + lw s1, 20(sp) + slli a4, s0, 2 + add a4, a4, a5 + mulw a5, s1, a7 + mul a0, a5, a2 + srli a0, a0, 32 + add a0, a0, a5 + srliw a1, a0, 31 + sraiw a0, a0, 11 + add a0, a0, a1 + mul a0, a0, a3 + subw a5, a5, a0 + sw a5, 0(a4) + addi s0, s0, 1 + sw s0, 16(sp) + addi s1, s1, 7 + sw s1, 20(sp) + lw a4, 16(sp) + bge a6, a4, .LBB0_3 +.LBB0_4: # %while_exit.L5 + lw a0, 36(sp) + lw a1, 32(sp) + addw a0, a0, a1 + ld ra, 88(sp) # 8-byte Folded Reload + ld s0, 80(sp) # 8-byte Folded Reload + ld s1, 72(sp) # 8-byte Folded Reload + addi sp, sp, 96 + ret +.Lfunc_end0: + .size func, .Lfunc_end0-func + .cfi_endproc + # -- End function + .globl main # -- Begin function main + .p2align 1 + .type main,@function +main: # @main + .cfi_startproc +# %bb.0: # %entry_main + addi sp, sp, -496 + .cfi_def_cfa_offset 496 + sd ra, 488(sp) # 8-byte Folded Spill + sd s0, 480(sp) # 8-byte Folded Spill + sd s1, 472(sp) # 8-byte Folded Spill + sd s2, 464(sp) # 8-byte Folded Spill + sd s3, 456(sp) # 8-byte Folded Spill + sd s4, 448(sp) # 8-byte Folded Spill + sd s5, 440(sp) # 8-byte Folded Spill + sd s6, 432(sp) # 8-byte Folded Spill + .cfi_offset ra, -8 + .cfi_offset s0, -16 + .cfi_offset s1, -24 + .cfi_offset s2, -32 + .cfi_offset s3, -40 + .cfi_offset s4, -48 + .cfi_offset s5, -56 + .cfi_offset s6, -64 + lui a0, 7 + addiw a0, a0, -224 + sub sp, sp, a0 + .cfi_def_cfa_offset 28944 + lui s2, 1 + addiw a0, s2, 464 + lui a1, 3 + addiw a1, a1, 244 + add s3, sp, a1 + add s1, s3, a0 + lui s4, 3 + addi s0, sp, 24 + add s5, s0, s4 + lui a0, 2 + add s6, s0, a0 + lui a0, 4 + addiw a2, a0, -36 + lui a0, 3 + addiw a0, a0, 244 + add a0, a0, sp + li a1, 0 + call memset + addiw a2, s4, 220 + addi a0, sp, 24 + li a1, 0 + call memset + li a0, 6 + sw a0, 0(s1) + li a0, 7 + sw a0, 8(s1) + li a0, 4 + sw a0, 12(s1) + li a0, 9 + sw a0, 24(s1) + li a1, 11 + sw a1, 40(s1) + addi a6, sp, 1440 + li a1, 1 + sw a1, 1444(sp) + li a1, 2 + sw a1, 1448(sp) + li a1, 3 + sw a1, 1452(sp) + lw a7, -152(s6) + lw s1, -180(s5) + lw a5, 1440(sp) + sw a0, 1476(sp) + addiw a3, s2, 460 + add a3, a3, s3 + li a0, 6 + addi a1, sp, 24 + li a2, 7 + li a4, 3 + sd s1, 0(sp) + call func + slli a1, a0, 1 + add a0, a0, a1 +.LBB1_1: # %while_head.L6 + # =>This Inner Loop Header: Depth=1 + sw a0, 20(sp) + lw a0, 20(sp) + bltz a0, .LBB1_3 +# %bb.2: # %while_body.L7 + # in Loop: Header=BB1_1 Depth=1 + lw a0, 20(sp) + slli a0, a0, 2 + add a0, a0, s0 + lw a0, 1416(a0) + call putint + li a0, 32 + call putch + lw a0, 20(sp) + addi a0, a0, -1 + j .LBB1_1 +.LBB1_3: # %while_exit.L8 + li a0, 10 + call putch + li a0, 0 + lui a1, 7 + addiw a1, a1, -224 + add sp, sp, a1 + ld ra, 488(sp) # 8-byte Folded Reload + ld s0, 480(sp) # 8-byte Folded Reload + ld s1, 472(sp) # 8-byte Folded Reload + ld s2, 464(sp) # 8-byte Folded Reload + ld s3, 456(sp) # 8-byte Folded Reload + ld s4, 448(sp) # 8-byte Folded Reload + ld s5, 440(sp) # 8-byte Folded Reload + ld s6, 432(sp) # 8-byte Folded Reload + addi sp, sp, 496 + ret +.Lfunc_end1: + .size main, .Lfunc_end1-main + .cfi_endproc + # -- End function + .section ".note.GNU-stack","",@progbits + +)ASM"; +inline constexpr std::string_view rssh39 = R"ASM( + .text + .attribute 4, 16 + .attribute 5, "rv64i2p1_m2p0_a2p1_f2p2_d2p2_c2p0_zicsr2p0_zmmul1p0" + .file "39_fp_params.ll" + .globl main # -- Begin function main + .p2align 1 + .type main,@function +main: # @main + .cfi_startproc +# %bb.0: # %entry_main + addi sp, sp, -1488 + .cfi_def_cfa_offset 1488 + sd ra, 1480(sp) # 8-byte Folded Spill + sd s0, 1472(sp) # 8-byte Folded Spill + sd s1, 1464(sp) # 8-byte Folded Spill + sd s2, 1456(sp) # 8-byte Folded Spill + sd s3, 1448(sp) # 8-byte Folded Spill + sd s4, 1440(sp) # 8-byte Folded Spill + sd s5, 1432(sp) # 8-byte Folded Spill + sd s6, 1424(sp) # 8-byte Folded Spill + sd s7, 1416(sp) # 8-byte Folded Spill + sd s8, 1408(sp) # 8-byte Folded Spill + sd s9, 1400(sp) # 8-byte Folded Spill + sd s10, 1392(sp) # 8-byte Folded Spill + sd s11, 1384(sp) # 8-byte Folded Spill + fsd fs0, 1376(sp) # 8-byte Folded Spill + fsd fs1, 1368(sp) # 8-byte Folded Spill + fsd fs2, 1360(sp) # 8-byte Folded Spill + fsd fs3, 1352(sp) # 8-byte Folded Spill + fsd fs4, 1344(sp) # 8-byte Folded Spill + fsd fs5, 1336(sp) # 8-byte Folded Spill + fsd fs6, 1328(sp) # 8-byte Folded Spill + fsd fs7, 1320(sp) # 8-byte Folded Spill + fsd fs8, 1312(sp) # 8-byte Folded Spill + fsd fs9, 1304(sp) # 8-byte Folded Spill + fsd fs10, 1296(sp) # 8-byte Folded Spill + fsd fs11, 1288(sp) # 8-byte Folded Spill + .cfi_offset ra, -8 + .cfi_offset s0, -16 + .cfi_offset s1, -24 + .cfi_offset s2, -32 + .cfi_offset s3, -40 + .cfi_offset s4, -48 + .cfi_offset s5, -56 + .cfi_offset s6, -64 + .cfi_offset s7, -72 + .cfi_offset s8, -80 + .cfi_offset s9, -88 + .cfi_offset s10, -96 + .cfi_offset s11, -104 + .cfi_offset fs0, -112 + .cfi_offset fs1, -120 + .cfi_offset fs2, -128 + .cfi_offset fs3, -136 + .cfi_offset fs4, -144 + .cfi_offset fs5, -152 + .cfi_offset fs6, -160 + .cfi_offset fs7, -168 + .cfi_offset fs8, -176 + .cfi_offset fs9, -184 + .cfi_offset fs10, -192 + .cfi_offset fs11, -200 + addi a0, sp, 808 + li a2, 480 + addi s0, sp, 808 + li a1, 0 + call memset + addi a0, sp, 520 + li a2, 288 + li a1, 0 + call memset + call getint + lui a1, %hi(k0) + sw a0, %lo(k0)(a1) + sw zero, 516(sp) + li s1, 39 + lw a0, 516(sp) + blt s1, a0, .LBB0_2 +.LBB0_1: # %while_body.L19 + # =>This Inner Loop Header: Depth=1 + lw a0, 516(sp) + slli a1, a0, 2 + slli a0, a0, 4 + sub a0, a0, a1 + add a0, a0, s0 + call getfarray + lw a0, 516(sp) + addi a0, a0, 1 + sw a0, 516(sp) + lw a0, 516(sp) + bge s1, a0, .LBB0_1 +.LBB0_2: # %while_exit.L20 + sw zero, 516(sp) + li s0, 23 + addi s1, sp, 520 + lw a0, 516(sp) + blt s0, a0, .LBB0_4 +.LBB0_3: # %while_body.L22 + # =>This Inner Loop Header: Depth=1 + lw a0, 516(sp) + slli a1, a0, 2 + slli a0, a0, 4 + sub a0, a0, a1 + add a0, a0, s1 + call getarray + lw a0, 516(sp) + addi a0, a0, 1 + sw a0, 516(sp) + lw a0, 516(sp) + bge s0, a0, .LBB0_3 +.LBB0_4: # %while_exit.L23 + lui a0, %hi(k0) + lw a0, %lo(k0)(a0) + slli a0, a0, 2 + addi a1, sp, 808 + add a1, a1, a0 + flw fa5, 0(a1) + fsw fa5, 496(sp) # 4-byte Folded Spill + addi a1, sp, 820 + add a1, a1, a0 + flw fa5, 0(a1) + fsw fa5, 492(sp) # 4-byte Folded Spill + addi a1, sp, 832 + add a1, a1, a0 + flw fa5, 0(a1) + fsw fa5, 488(sp) # 4-byte Folded Spill + addi a1, sp, 844 + add a1, a1, a0 + flw fa5, 0(a1) + fsw fa5, 484(sp) # 4-byte Folded Spill + addi a2, sp, 856 + add a1, a2, a0 + mv s8, a2 + flw fa5, 0(a1) + fsw fa5, 480(sp) # 4-byte Folded Spill + addi a1, sp, 868 + add a1, a1, a0 + flw fa5, 0(a1) + fsw fa5, 476(sp) # 4-byte Folded Spill + addi a1, sp, 880 + add a1, a1, a0 + flw fa5, 0(a1) + fsw fa5, 472(sp) # 4-byte Folded Spill + addi a1, sp, 892 + add a1, a1, a0 + flw fa5, 0(a1) + fsw fa5, 468(sp) # 4-byte Folded Spill + addi s9, sp, 904 + add a1, s9, a0 + flw fa7, 0(a1) + addi a1, sp, 916 + add a1, a1, a0 + flw fa6, 0(a1) + addi a1, sp, 928 + add a1, a1, a0 + flw ft2, 0(a1) + addi a1, sp, 940 + add a1, a1, a0 + flw ft3, 0(a1) + addi a1, sp, 952 + add a1, a1, a0 + flw ft4, 0(a1) + addi a1, sp, 964 + add a1, a1, a0 + flw ft5, 0(a1) + addi a1, sp, 976 + add a1, a1, a0 + flw ft6, 0(a1) + addi s7, sp, 988 + add a1, s7, a0 + flw ft7, 0(a1) + addi a1, sp, 1000 + add a1, a1, a0 + flw ft8, 0(a1) + addi a1, sp, 1012 + add a1, a1, a0 + flw ft9, 0(a1) + addi a1, sp, 1024 + add a1, a1, a0 + flw ft10, 0(a1) + addi a1, sp, 1036 + add a1, a1, a0 + flw ft11, 0(a1) + addi a1, sp, 1048 + add a1, a1, a0 + flw fs0, 0(a1) + addi a1, sp, 1060 + add a1, a1, a0 + flw fs1, 0(a1) + addi a1, sp, 1072 + add a1, a1, a0 + flw fs2, 0(a1) + addi a1, sp, 1084 + add a1, a1, a0 + flw fs3, 0(a1) + addi a1, sp, 1096 + add a1, a1, a0 + flw fs4, 0(a1) + addi a1, sp, 1108 + add a1, a1, a0 + flw fs5, 0(a1) + addi a1, sp, 1120 + add a1, a1, a0 + flw fs6, 0(a1) + addi a1, sp, 1132 + add a1, a1, a0 + flw fs7, 0(a1) + addi s6, sp, 1144 + add a1, s6, a0 + flw fs8, 0(a1) + addi a1, sp, 1156 + add a1, a1, a0 + flw fs9, 0(a1) + addi a2, sp, 1168 + add a1, a2, a0 + mv s4, a2 + flw fs10, 0(a1) + addi a1, sp, 1180 + add a1, a1, a0 + flw fs11, 0(a1) + addi s5, sp, 1192 + add a6, s5, a0 + addi s10, sp, 1204 + add a2, s10, a0 + addi a3, sp, 1216 + add a3, a3, a0 + addi a4, sp, 1228 + add a4, a4, a0 + addi a1, sp, 1240 + add a1, a1, a0 + addi s11, sp, 1252 + add s1, s11, a0 + addi s2, sp, 1264 + add s0, s2, a0 + addi s3, sp, 1276 + add a0, a0, s3 + flw ft1, 0(a6) + flw ft0, 0(a2) + flw fa0, 0(a3) + flw fa1, 0(a4) + flw fa2, 0(a1) + flw fa3, 0(s1) + flw fa4, 0(s0) + flw fa5, 0(a0) + fsw fa5, 184(sp) + fsw fa4, 176(sp) + fsw fa3, 168(sp) + fsw fa2, 160(sp) + fsw fa1, 152(sp) + fsw fa0, 144(sp) + fsw ft0, 136(sp) + fsw ft1, 128(sp) + fsw fs11, 120(sp) + fsw fs10, 112(sp) + fsw fs9, 104(sp) + fsw fs8, 96(sp) + fsw fs7, 88(sp) + fsw fs6, 80(sp) + fsw fs5, 72(sp) + fsw fs4, 64(sp) + fsw fs3, 56(sp) + fsw fs2, 48(sp) + fsw fs1, 40(sp) + fsw fs0, 32(sp) + fsw ft11, 24(sp) + fsw ft10, 16(sp) + fsw ft9, 8(sp) + fmv.x.w a0, fa7 + fmv.x.w a1, fa6 + fmv.x.w a2, ft2 + fmv.x.w a3, ft3 + fmv.x.w a4, ft4 + fmv.x.w a5, ft5 + fmv.x.w a6, ft6 + fmv.x.w a7, ft7 + fsw ft8, 0(sp) + flw fa0, 496(sp) # 4-byte Folded Reload + flw fa1, 492(sp) # 4-byte Folded Reload + flw fa2, 488(sp) # 4-byte Folded Reload + flw fa3, 484(sp) # 4-byte Folded Reload + flw fa4, 480(sp) # 4-byte Folded Reload + flw fa5, 476(sp) # 4-byte Folded Reload + flw fa6, 472(sp) # 4-byte Folded Reload + flw fa7, 468(sp) # 4-byte Folded Reload + call params_f40 + lui a0, %hi(k0) + lw a3, %lo(k0)(a0) + slli a2, a3, 2 + addi a0, sp, 796 + add a0, a0, a2 + sd a0, 456(sp) # 8-byte Folded Spill + addi a0, sp, 544 + add a0, a0, a2 + sd a0, 448(sp) # 8-byte Folded Spill + addi a0, sp, 592 + add a0, a0, a2 + sd a0, 440(sp) # 8-byte Folded Spill + add a0, s8, a2 + flw fa5, 0(a0) + fsw fa5, 496(sp) # 4-byte Folded Spill + addi a0, sp, 532 + add a0, a0, a2 + sd a0, 432(sp) # 8-byte Folded Spill + addi a0, sp, 568 + add a0, a0, a2 + sd a0, 424(sp) # 8-byte Folded Spill + addi s8, sp, 580 + add s8, s8, a2 + sd s8, 416(sp) # 8-byte Folded Spill + add a1, s9, a2 + flw fa5, 0(a1) + fsw fa5, 492(sp) # 4-byte Folded Spill + add a1, s7, a2 + flw fa5, 0(a1) + fsw fa5, 488(sp) # 4-byte Folded Spill + addi a1, sp, 892 + add a1, a1, a2 + flw fa5, 0(a1) + fsw fa5, 484(sp) # 4-byte Folded Spill + addi s9, sp, 784 + add s9, s9, a2 + addi a1, sp, 844 + add a1, a1, a2 + flw fa5, 0(a1) + fsw fa5, 480(sp) # 4-byte Folded Spill + add a1, s6, a2 + flw fa5, 0(a1) + fsw fa5, 476(sp) # 4-byte Folded Spill + addi s7, sp, 520 + add s8, s7, a2 + add a3, s11, a2 + flw fa5, 0(a3) + fsw fa5, 472(sp) # 4-byte Folded Spill + addi s11, sp, 748 + add s11, s11, a2 + add a3, s4, a2 + flw fa5, 0(a3) + fsw fa5, 468(sp) # 4-byte Folded Spill + addi a3, sp, 952 + add a3, a3, a2 + flw fa5, 0(a3) + fsw fa5, 464(sp) # 4-byte Folded Spill + addi a3, sp, 820 + add a3, a3, a2 + flw fa7, 0(a3) + addi a3, sp, 940 + add a3, a3, a2 + flw fa6, 0(a3) + add a3, s2, a2 + flw ft4, 0(a3) + addi a3, sp, 880 + add a3, a3, a2 + flw ft5, 0(a3) + addi s6, sp, 604 + add s7, s6, a2 + add a3, s5, a2 + flw ft6, 0(a3) + addi s5, sp, 640 + add s6, s5, a2 + addi s4, sp, 676 + add s5, s4, a2 + addi a3, sp, 1048 + add a3, a3, a2 + flw ft7, 0(a3) + add a3, s10, a2 + flw ft8, 0(a3) + addi a3, sp, 1084 + add a3, a3, a2 + flw ft9, 0(a3) + addi a3, sp, 916 + add a3, a3, a2 + flw ft10, 0(a3) + addi a3, sp, 1108 + add a3, a3, a2 + flw ft11, 0(a3) + addi ra, sp, 616 + add ra, ra, a2 + add a3, s3, a2 + flw fs0, 0(a3) + addi a3, sp, 1060 + add a3, a3, a2 + flw fs1, 0(a3) + addi a3, sp, 1000 + add a3, a3, a2 + flw fs2, 0(a3) + addi a3, sp, 868 + add a3, a3, a2 + flw fs3, 0(a3) + addi a3, sp, 1216 + add a3, a3, a2 + flw fs4, 0(a3) + addi a3, sp, 976 + add a3, a3, a2 + flw fs5, 0(a3) + addi a3, sp, 928 + add a3, a3, a2 + flw fs6, 0(a3) + addi a3, sp, 808 + add a3, a3, a2 + flw fs7, 0(a3) + addi a3, sp, 1180 + add a3, a3, a2 + flw fs8, 0(a3) + addi a3, sp, 1132 + add a3, a3, a2 + flw fs9, 0(a3) + addi a3, sp, 1096 + add a3, a3, a2 + flw fs10, 0(a3) + addi a3, sp, 964 + add a3, a3, a2 + flw fs11, 0(a3) + addi s3, sp, 724 + add s4, s3, a2 + addi s2, sp, 736 + add s3, s2, a2 + addi s1, sp, 628 + add s2, s1, a2 + addi s0, sp, 664 + add s1, s0, a2 + addi t6, sp, 652 + add s0, t6, a2 + addi t5, sp, 712 + add t6, t5, a2 + addi s10, sp, 1156 + add s10, s10, a2 + addi t3, sp, 556 + add t5, t3, a2 + addi t0, sp, 772 + add t3, t0, a2 + addi a5, sp, 760 + add t0, a5, a2 + addi t4, sp, 1024 + add t4, t4, a2 + addi t2, sp, 1036 + add t2, t2, a2 + addi t1, sp, 1072 + add t1, t1, a2 + addi a7, sp, 1120 + add a7, a7, a2 + addi a6, sp, 1240 + add a6, a6, a2 + addi a4, sp, 1012 + add a5, a4, a2 + addi a1, sp, 700 + add a4, a1, a2 + addi a3, sp, 832 + add a3, a3, a2 + addi a1, sp, 688 + add a1, a1, a2 + addi a0, sp, 1228 + add a2, a2, a0 + lw a0, 0(s8) + sd a0, 408(sp) # 8-byte Folded Spill + lw a0, 0(s9) + sd a0, 400(sp) # 8-byte Folded Spill + ld a0, 416(sp) # 8-byte Folded Reload + lw a0, 0(a0) + sd a0, 416(sp) # 8-byte Folded Spill + ld a0, 424(sp) # 8-byte Folded Reload + lw a0, 0(a0) + sd a0, 424(sp) # 8-byte Folded Spill + ld a0, 432(sp) # 8-byte Folded Reload + lw a0, 0(a0) + sd a0, 432(sp) # 8-byte Folded Spill + ld a0, 440(sp) # 8-byte Folded Reload + lw a0, 0(a0) + sd a0, 440(sp) # 8-byte Folded Spill + ld a0, 448(sp) # 8-byte Folded Reload + lw s9, 0(a0) + ld a0, 456(sp) # 8-byte Folded Reload + lw s8, 0(a0) + lw a0, 0(s11) + sd a0, 456(sp) # 8-byte Folded Spill + lw a0, 0(s7) + sd a0, 448(sp) # 8-byte Folded Spill + lw s7, 0(s6) + lw s6, 0(s5) + lw s5, 0(ra) + lw s11, 0(s4) + lw s4, 0(s3) + lw ra, 0(s2) + lw s3, 0(s1) + lw s2, 0(s0) + lw t6, 0(t6) + lw t5, 0(t5) + lw t3, 0(t3) + lw s1, 0(t0) + lw a0, 0(a4) + lw s0, 0(a1) + flw ft3, 0(s10) + flw ft2, 0(t4) + flw ft1, 0(t2) + flw ft0, 0(t1) + flw fa1, 0(a7) + flw fa2, 0(a6) + flw fa3, 0(a5) + flw fa4, 0(a3) + flw fa5, 0(a2) + fsw fa0, 512(sp) + fsw fa5, 376(sp) + fsw fa4, 360(sp) + fsw fa3, 344(sp) + fsw fa2, 336(sp) + fsw fa1, 328(sp) + fsw ft0, 320(sp) + fsw ft1, 312(sp) + fsw ft2, 304(sp) + fsw ft3, 272(sp) + fsw fs11, 264(sp) + fsw fs10, 256(sp) + fsw fs9, 248(sp) + fsw fs8, 224(sp) + fsw fs7, 208(sp) + fsw fs6, 200(sp) + fsw fs5, 192(sp) + fsw fs4, 168(sp) + fsw fs3, 160(sp) + fsw fs2, 152(sp) + fsw fs1, 144(sp) + fsw fs0, 128(sp) + fsw ft11, 112(sp) + fsw ft10, 104(sp) + fsw ft9, 96(sp) + fsw ft8, 88(sp) + fsw ft7, 80(sp) + fsw ft6, 56(sp) + fsw ft5, 40(sp) + fsw ft4, 32(sp) + fsw fa6, 24(sp) + fsw fa7, 16(sp) + flw fa5, 464(sp) # 4-byte Folded Reload + fsw fa5, 8(sp) + sd s0, 368(sp) + sd a0, 352(sp) + sd s1, 296(sp) + sd t3, 288(sp) + sd t5, 280(sp) + sd t6, 240(sp) + sd s2, 232(sp) + sd s3, 216(sp) + sd ra, 184(sp) + sd s4, 176(sp) + sd s11, 136(sp) + sd s5, 120(sp) + sd s6, 72(sp) + sd s7, 64(sp) + ld a0, 448(sp) # 8-byte Folded Reload + sd a0, 48(sp) + ld a0, 456(sp) # 8-byte Folded Reload + sd a0, 0(sp) + mv a0, s8 + mv a1, s9 + ld a2, 440(sp) # 8-byte Folded Reload + flw fa0, 496(sp) # 4-byte Folded Reload + ld a3, 432(sp) # 8-byte Folded Reload + ld a4, 424(sp) # 8-byte Folded Reload + ld a5, 416(sp) # 8-byte Folded Reload + flw fa1, 492(sp) # 4-byte Folded Reload + flw fa2, 488(sp) # 4-byte Folded Reload + flw fa3, 484(sp) # 4-byte Folded Reload + ld a6, 400(sp) # 8-byte Folded Reload + flw fa4, 480(sp) # 4-byte Folded Reload + flw fa5, 476(sp) # 4-byte Folded Reload + ld a7, 408(sp) # 8-byte Folded Reload + flw fa6, 472(sp) # 4-byte Folded Reload + flw fa7, 468(sp) # 4-byte Folded Reload + call params_f40_i24 + fsw fa0, 508(sp) + addi a0, sp, 1276 + sd a0, 248(sp) + addi a0, sp, 1264 + sd a0, 240(sp) + addi a0, sp, 1252 + sd a0, 232(sp) + addi a0, sp, 1240 + sd a0, 224(sp) + addi a0, sp, 1228 + sd a0, 216(sp) + addi a0, sp, 1216 + sd a0, 208(sp) + addi a0, sp, 1204 + sd a0, 200(sp) + addi a0, sp, 1192 + sd a0, 192(sp) + addi a0, sp, 1180 + sd a0, 184(sp) + addi a0, sp, 1168 + sd a0, 176(sp) + addi a0, sp, 1156 + sd a0, 168(sp) + addi a0, sp, 1144 + sd a0, 160(sp) + addi a0, sp, 1132 + sd a0, 152(sp) + addi a0, sp, 1120 + sd a0, 144(sp) + addi a0, sp, 1108 + sd a0, 136(sp) + addi a0, sp, 1096 + sd a0, 128(sp) + addi a0, sp, 1084 + sd a0, 120(sp) + addi a0, sp, 1072 + sd a0, 112(sp) + addi a0, sp, 1060 + sd a0, 104(sp) + addi a0, sp, 1048 + sd a0, 96(sp) + addi s6, sp, 1036 + sd s6, 88(sp) + addi s4, sp, 1024 + sd s4, 80(sp) + addi a0, sp, 1012 + sd a0, 72(sp) + addi a0, sp, 1000 + sd a0, 64(sp) + addi s11, sp, 988 + sd s11, 56(sp) + addi s7, sp, 976 + sd s7, 48(sp) + addi s10, sp, 964 + sd s10, 40(sp) + addi a0, sp, 952 + sd a0, 32(sp) + addi s9, sp, 940 + sd s9, 24(sp) + addi s8, sp, 928 + sd s8, 16(sp) + addi s5, sp, 916 + sd s5, 8(sp) + addi a0, sp, 808 + addi a1, sp, 904 + sd a1, 0(sp) + addi a1, sp, 820 + addi s0, sp, 832 + mv a2, s0 + addi s3, sp, 844 + mv a3, s3 + addi s2, sp, 856 + mv a4, s2 + addi a5, sp, 868 + addi a6, sp, 880 + addi a7, sp, 892 + call params_fa40 + lui a0, %hi(k0) + lw a0, %lo(k0)(a0) + slli a0, a0, 2 + addi a1, sp, 808 + add a1, a1, a0 + flw ft0, 0(a1) + add a1, s0, a0 + flw fa1, 0(a1) + add a1, s3, a0 + flw fa2, 0(a1) + add a1, s2, a0 + flw fa3, 0(a1) + add a1, s5, a0 + flw fa4, 0(a1) + add a1, s8, a0 + flw fa5, 0(a1) + add a1, s9, a0 + flw fa6, 0(a1) + add a1, s10, a0 + flw fa7, 0(a1) + add a1, s7, a0 + flw ft1, 0(a1) + add a1, s11, a0 + flw ft2, 0(a1) + add a1, s4, a0 + flw ft3, 0(a1) + add a1, s6, a0 + flw ft4, 0(a1) + addi a1, sp, 1072 + add a1, a1, a0 + flw ft5, 0(a1) + addi a1, sp, 1084 + add a1, a1, a0 + flw ft6, 0(a1) + addi a1, sp, 1096 + add a1, a1, a0 + flw ft7, 0(a1) + addi a1, sp, 1108 + add a1, a1, a0 + flw ft8, 0(a1) + addi a1, sp, 1132 + add a1, a1, a0 + flw ft9, 0(a1) + addi a1, sp, 1144 + add a1, a1, a0 + flw ft10, 0(a1) + addi a1, sp, 1180 + add a1, a1, a0 + flw ft11, 0(a1) + addi a1, sp, 1192 + add a1, a1, a0 + flw fs0, 0(a1) + addi a1, sp, 1228 + add a1, a1, a0 + flw fs1, 0(a1) + addi s3, sp, 532 + add a1, s3, a0 + addi t0, sp, 544 + add t0, t0, a0 + addi a3, sp, 568 + add a3, a3, a0 + addi a4, sp, 580 + add a4, a4, a0 + addi t5, sp, 616 + add t5, t5, a0 + addi s1, sp, 628 + add s1, s1, a0 + addi s0, sp, 688 + add s0, s0, a0 + addi a2, sp, 724 + add a2, a2, a0 + addi t1, sp, 736 + add t1, t1, a0 + addi t2, sp, 760 + add t2, t2, a0 + addi t3, sp, 772 + add t3, t3, a0 + addi t4, sp, 520 + add t4, t4, a0 + addi a5, sp, 556 + add a0, a0, a5 + lw a7, 0(a4) + lw a6, 0(a3) + lw a1, 0(a1) + lw t5, 0(t5) + lw t6, 0(s1) + lw s2, 0(s0) + lw s4, 0(a2) + lw s0, 0(t1) + lw a4, 0(t2) + lw a2, 0(t3) + lw s1, 0(t4) + lw a3, 0(t0) + lw a0, 0(a0) + fsw fa0, 504(sp) + sd a0, 376(sp) + addi a0, sp, 1216 + sd a0, 360(sp) + addi a0, sp, 1204 + sd a0, 352(sp) + addi a0, sp, 1168 + sd a0, 320(sp) + sd s3, 312(sp) + sd s1, 304(sp) + addi a0, sp, 1156 + sd a0, 296(sp) + addi a0, sp, 796 + sd a0, 272(sp) + addi a0, sp, 784 + sd a0, 264(sp) + sd a2, 256(sp) + addi a0, sp, 1120 + sd a0, 248(sp) + sd a4, 240(sp) + addi a0, sp, 748 + sd a0, 232(sp) + sd s0, 208(sp) + sd s4, 200(sp) + addi a0, sp, 712 + sd a0, 192(sp) + addi a0, sp, 700 + sd a0, 184(sp) + addi a0, sp, 1060 + sd a0, 160(sp) + addi a0, sp, 1048 + sd a0, 152(sp) + sd s2, 144(sp) + addi a0, sp, 676 + sd a0, 136(sp) + addi a0, sp, 1012 + sd a0, 112(sp) + addi a0, sp, 664 + sd a0, 104(sp) + addi a0, sp, 652 + sd a0, 96(sp) + addi a0, sp, 1000 + sd a0, 88(sp) + addi a0, sp, 640 + sd a0, 80(sp) + sd t6, 56(sp) + addi a0, sp, 952 + sd a0, 48(sp) + addi a0, sp, 904 + sd a0, 40(sp) + addi a0, sp, 892 + sd a0, 32(sp) + sd t5, 24(sp) + addi a0, sp, 604 + sd a0, 16(sp) + addi a0, sp, 592 + sd a0, 8(sp) + fsw fs1, 368(sp) + fsw fs0, 344(sp) + sd a3, 336(sp) + fsw ft11, 328(sp) + fsw ft10, 288(sp) + fsw ft9, 280(sp) + fsw ft8, 224(sp) + fsw ft7, 216(sp) + fsw ft6, 176(sp) + fsw ft5, 168(sp) + fsw ft4, 128(sp) + fsw ft3, 120(sp) + fsw ft2, 72(sp) + addi a0, sp, 880 + sd a0, 0(sp) + addi a0, sp, 520 + fsw ft1, 64(sp) + fmv.s fa0, ft0 + addi a2, sp, 820 + addi a4, sp, 868 + call params_mix + flw fa0, 512(sp) + sw a0, 500(sp) + call putfloat + li a0, 10 + call putch + flw fa0, 508(sp) + call putfloat + li a0, 10 + call putch + flw fa0, 504(sp) + call putfloat + li a0, 10 + call putch + lw a0, 500(sp) + call putint + li a0, 10 + call putch + li a0, 0 + ld ra, 1480(sp) # 8-byte Folded Reload + ld s0, 1472(sp) # 8-byte Folded Reload + ld s1, 1464(sp) # 8-byte Folded Reload + ld s2, 1456(sp) # 8-byte Folded Reload + ld s3, 1448(sp) # 8-byte Folded Reload + ld s4, 1440(sp) # 8-byte Folded Reload + ld s5, 1432(sp) # 8-byte Folded Reload + ld s6, 1424(sp) # 8-byte Folded Reload + ld s7, 1416(sp) # 8-byte Folded Reload + ld s8, 1408(sp) # 8-byte Folded Reload + ld s9, 1400(sp) # 8-byte Folded Reload + ld s10, 1392(sp) # 8-byte Folded Reload + ld s11, 1384(sp) # 8-byte Folded Reload + fld fs0, 1376(sp) # 8-byte Folded Reload + fld fs1, 1368(sp) # 8-byte Folded Reload + fld fs2, 1360(sp) # 8-byte Folded Reload + fld fs3, 1352(sp) # 8-byte Folded Reload + fld fs4, 1344(sp) # 8-byte Folded Reload + fld fs5, 1336(sp) # 8-byte Folded Reload + fld fs6, 1328(sp) # 8-byte Folded Reload + fld fs7, 1320(sp) # 8-byte Folded Reload + fld fs8, 1312(sp) # 8-byte Folded Reload + fld fs9, 1304(sp) # 8-byte Folded Reload + fld fs10, 1296(sp) # 8-byte Folded Reload + fld fs11, 1288(sp) # 8-byte Folded Reload + addi sp, sp, 1488 + ret +.Lfunc_end0: + .size main, .Lfunc_end0-main + .cfi_endproc + # -- End function + .globl params_f40 # -- Begin function params_f40 + .p2align 1 + .type params_f40,@function +params_f40: # @params_f40 + .cfi_startproc +# %bb.0: # %entry_params_f40 + addi sp, sp, -448 + .cfi_def_cfa_offset 448 + sd ra, 440(sp) # 8-byte Folded Spill + sd s0, 432(sp) # 8-byte Folded Spill + fsd fs0, 424(sp) # 8-byte Folded Spill + fsd fs1, 416(sp) # 8-byte Folded Spill + fsd fs2, 408(sp) # 8-byte Folded Spill + fsd fs3, 400(sp) # 8-byte Folded Spill + fsd fs4, 392(sp) # 8-byte Folded Spill + fsd fs5, 384(sp) # 8-byte Folded Spill + fsd fs6, 376(sp) # 8-byte Folded Spill + fsd fs7, 368(sp) # 8-byte Folded Spill + fsd fs8, 360(sp) # 8-byte Folded Spill + fsd fs9, 352(sp) # 8-byte Folded Spill + fsd fs10, 344(sp) # 8-byte Folded Spill + fsd fs11, 336(sp) # 8-byte Folded Spill + .cfi_offset ra, -8 + .cfi_offset s0, -16 + .cfi_offset fs0, -24 + .cfi_offset fs1, -32 + .cfi_offset fs2, -40 + .cfi_offset fs3, -48 + .cfi_offset fs4, -56 + .cfi_offset fs5, -64 + .cfi_offset fs6, -72 + .cfi_offset fs7, -80 + .cfi_offset fs8, -88 + .cfi_offset fs9, -96 + .cfi_offset fs10, -104 + .cfi_offset fs11, -112 + fmv.w.x ft0, a7 + fmv.w.x ft1, a6 + fmv.w.x ft2, a5 + fmv.w.x ft3, a4 + fmv.w.x ft4, a3 + fmv.w.x ft5, a2 + fmv.w.x ft6, a1 + fmv.w.x ft7, a0 + fsw fa0, 332(sp) + fsw fa1, 328(sp) + fsw fa2, 324(sp) + fsw fa3, 320(sp) + fsw fa4, 316(sp) + fsw fa5, 312(sp) + fsw fa6, 308(sp) + fsw fa7, 304(sp) + fsw ft7, 300(sp) + fsw ft6, 296(sp) + fsw ft5, 292(sp) + fsw ft4, 288(sp) + fsw ft3, 284(sp) + flw fa5, 632(sp) + fsw ft2, 280(sp) + fsw ft1, 276(sp) + fmv.w.x fa4, zero + flt.s a0, fa5, fa4 + flt.s a1, fa4, fa5 + or a0, a0, a1 + fsw ft0, 272(sp) + beqz a0, .LBB1_2 +# %bb.1: # %if_then.L0 + flw fa5, 332(sp) + flw fa4, 328(sp) + flw fa3, 324(sp) + flw fa2, 320(sp) + fadd.s fa5, fa5, fa4 + fadd.s fa5, fa5, fa3 + flw fa4, 316(sp) + flw fa3, 312(sp) + flw fa1, 308(sp) + fadd.s fa5, fa5, fa2 + flw fa2, 304(sp) + fadd.s fa4, fa4, fa3 + fadd.s fa4, fa4, fa1 + flw fa3, 300(sp) + flw fa1, 296(sp) + flw fa0, 292(sp) + fadd.s fa4, fa4, fa2 + flw fa2, 288(sp) + fadd.s fa3, fa3, fa1 + fadd.s fa3, fa3, fa0 + flw fa1, 284(sp) + flw fa0, 280(sp) + flw ft0, 276(sp) + fadd.s fa3, fa3, fa2 + flw fa2, 272(sp) + fadd.s fa1, fa1, fa0 + fadd.s fa1, fa1, ft0 + flw fa0, 448(sp) + flw ft0, 456(sp) + flw ft1, 464(sp) + fadd.s fa2, fa1, fa2 + flw fa1, 472(sp) + fadd.s fa0, fa0, ft0 + fadd.s fa0, fa0, ft1 + flw ft0, 480(sp) + flw ft1, 488(sp) + flw ft2, 496(sp) + fadd.s fa1, fa0, fa1 + flw fa0, 504(sp) + fadd.s ft0, ft0, ft1 + fadd.s ft0, ft0, ft2 + flw ft1, 512(sp) + flw ft2, 520(sp) + flw ft3, 528(sp) + fadd.s fa0, ft0, fa0 + flw ft0, 536(sp) + fadd.s ft1, ft1, ft2 + fadd.s ft1, ft1, ft3 + flw ft2, 544(sp) + flw ft3, 552(sp) + flw ft4, 560(sp) + fadd.s ft0, ft1, ft0 + flw ft1, 568(sp) + fadd.s ft2, ft2, ft3 + fadd.s ft2, ft2, ft4 + flw ft3, 576(sp) + flw ft4, 584(sp) + flw ft5, 592(sp) + fadd.s ft1, ft2, ft1 + flw ft2, 600(sp) + fadd.s ft3, ft3, ft4 + fadd.s ft3, ft3, ft5 + flw ft4, 608(sp) + flw ft5, 616(sp) + flw ft6, 624(sp) + flw ft7, 632(sp) + fadd.s ft2, ft3, ft2 + fadd.s ft3, ft4, ft5 + fadd.s ft3, ft3, ft6 + fadd.s ft3, ft3, ft7 + fsw fa5, 232(sp) + fsw fa4, 236(sp) + fsw fa3, 240(sp) + fsw fa2, 244(sp) + fsw fa1, 248(sp) + fsw fa0, 252(sp) + fsw ft0, 256(sp) + fsw ft1, 260(sp) + fsw ft2, 264(sp) + fsw ft3, 268(sp) + li a0, 10 + addi a1, sp, 232 + addi s0, sp, 232 + call putfarray + lui a0, %hi(k0) + lw a0, %lo(k0)(a0) + slli a0, a0, 2 + add a0, a0, s0 + flw fa0, 0(a0) + j .LBB1_3 +.LBB1_2: # %if_else.L1 + flw ft3, 328(sp) + flw ft2, 324(sp) + flw fa5, 320(sp) + fsw fa5, 228(sp) # 4-byte Folded Spill + flw fa5, 316(sp) + fsw fa5, 224(sp) # 4-byte Folded Spill + flw fa5, 312(sp) + fsw fa5, 220(sp) # 4-byte Folded Spill + flw fa5, 308(sp) + fsw fa5, 216(sp) # 4-byte Folded Spill + flw fa5, 304(sp) + fsw fa5, 212(sp) # 4-byte Folded Spill + flw fa5, 300(sp) + fsw fa5, 208(sp) # 4-byte Folded Spill + flw fa6, 296(sp) + flw fa7, 292(sp) + flw fa5, 288(sp) + fsw fa5, 204(sp) # 4-byte Folded Spill + flw fa5, 284(sp) + fsw fa5, 200(sp) # 4-byte Folded Spill + flw ft4, 280(sp) + flw ft5, 276(sp) + flw ft6, 272(sp) + flw ft7, 448(sp) + flw ft8, 456(sp) + flw ft9, 464(sp) + flw ft10, 472(sp) + flw ft11, 480(sp) + flw fs0, 488(sp) + flw fs1, 496(sp) + flw fs2, 504(sp) + flw fs3, 512(sp) + flw fs4, 520(sp) + flw fs5, 528(sp) + flw fs6, 536(sp) + flw fs7, 544(sp) + flw fs8, 552(sp) + flw fs9, 560(sp) + flw fs10, 568(sp) + flw fs11, 576(sp) + flw ft1, 584(sp) + flw ft0, 592(sp) + flw fa0, 600(sp) + flw fa1, 608(sp) + flw fa2, 616(sp) + flw fa5, 332(sp) + flw fa3, 624(sp) + flw fa4, 632(sp) + fadd.s fa5, fa5, ft3 + fadd.s fa5, fa5, ft2 + fsw fa5, 184(sp) + fsw fa4, 176(sp) + fsw fa3, 168(sp) + fsw fa2, 160(sp) + fsw fa1, 152(sp) + fsw fa0, 144(sp) + fsw ft0, 136(sp) + fsw ft1, 128(sp) + fsw fs11, 120(sp) + fsw fs10, 112(sp) + fsw fs9, 104(sp) + fsw fs8, 96(sp) + fsw fs7, 88(sp) + fsw fs6, 80(sp) + fsw fs5, 72(sp) + fsw fs4, 64(sp) + fsw fs3, 56(sp) + fsw fs2, 48(sp) + fsw fs1, 40(sp) + fsw fs0, 32(sp) + fsw ft11, 24(sp) + fsw ft10, 16(sp) + fsw ft9, 8(sp) + fmv.x.w a0, fa6 + fmv.x.w a1, fa7 + flw fa5, 204(sp) # 4-byte Folded Reload + fmv.x.w a2, fa5 + flw fa5, 200(sp) # 4-byte Folded Reload + fmv.x.w a3, fa5 + fmv.x.w a4, ft4 + fmv.x.w a5, ft5 + fmv.x.w a6, ft6 + fmv.x.w a7, ft7 + fsw ft8, 0(sp) + fmv.s fa0, ft3 + fmv.s fa1, ft2 + flw fa2, 228(sp) # 4-byte Folded Reload + flw fa3, 224(sp) # 4-byte Folded Reload + flw fa4, 220(sp) # 4-byte Folded Reload + flw fa5, 216(sp) # 4-byte Folded Reload + flw fa6, 212(sp) # 4-byte Folded Reload + flw fa7, 208(sp) # 4-byte Folded Reload + call params_f40 +.LBB1_3: # %if_then.L0 + ld ra, 440(sp) # 8-byte Folded Reload + ld s0, 432(sp) # 8-byte Folded Reload + fld fs0, 424(sp) # 8-byte Folded Reload + fld fs1, 416(sp) # 8-byte Folded Reload + fld fs2, 408(sp) # 8-byte Folded Reload + fld fs3, 400(sp) # 8-byte Folded Reload + fld fs4, 392(sp) # 8-byte Folded Reload + fld fs5, 384(sp) # 8-byte Folded Reload + fld fs6, 376(sp) # 8-byte Folded Reload + fld fs7, 368(sp) # 8-byte Folded Reload + fld fs8, 360(sp) # 8-byte Folded Reload + fld fs9, 352(sp) # 8-byte Folded Reload + fld fs10, 344(sp) # 8-byte Folded Reload + fld fs11, 336(sp) # 8-byte Folded Reload + addi sp, sp, 448 + ret +.Lfunc_end1: + .size params_f40, .Lfunc_end1-params_f40 + .cfi_endproc + # -- End function + .globl params_f40_i24 # -- Begin function params_f40_i24 + .p2align 1 + .type params_f40_i24,@function +params_f40_i24: # @params_f40_i24 + .cfi_startproc +# %bb.0: # %entry_params_f40_i24 + addi sp, sp, -800 + .cfi_def_cfa_offset 800 + sd ra, 792(sp) # 8-byte Folded Spill + sd s0, 784(sp) # 8-byte Folded Spill + sd s1, 776(sp) # 8-byte Folded Spill + sd s2, 768(sp) # 8-byte Folded Spill + sd s3, 760(sp) # 8-byte Folded Spill + sd s4, 752(sp) # 8-byte Folded Spill + sd s5, 744(sp) # 8-byte Folded Spill + sd s6, 736(sp) # 8-byte Folded Spill + sd s7, 728(sp) # 8-byte Folded Spill + sd s8, 720(sp) # 8-byte Folded Spill + fsd fs0, 712(sp) # 8-byte Folded Spill + fsd fs1, 704(sp) # 8-byte Folded Spill + fsd fs2, 696(sp) # 8-byte Folded Spill + fsd fs3, 688(sp) # 8-byte Folded Spill + fsd fs4, 680(sp) # 8-byte Folded Spill + fsd fs5, 672(sp) # 8-byte Folded Spill + fsd fs6, 664(sp) # 8-byte Folded Spill + fsd fs7, 656(sp) # 8-byte Folded Spill + fsd fs8, 648(sp) # 8-byte Folded Spill + fsd fs9, 640(sp) # 8-byte Folded Spill + fsd fs10, 632(sp) # 8-byte Folded Spill + fsd fs11, 624(sp) # 8-byte Folded Spill + .cfi_offset ra, -8 + .cfi_offset s0, -16 + .cfi_offset s1, -24 + .cfi_offset s2, -32 + .cfi_offset s3, -40 + .cfi_offset s4, -48 + .cfi_offset s5, -56 + .cfi_offset s6, -64 + .cfi_offset s7, -72 + .cfi_offset s8, -80 + .cfi_offset fs0, -88 + .cfi_offset fs1, -96 + .cfi_offset fs2, -104 + .cfi_offset fs3, -112 + .cfi_offset fs4, -120 + .cfi_offset fs5, -128 + .cfi_offset fs6, -136 + .cfi_offset fs7, -144 + .cfi_offset fs8, -152 + .cfi_offset fs9, -160 + .cfi_offset fs10, -168 + .cfi_offset fs11, -176 + ld t0, 1168(sp) + ld t1, 1152(sp) + ld t2, 1096(sp) + ld t3, 1088(sp) + ld t4, 1080(sp) + ld t5, 1040(sp) + ld t6, 1032(sp) + ld s2, 1016(sp) + ld s3, 984(sp) + ld s4, 976(sp) + ld s5, 936(sp) + ld s6, 920(sp) + ld s7, 872(sp) + ld s8, 864(sp) + ld s1, 848(sp) + ld s0, 800(sp) + sw a0, 620(sp) + sw a1, 616(sp) + sw a2, 612(sp) + fsw fa0, 608(sp) + sw a3, 604(sp) + sw a4, 600(sp) + sw a5, 596(sp) + fsw fa1, 592(sp) + fsw fa2, 588(sp) + fsw fa3, 584(sp) + sw a6, 580(sp) + fsw fa4, 576(sp) + fsw fa5, 572(sp) + sw a7, 568(sp) + fsw fa6, 564(sp) + sw s0, 560(sp) + fsw fa7, 556(sp) + sw s1, 552(sp) + sw s8, 548(sp) + sw s7, 544(sp) + sw s6, 540(sp) + sw s5, 536(sp) + sw s4, 532(sp) + sw s3, 528(sp) + sw s2, 524(sp) + sw t6, 520(sp) + sw t5, 516(sp) + sw t4, 512(sp) + lw a0, 620(sp) + sw t3, 508(sp) + sw t2, 504(sp) + sw t1, 500(sp) + sw t0, 496(sp) + beqz a0, .LBB2_4 +# %bb.1: # %if_then.L3 + flw fa5, 1008(sp) + flw fa4, 816(sp) + flw fa3, 1160(sp) + flw fa2, 576(sp) + fadd.s fa5, fa5, fa4 + fadd.s fa5, fa5, fa3 + flw fa4, 608(sp) + flw fa3, 960(sp) + flw fa1, 840(sp) + fadd.s fa5, fa5, fa2 + flw fa2, 584(sp) + fadd.s fa4, fa4, fa3 + fadd.s fa4, fa4, fa1 + flw fa3, 592(sp) + flw fa1, 904(sp) + flw fa0, 1000(sp) + fadd.s fa4, fa4, fa2 + flw fa2, 824(sp) + fadd.s fa3, fa3, fa1 + fadd.s fa3, fa3, fa0 + flw fa1, 808(sp) + flw fa0, 1064(sp) + flw ft0, 992(sp) + fadd.s fa3, fa3, fa2 + flw fa2, 588(sp) + fadd.s fa1, fa1, fa0 + fadd.s fa1, fa1, ft0 + flw fa0, 952(sp) + flw ft0, 1144(sp) + flw ft1, 1104(sp) + fadd.s fa2, fa1, fa2 + flw fa1, 1112(sp) + fadd.s fa0, fa0, ft0 + fadd.s fa0, fa0, ft1 + flw ft0, 880(sp) + flw ft1, 944(sp) + flw ft2, 1120(sp) + fadd.s fa1, fa0, fa1 + flw fa0, 896(sp) + fadd.s ft0, ft0, ft1 + fadd.s ft0, ft0, ft2 + flw ft1, 1056(sp) + flw ft2, 912(sp) + flw ft3, 1128(sp) + fadd.s fa0, ft0, fa0 + flw ft0, 1048(sp) + fadd.s ft1, ft1, ft2 + fadd.s ft1, ft1, ft3 + flw ft2, 572(sp) + flw ft3, 1072(sp) + flw ft4, 556(sp) + fadd.s ft0, ft1, ft0 + flw ft1, 1024(sp) + fadd.s ft2, ft2, ft3 + fadd.s ft2, ft2, ft4 + flw ft3, 856(sp) + flw ft4, 888(sp) + flw ft5, 968(sp) + fadd.s ft1, ft2, ft1 + flw ft2, 1176(sp) + fadd.s ft3, ft3, ft4 + fadd.s ft3, ft3, ft5 + flw ft4, 1136(sp) + flw ft5, 564(sp) + flw ft6, 832(sp) + flw ft7, 928(sp) + fadd.s ft2, ft3, ft2 + fadd.s ft3, ft4, ft5 + fadd.s ft3, ft3, ft6 + fadd.s ft3, ft3, ft7 + fsw fa5, 456(sp) + fsw fa4, 460(sp) + fsw fa3, 464(sp) + fsw fa2, 468(sp) + fsw fa1, 472(sp) + fsw fa0, 476(sp) + fsw ft0, 480(sp) + lw a0, 568(sp) + lw a1, 604(sp) + lw a2, 616(sp) + lw a3, 512(sp) + lw a4, 600(sp) + lw a5, 596(sp) + add a0, a0, a1 + add a6, a0, a2 + add a3, a3, a4 + add a7, a3, a5 + lw a1, 612(sp) + lw a2, 552(sp) + lw a4, 540(sp) + lw a5, 528(sp) + lw s1, 548(sp) + lw s0, 520(sp) + add a1, a1, a2 + add a1, a1, a4 + add a5, a5, s1 + add a5, a5, s0 + lw a2, 524(sp) + lw a4, 544(sp) + lw s1, 496(sp) + lw s0, 500(sp) + lw a0, 516(sp) + add a2, a2, a4 + add a2, a2, s1 + lw a4, 536(sp) + add a0, a0, s0 + lw s1, 532(sp) + lw s0, 560(sp) + lw a3, 504(sp) + fsw ft1, 484(sp) + add a0, a0, a4 + add s0, s0, s1 + add a3, a3, s0 + lw a4, 508(sp) + lw s1, 580(sp) + lw s0, 620(sp) + fsw ft2, 488(sp) + fsw ft3, 492(sp) + add a4, a4, s1 + add a4, a4, s0 + sw a6, 424(sp) + sw a7, 428(sp) + sw a1, 432(sp) + sw a5, 436(sp) + sw a2, 440(sp) + sw a0, 444(sp) + sw a3, 448(sp) + sw a4, 452(sp) + li a0, 10 + addi a1, sp, 456 + addi s0, sp, 456 + call putfarray + li a0, 8 + addi a1, sp, 424 + addi s1, sp, 424 + call putarray + sw zero, 420(sp) + li a0, 7 + lw a1, 420(sp) + blt a0, a1, .LBB2_3 +.LBB2_2: # %while_body.L5 + # =>This Inner Loop Header: Depth=1 + lw a1, 420(sp) + slli a2, a1, 2 + add a3, s1, a2 + lw a4, 0(a3) + add a2, a2, s0 + flw fa5, 0(a2) + fcvt.s.w fa4, a4 + fsub.s fa5, fa4, fa5 + fcvt.w.s a2, fa5, rtz + sw a2, 0(a3) + addi a1, a1, 1 + sw a1, 420(sp) + lw a1, 420(sp) + bge a0, a1, .LBB2_2 +.LBB2_3: # %while_exit.L6 + lui a0, %hi(k0) + lw a0, %lo(k0)(a0) + slli a0, a0, 2 + addi a1, sp, 424 + add a0, a0, a1 + lw a0, 0(a0) + fcvt.s.w fa0, a0 + j .LBB2_5 +.LBB2_4: # %if_else.L7 + flw fa5, 608(sp) + fsw fa5, 388(sp) # 4-byte Folded Spill + flw fa5, 592(sp) + fsw fa5, 400(sp) # 4-byte Folded Spill + flw fa5, 588(sp) + fsw fa5, 396(sp) # 4-byte Folded Spill + flw fa5, 584(sp) + fsw fa5, 392(sp) # 4-byte Folded Spill + flw fa5, 576(sp) + fsw fa5, 408(sp) # 4-byte Folded Spill + flw fa5, 572(sp) + fsw fa5, 404(sp) # 4-byte Folded Spill + flw fa5, 564(sp) + fsw fa5, 416(sp) # 4-byte Folded Spill + flw fa5, 556(sp) + fsw fa5, 412(sp) # 4-byte Folded Spill + flw fa7, 808(sp) + flw fa6, 816(sp) + flw ft2, 824(sp) + flw ft3, 832(sp) + flw ft4, 840(sp) + flw ft5, 856(sp) + flw ft6, 880(sp) + flw ft7, 888(sp) + flw ft8, 896(sp) + flw ft9, 904(sp) + flw ft10, 912(sp) + flw ft11, 928(sp) + flw fs0, 944(sp) + flw fs1, 952(sp) + flw fs2, 960(sp) + flw fs3, 968(sp) + flw fs4, 992(sp) + flw fs5, 1000(sp) + flw fs6, 1008(sp) + flw fs7, 1024(sp) + flw fs8, 1048(sp) + flw fs9, 1056(sp) + flw fs10, 1064(sp) + flw fs11, 1072(sp) + lw a7, 568(sp) + lw a6, 580(sp) + lw a5, 596(sp) + lw a4, 600(sp) + lw a2, 612(sp) + lw a1, 616(sp) + lw a0, 604(sp) + lw t0, 560(sp) + lw t1, 552(sp) + lw t2, 548(sp) + lw t3, 544(sp) + lw t4, 540(sp) + lw t5, 536(sp) + lw t6, 532(sp) + lw s2, 528(sp) + lw s3, 524(sp) + lw s4, 520(sp) + lw s5, 516(sp) + lw s6, 512(sp) + lw s7, 508(sp) + lw a3, 504(sp) + lw s0, 500(sp) + lw s1, 496(sp) + flw ft1, 1104(sp) + flw ft0, 1112(sp) + flw fa0, 1120(sp) + flw fa1, 1128(sp) + flw fa2, 1136(sp) + flw fa3, 1144(sp) + flw fa4, 1160(sp) + flw fa5, 1176(sp) + fsw fa5, 376(sp) + fsw fa4, 360(sp) + fsw fa3, 344(sp) + fsw fa2, 336(sp) + fsw fa1, 328(sp) + fsw fa0, 320(sp) + fsw ft0, 312(sp) + fsw ft1, 304(sp) + fsw fs11, 272(sp) + fsw fs10, 264(sp) + fsw fs9, 256(sp) + fsw fs8, 248(sp) + fsw fs7, 224(sp) + fsw fs6, 208(sp) + fsw fs5, 200(sp) + fsw fs4, 192(sp) + fsw fs3, 168(sp) + fsw fs2, 160(sp) + fsw fs1, 152(sp) + fsw fs0, 144(sp) + fsw ft11, 128(sp) + fsw ft10, 112(sp) + fsw ft9, 104(sp) + fsw ft8, 96(sp) + fsw ft7, 88(sp) + fsw ft6, 80(sp) + fsw ft5, 56(sp) + fsw ft4, 40(sp) + fsw ft3, 32(sp) + fsw ft2, 24(sp) + fsw fa6, 16(sp) + fsw fa7, 8(sp) + sd s1, 368(sp) + sd s0, 352(sp) + sd a3, 296(sp) + sd s7, 288(sp) + sd s6, 280(sp) + sd s5, 240(sp) + sd s4, 232(sp) + sd s3, 216(sp) + sd s2, 184(sp) + sd t6, 176(sp) + sd t5, 136(sp) + sd t4, 120(sp) + sd t3, 72(sp) + sd t2, 64(sp) + sd t1, 48(sp) + sd t0, 0(sp) + flw fa0, 388(sp) # 4-byte Folded Reload + mv a3, a0 + flw fa1, 400(sp) # 4-byte Folded Reload + flw fa2, 396(sp) # 4-byte Folded Reload + flw fa3, 392(sp) # 4-byte Folded Reload + flw fa4, 408(sp) # 4-byte Folded Reload + flw fa5, 404(sp) # 4-byte Folded Reload + flw fa6, 416(sp) # 4-byte Folded Reload + flw fa7, 412(sp) # 4-byte Folded Reload + call params_f40_i24 +.LBB2_5: # %while_exit.L6 + ld ra, 792(sp) # 8-byte Folded Reload + ld s0, 784(sp) # 8-byte Folded Reload + ld s1, 776(sp) # 8-byte Folded Reload + ld s2, 768(sp) # 8-byte Folded Reload + ld s3, 760(sp) # 8-byte Folded Reload + ld s4, 752(sp) # 8-byte Folded Reload + ld s5, 744(sp) # 8-byte Folded Reload + ld s6, 736(sp) # 8-byte Folded Reload + ld s7, 728(sp) # 8-byte Folded Reload + ld s8, 720(sp) # 8-byte Folded Reload + fld fs0, 712(sp) # 8-byte Folded Reload + fld fs1, 704(sp) # 8-byte Folded Reload + fld fs2, 696(sp) # 8-byte Folded Reload + fld fs3, 688(sp) # 8-byte Folded Reload + fld fs4, 680(sp) # 8-byte Folded Reload + fld fs5, 672(sp) # 8-byte Folded Reload + fld fs6, 664(sp) # 8-byte Folded Reload + fld fs7, 656(sp) # 8-byte Folded Reload + fld fs8, 648(sp) # 8-byte Folded Reload + fld fs9, 640(sp) # 8-byte Folded Reload + fld fs10, 632(sp) # 8-byte Folded Reload + fld fs11, 624(sp) # 8-byte Folded Reload + addi sp, sp, 800 + ret +.Lfunc_end2: + .size params_f40_i24, .Lfunc_end2-params_f40_i24 + .cfi_endproc + # -- End function + .globl params_fa40 # -- Begin function params_fa40 + .p2align 1 + .type params_fa40,@function +params_fa40: # @params_fa40 + .cfi_startproc +# %bb.0: # %entry_params_fa40 + addi sp, sp, -560 + .cfi_def_cfa_offset 560 + sd ra, 552(sp) # 8-byte Folded Spill + sd s0, 544(sp) # 8-byte Folded Spill + sd s1, 536(sp) # 8-byte Folded Spill + sd s2, 528(sp) # 8-byte Folded Spill + sd s3, 520(sp) # 8-byte Folded Spill + sd s4, 512(sp) # 8-byte Folded Spill + sd s5, 504(sp) # 8-byte Folded Spill + sd s6, 496(sp) # 8-byte Folded Spill + sd s7, 488(sp) # 8-byte Folded Spill + sd s8, 480(sp) # 8-byte Folded Spill + sd s9, 472(sp) # 8-byte Folded Spill + sd s10, 464(sp) # 8-byte Folded Spill + sd s11, 456(sp) # 8-byte Folded Spill + .cfi_offset ra, -8 + .cfi_offset s0, -16 + .cfi_offset s1, -24 + .cfi_offset s2, -32 + .cfi_offset s3, -40 + .cfi_offset s4, -48 + .cfi_offset s5, -56 + .cfi_offset s6, -64 + .cfi_offset s7, -72 + .cfi_offset s8, -80 + .cfi_offset s9, -88 + .cfi_offset s10, -96 + .cfi_offset s11, -104 + lui s1, %hi(k0) + lw s0, %lo(k0)(s1) + sd a0, 448(sp) + sd a1, 440(sp) + sd a2, 432(sp) + slli s0, s0, 2 + add a0, a0, s0 + flw fa5, 0(a0) + add a1, a1, s0 + flw fa4, 0(a1) + add a2, a2, s0 + flw fa3, 0(a2) + add a0, a3, s0 + flw fa2, 0(a0) + sd a3, 424(sp) + fadd.s fa5, fa5, fa4 + fadd.s fa5, fa5, fa3 + fadd.s fa5, fa5, fa2 + add a0, a4, s0 + flw fa4, 0(a0) + add a0, a5, s0 + flw fa3, 0(a0) + add a0, a6, s0 + flw fa2, 0(a0) + add a0, a7, s0 + flw fa1, 0(a0) + fadd.s fa4, fa4, fa3 + ld a0, 560(sp) + fadd.s fa4, fa4, fa2 + fadd.s fa4, fa4, fa1 + ld a1, 568(sp) + add a0, a0, s0 + flw fa3, 0(a0) + ld a0, 576(sp) + add a1, a1, s0 + ld a2, 584(sp) + flw fa2, 0(a1) + add a0, a0, s0 + flw fa1, 0(a0) + add a2, a2, s0 + flw fa0, 0(a2) + fadd.s fa3, fa3, fa2 + ld a0, 592(sp) + fadd.s fa3, fa3, fa1 + fadd.s fa3, fa3, fa0 + ld a1, 600(sp) + add a0, a0, s0 + flw fa2, 0(a0) + ld a0, 608(sp) + add a1, a1, s0 + ld a2, 616(sp) + flw fa1, 0(a1) + add a0, a0, s0 + flw fa0, 0(a0) + add a2, a2, s0 + flw ft0, 0(a2) + fadd.s fa2, fa2, fa1 + ld a0, 624(sp) + fadd.s fa2, fa2, fa0 + fadd.s fa2, fa2, ft0 + ld a1, 632(sp) + add a0, a0, s0 + flw fa1, 0(a0) + ld a0, 640(sp) + add a1, a1, s0 + ld a2, 648(sp) + flw fa0, 0(a1) + add a0, a0, s0 + flw ft0, 0(a0) + add a2, a2, s0 + flw ft1, 0(a2) + fadd.s fa1, fa1, fa0 + ld a0, 656(sp) + fadd.s fa1, fa1, ft0 + fadd.s fa1, fa1, ft1 + ld a1, 664(sp) + add a0, a0, s0 + flw fa0, 0(a0) + ld a0, 672(sp) + add a1, a1, s0 + ld a2, 680(sp) + flw ft0, 0(a1) + add a0, a0, s0 + flw ft1, 0(a0) + add a2, a2, s0 + flw ft2, 0(a2) + fadd.s fa0, fa0, ft0 + ld a0, 688(sp) + fadd.s fa0, fa0, ft1 + fadd.s fa0, fa0, ft2 + ld a1, 696(sp) + add a0, a0, s0 + flw ft0, 0(a0) + ld a0, 704(sp) + add a1, a1, s0 + ld a2, 712(sp) + flw ft1, 0(a1) + add a0, a0, s0 + flw ft2, 0(a0) + add a2, a2, s0 + flw ft3, 0(a2) + fadd.s ft0, ft0, ft1 + ld a0, 720(sp) + fadd.s ft0, ft0, ft2 + fadd.s ft0, ft0, ft3 + ld a1, 728(sp) + add a0, a0, s0 + flw ft1, 0(a0) + ld a0, 736(sp) + add a1, a1, s0 + ld a2, 744(sp) + flw ft2, 0(a1) + add a0, a0, s0 + flw ft3, 0(a0) + add a2, a2, s0 + flw ft4, 0(a2) + fadd.s ft1, ft1, ft2 + ld a0, 752(sp) + fadd.s ft1, ft1, ft3 + fadd.s ft1, ft1, ft4 + ld a1, 760(sp) + add a0, a0, s0 + flw ft2, 0(a0) + ld a0, 768(sp) + add a1, a1, s0 + ld a2, 776(sp) + flw ft3, 0(a1) + add a0, a0, s0 + flw ft4, 0(a0) + add a2, a2, s0 + flw ft5, 0(a2) + fadd.s ft2, ft2, ft3 + ld a0, 784(sp) + fadd.s ft2, ft2, ft4 + fadd.s ft2, ft2, ft5 + ld a1, 792(sp) + add a0, a0, s0 + flw ft3, 0(a0) + ld a0, 800(sp) + add a1, a1, s0 + ld a2, 808(sp) + flw ft4, 0(a1) + add a0, a0, s0 + flw ft5, 0(a0) + add a2, a2, s0 + flw ft6, 0(a2) + sd a4, 416(sp) + fadd.s ft3, ft3, ft4 + fadd.s ft3, ft3, ft5 + fadd.s ft3, ft3, ft6 + fsw fa5, 352(sp) + fsw fa4, 356(sp) + fsw fa3, 360(sp) + fsw fa2, 364(sp) + fsw fa1, 368(sp) + fsw fa0, 372(sp) + fsw ft0, 376(sp) + ld a0, 808(sp) + fsw ft1, 380(sp) + fsw ft2, 384(sp) + fsw ft3, 388(sp) + add a0, a0, s0 + flw fa5, 0(a0) + sd a5, 408(sp) + sd a6, 400(sp) + fmv.w.x fa4, zero + flt.s a0, fa5, fa4 + flt.s a1, fa4, fa5 + or a0, a0, a1 + fcvt.s.w fa5, a0 + flt.s a0, fa5, fa4 + flt.s a1, fa4, fa5 + or a0, a0, a1 + fcvt.s.w fa5, a0 + flt.s a0, fa5, fa4 + flt.s a1, fa4, fa5 + or a0, a0, a1 + sd a7, 392(sp) + beqz a0, .LBB3_2 +# %bb.1: # %if_then.L9 + li a0, 10 + addi a1, sp, 352 + addi s0, sp, 352 + call putfarray + lw a0, %lo(k0)(s1) + slli a0, a0, 2 + add a0, a0, s0 + flw fa0, 0(a0) + j .LBB3_3 +.LBB3_2: # %if_else.L10 + ld a0, 440(sp) + sd a0, 344(sp) # 8-byte Folded Spill + ld a0, 432(sp) + sd a0, 336(sp) # 8-byte Folded Spill + ld a0, 424(sp) + sd a0, 328(sp) # 8-byte Folded Spill + ld a0, 416(sp) + sd a0, 320(sp) # 8-byte Folded Spill + ld a0, 408(sp) + sd a0, 312(sp) # 8-byte Folded Spill + ld a0, 400(sp) + sd a0, 304(sp) # 8-byte Folded Spill + ld a0, 392(sp) + sd a0, 296(sp) # 8-byte Folded Spill + ld a0, 560(sp) + sd a0, 288(sp) # 8-byte Folded Spill + ld a0, 568(sp) + sd a0, 280(sp) # 8-byte Folded Spill + ld a0, 576(sp) + sd a0, 272(sp) # 8-byte Folded Spill + ld a0, 584(sp) + sd a0, 264(sp) # 8-byte Folded Spill + ld a0, 592(sp) + sd a0, 256(sp) # 8-byte Folded Spill + ld t4, 600(sp) + ld t5, 608(sp) + ld t6, 616(sp) + ld s2, 624(sp) + ld s3, 632(sp) + ld s4, 640(sp) + ld s5, 648(sp) + ld s6, 656(sp) + ld s7, 664(sp) + ld s8, 672(sp) + ld s9, 680(sp) + ld s10, 688(sp) + ld s11, 696(sp) + ld ra, 704(sp) + ld s1, 712(sp) + ld s0, 720(sp) + ld t2, 728(sp) + ld t1, 736(sp) + ld t0, 744(sp) + ld a7, 752(sp) + ld a6, 760(sp) + ld a5, 768(sp) + ld a4, 776(sp) + ld a3, 784(sp) + ld a2, 792(sp) + ld a1, 800(sp) + ld a0, 808(sp) + addi t3, sp, 352 + sd t3, 248(sp) + sd a0, 240(sp) + sd a1, 232(sp) + sd a2, 224(sp) + sd a3, 216(sp) + sd a4, 208(sp) + sd a5, 200(sp) + sd a6, 192(sp) + sd a7, 184(sp) + sd t0, 176(sp) + sd t1, 168(sp) + sd t2, 160(sp) + sd s0, 152(sp) + sd s1, 144(sp) + sd ra, 136(sp) + sd s11, 128(sp) + sd s10, 120(sp) + sd s9, 112(sp) + sd s8, 104(sp) + sd s7, 96(sp) + sd s6, 88(sp) + sd s5, 80(sp) + sd s4, 72(sp) + sd s3, 64(sp) + sd s2, 56(sp) + sd t6, 48(sp) + sd t5, 40(sp) + sd t4, 32(sp) + ld a0, 256(sp) # 8-byte Folded Reload + sd a0, 24(sp) + ld a0, 264(sp) # 8-byte Folded Reload + sd a0, 16(sp) + ld a0, 272(sp) # 8-byte Folded Reload + sd a0, 8(sp) + ld a0, 280(sp) # 8-byte Folded Reload + sd a0, 0(sp) + ld a0, 344(sp) # 8-byte Folded Reload + ld a1, 336(sp) # 8-byte Folded Reload + ld a2, 328(sp) # 8-byte Folded Reload + ld a3, 320(sp) # 8-byte Folded Reload + ld a4, 312(sp) # 8-byte Folded Reload + ld a5, 304(sp) # 8-byte Folded Reload + ld a6, 296(sp) # 8-byte Folded Reload + ld a7, 288(sp) # 8-byte Folded Reload + call params_fa40 +.LBB3_3: # %if_then.L9 + ld ra, 552(sp) # 8-byte Folded Reload + ld s0, 544(sp) # 8-byte Folded Reload + ld s1, 536(sp) # 8-byte Folded Reload + ld s2, 528(sp) # 8-byte Folded Reload + ld s3, 520(sp) # 8-byte Folded Reload + ld s4, 512(sp) # 8-byte Folded Reload + ld s5, 504(sp) # 8-byte Folded Reload + ld s6, 496(sp) # 8-byte Folded Reload + ld s7, 488(sp) # 8-byte Folded Reload + ld s8, 480(sp) # 8-byte Folded Reload + ld s9, 472(sp) # 8-byte Folded Reload + ld s10, 464(sp) # 8-byte Folded Reload + ld s11, 456(sp) # 8-byte Folded Reload + addi sp, sp, 560 + ret +.Lfunc_end3: + .size params_fa40, .Lfunc_end3-params_fa40 + .cfi_endproc + # -- End function + .globl params_mix # -- Begin function params_mix + .p2align 1 + .type params_mix,@function +params_mix: # @params_mix + .cfi_startproc +# %bb.0: # %entry_params_mix + addi sp, sp, -832 + .cfi_def_cfa_offset 832 + sd ra, 824(sp) # 8-byte Folded Spill + sd s0, 816(sp) # 8-byte Folded Spill + sd s1, 808(sp) # 8-byte Folded Spill + sd s2, 800(sp) # 8-byte Folded Spill + sd s3, 792(sp) # 8-byte Folded Spill + sd s4, 784(sp) # 8-byte Folded Spill + sd s5, 776(sp) # 8-byte Folded Spill + sd s6, 768(sp) # 8-byte Folded Spill + sd s7, 760(sp) # 8-byte Folded Spill + sd s8, 752(sp) # 8-byte Folded Spill + sd s9, 744(sp) # 8-byte Folded Spill + sd s10, 736(sp) # 8-byte Folded Spill + sd s11, 728(sp) # 8-byte Folded Spill + fsd fs0, 720(sp) # 8-byte Folded Spill + fsd fs1, 712(sp) # 8-byte Folded Spill + .cfi_offset ra, -8 + .cfi_offset s0, -16 + .cfi_offset s1, -24 + .cfi_offset s2, -32 + .cfi_offset s3, -40 + .cfi_offset s4, -48 + .cfi_offset s5, -56 + .cfi_offset s6, -64 + .cfi_offset s7, -72 + .cfi_offset s8, -80 + .cfi_offset s9, -88 + .cfi_offset s10, -96 + .cfi_offset s11, -104 + .cfi_offset fs0, -112 + .cfi_offset fs1, -120 + ld t0, 1208(sp) + ld t1, 1168(sp) + ld t2, 1136(sp) + ld t3, 1088(sp) + ld t4, 1072(sp) + ld t5, 1040(sp) + ld t6, 1032(sp) + ld s2, 976(sp) + ld s1, 888(sp) + ld s0, 856(sp) + fsw fa0, 708(sp) + sd a0, 696(sp) + sw a1, 692(sp) + sd a2, 680(sp) + fsw fa1, 676(sp) + sw a3, 672(sp) + fsw fa2, 668(sp) + fsw fa3, 664(sp) + sd a4, 656(sp) + sd a5, 648(sp) + sw a6, 644(sp) + sw a7, 640(sp) + sw s0, 636(sp) + fsw fa4, 632(sp) + fsw fa5, 628(sp) + fsw fa6, 624(sp) + sw s1, 620(sp) + fsw fa7, 616(sp) + sw s2, 612(sp) + sw t6, 608(sp) + sw t5, 604(sp) + sw t4, 600(sp) + lui a0, %hi(k0) + lw a0, %lo(k0)(a0) + ld a1, 680(sp) + sw t3, 596(sp) + flw fa2, 708(sp) + slli a0, a0, 2 + add a1, a1, a0 + flw fa1, 0(a1) + flw fa0, 676(sp) + flw ft0, 668(sp) + sw t2, 592(sp) + fadd.s fa2, fa2, fa1 + fadd.s fa2, fa2, fa0 + fadd.s fa2, fa2, ft0 + ld a1, 832(sp) + add a4, a4, a0 + flw fa1, 0(a4) + ld a2, 864(sp) + add a1, a1, a0 + flw fa0, 0(a1) + ld a1, 872(sp) + add a2, a2, a0 + flw ft0, 0(a2) + fadd.s fa3, fa3, fa1 + add a1, a1, a0 + flw fa1, 0(a1) + fadd.s fa3, fa3, fa0 + ld a1, 880(sp) + fadd.s fa3, fa3, ft0 + fadd.s fa4, fa1, fa4 + fadd.s fa5, fa4, fa5 + add a1, a1, a0 + flw fa4, 0(a1) + fadd.s fa5, fa5, fa6 + flw fa1, 896(sp) + flw fa0, 904(sp) + fadd.s fa4, fa4, fa7 + ld a1, 920(sp) + fadd.s fa4, fa4, fa1 + ld a2, 944(sp) + fadd.s fa4, fa4, fa0 + add a1, a1, a0 + flw fa1, 0(a1) + add a2, a2, a0 + flw fa0, 0(a2) + flw ft0, 952(sp) + flw ft1, 960(sp) + ld a1, 984(sp) + fadd.s fa1, fa1, fa0 + ld a2, 992(sp) + fadd.s fa1, fa1, ft0 + add a1, a1, a0 + flw fa0, 0(a1) + add a2, a2, a0 + flw ft0, 0(a2) + flw ft2, 1000(sp) + fadd.s fa1, fa1, ft1 + flw ft1, 1008(sp) + fadd.s fa0, fa0, ft0 + fadd.s fa0, fa0, ft2 + ld a1, 1080(sp) + fadd.s fa0, fa0, ft1 + flw ft0, 1048(sp) + flw ft1, 1056(sp) + add a1, a1, a0 + flw ft2, 0(a1) + flw ft3, 1112(sp) + fadd.s ft0, ft0, ft1 + ld a1, 1128(sp) + fadd.s ft0, ft0, ft2 + ld a2, 1152(sp) + flw ft1, 1120(sp) + add a1, a1, a0 + flw ft2, 0(a1) + add a2, a2, a0 + flw ft4, 0(a2) + fadd.s ft0, ft0, ft3 + flw ft3, 1160(sp) + fadd.s ft1, ft1, ft2 + fadd.s ft1, ft1, ft4 + ld a1, 1184(sp) + fadd.s ft1, ft1, ft3 + ld a2, 1192(sp) + flw ft2, 1176(sp) + add a1, a1, a0 + flw ft3, 0(a1) + add a2, a2, a0 + flw ft4, 0(a2) + flw ft5, 1200(sp) + sw t1, 588(sp) + fadd.s ft2, ft2, ft3 + fadd.s ft2, ft2, ft4 + fadd.s ft2, ft2, ft5 + fsw fa2, 544(sp) + fsw fa3, 548(sp) + fsw fa5, 552(sp) + fsw fa4, 556(sp) + fsw fa1, 560(sp) + fsw fa0, 564(sp) + fsw ft0, 568(sp) + ld a1, 696(sp) + fsw ft1, 572(sp) + fsw ft2, 576(sp) + sw zero, 580(sp) + add a1, a1, a0 + lw a2, 692(sp) + lw a3, 672(sp) + lw a1, 0(a1) + ld a4, 648(sp) + sw t0, 584(sp) + add a2, a2, a3 + add a6, a1, a2 + add a4, a4, a0 + lw a2, 0(a4) + ld a3, 840(sp) + lw a4, 644(sp) + ld a5, 848(sp) + lw s1, 640(sp) + add a3, a3, a0 + lw a3, 0(a3) + add a5, a5, a0 + lw a5, 0(a5) + add a4, a4, s1 + lw s1, 636(sp) + add a7, a2, a4 + add a3, a3, a5 + ld a4, 912(sp) + add t0, a3, s1 + ld a5, 928(sp) + lw s1, 620(sp) + add a4, a4, a0 + lw a4, 0(a4) + add a5, a5, a0 + lw a5, 0(a5) + ld s0, 936(sp) + add a4, a4, s1 + ld s1, 968(sp) + add t1, a4, a5 + add s0, s0, a0 + lw a5, 0(s0) + add s1, s1, a0 + lw s1, 0(s1) + ld s0, 1016(sp) + lw a1, 612(sp) + ld a2, 1024(sp) + add a5, a5, s1 + add s0, s0, a0 + lw s1, 0(s0) + add a2, a2, a0 + lw a2, 0(a2) + add t2, a5, a1 + lw a5, 608(sp) + ld s0, 1064(sp) + add a2, a2, s1 + lw s1, 604(sp) + lw a3, 600(sp) + add s0, s0, a0 + lw s0, 0(s0) + add a2, a2, a5 + add a3, a3, s1 + ld a5, 1096(sp) + add a3, a3, s0 + ld s1, 1104(sp) + lw s0, 596(sp) + add a5, a5, a0 + lw a5, 0(a5) + add s1, s1, a0 + ld a4, 1144(sp) + lw s1, 0(s1) + add a5, a5, s0 + lw s0, 592(sp) + add a0, a0, a4 + lw a4, 588(sp) + lw a1, 584(sp) + lw a0, 0(a0) + add a5, a5, s1 + add a4, a4, s0 + add a4, a4, a1 + add a0, a0, a4 + sw a6, 504(sp) + sw a7, 508(sp) + sw t0, 512(sp) + sw t1, 516(sp) + sw t2, 520(sp) + sw a2, 524(sp) + sw a3, 528(sp) + sw a5, 532(sp) + sw a0, 536(sp) + sw zero, 540(sp) + beqz a1, .LBB4_4 +# %bb.1: # %if_then.L12 + li a0, 10 + addi a1, sp, 544 + addi s0, sp, 544 + call putfarray + li a0, 10 + addi a1, sp, 504 + addi s1, sp, 504 + call putarray + sw zero, 500(sp) + li a0, 9 + lw a1, 500(sp) + blt a0, a1, .LBB4_3 +.LBB4_2: # %while_body.L14 + # =>This Inner Loop Header: Depth=1 + lw a1, 500(sp) + slli a2, a1, 2 + add a3, s1, a2 + lw a4, 0(a3) + add a2, a2, s0 + flw fa5, 0(a2) + fcvt.s.w fa4, a4 + fsub.s fa5, fa4, fa5 + fcvt.w.s a2, fa5, rtz + sw a2, 0(a3) + addi a1, a1, 1 + sw a1, 500(sp) + lw a1, 500(sp) + bge a0, a1, .LBB4_2 +.LBB4_3: # %while_exit.L15 + lui a0, %hi(k0) + lw a0, %lo(k0)(a0) + slli a0, a0, 2 + addi a1, sp, 504 + add a0, a0, a1 + lw a0, 0(a0) + flw fa5, 576(sp) + fcvt.s.w fa4, a0 + fmul.s fa5, fa4, fa5 + fcvt.w.s a0, fa5, rtz + j .LBB4_5 +.LBB4_4: # %if_else.L16 + flw fa0, 708(sp) + flw fa1, 676(sp) + flw fa2, 668(sp) + flw fa3, 664(sp) + ld a0, 656(sp) + sd a0, 488(sp) # 8-byte Folded Spill + ld a0, 648(sp) + sd a0, 480(sp) # 8-byte Folded Spill + ld a0, 832(sp) + sd a0, 472(sp) # 8-byte Folded Spill + ld a0, 840(sp) + sd a0, 464(sp) # 8-byte Folded Spill + ld a0, 848(sp) + sd a0, 456(sp) # 8-byte Folded Spill + ld a0, 864(sp) + sd a0, 448(sp) # 8-byte Folded Spill + ld a0, 872(sp) + sd a0, 440(sp) # 8-byte Folded Spill + flw fa4, 632(sp) + flw fa5, 628(sp) + flw fa6, 624(sp) + ld a0, 880(sp) + sd a0, 432(sp) # 8-byte Folded Spill + flw fa7, 616(sp) + flw ft0, 896(sp) + flw ft1, 904(sp) + ld a0, 912(sp) + sd a0, 408(sp) # 8-byte Folded Spill + ld a0, 920(sp) + sd a0, 400(sp) # 8-byte Folded Spill + ld s3, 928(sp) + ld s4, 936(sp) + ld s5, 944(sp) + flw ft2, 952(sp) + flw ft3, 960(sp) + ld s6, 968(sp) + ld s7, 984(sp) + ld s8, 992(sp) + flw ft4, 1000(sp) + flw ft5, 1008(sp) + ld s9, 1016(sp) + ld s10, 1024(sp) + flw ft6, 1048(sp) + flw ft7, 1056(sp) + ld ra, 1064(sp) + ld s1, 1080(sp) + ld t5, 1096(sp) + ld t4, 1104(sp) + flw ft8, 1112(sp) + flw ft9, 1120(sp) + ld s0, 1128(sp) + ld t2, 1144(sp) + ld t1, 1152(sp) + flw ft10, 1160(sp) + flw ft11, 1176(sp) + ld a6, 1184(sp) + ld a4, 1192(sp) + lw a2, 584(sp) + flw fs0, 1200(sp) + lw a0, 640(sp) + sd a0, 424(sp) # 8-byte Folded Spill + lw a0, 644(sp) + sd a0, 416(sp) # 8-byte Folded Spill + lw a0, 672(sp) + sd a0, 392(sp) # 8-byte Folded Spill + lw s2, 692(sp) + lw s11, 636(sp) + lw t6, 620(sp) + lw t3, 612(sp) + lw t0, 608(sp) + lw a7, 604(sp) + lw a5, 600(sp) + lw a3, 596(sp) + lw a1, 592(sp) + lw a0, 588(sp) + fcvt.s.w fs1, a2 + fcvt.w.s a2, fs0, rtz + sd a2, 376(sp) + sd a4, 360(sp) + sd a6, 352(sp) + sd a0, 336(sp) + sd t1, 320(sp) + sd t2, 312(sp) + sd a1, 304(sp) + sd s0, 296(sp) + sd t4, 272(sp) + sd t5, 264(sp) + sd a3, 256(sp) + sd s1, 248(sp) + sd a5, 240(sp) + sd ra, 232(sp) + sd a7, 208(sp) + sd t0, 200(sp) + sd s10, 192(sp) + sd s9, 184(sp) + sd s8, 160(sp) + sd s7, 152(sp) + sd t3, 144(sp) + sd s6, 136(sp) + sd s5, 112(sp) + sd s4, 104(sp) + sd s3, 96(sp) + ld a0, 400(sp) # 8-byte Folded Reload + sd a0, 88(sp) + ld a0, 408(sp) # 8-byte Folded Reload + sd a0, 80(sp) + sd t6, 56(sp) + ld a0, 432(sp) # 8-byte Folded Reload + sd a0, 48(sp) + ld a0, 440(sp) # 8-byte Folded Reload + sd a0, 40(sp) + ld a0, 448(sp) # 8-byte Folded Reload + sd a0, 32(sp) + sd s11, 24(sp) + ld a0, 456(sp) # 8-byte Folded Reload + sd a0, 16(sp) + fsw fs1, 368(sp) + fsw ft11, 344(sp) + fsw ft10, 328(sp) + fsw ft9, 288(sp) + fsw ft8, 280(sp) + fsw ft7, 224(sp) + fsw ft6, 216(sp) + fsw ft5, 176(sp) + fsw ft4, 168(sp) + fsw ft3, 128(sp) + fsw ft2, 120(sp) + fsw ft1, 72(sp) + ld a0, 464(sp) # 8-byte Folded Reload + sd a0, 8(sp) + ld a0, 472(sp) # 8-byte Folded Reload + sd a0, 0(sp) + addi a0, sp, 504 + addi a2, sp, 544 + fsw ft0, 64(sp) + mv a1, s2 + ld a3, 392(sp) # 8-byte Folded Reload + ld a4, 488(sp) # 8-byte Folded Reload + ld a5, 480(sp) # 8-byte Folded Reload + ld a6, 416(sp) # 8-byte Folded Reload + ld a7, 424(sp) # 8-byte Folded Reload + call params_mix +.LBB4_5: # %while_exit.L15 + ld ra, 824(sp) # 8-byte Folded Reload + ld s0, 816(sp) # 8-byte Folded Reload + ld s1, 808(sp) # 8-byte Folded Reload + ld s2, 800(sp) # 8-byte Folded Reload + ld s3, 792(sp) # 8-byte Folded Reload + ld s4, 784(sp) # 8-byte Folded Reload + ld s5, 776(sp) # 8-byte Folded Reload + ld s6, 768(sp) # 8-byte Folded Reload + ld s7, 760(sp) # 8-byte Folded Reload + ld s8, 752(sp) # 8-byte Folded Reload + ld s9, 744(sp) # 8-byte Folded Reload + ld s10, 736(sp) # 8-byte Folded Reload + ld s11, 728(sp) # 8-byte Folded Reload + fld fs0, 720(sp) # 8-byte Folded Reload + fld fs1, 712(sp) # 8-byte Folded Reload + addi sp, sp, 832 + ret +.Lfunc_end4: + .size params_mix, .Lfunc_end4-params_mix + .cfi_endproc + # -- End function + .type k0,@object # @k0 + .section .sbss,"aw",@nobits + .globl k0 + .p2align 2, 0x0 +k0: + .word 0 # 0x0 + .size k0, 4 + + .section ".note.GNU-stack","",@progbits + +)ASM"; +inline constexpr std::string_view rssh07 = R"ASM( + .text + .attribute 4, 16 + .attribute 5, "rv64i2p1_m2p0_a2p1_f2p2_d2p2_c2p0_zicsr2p0_zmmul1p0" + .file "07_arr_init_nd.ll" + .globl main # -- Begin function main + .p2align 1 + .type main,@function +main: # @main + .cfi_startproc +# %bb.0: # %entry_main + addi sp, sp, -512 + .cfi_def_cfa_offset 512 + sd ra, 504(sp) # 8-byte Folded Spill + .cfi_offset ra, -8 + sw zero, 496(sp) + sd zero, 488(sp) + sd zero, 480(sp) + sd zero, 472(sp) + sd zero, 464(sp) + sd zero, 456(sp) + sd zero, 448(sp) + sd zero, 440(sp) + sd zero, 376(sp) + sd zero, 384(sp) + sd zero, 392(sp) + sd zero, 400(sp) + sd zero, 408(sp) + sd zero, 416(sp) + sd zero, 424(sp) + sw zero, 432(sp) + li a7, 1 + sw a7, 316(sp) + li t0, 2 + sw t0, 320(sp) + li t1, 3 + sw t1, 324(sp) + li t2, 4 + sw t2, 328(sp) + li a6, 5 + sw a6, 332(sp) + li t4, 6 + sw t4, 336(sp) + li t3, 7 + sw t3, 340(sp) + li t6, 8 + sw t6, 344(sp) + li a1, 9 + sw a1, 348(sp) + li t5, 10 + sw t5, 352(sp) + li a3, 11 + sw a3, 356(sp) + li a5, 12 + sw a5, 360(sp) + li a4, 13 + sw a4, 364(sp) + li a2, 14 + sw a2, 368(sp) + li a0, 15 + sw a0, 372(sp) + sw a7, 256(sp) + sw t0, 260(sp) + sw t1, 264(sp) + sw t2, 268(sp) + sw a6, 272(sp) + sw t4, 276(sp) + sw t3, 280(sp) + sw t6, 284(sp) + sw a1, 288(sp) + sw t5, 292(sp) + sw a3, 296(sp) + sw a5, 300(sp) + sw a4, 304(sp) + sw a2, 308(sp) + sw a0, 312(sp) + sw a7, 196(sp) + sw t0, 200(sp) + sw t1, 204(sp) + sw t2, 208(sp) + sw a6, 212(sp) + sw t4, 216(sp) + sw t3, 220(sp) + sw t6, 224(sp) + sw a1, 228(sp) + sw t5, 232(sp) + sw a3, 236(sp) + sw a5, 240(sp) + sw a4, 244(sp) + sw a2, 248(sp) + sw a0, 252(sp) + sw zero, 192(sp) + sd zero, 184(sp) + sd zero, 176(sp) + sw a7, 116(sp) + sw t0, 120(sp) + sw t1, 124(sp) + sw t2, 128(sp) + sw zero, 132(sp) + sw zero, 136(sp) + sw t3, 140(sp) + sw zero, 144(sp) + sw zero, 148(sp) + sw t5, 152(sp) + sw a3, 156(sp) + sw a5, 160(sp) + sw zero, 164(sp) + sw zero, 168(sp) + sw zero, 172(sp) + sw zero, 112(sp) + sd zero, 104(sp) + sw a7, 8(sp) + sw t0, 12(sp) + sw t1, 16(sp) + sw t2, 20(sp) + sw a6, 24(sp) + addi a0, sp, 28 + li a2, 76 + li a1, 0 + call memset + li a0, 4 + ld ra, 504(sp) # 8-byte Folded Reload + addi sp, sp, 512 + ret +.Lfunc_end0: + .size main, .Lfunc_end0-main + .cfi_endproc + # -- End function + .section ".note.GNU-stack","",@progbits + +)ASM"; +} // namespace AssemblyCode \ No newline at end of file diff --git a/src/include/backend/RISCv64/RISCv64Backend.h b/src/include/backend/RISCv64/RISCv64Backend.h index 62791ed..8a6c92e 100644 --- a/src/include/backend/RISCv64/RISCv64Backend.h +++ b/src/include/backend/RISCv64/RISCv64Backend.h @@ -27,7 +27,7 @@ private: Module* module; bool irc_failed = false; - int foo = 0, foo1 = 0, foo2 = 0, foo3 = 0, foo4 = 0; + int foo = 0, foo1 = 0, foo2 = 0, foo3 = 0, foo4 = 0, foo5 = 0; }; } // namespace sysy diff --git a/src/include/backend/RISCv64/RISCv64Passes.h b/src/include/backend/RISCv64/RISCv64Passes.h index af3561e..6d79d2f 100644 --- a/src/include/backend/RISCv64/RISCv64Passes.h +++ b/src/include/backend/RISCv64/RISCv64Passes.h @@ -11,6 +11,7 @@ #include "PrologueEpilogueInsertion.h" #include "EliminateFrameIndices.h" #include "DivStrengthReduction.h" +#include "OFE.h" namespace sysy { diff --git a/src/sysyc.cpp b/src/sysyc.cpp index 4899858..b252588 100644 --- a/src/sysyc.cpp +++ b/src/sysyc.cpp @@ -71,8 +71,8 @@ void parseArgs(int argc, char **argv) { cerr << "Error: Optimization level must be non-negative." << endl; usage(EXIT_FAILURE); } else if (optLevel == 1) { - cerr << "debugging, exit..." << endl; - exit(-1); + cerr << "debugging, set optLevel to 0..." << endl; + optLevel = 0; } } catch (const std::invalid_argument& ia) { cerr << "Error: Invalid argument for -O: " << optarg << endl;