URL
https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk
Subversion Repositories openrisc_me
Compare Revisions
- This comparison shows the changes necessary to convert path
/openrisc/trunk/or1ksim/testsuite
- from Rev 115 to Rev 116
- ↔ Reverse comparison
Rev 115 → Rev 116
/test-code-or1k/inst-set-test/is-add-test.S
23,22 → 23,7
*/ |
|
/* ---------------------------------------------------------------------------- |
* Coding conventions |
* |
* A simple rising stack is provided starting at _stack and pointed to by |
* r1. r1 points to the next free word. Only 32-bit registers may be pushed |
* onto the stack. |
* |
* Local labels up to 49 are reserved for macros. Each is used only once in |
* all macros. You can get in a serious mess if you get local label clashing |
* in macros. |
* |
* Arguments to functions are passed in r3 through r8. |
* r9 is the link (return address) |
* r11 is for returning results |
* |
* Only r1 and r2 are preserved across function calls. It is up to the callee |
* to save any other registers required. |
* Coding conventions are described in inst-set-test.S |
* ------------------------------------------------------------------------- */ |
|
/* ---------------------------------------------------------------------------- |
/test-code-or1k/inst-set-test/Makefile.in
59,7 → 59,8
build_triplet = @build@ |
host_triplet = @host@ |
check_PROGRAMS = is-add-test$(EXEEXT) is-div-test$(EXEEXT) \ |
is-find-test$(EXEEXT) is-lws-test$(EXEEXT) $(am__EXEEXT_1) |
is-find-test$(EXEEXT) is-mac-test$(EXEEXT) \ |
is-lws-test$(EXEEXT) $(am__EXEEXT_1) |
subdir = inst-set-test |
DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in |
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 |
108,6 → 109,12
is_lws_test_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \ |
$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ |
$(is_lws_test_LDFLAGS) $(LDFLAGS) -o $@ |
am_is_mac_test_OBJECTS = is-mac-test.$(OBJEXT) |
is_mac_test_OBJECTS = $(am_is_mac_test_OBJECTS) |
is_mac_test_DEPENDENCIES = inst-set-test.lo |
is_mac_test_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \ |
$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ |
$(is_mac_test_LDFLAGS) $(LDFLAGS) -o $@ |
DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir) |
depcomp = $(SHELL) $(top_srcdir)/../../depcomp |
am__depfiles_maybe = depfiles |
128,11 → 135,12
$(LDFLAGS) -o $@ |
SOURCES = $(libinst_set_test_la_SOURCES) $(inst_set_test_old_SOURCES) \ |
$(is_add_test_SOURCES) $(is_div_test_SOURCES) \ |
$(is_find_test_SOURCES) $(is_lws_test_SOURCES) |
$(is_find_test_SOURCES) $(is_lws_test_SOURCES) \ |
$(is_mac_test_SOURCES) |
DIST_SOURCES = $(libinst_set_test_la_SOURCES) \ |
$(inst_set_test_old_SOURCES) $(is_add_test_SOURCES) \ |
$(is_div_test_SOURCES) $(is_find_test_SOURCES) \ |
$(is_lws_test_SOURCES) |
$(is_lws_test_SOURCES) $(is_mac_test_SOURCES) |
ETAGS = etags |
CTAGS = ctags |
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) |
278,6 → 286,11
|
is_find_test_LDFLAGS = -T$(srcdir)/inst-set-test.ld |
is_find_test_LDADD = inst-set-test.lo |
is_mac_test_SOURCES = inst-set-test.h \ |
is-mac-test.S |
|
is_mac_test_LDFLAGS = -T$(srcdir)/inst-set-test.ld |
is_mac_test_LDADD = inst-set-test.lo |
is_lws_test_SOURCES = inst-set-test.h \ |
is-lws-test.S |
|
359,6 → 372,9
is-lws-test$(EXEEXT): $(is_lws_test_OBJECTS) $(is_lws_test_DEPENDENCIES) |
@rm -f is-lws-test$(EXEEXT) |
$(is_lws_test_LINK) $(is_lws_test_OBJECTS) $(is_lws_test_LDADD) $(LIBS) |
is-mac-test$(EXEEXT): $(is_mac_test_OBJECTS) $(is_mac_test_DEPENDENCIES) |
@rm -f is-mac-test$(EXEEXT) |
$(is_mac_test_LINK) $(is_mac_test_OBJECTS) $(is_mac_test_LDADD) $(LIBS) |
|
mostlyclean-compile: |
-rm -f *.$(OBJEXT) |
372,6 → 388,7
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/is-div-test.Po@am__quote@ |
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/is-find-test.Po@am__quote@ |
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/is-lws-test.Po@am__quote@ |
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/is-mac-test.Po@am__quote@ |
|
.S.o: |
@am__fastdepCCAS_TRUE@ $(CPPASCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< |
/test-code-or1k/inst-set-test/inst-set-test.S
37,8 → 37,7
* r9 is the link (return address) |
* r11 is for returning results |
* |
* Only r1 and r2 are preserved across function calls. It is up to the callee |
* to save any other registers required. |
* All registers apart from r2, r9 and r11 are preserved across function calls. |
* ------------------------------------------------------------------------- */ |
|
/* ---------------------------------------------------------------------------- |
151,6 → 150,7
* ------------------------------------------------------------------------- */ |
.global _puts |
_puts: |
PUSH (r3) |
l.add r2,r0,r3 /* Copy the string pointer */ |
|
/* Loop getting and printing each char until end of string */ |
162,10 → 162,80
l.j 60b /* Repeat */ |
l.nop NOP_PUTC /* Delay slot */ |
|
61: l.jr r9 /* Return */ |
61: POP (r3) |
l.jr r9 /* Return */ |
l.nop |
|
/* ---------------------------------------------------------------------------- |
* Subroutine to print out a register in hex |
* |
* Parameters: |
* r3 The value to print |
* ------------------------------------------------------------------------- */ |
.section .rodata |
62: .string "0123456789abcdef" |
.section .text |
|
.global _puth |
_puth: |
PUSH (r3) |
PUSH (r4) |
|
l.add r2,r0,r3 /* Copy the value pointer */ |
LOAD_CONST (r4,62b) /* Ptr to digit chars */ |
|
l.srli r3,r2,28 /* Print each digit in turn. */ |
l.add r3,r4,r3 |
l.lbz r3,0(r3) |
l.nop NOP_PUTC |
|
l.srli r3,r2,24 |
l.andi r3,r3,0xf |
l.add r3,r4,r3 |
l.lbz r3,0(r3) |
l.nop NOP_PUTC |
|
l.srli r3,r2,20 |
l.andi r3,r3,0xf |
l.add r3,r4,r3 |
l.lbz r3,0(r3) |
l.nop NOP_PUTC |
|
l.srli r3,r2,16 |
l.andi r3,r3,0xf |
l.add r3,r4,r3 |
l.lbz r3,0(r3) |
l.nop NOP_PUTC |
|
l.srli r3,r2,12 |
l.andi r3,r3,0xf |
l.add r3,r4,r3 |
l.lbz r3,0(r3) |
l.nop NOP_PUTC |
|
l.srli r3,r2,8 |
l.andi r3,r3,0xf |
l.add r3,r4,r3 |
l.lbz r3,0(r3) |
l.nop NOP_PUTC |
|
l.srli r3,r2,4 |
l.andi r3,r3,0xf |
l.add r3,r4,r3 |
l.lbz r3,0(r3) |
l.nop NOP_PUTC |
|
l.andi r3,r2,0xf |
l.add r3,r4,r3 |
l.lbz r3,0(r3) |
l.nop NOP_PUTC |
|
POP (r4) /* Return */ |
POP (r3) |
l.jr r9 |
l.nop |
|
/* ---------------------------------------------------------------------------- |
* Subroutine to print out a test name prompt |
* |
* The string is preceded by two spaces |
175,10 → 245,10
* ------------------------------------------------------------------------- */ |
.global _ptest |
_ptest: |
PUSH(r9) /* Save the return address */ |
PUSH(r3) /* Save the test name for later */ |
PUSH (r9) /* Save the return address */ |
PUSH (r3) /* Save the test name for later */ |
|
LOAD_STR(r3, " ") /* Prefix */ |
LOAD_STR (r3, " ") /* Prefix */ |
l.jal _puts |
l.nop |
|
197,12 → 267,14
* ------------------------------------------------------------------------- */ |
.global _pok |
_pok: |
PUSH(r9) /* Save the return address */ |
PUSH (r9) /* Save the return address */ |
PUSH (r3) |
|
LOAD_STR(r3, "OK\n") |
LOAD_STR (r3, "OK\n") |
l.jal _puts |
l.nop |
|
POP (r3) |
POP (r9) |
l.jr r9 |
l.nop |
214,12 → 286,14
* ------------------------------------------------------------------------- */ |
.global _pfail |
_pfail: |
PUSH(r9) /* Save the return address */ |
PUSH (r9) /* Save the return address */ |
PUSH (r3) |
|
LOAD_STR(r3, "Failed: ") |
LOAD_STR (r3, "Failed: ") |
l.jal _puts |
l.nop |
|
POP (r3) |
POP (r9) |
l.jr r9 |
l.nop |
229,12 → 303,14
* ------------------------------------------------------------------------- */ |
.global _ptrue |
_ptrue: |
PUSH(r9) /* Save the return address */ |
PUSH (r9) /* Save the return address */ |
PUSH (r3) |
|
LOAD_STR(r3, "TRUE") |
LOAD_STR (r3, "TRUE") |
l.jal _puts |
l.nop |
|
POP (r3) |
POP (r9) |
l.jr r9 |
l.nop |
244,12 → 320,14
* ------------------------------------------------------------------------- */ |
.global _pfalse |
_pfalse: |
PUSH(r9) /* Save the return address */ |
PUSH (r9) /* Save the return address */ |
PUSH (r3) |
|
LOAD_STR(r3, "FALSE") |
LOAD_STR (r3, "FALSE") |
l.jal _puts |
l.nop |
|
POP (r3) |
POP (r9) |
l.jr r9 |
l.nop |
261,12 → 339,14
* ------------------------------------------------------------------------- */ |
.global _punexpected |
_punexpected: |
PUSH(r9) /* Save the return address */ |
PUSH (r9) /* Save the return address */ |
PUSH (r3) |
|
LOAD_STR(r3, " unexpected\n") |
LOAD_STR (r3, " unexpected\n") |
l.jal _puts |
l.nop |
|
POP (r3) |
POP (r9) |
l.jr r9 |
l.nop |
/test-code-or1k/inst-set-test/is-find-test.S
23,22 → 23,7
*/ |
|
/* ---------------------------------------------------------------------------- |
* Coding conventions |
* |
* A simple rising stack is provided starting at _stack and pointed to by |
* r1. r1 points to the next free word. Only 32-bit registers may be pushed |
* onto the stack. |
* |
* Local labels up to 49 are reserved for macros. Each is used only once in |
* all macros. You can get in a serious mess if you get local label clashing |
* in macros. |
* |
* Arguments to functions are passed in r3 through r8. |
* r9 is the link (return address) |
* r11 is for returning results |
* |
* Only r1 and r2 are preserved across function calls. It is up to the callee |
* to save any other registers required. |
* Coding conventions are described in inst-set-test.S |
* ------------------------------------------------------------------------- */ |
|
/* ---------------------------------------------------------------------------- |
/test-code-or1k/inst-set-test/is-mac-test.S
0,0 → 1,987
/* is-mac-test.S. l.mac, l.maci, l.macrc and l.msb instruction test of Or1ksim |
* |
* Copyright (C) 1999-2006 OpenCores |
* Copyright (C) 2010 Embecosm Limited |
* |
* Contributors various OpenCores participants |
* Contributor Jeremy Bennett <jeremy.bennett@embecosm.com> |
* |
* This file is part of OpenRISC 1000 Architectural Simulator. |
* |
* This program is free software; you can redistribute it and/or modify it |
* under the terms of the GNU General Public License as published by the Free |
* Software Foundation; either version 3 of the License, or (at your option) |
* any later version. |
* |
* This program is distributed in the hope that it will be useful, but WITHOUT |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
* more details. |
* |
* You should have received a copy of the GNU General Public License along |
* with this program. If not, see <http: www.gnu.org/licenses/>. |
*/ |
|
/* ---------------------------------------------------------------------------- |
* Coding conventions are described in inst-set-test.S |
* ------------------------------------------------------------------------- */ |
|
/* ---------------------------------------------------------------------------- |
* Test coverage |
* |
* The l.add, l.addc, l.addi and l.addic instructions should set the carry and |
* overflow flags. |
* |
* In addition the l.addc and l.addic instructions should add in the carry |
* bit. |
* |
* Problems in this area were reported in Bugs 1771 and 1776. Having fixed the |
* problem, this is (in good software engineering style), a regression test |
* to go with the fix. |
* |
* This is not a comprehensive test of any instruction (yet). |
* |
* Of course what is really needed is a comprehensive instruction test... |
* ------------------------------------------------------------------------- */ |
|
|
#include "inst-set-test.h" |
|
/* ---------------------------------------------------------------------------- |
* A macro to carry out a test of multiply accumulate read and clear |
* |
* Arguments |
* machi: Inital value of MACHI |
* maclo: Inital value of MACLO |
* op1: First operand value |
* op2: Second operand value |
* res: Expected result |
* ------------------------------------------------------------------------- */ |
#define TEST_MACRC(machi, maclo, op1, op2, res) \ |
LOAD_CONST (r2,maclo) ;\ |
l.mtspr r0,r2,SPR_MACLO ;\ |
LOAD_CONST (r2,machi) ;\ |
l.mtspr r0,r2,SPR_MACHI ;\ |
;\ |
LOAD_CONST (r5,op1) /* Load numbers to add */ ;\ |
LOAD_CONST (r6,op2) ;\ |
l.mac r5,r6 ;\ |
l.macrc r4 ;\ |
PUSH (r4) /* Save for later */ ;\ |
PUTS (" 0x") ;\ |
PUTH (machi) ;\ |
PUTS (" ") ;\ |
PUTH (maclo) ;\ |
PUTS (" + 0x") ;\ |
PUTH (op1) ;\ |
PUTS (" * 0x") ;\ |
PUTH (op2) ;\ |
PUTS (" = 0x") ;\ |
PUTH (res) ;\ |
PUTS (": ") ;\ |
POP (r4) ;\ |
CHECK_RES ("", r4, res) ;\ |
;\ |
l.mfspr r5,r0,SPR_MACHI ;\ |
l.sfne r5,r0 ;\ |
l.bf 50f ;\ |
;\ |
PUTS (" - MACHI cleared\n") ;\ |
;\ |
50: l.mfspr r6,r0,SPR_MACLO ;\ |
l.sfne r6,r0 ;\ |
l.bf 51f ;\ |
;\ |
PUTS (" - MACLO cleared\n") ;\ |
51: |
|
/* ---------------------------------------------------------------------------- |
* A macro to carry out a test of multiply accumulate in registers |
* |
* Arguments |
* machi: Inital value of MACHI |
* maclo: Inital value of MACLO |
* op1: First operand value |
* op2: Second operand value |
* reshi: Expected result |
* reslo: Expected result |
* ------------------------------------------------------------------------- */ |
#define TEST_MAC(machi, maclo, op1, op2, reshi, reslo) \ |
LOAD_CONST (r2,maclo) ;\ |
l.mtspr r0,r2,SPR_MACLO ;\ |
LOAD_CONST (r2,machi) ;\ |
l.mtspr r0,r2,SPR_MACHI ;\ |
;\ |
LOAD_CONST (r5,op1) /* Load numbers to add */ ;\ |
LOAD_CONST (r6,op2) ;\ |
l.mac r5,r6 ;\ |
l.mfspr r5,r0,SPR_MACHI ;\ |
l.mfspr r6,r0,SPR_MACLO ;\ |
PUSH (r5) /* Save for later */ ;\ |
PUSH (r6) ;\ |
PUTS (" 0x") ;\ |
PUTH (machi) ;\ |
PUTS (" ") ;\ |
PUTH (maclo) ;\ |
PUTS (" + 0x") ;\ |
PUTH (op1) ;\ |
PUTS (" * 0x") ;\ |
PUTH (op2) ;\ |
PUTS (" = 0x") ;\ |
PUTH (reshi) ;\ |
PUTS (" ") ;\ |
PUTH (reslo) ;\ |
PUTS (": ") ;\ |
POP (r6) ;\ |
POP (r5) ;\ |
CHECK_RES2 (r5, r6, reshi, reslo) |
|
|
/* ---------------------------------------------------------------------------- |
* A macro to carry out a test of multiply accumulate with immediate arg |
* |
* There is currently a bug in the assembler, so we must hand construct |
* l.maci r5,op1. |
* |
* Arguments |
* machi: Inital value of MACHI |
* maclo: Inital value of MACLO |
* op1: First operand value |
* op2: Second operand value |
* reshi: Expected result |
* reslo: Expected result |
* ------------------------------------------------------------------------- */ |
#define TEST_MACI(machi, maclo, op1, op2, reshi, reslo) \ |
LOAD_CONST (r2,maclo) ;\ |
l.mtspr r0,r2,SPR_MACLO ;\ |
LOAD_CONST (r2,machi) ;\ |
l.mtspr r0,r2,SPR_MACHI ;\ |
;\ |
LOAD_CONST (r5,op1) /* Load number to add */ ;\ |
.word (0x4c050000|op2) /* l.maci r5,op2 */ ;\ |
/* l.maci r5,op2 */ ;\ |
l.mfspr r5,r0,SPR_MACHI ;\ |
l.mfspr r6,r0,SPR_MACLO ;\ |
PUSH (r5) /* Save for later */ ;\ |
PUSH (r6) ;\ |
PUTS (" 0x") ;\ |
PUTH (machi) ;\ |
PUTS (" ") ;\ |
PUTH (maclo) ;\ |
PUTS (" + 0x") ;\ |
PUTH (op1) ;\ |
PUTS (" * 0x") ;\ |
PUTH (op2) ;\ |
PUTS (" = 0x") ;\ |
PUTH (reshi) ;\ |
PUTS (" ") ;\ |
PUTH (reslo) ;\ |
PUTS (": ") ;\ |
POP (r6) ;\ |
POP (r5) ;\ |
CHECK_RES2 (r5, r6, reshi, reslo) |
|
|
/* ---------------------------------------------------------------------------- |
* A macro to carry out a test of multiply and subract |
* |
* Arguments |
* machi: Inital value of MACHI |
* maclo: Inital value of MACLO |
* op1: First operand value |
* op2: Second operand value |
* reshi: Expected result |
* reslo: Expected result |
* ------------------------------------------------------------------------- */ |
#define TEST_MSB(machi, maclo, op1, op2, reshi, reslo) \ |
LOAD_CONST (r2,maclo) ;\ |
l.mtspr r0,r2,SPR_MACLO ;\ |
LOAD_CONST (r2,machi) ;\ |
l.mtspr r0,r2,SPR_MACHI ;\ |
;\ |
LOAD_CONST (r5,op1) /* Load numbers to add */ ;\ |
LOAD_CONST (r6,op2) ;\ |
l.msb r5,r6 ;\ |
l.mfspr r5,r0,SPR_MACHI ;\ |
l.mfspr r6,r0,SPR_MACLO ;\ |
PUSH (r5) /* Save for later */ ;\ |
PUSH (r6) ;\ |
PUTS (" 0x") ;\ |
PUTH (machi) ;\ |
PUTS (" ") ;\ |
PUTH (maclo) ;\ |
PUTS (" - 0x") ;\ |
PUTH (op1) ;\ |
PUTS (" * 0x") ;\ |
PUTH (op2) ;\ |
PUTS (" = 0x") ;\ |
PUTH (reshi) ;\ |
PUTS (" ") ;\ |
PUTH (reslo) ;\ |
PUTS (": ") ;\ |
POP (r6) ;\ |
POP (r5) ;\ |
CHECK_RES2 (r5, r6, reshi, reslo) |
|
|
.section .text |
.global _start |
_start: |
|
/* ---------------------------------------------------------------------------- |
* Test of multiply signed and accumulate, l.mac |
* ------------------------------------------------------------------------- */ |
_mac: |
LOAD_STR (r3, "l.mac\n") |
l.jal _puts |
l.nop |
|
/* MAC two small positive numbers on a zero total */ |
TEST_MAC (0x00000000, 0x00000000, |
0x00000002, 0x00000003, |
0x00000000, 0x00000006) |
|
/* MAC two small positive numbers on a small positive total */ |
TEST_MAC (0x00000000, 0x00000006, |
0x00000002, 0x00000003, |
0x00000000, 0x0000000c) |
|
/* MAC two small positive numbers on a moderate positive total */ |
TEST_MAC (0x00000000, 0xfffffffa, |
0x00000002, 0x00000003, |
0x00000001, 0x00000000) |
|
/* MAC two small positive numbers on a large positive total */ |
TEST_MAC (0x3fffffff, 0xfffffffa, |
0x00000002, 0x00000003, |
0x40000000, 0x00000000) |
|
/* MAC two small positive numbers on a small negative total */ |
TEST_MAC (0xffffffff, 0xfffffffa, |
0x00000002, 0x00000003, |
0x00000000, 0x00000000) |
|
/* MAC two small positive numbers on a moderate negative total */ |
TEST_MAC (0xffffffff, 0x00000000, |
0x00000002, 0x00000003, |
0xffffffff, 0x00000006) |
|
/* MAC two small positive numbers on a large negative total */ |
TEST_MAC (0x80000000, 0x00000000, |
0x00000002, 0x00000003, |
0x80000000, 0x00000006) |
|
PUTC ('\n') |
|
/* MAC two moderate positive numbers on a zero total */ |
TEST_MAC (0x00000000, 0x00000000, |
0x00008001, 0x0000fffe, |
0x00000000, 0x7ffffffe) |
|
/* MAC two moderate positive numbers on a small positive total */ |
TEST_MAC (0x00000000, 0x00000002, |
0x00008001, 0x0000fffe, |
0x00000000, 0x80000000) |
|
/* MAC two moderate positive numbers on a moderate positive total */ |
TEST_MAC (0x00000000, 0x80000002, |
0x00008001, 0x0000fffe, |
0x00000001, 0x00000000) |
|
/* MAC two moderate positive numbers on a large positive total */ |
TEST_MAC (0x7fffffff, 0x80000001, |
0x00008001, 0x0000fffe, |
0x7fffffff, 0xffffffff) |
|
/* MAC two moderate positive numbers on a small negative total */ |
TEST_MAC (0xffffffff, 0xffffffff, |
0x00008001, 0x0000fffe, |
0x00000000, 0x7ffffffd) |
|
/* MAC two moderate positive numbers on a moderate negative total */ |
TEST_MAC (0xffffffff, 0x80000002, |
0x00008001, 0x0000fffe, |
0x00000000, 0x00000000) |
|
/* MAC two moderate positive numbers on a large negative total */ |
TEST_MAC (0xfffffffe, 0x80000002, |
0x00008001, 0x0000fffe, |
0xffffffff, 0x00000000) |
|
PUTC ('\n') |
|
/* MAC two small negative numbers on a zero total */ |
TEST_MAC (0x00000000, 0x00000000, |
0xfffffffe, 0xfffffffd, |
0x00000000, 0x00000006) |
|
/* MAC two small negative numbers on a small positive total */ |
TEST_MAC (0x00000000, 0x00000006, |
0xfffffffe, 0xfffffffd, |
0x00000000, 0x0000000c) |
|
/* MAC two small negative numbers on a small negative total */ |
TEST_MAC (0xffffffff, 0xffffffff, |
0xfffffffe, 0xfffffffd, |
0x00000000, 0x00000005) |
|
PUTC ('\n') |
|
/* MAC one small positive and one small negative number on a zero |
total */ |
TEST_MAC (0x00000000, 0x00000000, |
0x00000002, 0xfffffffd, |
0xffffffff, 0xfffffffa) |
|
/* MAC one small positive and one small negative number on a small |
positive total */ |
TEST_MAC (0x00000000, 0x0000000c, |
0x00000002, 0xfffffffd, |
0x00000000, 0x00000006) |
|
/* MAC one small positive and one small negative number on a moderate |
positive total */ |
TEST_MAC (0x00000001, 0x00000005, |
0x00000002, 0xfffffffd, |
0x00000000, 0xffffffff) |
|
/* MAC one small positive and one small negative number on a large |
positive total */ |
TEST_MAC (0x7fffffff, 0xffffffff, |
0x00000002, 0xfffffffd, |
0x7fffffff, 0xfffffff9) |
|
/* MAC one small positive and one small negative number on a small |
negative total */ |
TEST_MAC (0xffffffff, 0xffffffff, |
0x00000002, 0xfffffffd, |
0xffffffff, 0xfffffff9) |
|
/* MAC one small positive and one small negative number on a moderate |
negative total */ |
TEST_MAC (0xffffffff, 0x00000005, |
0x00000002, 0xfffffffd, |
0xfffffffe, 0xffffffff) |
|
/* MAC one small positive and one small negative number on a large |
negative total */ |
TEST_MAC (0x80000000, 0x00000006, |
0x00000002, 0xfffffffd, |
0x80000000, 0x00000000) |
|
PUTC ('\n') |
|
/* MAC one moderate positive and one moderate negative number on a |
zero total */ |
TEST_MAC (0x00000000, 0x00000000, |
0x00008000, 0xffff0000, |
0xffffffff, 0x80000000) |
|
/* MAC one moderate positive and one moderate negative number on a |
small positive total */ |
TEST_MAC (0x00000000, 0x00000006, |
0x00008000, 0xffff0000, |
0xffffffff, 0x80000006) |
|
/* MAC one moderate positive and one moderate negative number on a |
moderate positive total */ |
TEST_MAC (0x00000000, 0x80000000, |
0x00008000, 0xffff0000, |
0x00000000, 0x00000000) |
|
/* MAC one moderate positive and one moderate negative number on a |
large positive total */ |
TEST_MAC (0x7fffffff, 0xffffffff, |
0x00008000, 0xffff0000, |
0x7fffffff, 0x7fffffff) |
|
/* MAC one moderate positive and one moderate negative number on a |
small negative total */ |
TEST_MAC (0xffffffff, 0xffffffff, |
0x00008000, 0xffff0000, |
0xffffffff, 0x7fffffff) |
|
/* MAC one moderate positive and one moderate negative number on a |
moderate negative total */ |
TEST_MAC (0xffffffff, 0x7fffffff, |
0x00008000, 0xffff0000, |
0xfffffffe, 0xffffffff) |
|
/* MAC one moderate positive and one moderate negative number on a |
large negative total */ |
TEST_MAC (0x80000000, 0x80000000, |
0x00008000, 0xffff0000, |
0x80000000, 0x00000000) |
|
PUTC ('\n') |
|
/* ---------------------------------------------------------------------------- |
* Test of multiply signed and accumulate, l.maci |
* ------------------------------------------------------------------------- */ |
_maci: |
LOAD_STR (r3, "l.maci\n") |
l.jal _puts |
l.nop |
|
/* MAC two small positive numbers on a zero total */ |
TEST_MACI (0x00000000, 0x00000000, |
0x00000002, 0x0003, |
0x00000000, 0x00000006) |
|
/* MAC two small positive numbers on a small positive total */ |
TEST_MACI (0x00000000, 0x00000006, |
0x00000002, 0x0003, |
0x00000000, 0x0000000c) |
|
/* MAC two small positive numbers on a moderate positive total */ |
TEST_MACI (0x00000000, 0xfffffffa, |
0x00000002, 0x0003, |
0x00000001, 0x00000000) |
|
/* MAC two small positive numbers on a large positive total */ |
TEST_MACI (0x3fffffff, 0xfffffffa, |
0x00000002, 0x0003, |
0x40000000, 0x00000000) |
|
/* MAC two small positive numbers on a small negative total */ |
TEST_MACI (0xffffffff, 0xfffffffa, |
0x00000002, 0x0003, |
0x00000000, 0x00000000) |
|
/* MAC two small positive numbers on a moderate negative total */ |
TEST_MACI (0xffffffff, 0x00000000, |
0x00000002, 0x0003, |
0xffffffff, 0x00000006) |
|
/* MAC two small positive numbers on a large negative total */ |
TEST_MACI (0x80000000, 0x00000000, |
0x00000002, 0x0003, |
0x80000000, 0x00000006) |
|
PUTC ('\n') |
tmp: |
/* MAC two moderate positive numbers on a zero total */ |
TEST_MACI (0x00000000, 0x00000000, |
0x00010002, 0x7fff, |
0x00000000, 0x7ffffffe) |
|
/* MAC two moderate positive numbers on a small positive total */ |
TEST_MACI (0x00000000, 0x00000002, |
0x00010002, 0x7fff, |
0x00000000, 0x80000000) |
|
/* MAC two moderate positive numbers on a moderate positive total */ |
TEST_MACI (0x00000000, 0x80000002, |
0x00010002, 0x7fff, |
0x00000001, 0x00000000) |
|
/* MAC two moderate positive numbers on a large positive total */ |
TEST_MACI (0x7fffffff, 0x80000001, |
0x00010002, 0x7fff, |
0x7fffffff, 0xffffffff) |
|
/* MAC two moderate positive numbers on a small negative total */ |
TEST_MACI (0xffffffff, 0xffffffff, |
0x00010002, 0x7fff, |
0x00000000, 0x7ffffffd) |
|
/* MAC two moderate positive numbers on a moderate negative total */ |
TEST_MACI (0xffffffff, 0x80000002, |
0x00010002, 0x7fff, |
0x00000000, 0x00000000) |
|
/* MAC two moderate positive numbers on a large negative total */ |
TEST_MACI (0xfffffffe, 0x80000002, |
0x00010002, 0x7fff, |
0xffffffff, 0x00000000) |
|
PUTC ('\n') |
|
/* MAC two small negative numbers on a zero total */ |
TEST_MACI (0x00000000, 0x00000000, |
0xfffffffe, 0xfffd, |
0x00000000, 0x00000006) |
|
/* MAC two small negative numbers on a small positive total */ |
TEST_MACI (0x00000000, 0x00000006, |
0xfffffffe, 0xfffd, |
0x00000000, 0x0000000c) |
|
/* MAC two small negative numbers on a small negative total */ |
TEST_MACI (0xffffffff, 0xffffffff, |
0xfffffffe, 0xfffd, |
0x00000000, 0x00000005) |
|
PUTC ('\n') |
|
/* MAC one small positive and one small negative number on a zero |
total */ |
TEST_MACI (0x00000000, 0x00000000, |
0x00000002, 0xfffd, |
0xffffffff, 0xfffffffa) |
|
/* MAC one small positive and one small negative number on a small |
positive total */ |
TEST_MACI (0x00000000, 0x0000000c, |
0x00000002, 0xfffd, |
0x00000000, 0x00000006) |
|
/* MAC one small positive and one small negative number on a moderate |
positive total */ |
TEST_MACI (0x00000001, 0x00000005, |
0x00000002, 0xfffd, |
0x00000000, 0xffffffff) |
|
/* MAC one small positive and one small negative number on a large |
positive total */ |
TEST_MACI (0x7fffffff, 0xffffffff, |
0x00000002, 0xfffd, |
0x7fffffff, 0xfffffff9) |
|
/* MAC one small positive and one small negative number on a small |
negative total */ |
TEST_MACI (0xffffffff, 0xffffffff, |
0x00000002, 0xfffd, |
0xffffffff, 0xfffffff9) |
|
/* MAC one small positive and one small negative number on a moderate |
negative total */ |
TEST_MACI (0xffffffff, 0x00000005, |
0x00000002, 0xfffd, |
0xfffffffe, 0xffffffff) |
|
/* MAC one small positive and one small negative number on a large |
negative total */ |
TEST_MACI (0x80000000, 0x00000006, |
0x00000002, 0xfffd, |
0x80000000, 0x00000000) |
|
PUTC ('\n') |
|
/* MAC one moderate positive and one moderate negative number on a |
zero total */ |
TEST_MACI (0x00000000, 0x00000000, |
0x00010000, 0x8000, |
0xffffffff, 0x80000000) |
|
/* MAC one moderate positive and one moderate negative number on a |
small positive total */ |
TEST_MACI (0x00000000, 0x00000006, |
0x00010000, 0x8000, |
0xffffffff, 0x80000006) |
|
/* MAC one moderate positive and one moderate negative number on a |
moderate positive total */ |
TEST_MACI (0x00000000, 0x80000000, |
0x00010000, 0x8000, |
0x00000000, 0x00000000) |
|
/* MAC one moderate positive and one moderate negative number on a |
large positive total */ |
TEST_MACI (0x7fffffff, 0xffffffff, |
0x00010000, 0x8000, |
0x7fffffff, 0x7fffffff) |
|
/* MAC one moderate positive and one moderate negative number on a |
small negative total */ |
TEST_MACI (0xffffffff, 0xffffffff, |
0x00010000, 0x8000, |
0xffffffff, 0x7fffffff) |
|
/* MAC one moderate positive and one moderate negative number on a |
moderate negative total */ |
TEST_MACI (0xffffffff, 0x7fffffff, |
0x00010000, 0x8000, |
0xfffffffe, 0xffffffff) |
|
/* MAC one moderate positive and one moderate negative number on a |
large negative total */ |
TEST_MACI (0x80000000, 0x80000000, |
0x00010000, 0x8000, |
0x80000000, 0x00000000) |
|
PUTC ('\n') |
|
/* ---------------------------------------------------------------------------- |
* Test of multiply signed and accumulate, read and clear l.macrc |
* ------------------------------------------------------------------------- */ |
_macrc: |
LOAD_STR (r3, "l.macrc\n") |
l.jal _puts |
l.nop |
|
/* MAC two small positive numbers on a zero total */ |
TEST_MACRC (0x00000000, 0x00000000, |
0x00000002, 0x00000003, |
0x00000006) |
|
/* MAC two small positive numbers on a small positive total */ |
TEST_MACRC (0x00000000, 0x00000006, |
0x00000002, 0x00000003, |
0x0000000c) |
|
/* MAC two small positive numbers on a moderate positive total */ |
TEST_MACRC (0x00000000, 0xfffffffa, |
0x00000002, 0x00000003, |
0x00000000) |
|
/* MAC two small positive numbers on a large positive total */ |
TEST_MACRC (0x3fffffff, 0xfffffffa, |
0x00000002, 0x00000003, |
0x00000000) |
|
/* MAC two small positive numbers on a small negative total */ |
TEST_MACRC (0xffffffff, 0xfffffffa, |
0x00000002, 0x00000003, |
0x00000000) |
|
/* MAC two small positive numbers on a moderate negative total */ |
TEST_MACRC (0xffffffff, 0x00000000, |
0x00000002, 0x00000003, |
0x00000006) |
|
/* MAC two small positive numbers on a large negative total */ |
TEST_MACRC (0x80000000, 0x00000000, |
0x00000002, 0x00000003, |
0x00000006) |
|
PUTC ('\n') |
|
/* MAC two moderate positive numbers on a zero total */ |
TEST_MACRC (0x00000000, 0x00000000, |
0x00008001, 0x0000fffe, |
0x7ffffffe) |
|
/* MAC two moderate positive numbers on a small positive total */ |
TEST_MACRC (0x00000000, 0x00000002, |
0x00008001, 0x0000fffe, |
0x80000000) |
|
/* MAC two moderate positive numbers on a moderate positive total */ |
TEST_MACRC (0x00000000, 0x80000002, |
0x00008001, 0x0000fffe, |
0x00000000) |
|
/* MAC two moderate positive numbers on a large positive total */ |
TEST_MACRC (0x7fffffff, 0x80000001, |
0x00008001, 0x0000fffe, |
0xffffffff) |
|
/* MAC two moderate positive numbers on a small negative total */ |
TEST_MACRC (0xffffffff, 0xffffffff, |
0x00008001, 0x0000fffe, |
0x7ffffffd) |
|
/* MAC two moderate positive numbers on a moderate negative total */ |
TEST_MACRC (0xffffffff, 0x80000002, |
0x00008001, 0x0000fffe, |
0x00000000) |
|
/* MAC two moderate positive numbers on a large negative total */ |
TEST_MACRC (0xfffffffe, 0x80000002, |
0x00008001, 0x0000fffe, |
0x00000000) |
|
PUTC ('\n') |
|
/* MAC two small negative numbers on a zero total */ |
TEST_MACRC (0x00000000, 0x00000000, |
0xfffffffe, 0xfffffffd, |
0x00000006) |
|
/* MAC two small negative numbers on a small positive total */ |
TEST_MACRC (0x00000000, 0x00000006, |
0xfffffffe, 0xfffffffd, |
0x0000000c) |
|
/* MAC two small negative numbers on a small negative total */ |
TEST_MACRC (0xffffffff, 0xffffffff, |
0xfffffffe, 0xfffffffd, |
0x00000005) |
|
PUTC ('\n') |
|
/* MAC one small positive and one small negative number on a zero |
total */ |
TEST_MACRC (0x00000000, 0x00000000, |
0x00000002, 0xfffffffd, |
0xfffffffa) |
|
/* MAC one small positive and one small negative number on a small |
positive total */ |
TEST_MACRC (0x00000000, 0x0000000c, |
0x00000002, 0xfffffffd, |
0x00000006) |
|
/* MAC one small positive and one small negative number on a moderate |
positive total */ |
TEST_MACRC (0x00000001, 0x00000005, |
0x00000002, 0xfffffffd, |
0xffffffff) |
|
/* MAC one small positive and one small negative number on a large |
positive total */ |
TEST_MACRC (0x7fffffff, 0xffffffff, |
0x00000002, 0xfffffffd, |
0xfffffff9) |
|
/* MAC one small positive and one small negative number on a small |
negative total */ |
TEST_MACRC (0xffffffff, 0xffffffff, |
0x00000002, 0xfffffffd, |
0xfffffff9) |
|
/* MAC one small positive and one small negative number on a moderate |
negative total */ |
TEST_MACRC (0xffffffff, 0x00000005, |
0x00000002, 0xfffffffd, |
0xffffffff) |
|
/* MAC one small positive and one small negative number on a large |
negative total */ |
TEST_MACRC (0x80000000, 0x00000006, |
0x00000002, 0xfffffffd, |
0x00000000) |
|
PUTC ('\n') |
|
/* MAC one moderate positive and one moderate negative number on a |
zero total */ |
TEST_MACRC (0x00000000, 0x00000000, |
0x00008000, 0xffff0000, |
0x80000000) |
|
/* MAC one moderate positive and one moderate negative number on a |
small positive total */ |
TEST_MACRC (0x00000000, 0x00000006, |
0x00008000, 0xffff0000, |
0x80000006) |
|
/* MAC one moderate positive and one moderate negative number on a |
moderate positive total */ |
TEST_MACRC (0x00000000, 0x80000000, |
0x00008000, 0xffff0000, |
0x00000000) |
|
/* MAC one moderate positive and one moderate negative number on a |
large positive total */ |
TEST_MACRC (0x7fffffff, 0xffffffff, |
0x00008000, 0xffff0000, |
0x7fffffff) |
|
/* MAC one moderate positive and one moderate negative number on a |
small negative total */ |
TEST_MACRC (0xffffffff, 0xffffffff, |
0x00008000, 0xffff0000, |
0x7fffffff) |
|
/* MAC one moderate positive and one moderate negative number on a |
moderate negative total */ |
TEST_MACRC (0xffffffff, 0x7fffffff, |
0x00008000, 0xffff0000, |
0xffffffff) |
|
/* MAC one moderate positive and one moderate negative number on a |
large negative total */ |
TEST_MACRC (0x80000000, 0x80000000, |
0x00008000, 0xffff0000, |
0x00000000) |
|
PUTC ('\n') |
|
/* ---------------------------------------------------------------------------- |
* Test of multiply signed and accumulate, l.msb |
* ------------------------------------------------------------------------- */ |
_msb: |
LOAD_STR (r3, "l.msb\n") |
l.jal _puts |
l.nop |
|
/* MSB two small positive numbers on a zero total */ |
TEST_MSB (0x00000000, 0x00000000, |
0x00000002, 0x00000003, |
0xffffffff, 0xfffffffa) |
|
/* MSB two small positive numbers on a small positive total */ |
TEST_MSB (0x00000000, 0x0000000c, |
0x00000002, 0x00000003, |
0x00000000, 0x00000006) |
|
/* MSB two small positive numbers on a moderate positive total */ |
TEST_MSB (0x00000001, 0x00000000, |
0x00000002, 0x00000003, |
0x00000000, 0xfffffffa) |
|
/* MSB two small positive numbers on a large positive total */ |
TEST_MSB (0x40000000, 0x00000000, |
0x00000002, 0x00000003, |
0x3fffffff, 0xfffffffa) |
|
/* MSB two small positive numbers on a small negative total */ |
TEST_MSB (0xffffffff, 0xfffffffa, |
0x00000002, 0x00000003, |
0xffffffff, 0xfffffff4) |
|
/* MSB two small positive numbers on a moderate negative total */ |
TEST_MSB (0xffffffff, 0x00000005, |
0x00000002, 0x00000003, |
0xfffffffe, 0xffffffff) |
|
/* MSB two small positive numbers on a large negative total */ |
TEST_MSB (0x80000000, 0x00000006, |
0x00000002, 0x00000003, |
0x80000000, 0x00000000) |
|
PUTC ('\n') |
|
/* MSB two moderate positive numbers on a zero total */ |
TEST_MSB (0x00000000, 0x00000000, |
0x00008001, 0x0000fffe, |
0xffffffff, 0x80000002) |
|
/* MSB two moderate positive numbers on a small positive total */ |
TEST_MSB (0x00000000, 0x00000002, |
0x00008001, 0x0000fffe, |
0xffffffff, 0x80000004) |
|
/* MSB two moderate positive numbers on a moderate positive total */ |
TEST_MSB (0x00000000, 0x80000002, |
0x00008001, 0x0000fffe, |
0x00000000, 0x00000004) |
|
/* MSB two moderate positive numbers on a large positive total */ |
TEST_MSB (0x7fffffff, 0x7ffffffd, |
0x00008001, 0x0000fffe, |
0x7ffffffe, 0xffffffff) |
|
/* MSB two moderate positive numbers on a small negative total */ |
TEST_MSB (0xffffffff, 0xffffffff, |
0x00008001, 0x0000fffe, |
0xffffffff, 0x80000001) |
|
/* MSB two moderate positive numbers on a moderate negative total */ |
TEST_MSB (0xffffffff, 0x80000002, |
0x00008001, 0x0000fffe, |
0xffffffff, 0x00000004) |
|
/* MSB two moderate positive numbers on a large negative total */ |
TEST_MSB (0xfffffffe, 0x80000002, |
0x00008001, 0x0000fffe, |
0xfffffffe, 0x00000004) |
|
PUTC ('\n') |
|
/* MSB two small negative numbers on a zero total */ |
TEST_MSB (0x00000000, 0x00000006, |
0xfffffffe, 0xfffffffd, |
0x00000000, 0x00000000) |
|
/* MSB two small negative numbers on a small positive total */ |
TEST_MSB (0x00000000, 0x0000000c, |
0xfffffffe, 0xfffffffd, |
0x00000000, 0x00000006) |
|
/* MSB two small negative numbers on a small negative total */ |
TEST_MSB (0xffffffff, 0xffffffff, |
0xfffffffe, 0xfffffffd, |
0xffffffff, 0xfffffff9) |
|
PUTC ('\n') |
|
/* MSB one small positive and one small negative number on a zero |
total */ |
TEST_MSB (0x00000000, 0x00000000, |
0x00000002, 0xfffffffd, |
0x00000000, 0x00000006) |
|
/* MSB one small positive and one small negative number on a small |
positive total */ |
TEST_MSB (0x00000000, 0x00000006, |
0x00000002, 0xfffffffd, |
0x00000000, 0x0000000c) |
|
/* MSB one small positive and one small negative number on a moderate |
positive total */ |
TEST_MSB (0x00000000, 0xffffffff, |
0x00000002, 0xfffffffd, |
0x00000001, 0x00000005) |
|
/* MSB one small positive and one small negative number on a large |
positive total */ |
TEST_MSB (0x7fffffff, 0xfffffff9, |
0x00000002, 0xfffffffd, |
0x7fffffff, 0xffffffff) |
|
/* MSB one small positive and one small negative number on a small |
negative total */ |
TEST_MSB (0xffffffff, 0xfffffff9, |
0x00000002, 0xfffffffd, |
0xffffffff, 0xffffffff) |
|
/* MSB one small positive and one small negative number on a moderate |
negative total */ |
TEST_MSB (0xfffffffe, 0xffffffff, |
0x00000002, 0xfffffffd, |
0xffffffff, 0x00000005) |
|
/* MSB one small positive and one small negative number on a large |
negative total */ |
TEST_MSB (0x80000000, 0x00000000, |
0x00000002, 0xfffffffd, |
0x80000000, 0x00000006) |
|
PUTC ('\n') |
|
/* MSB one moderate positive and one moderate negative number on a |
zero total */ |
TEST_MSB (0x00000000, 0x00000000, |
0x00008000, 0xffff0000, |
0x00000000, 0x80000000) |
|
/* MSB one moderate positive and one moderate negative number on a |
small positive total */ |
TEST_MSB (0x00000000, 0x00000006, |
0x00008000, 0xffff0000, |
0x00000000, 0x80000006) |
|
/* MSB one moderate positive and one moderate negative number on a |
moderate positive total */ |
TEST_MSB (0x00000000, 0x80000000, |
0x00008000, 0xffff0000, |
0x00000001, 0x00000000) |
|
/* MSB one moderate positive and one moderate negative number on a |
large positive total */ |
TEST_MSB (0x7fffffff, 0x7fffffff, |
0x00008000, 0xffff0000, |
0x7fffffff, 0xffffffff) |
|
/* MSB one moderate positive and one moderate negative number on a |
small negative total */ |
TEST_MSB (0xffffffff, 0xffffffff, |
0x00008000, 0xffff0000, |
0x00000000, 0x7fffffff) |
|
/* MSB one moderate positive and one moderate negative number on a |
moderate negative total */ |
TEST_MSB (0xfffffffe, 0xffffffff, |
0x00008000, 0xffff0000, |
0xffffffff, 0x7fffffff) |
|
/* MSB one moderate positive and one moderate negative number on a |
large negative total */ |
TEST_MSB (0x80000000, 0x00000000, |
0x00008000, 0xffff0000, |
0x80000000, 0x80000000) |
|
PUTC ('\n') |
|
/* ---------------------------------------------------------------------------- |
* All done |
* ------------------------------------------------------------------------- */ |
_exit: |
LOAD_STR (r3, "Test completed\n") |
l.jal _puts |
l.nop |
|
TEST_EXIT |
test-code-or1k/inst-set-test/is-mac-test.S
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: test-code-or1k/inst-set-test/Makefile.am
===================================================================
--- test-code-or1k/inst-set-test/Makefile.am (revision 115)
+++ test-code-or1k/inst-set-test/Makefile.am (revision 116)
@@ -44,6 +44,7 @@
check_PROGRAMS = is-add-test \
is-div-test \
is-find-test \
+ is-mac-test \
is-lws-test \
$(INST_SET_TEST_OLD)
@@ -63,6 +64,11 @@
is_find_test_LDFLAGS = -T$(srcdir)/inst-set-test.ld
is_find_test_LDADD = inst-set-test.lo
+is_mac_test_SOURCES = inst-set-test.h \
+ is-mac-test.S
+is_mac_test_LDFLAGS = -T$(srcdir)/inst-set-test.ld
+is_mac_test_LDADD = inst-set-test.lo
+
is_lws_test_SOURCES = inst-set-test.h \
is-lws-test.S
is_lws_test_LDFLAGS = -T$(srcdir)/inst-set-test.ld
/test-code-or1k/inst-set-test/inst-set-test.h
22,39 → 22,11
with this program. If not, see <http: www.gnu.org/licenses/>. */ |
|
|
/* ---------------------------------------------------------------------------- |
* Test coverage |
* |
* The l.lws instruction was omitted from Or1ksim originally. It is specified |
* for ORBIS32, even though it is functionally equivalent to l.lwz. |
* |
* Having fixed the problem, this is (in good software engineering style), a |
* regresison test to go with the fix. |
* |
* Of course what is really needed is a comprehensive instruction test... |
* ------------------------------------------------------------------------- */ |
|
|
#include "spr-defs.h" |
#include "board.h" |
|
/* ---------------------------------------------------------------------------- |
* Coding conventions |
* |
* A simple rising stack is provided starting at _stack and pointed to by |
* r1. r1 points to the next free word. Only 32-bit registers may be pushed |
* onto the stack. |
* |
* Local labels up to 49 are reserved for macros. Each is used only once in |
* all macros. You can get in a serious mess if you get local label clashing |
* in macros. |
* |
* Arguments to functions are passed in r3 through r8. |
* r9 is the link (return address) |
* r11 is for returning results |
* |
* Only r1 and r2 are preserved across function calls. It is up to the callee |
* to save any other registers required. |
* Coding conventions are described in inst-set-test.S |
* ------------------------------------------------------------------------- */ |
|
|
142,9 → 114,35
l.nop NOP_PUTC |
|
/* ---------------------------------------------------------------------------- |
* Macro to print a string |
* |
* Arguments: |
* s The string to print |
* ------------------------------------------------------------------------- */ |
#define PUTS(s) \ |
LOAD_STR (r3, s) ;\ |
PUSH (r9) ;\ |
l.jal _puts ;\ |
l.nop ;\ |
POP (r9) |
|
/* ---------------------------------------------------------------------------- |
* Macro to print a hex value |
* |
* Arguments: |
* v The value to print |
* ------------------------------------------------------------------------- */ |
#define PUTH(v) \ |
LOAD_CONST (r3, v) ;\ |
PUSH (r9) ;\ |
l.jal _puth ;\ |
l.nop ;\ |
POP (r9) |
|
/* ---------------------------------------------------------------------------- |
* Macro for recording the result of a test |
* |
* The test result is in r4. Print out the name of test indented two spaces, |
* The test result is in reg. Print out the name of test indented two spaces, |
* followed by ": ", either "OK" or "Failed" and a newline. |
* |
* Arguments: |
253,6 → 251,71
9: |
|
/* ---------------------------------------------------------------------------- |
* Macro for recording the result of a test (in two regs) |
* |
* The test result is in reg1 and reg2. Print out the name of test indented |
* two spaces, followed by ": ", either "OK" or "Failed" and a newline. |
* |
* Arguments: |
* str Textual name of the test |
* reg1 The result to test (not r2) |
* reg2 The result to test (not r2) |
* val1 Desired result of the test |
* val2 Desired result of the test |
* ------------------------------------------------------------------------- */ |
#define CHECK_RES2(reg1, reg2, val1, val2) \ |
PUSH (reg2) /* Save the test registers */ ;\ |
PUSH (reg1) ;\ |
;\ |
LOAD_CONST(r2,val1) /* First desired result */ ;\ |
POP (reg1) /* First register to test */ ;\ |
PUSH (reg1) /* May need again later */ ;\ |
l.sfeq r2,reg1 /* Does the result match? */ ;\ |
l.bf 10f ;\ |
l.nop ;\ |
;\ |
/* First register failed. */ ;\ |
l.jal _pfail /* Test failed */ ;\ |
l.nop ;\ |
POP (reg1) /* Report the registers */ ;\ |
l.add r3,r0,reg1 ;\ |
l.nop NOP_REPORT ;\ |
POP (reg2) /* Report the registers */ ;\ |
l.add r3,r0,reg2 ;\ |
l.j 12f ;\ |
l.nop NOP_REPORT ;\ |
;\ |
/* First register matched, check the second */ ;\ |
10: ;\ |
LOAD_CONST(r2,val2) /* Second desired result */ ;\ |
POP (reg1) /* First register to test */ ;\ |
POP (reg2) /* Second register to test */ ;\ |
PUSH (reg2) /* May need again later */ ;\ |
PUSH (reg1) /* May need again later */ ;\ |
l.sfeq r2,reg2 /* Does the result match? */ ;\ |
l.bf 11f ;\ |
l.nop ;\ |
;\ |
/* Second register failed. */ ;\ |
l.jal _pfail /* Test failed */ ;\ |
l.nop ;\ |
POP (reg1) /* Report the registers */ ;\ |
l.add r3,r0,reg1 ;\ |
l.nop NOP_REPORT ;\ |
POP (reg2) /* Report the registers */ ;\ |
l.add r3,r0,reg2 ;\ |
l.j 12f ;\ |
l.nop NOP_REPORT ;\ |
;\ |
/* Both registers passed */ ;\ |
11: ;\ |
POP (reg1) /* Discard the registers */ ;\ |
POP (reg2) /* Discard the registers */ ;\ |
l.jal _pok /* Test succeeded */ ;\ |
l.nop ;\ |
12: |
|
/* ---------------------------------------------------------------------------- |
* Macro to report 0xdeaddead and then terminate |
* ------------------------------------------------------------------------- */ |
#define TEST_EXIT \ |
/test-code-or1k/inst-set-test/is-div-test.S
23,22 → 23,7
*/ |
|
/* ---------------------------------------------------------------------------- |
* Coding conventions |
* |
* A simple rising stack is provided starting at _stack and pointed to by |
* r1. r1 points to the next free word. Only 32-bit registers may be pushed |
* onto the stack. |
* |
* Local labels up to 49 are reserved for macros. Each is used only once in |
* all macros. You can get in a serious mess if you get local label clashing |
* in macros. |
* |
* Arguments to functions are passed in r3 through r8. |
* r9 is the link (return address) |
* r11 is for returning results |
* |
* Only r1 and r2 are preserved across function calls. It is up to the callee |
* to save any other registers required. |
* Coding conventions are described in inst-set-test.S |
* ------------------------------------------------------------------------- */ |
|
/* ---------------------------------------------------------------------------- |
/test-code-or1k/inst-set-test/is-lws-test.S
23,22 → 23,7
*/ |
|
/* ---------------------------------------------------------------------------- |
* Coding conventions |
* |
* A simple rising stack is provided starting at _stack and pointed to by |
* r1. r1 points to the next free word. Only 32-bit registers may be pushed |
* onto the stack. |
* |
* Local labels up to 49 are reserved for macros. Each is used only once in |
* all macros. You can get in a serious mess if you get local label clashing |
* in macros. |
* |
* Arguments to functions are passed in r3 through r8. |
* r9 is the link (return address) |
* r11 is for returning results |
* |
* Only r1 and r2 are preserved across function calls. It is up to the callee |
* to save any other registers required. |
* Coding conventions are described in inst-set-test.S |
* ------------------------------------------------------------------------- */ |
|
/* ---------------------------------------------------------------------------- |
/test-code-or1k/ChangeLog
1,3 → 1,16
2010-06-11 Jeremy Bennett <jeremy.bennett@embecosm.com> |
* inst-set-test/inst-set-test.h: Calling conventions updated. |
<CHECK_RES2>: New macro created. |
<PUTS>: New macro created. |
<PUTH>: New macro created. |
* inst-set-test/inst-set-test.S: New calling convention |
implemented throughout. |
(puth): Created. |
* inst-set-test/is-mac-test.S: Created. |
* inst-set-test/Makefile.am: Updated for new tests |
* inst-set-test/Makefile.in: Regenerated. |
* mul/mul.c: Corrected expected results. |
|
2010-06-10 Jeremy Bennett <jeremy.bennett@embecosm.com> |
* inst-set-test/is-add-test.S: Commenting corrected. |
* inst-set-test/is-find-test.S: Created. |
/test-code-or1k/mul/mul.c
30,8 → 30,8
#include "support.h" |
|
#define T1 0xa6312f33 |
#define T2 0x0d4de375 |
#define T3 0x61ab48dc |
#define T2 0x059b8f08 |
#define T3 0x00000000 |
|
#define MAC(x,y) asm volatile ("l.mac\t%0,%1" : : "r" (x), "r" (y)) |
#define MACRC macrc() |
/or1ksim.tests/inst-set-test.exp
283,3 → 283,220
"!report(0xdeaddead);" \ |
"!exit(0)"] \ |
"inst-set-test.cfg" "inst-set-test/is-lws-test" |
|
# Run the l.mac test |
run_or1ksim "mac-test" \ |
[list "!l.mac" \ |
" 0x00000000 00000000 + 0x00000002 * 0x00000003 = 0x00000000 00000006: OK" \ |
" 0x00000000 00000006 + 0x00000002 * 0x00000003 = 0x00000000 0000000c: OK" \ |
" 0x00000000 fffffffa + 0x00000002 * 0x00000003 = 0x00000001 00000000: OK" \ |
" 0x3fffffff fffffffa + 0x00000002 * 0x00000003 = 0x40000000 00000000: OK" \ |
" 0xffffffff fffffffa + 0x00000002 * 0x00000003 = 0x00000000 00000000: OK" \ |
" 0xffffffff 00000000 + 0x00000002 * 0x00000003 = 0xffffffff 00000006: OK" \ |
" 0x80000000 00000000 + 0x00000002 * 0x00000003 = 0x80000000 00000006: OK" \ |
"!" \ |
" 0x00000000 00000000 + 0x00008001 * 0x0000fffe = 0x00000000 7ffffffe: OK" \ |
" 0x00000000 00000002 + 0x00008001 * 0x0000fffe = 0x00000000 80000000: OK" \ |
" 0x00000000 80000002 + 0x00008001 * 0x0000fffe = 0x00000001 00000000: OK" \ |
" 0x7fffffff 80000001 + 0x00008001 * 0x0000fffe = 0x7fffffff ffffffff: OK" \ |
" 0xffffffff ffffffff + 0x00008001 * 0x0000fffe = 0x00000000 7ffffffd: OK" \ |
" 0xffffffff 80000002 + 0x00008001 * 0x0000fffe = 0x00000000 00000000: OK" \ |
" 0xfffffffe 80000002 + 0x00008001 * 0x0000fffe = 0xffffffff 00000000: OK" \ |
"!" \ |
" 0x00000000 00000000 + 0xfffffffe * 0xfffffffd = 0x00000000 00000006: OK" \ |
" 0x00000000 00000006 + 0xfffffffe * 0xfffffffd = 0x00000000 0000000c: OK" \ |
" 0xffffffff ffffffff + 0xfffffffe * 0xfffffffd = 0x00000000 00000005: OK" \ |
"!" \ |
" 0x00000000 00000000 + 0x00000002 * 0xfffffffd = 0xffffffff fffffffa: OK" \ |
" 0x00000000 0000000c + 0x00000002 * 0xfffffffd = 0x00000000 00000006: OK" \ |
" 0x00000001 00000005 + 0x00000002 * 0xfffffffd = 0x00000000 ffffffff: OK" \ |
" 0x7fffffff ffffffff + 0x00000002 * 0xfffffffd = 0x7fffffff fffffff9: OK" \ |
" 0xffffffff ffffffff + 0x00000002 * 0xfffffffd = 0xffffffff fffffff9: OK" \ |
" 0xffffffff 00000005 + 0x00000002 * 0xfffffffd = 0xfffffffe ffffffff: OK" \ |
" 0x80000000 00000006 + 0x00000002 * 0xfffffffd = 0x80000000 00000000: OK" \ |
"!" \ |
" 0x00000000 00000000 + 0x00008000 * 0xffff0000 = 0xffffffff 80000000: OK" \ |
" 0x00000000 00000006 + 0x00008000 * 0xffff0000 = 0xffffffff 80000006: OK" \ |
" 0x00000000 80000000 + 0x00008000 * 0xffff0000 = 0x00000000 00000000: OK" \ |
" 0x7fffffff ffffffff + 0x00008000 * 0xffff0000 = 0x7fffffff 7fffffff: OK" \ |
" 0xffffffff ffffffff + 0x00008000 * 0xffff0000 = 0xffffffff 7fffffff: OK" \ |
" 0xffffffff 7fffffff + 0x00008000 * 0xffff0000 = 0xfffffffe ffffffff: OK" \ |
" 0x80000000 80000000 + 0x00008000 * 0xffff0000 = 0x80000000 00000000: OK" \ |
"!" \ |
"l.maci" \ |
" 0x00000000 00000000 + 0x00000002 * 0x00000003 = 0x00000000 00000006: OK" \ |
" 0x00000000 00000006 + 0x00000002 * 0x00000003 = 0x00000000 0000000c: OK" \ |
" 0x00000000 fffffffa + 0x00000002 * 0x00000003 = 0x00000001 00000000: OK" \ |
" 0x3fffffff fffffffa + 0x00000002 * 0x00000003 = 0x40000000 00000000: OK" \ |
" 0xffffffff fffffffa + 0x00000002 * 0x00000003 = 0x00000000 00000000: OK" \ |
" 0xffffffff 00000000 + 0x00000002 * 0x00000003 = 0xffffffff 00000006: OK" \ |
" 0x80000000 00000000 + 0x00000002 * 0x00000003 = 0x80000000 00000006: OK" \ |
"!" \ |
" 0x00000000 00000000 + 0x00010002 * 0x00007fff = 0x00000000 7ffffffe: OK" \ |
" 0x00000000 00000002 + 0x00010002 * 0x00007fff = 0x00000000 80000000: OK" \ |
" 0x00000000 80000002 + 0x00010002 * 0x00007fff = 0x00000001 00000000: OK" \ |
" 0x7fffffff 80000001 + 0x00010002 * 0x00007fff = 0x7fffffff ffffffff: OK" \ |
" 0xffffffff ffffffff + 0x00010002 * 0x00007fff = 0x00000000 7ffffffd: OK" \ |
" 0xffffffff 80000002 + 0x00010002 * 0x00007fff = 0x00000000 00000000: OK" \ |
" 0xfffffffe 80000002 + 0x00010002 * 0x00007fff = 0xffffffff 00000000: OK" \ |
"!" \ |
" 0x00000000 00000000 + 0xfffffffe * 0x0000fffd = 0x00000000 00000006: OK" \ |
" 0x00000000 00000006 + 0xfffffffe * 0x0000fffd = 0x00000000 0000000c: OK" \ |
" 0xffffffff ffffffff + 0xfffffffe * 0x0000fffd = 0x00000000 00000005: OK" \ |
"!" \ |
" 0x00000000 00000000 + 0x00000002 * 0x0000fffd = 0xffffffff fffffffa: OK" \ |
" 0x00000000 0000000c + 0x00000002 * 0x0000fffd = 0x00000000 00000006: OK" \ |
" 0x00000001 00000005 + 0x00000002 * 0x0000fffd = 0x00000000 ffffffff: OK" \ |
" 0x7fffffff ffffffff + 0x00000002 * 0x0000fffd = 0x7fffffff fffffff9: OK" \ |
" 0xffffffff ffffffff + 0x00000002 * 0x0000fffd = 0xffffffff fffffff9: OK" \ |
" 0xffffffff 00000005 + 0x00000002 * 0x0000fffd = 0xfffffffe ffffffff: OK" \ |
" 0x80000000 00000006 + 0x00000002 * 0x0000fffd = 0x80000000 00000000: OK" \ |
"!" \ |
" 0x00000000 00000000 + 0x00010000 * 0x00008000 = 0xffffffff 80000000: OK" \ |
" 0x00000000 00000006 + 0x00010000 * 0x00008000 = 0xffffffff 80000006: OK" \ |
" 0x00000000 80000000 + 0x00010000 * 0x00008000 = 0x00000000 00000000: OK" \ |
" 0x7fffffff ffffffff + 0x00010000 * 0x00008000 = 0x7fffffff 7fffffff: OK" \ |
" 0xffffffff ffffffff + 0x00010000 * 0x00008000 = 0xffffffff 7fffffff: OK" \ |
" 0xffffffff 7fffffff + 0x00010000 * 0x00008000 = 0xfffffffe ffffffff: OK" \ |
" 0x80000000 80000000 + 0x00010000 * 0x00008000 = 0x80000000 00000000: OK" \ |
"!" \ |
"l.macrc" \ |
" 0x00000000 00000000 + 0x00000002 * 0x00000003 = 0x00000006: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0x00000000 00000006 + 0x00000002 * 0x00000003 = 0x0000000c: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0x00000000 fffffffa + 0x00000002 * 0x00000003 = 0x00000000: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0x3fffffff fffffffa + 0x00000002 * 0x00000003 = 0x00000000: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0xffffffff fffffffa + 0x00000002 * 0x00000003 = 0x00000000: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0xffffffff 00000000 + 0x00000002 * 0x00000003 = 0x00000006: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0x80000000 00000000 + 0x00000002 * 0x00000003 = 0x00000006: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
"!" \ |
" 0x00000000 00000000 + 0x00008001 * 0x0000fffe = 0x7ffffffe: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0x00000000 00000002 + 0x00008001 * 0x0000fffe = 0x80000000: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0x00000000 80000002 + 0x00008001 * 0x0000fffe = 0x00000000: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0x7fffffff 80000001 + 0x00008001 * 0x0000fffe = 0xffffffff: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0xffffffff ffffffff + 0x00008001 * 0x0000fffe = 0x7ffffffd: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0xffffffff 80000002 + 0x00008001 * 0x0000fffe = 0x00000000: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0xfffffffe 80000002 + 0x00008001 * 0x0000fffe = 0x00000000: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
"!" \ |
" 0x00000000 00000000 + 0xfffffffe * 0xfffffffd = 0x00000006: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0x00000000 00000006 + 0xfffffffe * 0xfffffffd = 0x0000000c: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0xffffffff ffffffff + 0xfffffffe * 0xfffffffd = 0x00000005: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
"!" \ |
" 0x00000000 00000000 + 0x00000002 * 0xfffffffd = 0xfffffffa: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0x00000000 0000000c + 0x00000002 * 0xfffffffd = 0x00000006: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0x00000001 00000005 + 0x00000002 * 0xfffffffd = 0xffffffff: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0x7fffffff ffffffff + 0x00000002 * 0xfffffffd = 0xfffffff9: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0xffffffff ffffffff + 0x00000002 * 0xfffffffd = 0xfffffff9: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0xffffffff 00000005 + 0x00000002 * 0xfffffffd = 0xffffffff: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0x80000000 00000006 + 0x00000002 * 0xfffffffd = 0x00000000: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
"!" \ |
" 0x00000000 00000000 + 0x00008000 * 0xffff0000 = 0x80000000: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0x00000000 00000006 + 0x00008000 * 0xffff0000 = 0x80000006: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0x00000000 80000000 + 0x00008000 * 0xffff0000 = 0x00000000: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0x7fffffff ffffffff + 0x00008000 * 0xffff0000 = 0x7fffffff: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0xffffffff ffffffff + 0x00008000 * 0xffff0000 = 0x7fffffff: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0xffffffff 7fffffff + 0x00008000 * 0xffff0000 = 0xffffffff: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
" 0x80000000 80000000 + 0x00008000 * 0xffff0000 = 0x00000000: OK" \ |
" - MACHI cleared" \ |
" - MACLO cleared" \ |
"!" \ |
"l.msb" \ |
" 0x00000000 00000000 - 0x00000002 * 0x00000003 = 0xffffffff fffffffa: OK" \ |
" 0x00000000 0000000c - 0x00000002 * 0x00000003 = 0x00000000 00000006: OK" \ |
" 0x00000001 00000000 - 0x00000002 * 0x00000003 = 0x00000000 fffffffa: OK" \ |
" 0x40000000 00000000 - 0x00000002 * 0x00000003 = 0x3fffffff fffffffa: OK" \ |
" 0xffffffff fffffffa - 0x00000002 * 0x00000003 = 0xffffffff fffffff4: OK" \ |
" 0xffffffff 00000005 - 0x00000002 * 0x00000003 = 0xfffffffe ffffffff: OK" \ |
" 0x80000000 00000006 - 0x00000002 * 0x00000003 = 0x80000000 00000000: OK" \ |
"!" \ |
" 0x00000000 00000000 - 0x00008001 * 0x0000fffe = 0xffffffff 80000002: OK" \ |
" 0x00000000 00000002 - 0x00008001 * 0x0000fffe = 0xffffffff 80000004: OK" \ |
" 0x00000000 80000002 - 0x00008001 * 0x0000fffe = 0x00000000 00000004: OK" \ |
" 0x7fffffff 7ffffffd - 0x00008001 * 0x0000fffe = 0x7ffffffe ffffffff: OK" \ |
" 0xffffffff ffffffff - 0x00008001 * 0x0000fffe = 0xffffffff 80000001: OK" \ |
" 0xffffffff 80000002 - 0x00008001 * 0x0000fffe = 0xffffffff 00000004: OK" \ |
" 0xfffffffe 80000002 - 0x00008001 * 0x0000fffe = 0xfffffffe 00000004: OK" \ |
"!" \ |
" 0x00000000 00000006 - 0xfffffffe * 0xfffffffd = 0x00000000 00000000: OK" \ |
" 0x00000000 0000000c - 0xfffffffe * 0xfffffffd = 0x00000000 00000006: OK" \ |
" 0xffffffff ffffffff - 0xfffffffe * 0xfffffffd = 0xffffffff fffffff9: OK" \ |
"!" \ |
" 0x00000000 00000000 - 0x00000002 * 0xfffffffd = 0x00000000 00000006: OK" \ |
" 0x00000000 00000006 - 0x00000002 * 0xfffffffd = 0x00000000 0000000c: OK" \ |
" 0x00000000 ffffffff - 0x00000002 * 0xfffffffd = 0x00000001 00000005: OK" \ |
" 0x7fffffff fffffff9 - 0x00000002 * 0xfffffffd = 0x7fffffff ffffffff: OK" \ |
" 0xffffffff fffffff9 - 0x00000002 * 0xfffffffd = 0xffffffff ffffffff: OK" \ |
" 0xfffffffe ffffffff - 0x00000002 * 0xfffffffd = 0xffffffff 00000005: OK" \ |
" 0x80000000 00000000 - 0x00000002 * 0xfffffffd = 0x80000000 00000006: OK" \ |
"!" \ |
" 0x00000000 00000000 - 0x00008000 * 0xffff0000 = 0x00000000 80000000: OK" \ |
" 0x00000000 00000006 - 0x00008000 * 0xffff0000 = 0x00000000 80000006: OK" \ |
" 0x00000000 80000000 - 0x00008000 * 0xffff0000 = 0x00000001 00000000: OK" \ |
" 0x7fffffff 7fffffff - 0x00008000 * 0xffff0000 = 0x7fffffff ffffffff: OK" \ |
" 0xffffffff ffffffff - 0x00008000 * 0xffff0000 = 0x00000000 7fffffff: OK" \ |
" 0xfffffffe ffffffff - 0x00008000 * 0xffff0000 = 0xffffffff 7fffffff: OK" \ |
" 0x80000000 00000000 - 0x00008000 * 0xffff0000 = 0x80000000 80000000: OK" \ |
"!" \ |
"!Test completed" \ |
"!report(0xdeaddead);" \ |
"!exit(0)"] \ |
"inst-set-test.cfg" "inst-set-test/is-mac-test" |
/or1ksim.tests/mul.exp
27,10 → 27,10
# Run the multiplication test |
run_or1ksim "mul" \ |
[list "00000000" \ |
"70a2588c" \ |
"cac28a17" \ |
"a6312f33, expected a6312f33" \ |
"0d4de375, expected 0d4de375" \ |
"61ab48dc, expected 61ab48dc" \ |
"059b8f08, expected 059b8f08" \ |
"00000000, expected 00000000" \ |
"!report(0xdeaddead);" \ |
"!Test succesful." \ |
"!exit(0)"] \ |
/ChangeLog
1,3 → 1,8
2010-06-11 Jeremy Bennett <jeremy.bennett@embecosm.com> |
* or1ksim.tests/inst-set-test.exp: Added MAC tests. |
* or1ksim.tests/mul.exp: Corrected erroneous expected results. |
* README: Updated with new tests. |
|
2010-06-10 Jeremy Bennett <jeremy.bennett@embecosm.com> |
* or1ksim.tests/inst-set-test.exp: Added find tests. |
* README: Updated with new tests. |
/README
12,9 → 12,9
Tests are provided for the standalone simulator (or1ksim) and for the library |
(libsim.a). |
|
At the time of writing a total of 1,261 tests compile, run and pass. That |
figure is broken down into 997 tests of the standalone simulator and 264 tests |
of the library |
At the time of writing a total of 1,450 tests compile, run and pass. That |
figure is broken down into 1,186 tests of the standalone simulator and 264 |
tests of the library |
|
Configuration and make files are provided for further test programs. These |
come in three categories. |
46,7 → 46,7
Working tests |
============= |
|
A total of 997 tests of standalone Or1ksim: |
A total of 1,186 tests of standalone Or1ksim: |
|
basic: 8 tests of a wide range of instructions and registers. |
cache: 5 tests of the Or1ksim cache modeling |
70,6 → 70,7
is-div-test: 4 tests of the l.div and l.divu instructions (Bug 1770). |
is-find-test: 14 tests of the l.ff1 and l.fl1 instructions (Bug 1772). |
is-lws-test: 13 tests of the l.lws instruction (Bug 1767). |
is-mac-test: 189 tests of the MAC instructions (Bug 1773). |
mem-test: 16 tests of simple memory access. |
mmu: 110 tests of the MMU. |
mul: 5 tests of the multiply functionality. |