URL https://opencores.org/ocsvn/ssbcc/ssbcc/trunk

Subversion Repositories ssbcc

[/] [ssbcc/] [trunk/] [lib/] [9x8/] [tb/] [math/] [uc.s] - Blame information for rev 4

Details | Compare with Previous | View Log


; Copyright 2014, Sinclair R.F., Inc.
; Test bench for ../../math.s
 
.include math.s
 
.macro push16
.macro push24
.macro push32
 
.main
 
  ; Test u8 + u8 ==> u16
  0x7F 0x80
  0x7F 0x81
  0x80 0x7F
  0x80 0x80
  0x80 0x81
  0xFF 0x00
  0xFF 0x01
  0xFF 0x02
  0xFF 0xFE
  0xFF 0xFF
  ${10-1} :loop__u8_u8_u16 >r
    .call(out8,over)
    .call(out8,dup)
    .call(math__add_u8_u8_u16) .call(out16)
    .outstrobe(O_VALUE_DONE)
  r> .jumpc(loop__u8_u8_u16,1-) drop
 
  .push16(0x007F) 0x80
  .push16(0x007F) 0x81
  .push16(0x0080) 0x7F
  .push16(0x0080) 0x80
  .push16(0x0080) 0x81
  .push16(0x00FF) 0x00
  .push16(0x00FF) 0x01
  .push16(0x00FF) 0x02
  .push16(0x00FF) 0xFE
  .push16(0x00FF) 0xFF
  .push16(0x017F) 0x80
  .push16(0x017F) 0x81
  .push16(0x0180) 0x7F
  .push16(0x0180) 0x80
  .push16(0x0180) 0x81
  .push16(0x01FF) 0x00
  .push16(0x01FF) 0x01
  .push16(0x01FF) 0x02
  .push16(0x01FF) 0xFE
  .push16(0x01FF) 0xFF
  ${20-1} :loop__u16_u8_u16 >r
    >r over .call(out16,over)
    r> .call(out8,dup)
    .call(math__add_u16_u8_u16) .call(out16)
    .outstrobe(O_VALUE_DONE)
  r> .jumpc(loop__u16_u8_u16,1-) drop
 
  .push24(0x0001FF) 0xFF
  ${1-1} :loop__u24_u8_u24 >r
    >r .call(preserve_out24) r>
    .call(out8,dup)
    .call(math__add_u24_u8_u24)
    .call(out24)
    .outstrobe(O_VALUE_DONE)
  r> .jumpc(loop__u24_u8_u24,1-) drop
 
  .push24(0x0001FF) 0xFF
  ${1-1} :loop__u24_u8_u32 >r
    >r .call(preserve_out24) r>
    .call(out8,dup)
    .call(math__add_u24_u8_u32)
    .call(out32)
    .outstrobe(O_VALUE_DONE)
  r> .jumpc(loop__u24_u8_u32,1-) drop
 
  .push32(0x00800000) 0xFF
  ${1-1} :loop__u32_u8_u32 >r
    >r .call(preserve_out32) r>
    .call(out8,dup)
    .call(math__add_u32_u8_u32)
    .call(out32)
    .outstrobe(O_VALUE_DONE)
  r> .jumpc(loop__u32_u8_u32,1-) drop
 
  .push32(${0x00800000+0*1280*960*4}) .push24(${1280*960*4})
  .push32(${0x00800000+1*1280*960*4}) .push24(${1280*960*4})
  .push32(${0x00800000+2*1280*960*4}) .push24(${1280*960*4})
  .push32(${0x00800000+3*1280*960*4}) .push24(${1280*960*4})
  .push32(${0x00800000+4*1280*960*4}) .push24(${1280*960*4})
  ${5-1} :loop__u32_u24_u32 >r
    >r >r >r .call(preserve_out32) r> r> r>
    .call(preserve_out24)
    .call(math__add_u32_u24_u32)
    .call(out32)
    .outstrobe(O_VALUE_DONE)
  r> .jumpc(loop__u32_u24_u32,1-) drop
 
  .push32(${0x00800000+0*1280*960*4}) .push32(${1280*960*4})
  .push32(${0x00800000+1*1280*960*4}) .push32(${1280*960*4})
  .push32(${0x00800000+2*1280*960*4}) .push32(${1280*960*4})
  .push32(${0x00800000+3*1280*960*4}) .push32(${1280*960*4})
  .push32(${0x00800000+4*1280*960*4}) .push32(${1280*960*4})
  ${5-1} :loop__u32_u32_u32 >r
    >r >r >r >r .call(preserve_out32) r> r> r> r>
    .call(preserve_out32)
    .call(math__add_u32_u32_u32)
    .call(out32)
    .outstrobe(O_VALUE_DONE)
  r> .jumpc(loop__u32_u32_u32,1-) drop
 
  ; terminate and wait forever
  .outstrobe(O_TERMINATE) :infinite .jump(infinite)
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Routines to output results.
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
.function preserve_out24
 
  .outport(O_VALUE,>r)
  .outport(O_VALUE,>r)
  O_VALUE outport
  r> r>
  .return
 
.function preserve_out32
  .outport(O_VALUE,>r)
  .outport(O_VALUE,>r)
  .outport(O_VALUE,>r)
  O_VALUE outport
  r> r> r>
  .return
 
.function out8
 
 
.function out16
 
 
.function out24
 
 
.function out32
  ${4-1} :loop swap .outport(O_VALUE) .jumpc(loop,1-) drop
  .return

Line No.	Rev	Author	Line
1	4	sinclairrf	`; Copyright 2014, Sinclair R.F., Inc.`
2			`; Test bench for ../../math.s`
3
4			`.include math.s`
5
6			`.macro push16`
7			`.macro push24`
8			`.macro push32`
9
10			`.main`
11
12			`; Test u8 + u8 ==> u16`
13			`0x7F 0x80`
14			`0x7F 0x81`
15			`0x80 0x7F`
16			`0x80 0x80`
17			`0x80 0x81`
18			`0xFF 0x00`
19			`0xFF 0x01`
20			`0xFF 0x02`
21			`0xFF 0xFE`
22			`0xFF 0xFF`
23			`${10-1} :loop__u8_u8_u16 >r`
24			`.call(out8,over)`
25			`.call(out8,dup)`
26			`.call(math__add_u8_u8_u16) .call(out16)`
27			`.outstrobe(O_VALUE_DONE)`
28			`r> .jumpc(loop__u8_u8_u16,1-) drop`
29
30			`.push16(0x007F) 0x80`
31			`.push16(0x007F) 0x81`
32			`.push16(0x0080) 0x7F`
33			`.push16(0x0080) 0x80`
34			`.push16(0x0080) 0x81`
35			`.push16(0x00FF) 0x00`
36			`.push16(0x00FF) 0x01`
37			`.push16(0x00FF) 0x02`
38			`.push16(0x00FF) 0xFE`
39			`.push16(0x00FF) 0xFF`
40			`.push16(0x017F) 0x80`
41			`.push16(0x017F) 0x81`
42			`.push16(0x0180) 0x7F`
43			`.push16(0x0180) 0x80`
44			`.push16(0x0180) 0x81`
45			`.push16(0x01FF) 0x00`
46			`.push16(0x01FF) 0x01`
47			`.push16(0x01FF) 0x02`
48			`.push16(0x01FF) 0xFE`
49			`.push16(0x01FF) 0xFF`
50			`${20-1} :loop__u16_u8_u16 >r`
51			`>r over .call(out16,over)`
52			`r> .call(out8,dup)`
53			`.call(math__add_u16_u8_u16) .call(out16)`
54			`.outstrobe(O_VALUE_DONE)`
55			`r> .jumpc(loop__u16_u8_u16,1-) drop`
56
57			`.push24(0x0001FF) 0xFF`
58			`${1-1} :loop__u24_u8_u24 >r`
59			`>r .call(preserve_out24) r>`
60			`.call(out8,dup)`
61			`.call(math__add_u24_u8_u24)`
62			`.call(out24)`
63			`.outstrobe(O_VALUE_DONE)`
64			`r> .jumpc(loop__u24_u8_u24,1-) drop`
65
66			`.push24(0x0001FF) 0xFF`
67			`${1-1} :loop__u24_u8_u32 >r`
68			`>r .call(preserve_out24) r>`
69			`.call(out8,dup)`
70			`.call(math__add_u24_u8_u32)`
71			`.call(out32)`
72			`.outstrobe(O_VALUE_DONE)`
73			`r> .jumpc(loop__u24_u8_u32,1-) drop`
74
75			`.push32(0x00800000) 0xFF`
76			`${1-1} :loop__u32_u8_u32 >r`
77			`>r .call(preserve_out32) r>`
78			`.call(out8,dup)`
79			`.call(math__add_u32_u8_u32)`
80			`.call(out32)`
81			`.outstrobe(O_VALUE_DONE)`
82			`r> .jumpc(loop__u32_u8_u32,1-) drop`
83
84			`.push32(${0x00800000+012809604}) .push24(${1280960*4})`
85			`.push32(${0x00800000+112809604}) .push24(${1280960*4})`
86			`.push32(${0x00800000+212809604}) .push24(${1280960*4})`
87			`.push32(${0x00800000+312809604}) .push24(${1280960*4})`
88			`.push32(${0x00800000+412809604}) .push24(${1280960*4})`
89			`${5-1} :loop__u32_u24_u32 >r`
90			`>r >r >r .call(preserve_out32) r> r> r>`
91			`.call(preserve_out24)`
92			`.call(math__add_u32_u24_u32)`
93			`.call(out32)`
94			`.outstrobe(O_VALUE_DONE)`
95			`r> .jumpc(loop__u32_u24_u32,1-) drop`
96
97			`.push32(${0x00800000+012809604}) .push32(${1280960*4})`
98			`.push32(${0x00800000+112809604}) .push32(${1280960*4})`
99			`.push32(${0x00800000+212809604}) .push32(${1280960*4})`
100			`.push32(${0x00800000+312809604}) .push32(${1280960*4})`
101			`.push32(${0x00800000+412809604}) .push32(${1280960*4})`
102			`${5-1} :loop__u32_u32_u32 >r`
103			`>r >r >r >r .call(preserve_out32) r> r> r> r>`
104			`.call(preserve_out32)`
105			`.call(math__add_u32_u32_u32)`
106			`.call(out32)`
107			`.outstrobe(O_VALUE_DONE)`
108			`r> .jumpc(loop__u32_u32_u32,1-) drop`
109
110			`; terminate and wait forever`
111			`.outstrobe(O_TERMINATE) :infinite .jump(infinite)`
112
113			`;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;`
114			`;`
115			`; Routines to output results.`
116			`;`
117			`;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;`
118
119			`.function preserve_out24`
120
121			`.outport(O_VALUE,>r)`
122			`.outport(O_VALUE,>r)`
123			`O_VALUE outport`
124			`r> r>`
125			`.return`
126
127			`.function preserve_out32`
128			`.outport(O_VALUE,>r)`
129			`.outport(O_VALUE,>r)`
130			`.outport(O_VALUE,>r)`
131			`O_VALUE outport`
132			`r> r> r>`
133			`.return`
134
135			`.function out8`
136
137
138			`.function out16`
139
140
141			`.function out24`
142
143
144			`.function out32`
145			`${4-1} :loop swap .outport(O_VALUE) .jumpc(loop,1-) drop`
146			`.return`

Browse

Tools

Subversion Repositories ssbcc

[/] [ssbcc/] [trunk/] [lib/] [9x8/] [tb/] [math/] [uc.s] - Blame information for rev 4