program: globals: "tab1" { int32[5] } extern "print_sint": int4s -> void extern "newline": void extern "space": void "copy"(ptr %0, ptr %1, int4s %2) locals: int4s %3, int4s %5, ptr %6, int4s %7, ptr %8, int4s %9, int4s %10, int4s %11, int4s %12, int4s %13, int4s %14, int1s %15 result: void %4 stacksize: struct {} entry: copy19 exit: copy0 copy9: imm %10, imm_sizeof (int32) --> copy8 copy8: mul %9, %3, %10 --> copy7 copy7: addp %8, %1, %9 --> copy6 copy6: load int32, %8, %7 --> copy5 copy5: store int32, %6, %7 --> copy4 copy4: imm %5, imm_int 1 --> copy3 copy3: add %3, %3, %5 --> copy2 copy2: --> copy16 copy19: emit _cost2 --> copy18 copy18: imm %15, imm_int 0 --> copy17 copy17: int1sto4 %3, %15 --> copy2 copy16: lt %14, %3, %2 --> copy15 copy15: notbool %13, %14 --> copy14 copy14: %13? --> copy1, copy13 copy13: emit _cost0 --> copy12 copy12: imm %12, imm_sizeof (int32) --> copy11 copy11: mul %11, %3, %12 --> copy10 copy10: addp %6, %0, %11 --> copy9 copy1: emit _cost1 --> copy0 copy0: return "print_tab"(ptr %0, int4s %1) locals: int4s %2, int1u %4, int4s %5, int1u %6, int4s %7, int1u %8, ptr %9, int4s %10, int4s %11, int4s %12, int4s %13, int1s %14 result: void %3 stacksize: struct {} entry: print_tab18 exit: print_tab0 print_tab9: addp %9, %0, %10 --> print_tab8 print_tab8: load int32, %9, %7 --> print_tab7 print_tab7: call "print_sint", [%7], %8: int4s -> void --> print_tab6 print_tab6: call "space", [], %6: void --> print_tab5 print_tab5: imm %5, imm_int 1 --> print_tab4 print_tab4: add %2, %2, %5 --> print_tab3 print_tab3: --> print_tab15 print_tab2: emit _cost4 --> print_tab1 print_tab18: emit _cost5 --> print_tab17 print_tab17: imm %14, imm_int 0 --> print_tab16 print_tab16: int1sto4 %2, %14 --> print_tab3 print_tab15: lt %13, %2, %1 --> print_tab14 print_tab14: notbool %12, %13 --> print_tab13 print_tab13: %12? --> print_tab2, print_tab12 print_tab12: emit _cost3 --> print_tab11 print_tab11: imm %11, imm_sizeof (int32) --> print_tab10 print_tab10: mul %10, %2, %11 --> print_tab9 print_tab1: call "newline", [], %4: void --> print_tab0 print_tab0: return "main"() locals: int1s %1, ptr %2, int4s %3, int1u %4, int1s %5, ptr %6, offset %7, ptr %8, int4s %9, int1u %10, int1s %11, ptr %12, offset %13, ptr %14, int4s %15, int1u %16, int1s %17, ptr %18, ptr %19, int4s %20, int1u %21, int1s %22, ptr %23, offset %24, ptr %25, ptr %26, int4s %27, int1u %28, int1s %29, ptr %30, offset %31, ptr %32, int4s %33, int1s %34, ptr %35, int1s %36, int1s %37, int1s %38, ptr %39, offset %40, ptr %41, int4s %42, int1s %43, ptr %44, int1s %45, int1s %46, int1s %47, ptr %48, offset %49, ptr %50, int4s %51, int1s %52, ptr %53, int1s %54, int1s %55, int1s %56, ptr %57, offset %58, ptr %59, int4s %60, int1s %61, ptr %62, int1s %63, int1s %64, int1s %65, ptr %66, offset %67, ptr %68, int4s %69, int1s %70, ptr %71, int1s %72, int1s %73, int1s %74, ptr %75, offset %76, ptr %77, int4u %78, ptr %79, offset %80, offset %81, offset %82, ptr %83, int4u %84, ptr %85, offset %86, offset %87, offset %88, ptr %89, int4u %90, ptr %91, offset %92, offset %93, offset %94, ptr %95, int4u %96, ptr %97, offset %98, offset %99, offset %100, ptr %101, int4u %102, ptr %103, offset %104, offset %105, offset %106 result: int4s %0 stacksize: struct {int32[5], int32[5]} entry: main118 exit: main0 main99: imm %90, imm_int 25 --> main98 main98: store int32, %89, %90 --> main97 main97: imm %85, imm_addr "tab1" --> main96 main96: imm %87, imm_int 0 --> main95 main95: imm %88, imm_offset { int32[5], 3 } --> main94 main94: add %86, %87, %88 --> main93 main93: addp %83, %85, %86 --> main92 main92: imm %84, imm_int 56 --> main91 main91: store int32, %83, %84 --> main90 main90: imm %79, imm_addr "tab1" --> main89 main9: call "print_tab", [%8, %9], %10: ptr -> int4s -> void --> main8 main89: imm %81, imm_int 0 --> main88 main88: imm %82, imm_offset { int32[5], 4 } --> main87 main87: add %80, %81, %82 --> main86 main86: addp %77, %79, %80 --> main85 main85: imm %78, imm_int -32 --> main84 main84: store int32, %77, %78 --> main83 main83: emit _cost6 --> main82 main82: imm %75, imm_addr STACK --> main81 main81: imm %76, imm_offset { struct {int32[5], int32[5]}, 1 } --> main80 main80: addp %71, %75, %76 --> main79 main8: imm %6, imm_addr STACK --> main7 main79: imm %73, imm_int 0 --> main78 main78: imm %74, imm_sizeof (int32) --> main77 main77: mul %72, %73, %74 --> main76 main76: addp %68, %71, %72 --> main75 main75: imm %70, imm_int 0 --> main74 main74: int1sto4 %69, %70 --> main73 main73: store int32, %68, %69 --> main72 main72: imm %66, imm_addr STACK --> main71 main71: imm %67, imm_offset { struct {int32[5], int32[5]}, 1 } --> main70 main70: addp %62, %66, %67 --> main69 main7: imm %7, imm_offset { struct {int32[5], int32[5]}, 1 } --> main6 main69: imm %64, imm_int 1 --> main68 main68: imm %65, imm_sizeof (int32) --> main67 main67: mul %63, %64, %65 --> main66 main66: addp %59, %62, %63 --> main65 main65: imm %61, imm_int 1 --> main64 main64: int1sto4 %60, %61 --> main63 main63: store int32, %59, %60 --> main62 main62: imm %57, imm_addr STACK --> main61 main61: imm %58, imm_offset { struct {int32[5], int32[5]}, 1 } --> main60 main60: addp %53, %57, %58 --> main59 main6: addp %2, %6, %7 --> main5 main59: imm %55, imm_int 2 --> main58 main58: imm %56, imm_sizeof (int32) --> main57 main57: mul %54, %55, %56 --> main56 main56: addp %50, %53, %54 --> main55 main55: imm %52, imm_int 2 --> main54 main54: int1sto4 %51, %52 --> main53 main53: store int32, %50, %51 --> main52 main52: imm %48, imm_addr STACK --> main51 main51: imm %49, imm_offset { struct {int32[5], int32[5]}, 1 } --> main50 main50: addp %44, %48, %49 --> main49 main5: imm %5, imm_int 5 --> main4 main49: imm %46, imm_int 3 --> main48 main48: imm %47, imm_sizeof (int32) --> main47 main47: mul %45, %46, %47 --> main46 main46: addp %41, %44, %45 --> main45 main45: imm %43, imm_int 3 --> main44 main44: int1sto4 %42, %43 --> main43 main43: store int32, %41, %42 --> main42 main42: imm %39, imm_addr STACK --> main41 main41: imm %40, imm_offset { struct {int32[5], int32[5]}, 1 } --> main40 main40: addp %35, %39, %40 --> main39 main4: int1sto4 %3, %5 --> main3 main39: imm %37, imm_int 4 --> main38 main38: imm %38, imm_sizeof (int32) --> main37 main37: mul %36, %37, %38 --> main36 main36: addp %32, %35, %36 --> main35 main35: imm %34, imm_int 4 --> main34 main34: int1sto4 %33, %34 --> main33 main33: store int32, %32, %33 --> main32 main32: imm %30, imm_addr STACK --> main31 main31: imm %31, imm_offset { struct {int32[5]}, 0 } --> main30 main30: addp %25, %30, %31 --> main29 main3: call "print_tab", [%2, %3], %4: ptr -> int4s -> void --> main2 main29: imm %26, imm_addr "tab1" --> main28 main28: imm %29, imm_int 5 --> main27 main27: int1sto4 %27, %29 --> main26 main26: call "copy", [%25, %26, %27], %28: ptr -> ptr -> int4s -> void --> main25 main25: imm %18, imm_addr "tab1" --> main24 main24: imm %23, imm_addr STACK --> main23 main23: imm %24, imm_offset { struct {int32[5], int32[5]}, 1 } --> main22 main22: addp %19, %23, %24 --> main21 main21: imm %22, imm_int 5 --> main20 main20: int1sto4 %20, %22 --> main19 main2: imm %1, imm_int 0 --> main1 main19: call "copy", [%18, %19, %20], %21: ptr -> ptr -> int4s -> void --> main18 main18: imm %14, imm_addr "tab1" --> main17 main17: imm %17, imm_int 5 --> main16 main16: int1sto4 %15, %17 --> main15 main15: call "print_tab", [%14, %15], %16: ptr -> int4s -> void --> main14 main14: imm %12, imm_addr STACK --> main13 main13: imm %13, imm_offset { struct {int32[5]}, 0 } --> main12 main12: addp %8, %12, %13 --> main11 main118: imm %103, imm_addr "tab1" --> main117 main117: imm %105, imm_int 0 --> main116 main116: imm %106, imm_offset { int32[5], 0 } --> main115 main115: add %104, %105, %106 --> main114 main114: addp %101, %103, %104 --> main113 main113: imm %102, imm_int 10 --> main112 main112: store int32, %101, %102 --> main111 main111: imm %97, imm_addr "tab1" --> main110 main110: imm %99, imm_int 0 --> main109 main11: imm %11, imm_int 5 --> main10 main109: imm %100, imm_offset { int32[5], 1 } --> main108 main108: add %98, %99, %100 --> main107 main107: addp %95, %97, %98 --> main106 main106: imm %96, imm_int -3 --> main105 main105: store int32, %95, %96 --> main104 main104: imm %91, imm_addr "tab1" --> main103 main103: imm %93, imm_int 0 --> main102 main102: imm %94, imm_offset { int32[5], 2 } --> main101 main101: add %92, %93, %94 --> main100 main100: addp %89, %91, %92 --> main99 main10: int1sto4 %9, %11 --> main9 main1: int1sto4 %0, %1 --> main0 main0: return %0