Subversion Repositories yacc

        .file   1 "rs_tak.c"

 # -G value = 8, Cpu = 3000, ISA = 1

 # GNU C version egcs-2.90.23 980102 (egcs-1.0.1 release) (sde) [AL 1.1, MM 40] Algorithmics SDE-MIPS v4.0.5 compiled by GNU C version egcs-2.91.57 19980901 (egcs-1.1 release).

 # options passed:  -O2 -O -Wall

 # options enabled:  -fdefer-pop -fomit-frame-pointer -fthread-jumps

 # -fpeephole -finline -fkeep-static-consts -fpcc-struct-return

 # -fdelayed-branch -fcommon -fverbose-asm -fgnu-linker -falias-check

 # -fargument-alias -msplit-addresses -mgas -mrnames -mgpOPT -mgpopt

 # -membedded-data -meb -mmad -marg32 -mdebugh -mdebugi -mmadd -mno-gpconst

 # -mcpu=3000

gcc2_compiled.:

        .sdata

        .align  0

        .align  2

lfsr_state:

        .size   lfsr_state,4

        .word   1

        .globl  Pp

        .data

        .align  0

        .align  2

Pp:

        .size   Pp,36

        .word   1

        .word   0

        .word   1

        .word   1

        .word   1

        .word   0

        .word   0

        .word   0

        .word   1

        .rdata

        .align  0

        .align  2

.LC0:

        .ascii  "index dump\n\000"

        .align  2

.LC1:

        .ascii  " \000"

        .align  2

.LC2:

        .ascii  "\n\000"

        .align  2

.LC3:

        .ascii  "Alpha_to dump\n\000"

        .rdata

        .align  0

        .align  2

.LC4:

        .ascii  "Gg dump\n\000"

        .rdata

        .align  0

        .align  2

.LC5:

        .ascii  "It takes very very long time for RTL Simulation.\n\000"

        .align  2

.LC6:

        .ascii  "Reed-Solomon code is \000"

        .align  2

.LC7:

        .ascii  "over GF(\000"

        .align  2

.LC8:

        .ascii  ")\n\000"

        .align  2

.LC9:

        .ascii  "test erasures: \000"

        .align  2

.LC10:

        .ascii  "errors \000"

        .align  2

.LC11:

        .ascii  "Warning: \000"

        .align  2

.LC12:

        .ascii  "errors and \000"

        .align  2

.LC13:

        .ascii  "erasures exceeds the correction ability of the code\n\000"

        .align  2

.LC14:

        .ascii  "Init_RS Done\000"

        .align  2

.LC15:

        .ascii  " Trial \000"

        .align  2

.LC16:

        .ascii  "Making Encode Data\000"

        .align  2

.LC17:

        .ascii  "\n"

        .ascii  " erasing:\000"

        .align  2

.LC18:

        .ascii  " erroring:\000"

        .align  2

.LC19:

        .ascii  "errs + erasures corrected: \000"

        .align  2

.LC20:

        .ascii  "RS decoder detected failure\n\000"

        .align  2

.LC21:

        .ascii  " Undetected decoding failure!\n\000"

        .align  2

.LC22:

        .ascii  " \n\n"

        .ascii  "Trials: \000"

        .align  2

.LC23:

        .ascii  " decoding failures: \000"

        .align  2

.LC24:

        .ascii  " not detected by decoder: \000"

        .align  2

.LC25:

        .ascii  "$finish\000"

        .comm   Alpha_to,1024

        .comm   Index_of,1024

        .comm   Gg,132

        .comm   data,255

        .comm   tdata,255

        .comm   ddata,255

        .comm   eras_pos,1020

        .text

        .text

        .align  2

        .globl  print_uart

        .ent    print_uart

print_uart:

        .frame  $sp,0,$ra                # vars= 0, regs= 0/0, args= 0, extra= 0

        .mask   0x00000000,0

        .fmask  0x00000000,0

        lbu     $v0,0($a0)

        beq     $v0,$zero,.L3

        li      $v1,16380                       # 0x00003ffc

.L5:

        #.set   volatile

        lw      $v0,0($v1)

        #.set   novolatile

        andi    $v0,$v0,0x0100

        bne     $v0,$zero,.L5

        lbu     $v0,0($a0)

        #.set   volatile

        sb      $v0,0($v1)

        #.set   novolatile

        addu    $a0,$a0,1

        lbu     $v0,0($a0)

        bne     $v0,$zero,.L5

.L3:

        j       $ra

        .end    print_uart

        .size   print_uart,.-print_uart

        .align  2

        .globl  putc_uart

        .ent    putc_uart

putc_uart:

        .frame  $sp,0,$ra                # vars= 0, regs= 0/0, args= 0, extra= 0

        .mask   0x00000000,0

        .fmask  0x00000000,0

        andi    $a0,$a0,0x00ff

        li      $v1,16380                       # 0x00003ffc

.L11:

        #.set   volatile

        lw      $v0,0($v1)

        #.set   novolatile

        andi    $v0,$v0,0x0100

        .set    noreorder

        .set    nomacro

        bne     $v0,$zero,.L11

        li      $v0,16380                       # 0x00003ffc

        .set    macro

        .set    reorder

        #.set   volatile

        sb      $a0,0($v0)

        #.set   novolatile

        j       $ra

        .end    putc_uart

        .size   putc_uart,.-putc_uart

        .align  2

        .globl  read_uart

        .ent    read_uart

read_uart:

        .frame  $sp,0,$ra                # vars= 0, regs= 0/0, args= 0, extra= 0

        .mask   0x00000000,0

        .fmask  0x00000000,0

        li      $v0,16380                       # 0x00003ffc

        #.set   volatile

        lw      $v0,0($v0)

        #.set   novolatile

        .set    noreorder

        .set    nomacro

        j       $ra

        andi    $v0,$v0,0x00ff

        .set    macro

        .set    reorder

        .end    read_uart

        .size   read_uart,.-read_uart

        .align  2

        .globl  print

        .ent    print

print:

        .frame  $sp,0,$ra                # vars= 0, regs= 0/0, args= 0, extra= 0

        .mask   0x00000000,0

        .fmask  0x00000000,0

        lbu     $v0,0($a0)

        .set    noreorder

        .set    nomacro

        beq     $v0,$zero,.L18

        move    $v1,$v0

        .set    macro

        .set    reorder

        li      $a1,16368                       # 0x00003ff0

        move    $v0,$v1

.L21:

        #.set   volatile

        sb      $v0,0($a1)

        #.set   novolatile

        addu    $a0,$a0,1

        lbu     $v1,0($a0)

        .set    noreorder

        .set    nomacro

        bne     $v1,$zero,.L21

        move    $v0,$v1

        .set    macro

        .set    reorder

.L18:

        li      $v0,16368                       # 0x00003ff0

        #.set   volatile

        sb      $zero,0($v0)

        #.set   novolatile

        j       $ra

        .end    print

        .size   print,.-print

        .align  2

        .globl  print_char

        .ent    print_char

print_char:

        .frame  $sp,0,$ra                # vars= 0, regs= 0/0, args= 0, extra= 0

        .mask   0x00000000,0

        .fmask  0x00000000,0

        andi    $a0,$a0,0x00ff

        li      $v0,16368                       # 0x00003ff0

        #.set   volatile

        sb      $a0,0($v0)

        #.set   novolatile

        j       $ra

        .end    print_char

        .size   print_char,.-print_char

        .align  2

        .globl  print_uchar

        .ent    print_uchar

print_uchar:

        .frame  $sp,0,$ra                # vars= 0, regs= 0/0, args= 0, extra= 0

        .mask   0x00000000,0

        .fmask  0x00000000,0

        andi    $a0,$a0,0x00ff

        li      $v0,16369                       # 0x00003ff1

        #.set   volatile

        sb      $a0,0($v0)

        #.set   novolatile

        j       $ra

        .end    print_uchar

        .size   print_uchar,.-print_uchar

        .text

        .align  2

        .globl  random

        .ent    random

random:

        .frame  $sp,0,$ra                # vars= 0, regs= 0/0, args= 0, extra= 0

        .mask   0x00000000,0

        .fmask  0x00000000,0

        lw      $v1,lfsr_state

        andi    $v0,$v1,0x0001

        .set    noreorder

        .set    nomacro

        beq     $v0,$zero,.L25

        srl     $v0,$v1,1

        .set    macro

        .set    reorder

        li      $v1,-2147483648                 # 0x80000000

        ori     $v1,$v1,0x0057

        .set    noreorder

        .set    nomacro

        b       .L27

        xor     $v0,$v0,$v1

        .set    macro

        .set    reorder

.L25:

        lw      $v0,lfsr_state

        srl     $v0,$v0,1

.L27:

        sw      $v0,lfsr_state

        lw      $v0,lfsr_state

        j       $ra

        .end    random

        .size   random,.-random

        .align  2

        .globl  print_num

        .ent    print_num

print_num:

        .frame  $sp,40,$ra              # vars= 0, regs= 5/0, args= 16, extra= 0

        .mask   0x800f0000,-8

        .fmask  0x00000000,0

        subu    $sp,$sp,40

        sw      $ra,32($sp)

        sw      $s3,28($sp)

        sw      $s2,24($sp)

        sw      $s1,20($sp)

        sw      $s0,16($sp)

        move    $s2,$a0

        li      $s1,1000                        # 0x000003e8

        li      $s3,-858993459                  # 0xcccccccd

.L32:

        divu    $s0,$s2,$s1

        addu    $a0,$s0,48

        .set    noreorder

        .set    nomacro

        jal     print_char

        andi    $a0,$a0,0x00ff

        .set    macro

        .set    reorder

        mult    $s0,$s1

        mflo    $v0

        subu    $s2,$s2,$v0

        multu   $s1,$s3

        mfhi    $v0

        srl     $s1,$v0,3

        bne     $s1,$zero,.L32

        lw      $ra,32($sp)

        lw      $s3,28($sp)

        lw      $s2,24($sp)

        lw      $s1,20($sp)

        lw      $s0,16($sp)

        .set    noreorder

        .set    nomacro

        j       $ra

        addu    $sp,$sp,40

        .set    macro

        .set    reorder

        .end    print_num

        .size   print_num,.-print_num

        .align  2

        .globl  memcpy

        .ent    memcpy

memcpy:

        .frame  $sp,0,$ra                # vars= 0, regs= 0/0, args= 0, extra= 0

        .mask   0x00000000,0

        .fmask  0x00000000,0

        .set    noreorder

        .set    nomacro

        beq     $a2,$zero,.L36

        move    $v1,$zero

        .set    macro

        .set    reorder

.L38:

        lbu     $v0,0($a1)

        sb      $v0,0($a0)

        addu    $a1,$a1,1

        addu    $v1,$v1,1

        sltu    $v0,$v1,$a2

        .set    noreorder

        .set    nomacro

        bne     $v0,$zero,.L38

        addu    $a0,$a0,1

        .set    macro

        .set    reorder

.L36:

        j       $ra

        .end    memcpy

        .size   memcpy,.-memcpy

        .align  2

        .globl  memcmp

        .ent    memcmp

memcmp:

        .frame  $sp,0,$ra                # vars= 0, regs= 0/0, args= 0, extra= 0

        .mask   0x00000000,0

        .fmask  0x00000000,0

        .set    noreorder

        .set    nomacro

        beq     $a2,$zero,.L42

        move    $a3,$zero

        .set    macro

        .set    reorder

.L44:

        lbu     $v1,0($a0)

        lbu     $v0,0($a1)

        addu    $a1,$a1,1

        .set    noreorder

        .set    nomacro

        beq     $v1,$v0,.L43

        addu    $a0,$a0,1

        .set    macro

        .set    reorder

        .set    noreorder

        .set    nomacro

        b       .L47

        li      $v0,1                   # 0x00000001

        .set    macro

        .set    reorder

.L43:

        addu    $a3,$a3,1

        sltu    $v0,$a3,$a2

        bne     $v0,$zero,.L44

.L42:

        move    $v0,$zero

.L47:

        j       $ra

        .end    memcmp

        .size   memcmp,.-memcmp

        .text

        .align  2

        .globl  init_rs

        .ent    init_rs

init_rs:

        .frame  $sp,24,$ra              # vars= 0, regs= 1/0, args= 16, extra= 0

        .mask   0x80000000,-8

        .fmask  0x00000000,0

        subu    $sp,$sp,24

        sw      $ra,16($sp)

        jal     generate_gf

        jal     gen_poly

        lw      $ra,16($sp)

        .set    noreorder

        .set    nomacro

        j       $ra

        addu    $sp,$sp,24

        .set    macro

        .set    reorder

        .end    init_rs

        .size   init_rs,.-init_rs

        .text

        .align  2

        .globl  generate_gf

        .ent    generate_gf

generate_gf:

        .frame  $sp,32,$ra              # vars= 0, regs= 4/0, args= 16, extra= 0

        .mask   0x80070000,-4

        .fmask  0x00000000,0

        subu    $sp,$sp,32

        sw      $ra,28($sp)

        sw      $s2,24($sp)

        sw      $s1,20($sp)

        sw      $s0,16($sp)

        li      $a1,1                   # 0x00000001

        lui     $v0,%hi(Alpha_to+32) # high

        sw      $zero,%lo(Alpha_to+32)($v0)

        move    $s0,$zero

        lui     $v0,%hi(Alpha_to) # high

        addiu   $a0,$v0,%lo(Alpha_to) # low

        lui     $v0,%hi(Index_of) # high

        addiu   $a3,$v0,%lo(Index_of) # low

        lui     $v0,%hi(Pp) # high

        addiu   $a2,$v0,%lo(Pp) # low

.L63:

        sll     $v1,$s0,2

        addu    $v0,$v1,$a0

        sw      $a1,0($v0)

        sll     $v0,$a1,2

        addu    $v0,$v0,$a3

        sw      $s0,0($v0)

        addu    $v1,$v1,$a2

        lw      $v0,0($v1)

        beq     $v0,$zero,.L64

        lw      $v0,32($a0)

        xor     $v0,$a1,$v0

        sw      $v0,32($a0)

.L64:

        addu    $s0,$s0,1

        slt     $v0,$s0,8

        .set    noreorder

        .set    nomacro

        bne     $v0,$zero,.L63

        sll     $a1,$a1,1

        .set    macro

        .set    reorder

        lui     $v1,%hi(Index_of) # high

        addiu   $v1,$v1,%lo(Index_of) # low

        lui     $v0,%hi(Alpha_to+32) # high

        lw      $v0,%lo(Alpha_to+32)($v0)

        sll     $v0,$v0,2

        addu    $v0,$v0,$v1

        li      $v1,8                   # 0x00000008

        sw      $v1,0($v0)

        sra     $a1,$a1,1

        li      $s0,9                   # 0x00000009

        lui     $v0,%hi(Alpha_to) # high

        addiu   $a2,$v0,%lo(Alpha_to) # low

        lui     $v0,%hi(Index_of) # high

        addiu   $a3,$v0,%lo(Index_of) # low

        addu    $v0,$s0,-1

.L84:

        sll     $v0,$v0,2

        addu    $v0,$v0,$a2

        lw      $v1,0($v0)

        slt     $v0,$v1,$a1

        .set    noreorder

        .set    nomacro

        bne     $v0,$zero,.L70

        sll     $v0,$s0,2

        .set    macro

        .set    reorder

        addu    $v0,$v0,$a2

        xor     $v1,$a1,$v1

        sll     $v1,$v1,1

        lw      $a0,32($a2)

        .set    noreorder

        .set    nomacro

        b       .L83

        xor     $v1,$v1,$a0

        .set    macro

        .set    reorder

.L70:

        addu    $v0,$v0,$a2

        addu    $v1,$s0,-1

        sll     $v1,$v1,2

        addu    $v1,$v1,$a2

        lw      $v1,0($v1)

        sll     $v1,$v1,1

.L83:

        sw      $v1,0($v0)

        sll     $v0,$s0,2

        addu    $v0,$v0,$a2

        lw      $v0,0($v0)

        sll     $v0,$v0,2

        addu    $v0,$v0,$a3

        sw      $s0,0($v0)

        addu    $s0,$s0,1

        slt     $v0,$s0,255

        .set    noreorder

        .set    nomacro

        bne     $v0,$zero,.L84

        addu    $v0,$s0,-1

        .set    macro

        .set    reorder

        lui     $v1,%hi(Index_of) # high

        li      $v0,255                 # 0x000000ff

        sw      $v0,%lo(Index_of)($v1)

        lui     $v0,%hi(Alpha_to+1020) # high

        sw      $zero,%lo(Alpha_to+1020)($v0)

        lui     $a0,%hi(.LC0) # high

        .set    noreorder

        .set    nomacro

        jal     print

        addiu   $a0,$a0,%lo(.LC0) # low

        .set    macro

        .set    reorder

        move    $s0,$zero

        lui     $v0,%hi(Index_of) # high

        addiu   $s2,$v0,%lo(Index_of) # low

        lui     $s1,%hi(.LC1) # high

        sll     $v0,$s0,2

.L85:

        addu    $v0,$v0,$s2

        lbu     $a0,3($v0)

        .set    noreorder

        .set    nomacro

        jal     print_uchar

        addu    $s0,$s0,1

        .set    macro

        .set    reorder

        .set    noreorder

        .set    nomacro

        jal     print

        addiu   $a0,$s1,%lo(.LC1) # low

        .set    macro

        .set    reorder

        slt     $v0,$s0,255

        .set    noreorder

        .set    nomacro

        bne     $v0,$zero,.L85

        sll     $v0,$s0,2

        .set    macro

        .set    reorder

        lui     $a0,%hi(.LC2) # high

        .set    noreorder

        .set    nomacro

        jal     print

        addiu   $a0,$a0,%lo(.LC2) # low

        .set    macro

        .set    reorder

        lui     $a0,%hi(.LC3) # high

        .set    noreorder

        .set    nomacro

        jal     print

        addiu   $a0,$a0,%lo(.LC3) # low

        .set    macro

        .set    reorder

        move    $s0,$zero

        lui     $v0,%hi(Alpha_to) # high

        addiu   $s2,$v0,%lo(Alpha_to) # low

        lui     $s1,%hi(.LC1) # high

        sll     $v0,$s0,2

.L86:

        addu    $v0,$v0,$s2

        lbu     $a0,3($v0)

        .set    noreorder

        .set    nomacro

        jal     print_uchar

        addu    $s0,$s0,1

        .set    macro

        .set    reorder

        .set    noreorder

        .set    nomacro

        jal     print

        addiu   $a0,$s1,%lo(.LC1) # low

        .set    macro

        .set    reorder

        slt     $v0,$s0,255

        .set    noreorder

        .set    nomacro

        bne     $v0,$zero,.L86

        sll     $v0,$s0,2

        .set    macro

        .set    reorder

        lui     $a0,%hi(.LC2) # high

        .set    noreorder

        .set    nomacro

        jal     print

        addiu   $a0,$a0,%lo(.LC2) # low

        .set    macro

        .set    reorder

        lw      $ra,28($sp)

        lw      $s2,24($sp)

        lw      $s1,20($sp)

        lw      $s0,16($sp)

        .set    noreorder

        .set    nomacro

        j       $ra

        addu    $sp,$sp,32

        .set    macro

        .set    reorder

        .end    generate_gf

        .size   generate_gf,.-generate_gf

        .text

        .align  2

        .globl  gen_poly

        .ent    gen_poly

gen_poly:

        .frame  $sp,32,$ra              # vars= 0, regs= 4/0, args= 16, extra= 0

        .mask   0x80070000,-4

        .fmask  0x00000000,0

        subu    $sp,$sp,32

        sw      $ra,28($sp)

        sw      $s2,24($sp)

        sw      $s1,20($sp)

        sw      $s0,16($sp)

        lui     $v1,%hi(Gg) # high

        addiu   $a0,$v1,%lo(Gg) # low

        lui     $v0,%hi(Alpha_to+4) # high