RPCS3/ps3autotests
1
0
Fork 0
mirror of https://github.com/RPCS3/ps3autotests.git synced 2024-11-08 11:52:58 +01:00
Code Issues Projects Releases Wiki Activity

Merge pull request #2 from danilaml/prepare-new-tests

Browse Source 
Added tests from @AlexAltea
This commit is contained in:
Ani 2017-09-06 22:26:22 +01:00 committed by GitHub
commit a4c2be9c5e
60 changed files with 59977 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
run-tests.py Normal file
View File

@ -0,0 +1,108 @@
#!/usr/bin/python
import os
import ntpath
import sys
import subprocess
# Constants
OUTPUT_STDOUT = 0 # All output is obtained through stdout. Isn't used by rpcs3.
OUTPUT_FILE = 1 # The test generates a file called 'output.txt'
OUTPUT_TTYLOG = 2 # rpcs3 saves ps3 stdout into TTY.log near executable
COMPARE_BIN = 0 # Output is validated byte per byte
COMPARE_TEXT = 1 # Output is validated as text, replacing CRLF with LF
COMPARE_SMART = 2 # Output is validated following rules specified below
# Absolute path to this script
scriptFolder = os.path.dirname(os.path.realpath(__file__))
# List of tests and benchmarks
autotests = (
('tests/cpu/basic', OUTPUT_TTYLOG, COMPARE_TEXT),
('tests/cpu/ppu_branch', OUTPUT_FILE, COMPARE_TEXT),
('tests/cpu/ppu_float_arithmetic', OUTPUT_FILE, COMPARE_TEXT),
('tests/cpu/ppu_float_compare', OUTPUT_FILE, COMPARE_TEXT),
('tests/cpu/ppu_float_conversion', OUTPUT_FILE, COMPARE_TEXT),
('tests/cpu/ppu_float_load', OUTPUT_FILE, COMPARE_TEXT),
('tests/cpu/ppu_float_store', OUTPUT_FILE, COMPARE_TEXT),
# ('tests/cpu/ppu_gpr', OUTPUT_TTYLOG, COMPARE_TEXT), takes too long
('tests/cpu/ppu_integer_arithmetic', OUTPUT_FILE, COMPARE_TEXT),
('tests/cpu/ppu_integer_compare', OUTPUT_FILE, COMPARE_TEXT),
('tests/cpu/ppu_integer_logical', OUTPUT_FILE, COMPARE_TEXT),
('tests/cpu/ppu_integer_rotate', OUTPUT_FILE, COMPARE_TEXT),
('tests/cpu/ppu_integer_shift', OUTPUT_FILE, COMPARE_TEXT),
('tests/cpu/ppu_vector_integer_arithmetic', OUTPUT_FILE, COMPARE_TEXT),
# ('tests/cpu/ppu_vpu', OUTPUT_TTYLOG, COMPARE_TEXT),
# ('tests/cpu/spu_alu', OUTPUT_TTYLOG, COMPARE_TEXT), .expected isn't correct
# ('tests/cpu/spu_fpu', OUTPUT_TTYLOG, COMPARE_TEXT), .expected isn't correct
# ('tests/cpu/spu_generic', OUTPUT_TTYLOG, COMPARE_TEXT),
('tests/lv2/sys_event_flag', OUTPUT_TTYLOG, COMPARE_TEXT),
('tests/lv2/sys_process', OUTPUT_TTYLOG, COMPARE_TEXT),
('tests/lv2/sys_semaphore', OUTPUT_TTYLOG, COMPARE_TEXT),
)
# Main
def runTests(emulator, baseDir):
errors = False
# Run tests
for test in autotests:
# Parameters
relProjectFolder = test[0]
absProjectFolder = os.path.join(scriptFolder, relProjectFolder)
projectName = ntpath.basename(relProjectFolder)
elfPath = os.path.join(absProjectFolder, projectName) + '.ppu.self'
if (not os.path.isfile(elfPath)):
elfPath = os.path.join(absProjectFolder, projectName) + '.ppu.elf'
expectedPath = os.path.join(absProjectFolder, projectName) + '.expected'
outputPath = os.path.join(absProjectFolder, 'output.txt')
ttyPath = os.path.join(os.path.dirname(emulator),"TTY.log")
outputMethod = test[1]
compareMethod = test[2]
# Command & Expected file
cmd = emulator + ' ' + os.path.join(baseDir, elfPath)
expected = open(os.path.join(baseDir, expectedPath), 'rb')
# Get output
if outputMethod == OUTPUT_STDOUT:
result = subprocess.check_output(cmd, shell=True)
if outputMethod == OUTPUT_FILE:
subprocess.check_output(cmd, shell=True);
result = open(outputPath, 'rb').read()
if outputMethod == OUTPUT_TTYLOG:
subprocess.check_output(cmd, shell=True);
result = open(ttyPath, 'rb').read()
# Compare output
if compareMethod == COMPARE_TEXT:
result = result.replace('\r\n', '\n')
if result == expected.read():
print " - Success: ", relProjectFolder
else:
print " - Error: ", relProjectFolder
errors = True
# Delete output file if necessary
if outputMethod == OUTPUT_FILE:
os.remove(outputPath)
# Return errors
if errors:
print "Some tests failed!"
exit(1)
else:
print "All tests succeeded!"
exit(0)
if __name__ == '__main__':
if len(sys.argv) <= 1:
print 'PS3 Autotests: Tests, benchmarks and demos for emulators'
print 'Usage: run-tests.py [arguments] path/to/emulator.exe'
print 'Arguments: (none available)'
else:
baseDir = os.path.dirname(os.path.abspath(__file__)).replace('\\', '/')
emulator = sys.argv[len(sys.argv) - 1]
runTests(emulator, baseDir)

12
tests/cpu/basic/basic.cpp Normal file
View File

@ -0,0 +1,12 @@
/**
* (c) 2015 Alexandro Sanchez Bach. All rights reserved.
* Released under GPL v2 license. Read LICENSE for more details.
*/
#include <stdio.h>
int main(void)
{
printf("Hello World!\n");
return 0;
}

0
tests/cpu/hello_world/hello_world.expected → tests/cpu/basic/basic.expected
View File

BIN
tests/cpu/basic/basic.ppu.elf Normal file
View File

Binary file not shown.

BIN
tests/cpu/basic/basic.ppu.self Normal file
View File

Binary file not shown.

7
tests/cpu/hello_world/hello_world.cpp
View File

@ -1,7 +0,0 @@
#include <stdio.h>
int main(void)
{
printf("Hello World!\n");
return 0;
}

BIN
tests/cpu/hello_world/hello_world.ppu.elf
View File

Binary file not shown.

90
tests/cpu/ppu_branch/ppu_branch.cpp Normal file
View File

@ -0,0 +1,90 @@
/**
* (c) 2015 Alexandro Sanchez Bach. All rights reserved.
* Released under GPL v2 license. Read LICENSE for more details.
*/
#include <stdio.h>
#include "../../../common/output.h"
#define TEST_BRANCH(branch) { \
uint32_t branched = 0; \
__asm__ ( \
" xor %0, %0, %0; " \
branch "1f; " \
" xori %0, %0, 0x1; " \
"1: xori %0, %0, 0x1; " \
: "=r"(branched)); \
fprintf(handler, branch " -> %d\n", branched); \
}
#define TEST_BRANCH_COND(branch, values) \
for (uint32_t i = 0; i < sizeof(values)/sizeof(values[0]); i++) { \
uint32_t branched = 0; \
__asm__ ( \
" mtcr %1; " \
" xor %0, %0, %0; " \
branch ", 1f; " \
" xori %0, %0, 0x1; " \
"1: xori %0, %0, 0x1; " \
: "=r"(branched) : "r"(values[i])); \
fprintf(handler, branch "[%08X] -> %d\n", values[i], branched); \
}
#define TEST_BRANCH_CONDS(suffix, reg, values) \
TEST_BRANCH_COND("beq" suffix " " reg, values); \
TEST_BRANCH_COND("bge" suffix " " reg, values); \
TEST_BRANCH_COND("bgt" suffix " " reg, values); \
TEST_BRANCH_COND("ble" suffix " " reg, values); \
TEST_BRANCH_COND("blt" suffix " " reg, values); \
TEST_BRANCH_COND("bnl" suffix " " reg, values); \
TEST_BRANCH_COND("bne" suffix " " reg, values); \
TEST_BRANCH_COND("bng" suffix " " reg, values); \
TEST_BRANCH_COND("bns" suffix " " reg, values); \
TEST_BRANCH_COND("bnu" suffix " " reg, values); \
TEST_BRANCH_COND("bso" suffix " " reg, values); \
TEST_BRANCH_COND("bun" suffix " " reg, values);
// CR0
uint32_t cr0Values[] = {
0x00000000, 0x10000000, 0x20000000, 0x30000000, // 0 1 2 3
0x40000000, 0x50000000, 0x60000000, 0x70000000, // 4 5 6 7
0x80000000, 0x90000000, 0xA0000000, 0xB0000000, // 8 9 10 11
0xC0000000, 0xD0000000, 0xE0000000, 0xF0000000, // 12 13 14 15
};
// CR6
uint32_t cr6Values[] = {
0x00000000, 0x00000010, 0x00000020, 0x00000030, // 0 1 2 3
0x00000040, 0x00000050, 0x00000060, 0x00000070, // 4 5 6 7
0x00000080, 0x00000090, 0x000000A0, 0x000000B0, // 8 9 10 11
0x000000C0, 0x000000D0, 0x000000E0, 0x000000F0, // 12 13 14 15
};
// CR7
uint32_t cr7Values[] = {
0x00000000, 0x00000001, 0x00000002, 0x00000003, // 0 1 2 3
0x00000004, 0x00000005, 0x00000006, 0x00000007, // 4 5 6 7
0x00000008, 0x00000009, 0x0000000A, 0x0000000B, // 8 9 10 11
0x0000000C, 0x0000000D, 0x0000000E, 0x0000000F, // 12 13 14 15
};
int main(void)
{
FILE* handler = fopen("/app_home/" OUTPUT_FILE, "wb");
// Branch Instructions
TEST_BRANCH("b ");
TEST_BRANCH("bl ");
TEST_BRANCH_CONDS(" ", "cr0", cr0Values);
TEST_BRANCH_CONDS(" ", "cr6", cr6Values);
TEST_BRANCH_CONDS(" ", "cr7", cr7Values);
TEST_BRANCH_CONDS("+", "cr0", cr0Values);
TEST_BRANCH_CONDS("+", "cr6", cr6Values);
TEST_BRANCH_CONDS("+", "cr7", cr7Values);
TEST_BRANCH_CONDS("-", "cr0", cr0Values);
TEST_BRANCH_CONDS("-", "cr6", cr6Values);
TEST_BRANCH_CONDS("-", "cr7", cr7Values);
return 0;
}

1730
tests/cpu/ppu_branch/ppu_branch.expected Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
tests/cpu/ppu_branch/ppu_branch.ppu.elf Normal file
View File

Binary file not shown.

BIN
tests/cpu/ppu_branch/ppu_branch.ppu.self Normal file
View File

Binary file not shown.

159
tests/cpu/ppu_float_arithmetic/ppu_float_arithmetic.cpp Normal file
View File

@ -0,0 +1,159 @@
/**
* (c) 2015 Alexandro Sanchez Bach. All rights reserved.
* Released under GPL v2 license. Read LICENSE for more details.
*/
#include <float.h>
#include <math.h>
#include <stdio.h>
#include "../../../common/output.h"
// Show results
#define PRINT1(name, i, FPR) \
fprintf(handler, name"([%02d]) -> %016llX [%08X : %08X]\n", i, *(uint64_t*)&FPR, getFPSCR(), getCR());
#define PRINT2(name, i, j, FPR) \
fprintf(handler, name"([%02d],[%02d]) -> %016llX [%08X : %08X]\n", i, j, *(uint64_t*)&FPR, getFPSCR(), getCR());
#define PRINT3(name, i, j, k, FPR) \
fprintf(handler, name"([%02d],[%02d],[%02d]) -> %016llX [%08X : %08X]\n", i, j, k, *(uint64_t*)&FPR, getFPSCR(), getCR());
#define PRINT4(name, i, j, k, l, FPR) \
fprintf(handler, name"([%02d],[%02d],[%02d],[%02d]) -> %016llX [%08X : %08X]\n", i, j, k, l, *(uint64_t*)&FPR, getFPSCR(), getCR());
// Array sizes
#define TESTSIZEF (sizeof(testFloats)/sizeof(float))
#define TESTSIZED (sizeof(testDoubles)/sizeof(double))
// Loops with floats
#define ITERATE1F(x) \
for (uint32_t i = 0; i < TESTSIZEF; i++) \
{float f0, f1=testFloats[i]; clearCR(); clearFPSCR(); x;}
#define ITERATE2F(x) \
for (uint32_t i = 0; i < TESTSIZEF; i++) \
for (uint32_t j = 0; j < TESTSIZEF; j++) \
{float f0, f1=testFloats[i], f2=testFloats[j]; clearCR(); clearFPSCR(); x;}
#define ITERATE3F(x) \
for (uint32_t i = 0; i < TESTSIZEF; i++) \
for (uint32_t j = 0; j < TESTSIZEF; j++) \
{float f0, f1=testFloats[i], f2=testFloats[j], f3=testFloats[(i+j)%TESTSIZEF]; clearCR(); clearFPSCR(); x;}
// Loops with doubles
#define ITERATE1D(x) \
for (uint32_t i = 0; i < TESTSIZED; i++) \
{double d0, d1=testDoubles[i]; clearCR(); clearFPSCR(); x;}
#define ITERATE2D(x) \
for (uint32_t i = 0; i < TESTSIZED; i++) \
for (uint32_t j = 0; j < TESTSIZED; j++) \
{double d0, d1=testDoubles[i], d2=testDoubles[j]; clearCR(); clearFPSCR(); x;}
#define ITERATE3D(x) \
for (uint32_t i = 0; i < TESTSIZED; i++) \
for (uint32_t j = 0; j < TESTSIZED; j++) \
{double d0, d1=testDoubles[i], d2=testDoubles[j], d3=testDoubles[(i+j)%TESTSIZED]; clearCR(); clearFPSCR(); x;}
// Get contents of the CR register
uint32_t getCR()
{
uint32_t CR;
__asm__ ("mfcr %0" : "=r"(CR));
return CR;
};
// Get contents of the FPSCR register
uint32_t getFPSCR()
{
double FPSCR = 0.0;
__asm__ ("mffs %0" : "=f"(FPSCR));
return ((uint32_t*)&FPSCR)[1];
};
// Clear CR register
void clearCR()
{
uint32_t CR = 0;
__asm__ ("mtcr %0" : "=r"(CR));
};
// Clear FPSCR register
void clearFPSCR()
{
__asm__ ("mtfsfi 0, 0");
__asm__ ("mtfsfi 1, 0");
__asm__ ("mtfsfi 2, 0");
__asm__ ("mtfsfi 3, 0");
__asm__ ("mtfsfi 4, 0");
__asm__ ("mtfsfi 5, 0");
__asm__ ("mtfsfi 6, 0");
__asm__ ("mtfsfi 7, 0");
};
const float testFloats[] = {
0.0f, -0.0f, 1.0f, -1.0f, // 0 1 2 3
1.5f, -1.5f, 1.6f, -1.6f, // 4 5 6 7
1.4f, -1.4f, 2.0f, NAN, // 8 9 10 11
-10000000.4f, 20000000.0f, -20000.5f, 20000.6f, // 12 13 14 15
FLT_MIN, FLT_MAX, INFINITY, -INFINITY, // 16 17 18 19
};
const double testDoubles[] = {
0.0, -0.0, 1.0, -1.0, // 0 1 2 3
1.5, -1.5, 1.6, -1.6, // 4 5 6 7
1.4, -1.4, 2.0, NAN, // 8 9 10 11
-10000000.4, 20000000.0, -20000.5, 20000.6, // 12 13 14 15
DBL_MIN, DBL_MAX, INFINITY, -INFINITY, // 16 17 18 19
};
int main(void)
{
FILE* handler = fopen("/app_home/" OUTPUT_FILE, "wb");
// Floating-Point Arithmetic Instructions
ITERATE2D(__asm__ ("fadd %0,%1,%2" : "=f"(d0) : "f"(d1), "f"(d2)); PRINT2("fadd ",i,j,d0));
ITERATE2D(__asm__ ("fadd. %0,%1,%2" : "=f"(d0) : "f"(d1), "f"(d2)); PRINT2("fadd. ",i,j,d0));
ITERATE2F(__asm__ ("fadds %0,%1,%2" : "=f"(f0) : "f"(f1), "f"(f2)); PRINT2("fadds ",i,j,f0));
ITERATE2F(__asm__ ("fadds. %0,%1,%2" : "=f"(f0) : "f"(f1), "f"(f2)); PRINT2("fadds.",i,j,f0));
ITERATE2D(__asm__ ("fsub %0,%1,%2" : "=f"(d0) : "f"(d1), "f"(d2)); PRINT2("fsub ",i,j,d0));
ITERATE2D(__asm__ ("fsub. %0,%1,%2" : "=f"(d0) : "f"(d1), "f"(d2)); PRINT2("fsub. ",i,j,d0));
ITERATE2F(__asm__ ("fsubs %0,%1,%2" : "=f"(f0) : "f"(f1), "f"(f2)); PRINT2("fsubs ",i,j,f0));
ITERATE2F(__asm__ ("fsubs. %0,%1,%2" : "=f"(f0) : "f"(f1), "f"(f2)); PRINT2("fsubs.",i,j,f0));
ITERATE2D(__asm__ ("fmul %0,%1,%2" : "=f"(d0) : "f"(d1), "f"(d2)); PRINT2("fmul ",i,j,d0));
ITERATE2D(__asm__ ("fmul. %0,%1,%2" : "=f"(d0) : "f"(d1), "f"(d2)); PRINT2("fmul. ",i,j,d0));
ITERATE2F(__asm__ ("fmuls %0,%1,%2" : "=f"(f0) : "f"(f1), "f"(f2)); PRINT2("fmuls ",i,j,f0));
ITERATE2F(__asm__ ("fmuls. %0,%1,%2" : "=f"(f0) : "f"(f1), "f"(f2)); PRINT2("fmuls.",i,j,f0));
ITERATE2D(__asm__ ("fdiv %0,%1,%2" : "=f"(d0) : "f"(d1), "f"(d2)); PRINT2("fdiv ",i,j,d0));
ITERATE2D(__asm__ ("fdiv. %0,%1,%2" : "=f"(d0) : "f"(d1), "f"(d2)); PRINT2("fdiv. ",i,j,d0));
ITERATE2F(__asm__ ("fdivs %0,%1,%2" : "=f"(f0) : "f"(f1), "f"(f2)); PRINT2("fdivs ",i,j,f0));
ITERATE2F(__asm__ ("fdivs. %0,%1,%2" : "=f"(f0) : "f"(f1), "f"(f2)); PRINT2("fdivs.",i,j,f0));
ITERATE1D(__asm__ ("fsqrt %0,%1" : "=f"(d0) : "f"(d1)); PRINT1("fsqrt ",i,d0));
ITERATE1D(__asm__ ("fsqrt. %0,%1" : "=f"(d0) : "f"(d1)); PRINT1("fsqrt. ",i,d0));
ITERATE1F(__asm__ ("fsqrts %0,%1" : "=f"(f0) : "f"(f1)); PRINT1("fsqrts ",i,f0));
ITERATE1F(__asm__ ("fsqrts. %0,%1" : "=f"(f0) : "f"(f1)); PRINT1("fsqrts. ",i,f0));
ITERATE1F(__asm__ ("fres %0,%1" : "=f"(f0) : "f"(f1)); PRINT1("fres ",i,f0));
ITERATE1F(__asm__ ("fres. %0,%1" : "=f"(f0) : "f"(f1)); PRINT1("fres. ",i,f0));
ITERATE1D(__asm__ ("frsqrte %0,%1" : "=f"(d0) : "f"(d1)); PRINT1("frsqrte ",i,d0));
ITERATE1D(__asm__ ("frsqrte. %0,%1" : "=f"(d0) : "f"(d1)); PRINT1("frsqrte.",i,d0));
ITERATE3D(__asm__ ("fsel %0,%1,%2,%3" : "=f"(d0) : "f"(d1), "f"(d2), "f"(d3)); PRINT3("fsel ",i,j,(i+j)%TESTSIZED,d0));
ITERATE3D(__asm__ ("fsel. %0,%1,%2,%3" : "=f"(d0) : "f"(d1), "f"(d2), "f"(d3)); PRINT3("fsel. ",i,j,(i+j)%TESTSIZED,d0));
// Floating-Point Multiply-Add Instructions
ITERATE3D(__asm__ ("fmadd %0,%1,%2,%3" : "=f"(d0) : "f"(d1), "f"(d2), "f"(d3)); PRINT3("fmadd ",i,j,(i+j)%TESTSIZED,d0));
ITERATE3D(__asm__ ("fmadd. %0,%1,%2,%3" : "=f"(d0) : "f"(d1), "f"(d2), "f"(d3)); PRINT3("fmadd. ",i,j,(i+j)%TESTSIZED,d0));
ITERATE3F(__asm__ ("fmadds %0,%1,%2,%3" : "=f"(f0) : "f"(f1), "f"(f2), "f"(f3)); PRINT3("fmadds ",i,j,(i+j)%TESTSIZED,f0));
ITERATE3F(__asm__ ("fmadds. %0,%1,%2,%3" : "=f"(f0) : "f"(f1), "f"(f2), "f"(f3)); PRINT3("fmadds. ",i,j,(i+j)%TESTSIZED,f0));
ITERATE3D(__asm__ ("fmsub %0,%1,%2,%3" : "=f"(d0) : "f"(d1), "f"(d2), "f"(d3)); PRINT3("fmsub ",i,j,(i+j)%TESTSIZED,d0));
ITERATE3D(__asm__ ("fmsub. %0,%1,%2,%3" : "=f"(d0) : "f"(d1), "f"(d2), "f"(d3)); PRINT3("fmsub. ",i,j,(i+j)%TESTSIZED,d0));
ITERATE3F(__asm__ ("fmsubs %0,%1,%2,%3" : "=f"(f0) : "f"(f1), "f"(f2), "f"(f3)); PRINT3("fmsubs ",i,j,(i+j)%TESTSIZED,f0));
ITERATE3F(__asm__ ("fmsubs. %0,%1,%2,%3" : "=f"(f0) : "f"(f1), "f"(f2), "f"(f3)); PRINT3("fmsubs. ",i,j,(i+j)%TESTSIZED,f0));
ITERATE3D(__asm__ ("fnmadd %0,%1,%2,%3" : "=f"(d0) : "f"(d1), "f"(d2), "f"(d3)); PRINT3("fnmadd ",i,j,(i+j)%TESTSIZED,d0));
ITERATE3D(__asm__ ("fnmadd. %0,%1,%2,%3" : "=f"(d0) : "f"(d1), "f"(d2), "f"(d3)); PRINT3("fnmadd. ",i,j,(i+j)%TESTSIZED,d0));
ITERATE3F(__asm__ ("fnmadds %0,%1,%2,%3" : "=f"(f0) : "f"(f1), "f"(f2), "f"(f3)); PRINT3("fnmadds ",i,j,(i+j)%TESTSIZED,f0));
ITERATE3F(__asm__ ("fnmadds. %0,%1,%2,%3" : "=f"(f0) : "f"(f1), "f"(f2), "f"(f3)); PRINT3("fnmadds.",i,j,(i+j)%TESTSIZED,f0));
ITERATE3D(__asm__ ("fnmsub %0,%1,%2,%3" : "=f"(d0) : "f"(d1), "f"(d2), "f"(d3)); PRINT3("fnmsub ",i,j,(i+j)%TESTSIZED,d0));
ITERATE3D(__asm__ ("fnmsub. %0,%1,%2,%3" : "=f"(d0) : "f"(d1), "f"(d2), "f"(d3)); PRINT3("fnmsub. ",i,j,(i+j)%TESTSIZED,d0));
ITERATE3F(__asm__ ("fnmsubs %0,%1,%2,%3" : "=f"(f0) : "f"(f1), "f"(f2), "f"(f3)); PRINT3("fnmsubs ",i,j,(i+j)%TESTSIZED,f0));
ITERATE3F(__asm__ ("fnmsubs. %0,%1,%2,%3" : "=f"(f0) : "f"(f1), "f"(f2), "f"(f3)); PRINT3("fnmsubs.",i,j,(i+j)%TESTSIZED,f0));
return 0;
}

13760
tests/cpu/ppu_float_arithmetic/ppu_float_arithmetic.expected Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
tests/cpu/ppu_float_arithmetic/ppu_float_arithmetic.ppu.elf Normal file
View File

Binary file not shown.

BIN
tests/cpu/ppu_float_arithmetic/ppu_float_arithmetic.ppu.self Normal file
View File

Binary file not shown.

107
tests/cpu/ppu_float_compare/ppu_float_compare.cpp Normal file
View File

@ -0,0 +1,107 @@
/**
* (c) 2015 Alexandro Sanchez Bach. All rights reserved.
* Released under GPL v2 license. Read LICENSE for more details.
*/
#include <float.h>
#include <math.h>
#include <stdio.h>
#include "../../../common/output.h"
// Show results
#define PRINT1(name, i) \
fprintf(handler, name"([%02d]) -> [%08X : %08X]\n", i, getFPSCR(), getCR());
#define PRINT2(name, i, j) \
fprintf(handler, name"([%02d],[%02d]) -> [%08X : %08X]\n", i, j, getFPSCR(), getCR());
#define PRINT3(name, i, j, k) \
fprintf(handler, name"([%02d],[%02d],[%02d]) -> [%08X : %08X]\n", i, j, k, getFPSCR(), getCR());
// Array sizes
#define TESTSIZEF (sizeof(testFloats)/sizeof(float))
#define TESTSIZED (sizeof(testDoubles)/sizeof(double))
// Loops with floats
#define ITERATE1F(x) \
for (uint32_t i = 0; i < TESTSIZEF; i++) \
{float f0, f1=testFloats[i]; clearCR(); clearFPSCR(); x;}
#define ITERATE2F(x) \
for (uint32_t i = 0; i < TESTSIZEF; i++) \
for (uint32_t j = 0; j < TESTSIZEF; j++) \
{float f0, f1=testFloats[i], f2=testFloats[j]; clearCR(); clearFPSCR(); x;}
// Loops with doubles
#define ITERATE1D(x) \
for (uint32_t i = 0; i < TESTSIZED; i++) \
{double d0, d1=testDoubles[i]; clearCR(); clearFPSCR(); x;}
#define ITERATE2D(x) \
for (uint32_t i = 0; i < TESTSIZED; i++) \
for (uint32_t j = 0; j < TESTSIZED; j++) \
{double d0, d1=testDoubles[i], d2=testDoubles[j]; clearCR(); clearFPSCR(); x;}
// Get contents of the CR register
uint32_t getCR()
{
uint32_t CR;
__asm__ ("mfcr %0" : "=r"(CR));
return CR;
};
// Get contents of the FPSCR register
uint32_t getFPSCR()
{
double FPSCR = 0.0;
__asm__ ("mffs %0" : "=f"(FPSCR));
return ((uint32_t*)&FPSCR)[1];
};
// Clear CR register
void clearCR()
{
uint32_t CR = 0;
__asm__ ("mtcr %0" : "=r"(CR));
};
// Clear FPSCR register
void clearFPSCR()
{
__asm__ ("mtfsfi 0, 0");
__asm__ ("mtfsfi 1, 0");
__asm__ ("mtfsfi 2, 0");
__asm__ ("mtfsfi 3, 0");
__asm__ ("mtfsfi 4, 0");
__asm__ ("mtfsfi 5, 0");
__asm__ ("mtfsfi 6, 0");
__asm__ ("mtfsfi 7, 0");
};
const float testFloats[] = {
0.0f, -0.0f, 1.0f, -1.0f, // 0 1 2 3
1.5f, -1.5f, 1.6f, -1.6f, // 4 5 6 7
1.4f, -1.4f, 2.0f, NAN, // 8 9 10 11
-10000000.4f, 20000000.0f, -20000.5f, 20000.6f, // 12 13 14 15
FLT_MIN, FLT_MAX, INFINITY, -INFINITY, // 16 17 18 19
};
const double testDoubles[] = {
0.0, -0.0, 1.0, -1.0, // 0 1 2 3
1.5, -1.5, 1.6, -1.6, // 4 5 6 7
1.4, -1.4, 2.0, NAN, // 8 9 10 11
-10000000.4, 20000000.0, -20000.5, 20000.6, // 12 13 14 15
DBL_MIN, DBL_MAX, INFINITY, -INFINITY, // 16 17 18 19
};
int main(void)
{
FILE* handler = fopen("/app_home/" OUTPUT_FILE, "wb");
// Floating-Point Compare Instructions
ITERATE2D(__asm__ ("fcmpu 1,%1,%2\n" "mffs %0" : "=f"(d0) : "f"(d1), "f"(d2)); PRINT2("fcmpu ",i,j));
ITERATE2F(__asm__ ("fcmpu 1,%1,%2\n" "mffs %0" : "=f"(f0) : "f"(f1), "f"(f2)); PRINT2("fcmpu ",i,j));
ITERATE2D(__asm__ ("fcmpo 1,%1,%2\n" "mffs %0" : "=f"(d0) : "f"(d1), "f"(d2)); PRINT2("fcmpo ",i,j));
ITERATE2F(__asm__ ("fcmpo 1,%1,%2\n" "mffs %0" : "=f"(f0) : "f"(f1), "f"(f2)); PRINT2("fcmpo ",i,j));
return 0;
}

1600
tests/cpu/ppu_float_compare/ppu_float_compare.expected Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
tests/cpu/ppu_float_compare/ppu_float_compare.ppu.elf Normal file
View File

Binary file not shown.

BIN
tests/cpu/ppu_float_compare/ppu_float_compare.ppu.self Normal file
View File

Binary file not shown.

127
tests/cpu/ppu_float_conversion/ppu_float_conversion.cpp Normal file
View File

@ -0,0 +1,127 @@
/**
* (c) 2015 Alexandro Sanchez Bach. All rights reserved.
* Released under GPL v2 license. Read LICENSE for more details.
*/
#include <float.h>
#include <math.h>
#include <stdio.h>
#include "../../../common/output.h"
// Show results
#define PRINT1(name, i, FPR) \
fprintf(handler, name"([%02d]) -> %016llX [%08X : %08X]\n", i, *(uint64_t*)&FPR, getFPSCR(), getCR());
#define PRINT2(name, i, j, FPR) \
fprintf(handler, name"([%02d],[%02d]) -> %016llX [%08X : %08X]\n", i, j, *(uint64_t*)&FPR, getFPSCR(), getCR());
#define PRINT3(name, i, j, k, FPR) \
fprintf(handler, name"([%02d],[%02d],[%02d]) -> %016llX [%08X : %08X]\n", i, j, k, *(uint64_t*)&FPR, getFPSCR(), getCR());
// Array sizes
#define TESTSIZEF (sizeof(testFloats)/sizeof(float))
#define TESTSIZED (sizeof(testDoubles)/sizeof(double))
// Loops with floats
#define ITERATE1F(x) \
for (uint32_t i = 0; i < TESTSIZEF; i++) \
{float f0, f1=testFloats[i]; clearCR(); clearFPSCR(); x;}
#define ITERATE2F(x) \
for (uint32_t i = 0; i < TESTSIZEF; i++) \
for (uint32_t j = 0; j < TESTSIZEF; j++) \
{float f0, f1=testFloats[i], f2=testFloats[j]; clearCR(); clearFPSCR(); x;}
// Loops with doubles
#define ITERATE1D(x) \
for (uint32_t i = 0; i < TESTSIZED; i++) \
{double d0, d1=testDoubles[i]; clearCR(); clearFPSCR(); x;}
#define ITERATE2D(x) \
for (uint32_t i = 0; i < TESTSIZED; i++) \
for (uint32_t j = 0; j < TESTSIZED; j++) \
{double d0, d1=testDoubles[i], d2=testDoubles[j]; clearCR(); clearFPSCR(); x;}
// Get contents of the CR register
uint32_t getCR()
{
uint32_t CR;
__asm__ ("mfcr %0" : "=r"(CR));
return CR;
};
// Get contents of the FPSCR register
uint32_t getFPSCR()
{
double FPSCR = 0.0;
__asm__ ("mffs %0" : "=f"(FPSCR));
return ((uint32_t*)&FPSCR)[1];
};
// Clear CR register
void clearCR()
{
uint32_t CR = 0;
__asm__ ("mtcr %0" : "=r"(CR));
};
// Clear FPSCR register
void clearFPSCR()
{
__asm__ ("mtfsfi 0, 0");
__asm__ ("mtfsfi 1, 0");
__asm__ ("mtfsfi 2, 0");
__asm__ ("mtfsfi 3, 0");
__asm__ ("mtfsfi 4, 0");
__asm__ ("mtfsfi 5, 0");
__asm__ ("mtfsfi 6, 0");
__asm__ ("mtfsfi 7, 0");
};
const float testFloats[] = {
0.0f, -0.0f, 1.0f, -1.0f, // 0 1 2 3
1.5f, -1.5f, 1.6f, -1.6f, // 4 5 6 7
1.4f, -1.4f, 2.0f, NAN, // 8 9 10 11
-10000000.4f, 20000000.0f, -20000.5f, 20000.6f, // 12 13 14 15
FLT_MIN, FLT_MAX, INFINITY, -INFINITY, // 16 17 18 19
};
const double testDoubles[] = {
0.0, -0.0, 1.0, -1.0, // 0 1 2 3
1.5, -1.5, 1.6, -1.6, // 4 5 6 7
1.4, -1.4, 2.0, NAN, // 8 9 10 11
-10000000.4, 20000000.0, -20000.5, 20000.6, // 12 13 14 15
DBL_MIN, DBL_MAX, INFINITY, -INFINITY, // 16 17 18 19
};
int main(void)
{
FILE* handler = fopen("/app_home/" OUTPUT_FILE, "wb");
// Integer Arithmetic Instructions
ITERATE1D(__asm__ ("frsp %0,%1" : "=f"(d0) : "f"(d1)); PRINT1("frsp ",i,d0));
ITERATE1D(__asm__ ("frsp. %0,%1" : "=f"(d0) : "f"(d1)); PRINT1("frsp. ",i,d0));
ITERATE1F(__asm__ ("frsp %0,%1" : "=f"(f0) : "f"(f1)); PRINT1("frsp ",i,f0));
ITERATE1F(__asm__ ("frsp. %0,%1" : "=f"(f0) : "f"(f1)); PRINT1("frsp. ",i,f0));
ITERATE1D(__asm__ ("fcfid %0,%1" : "=f"(d0) : "f"(d1)); PRINT1("fcfid ",i,d0));
ITERATE1D(__asm__ ("fcfid. %0,%1" : "=f"(d0) : "f"(d1)); PRINT1("fcfid. ",i,d0));
ITERATE1F(__asm__ ("fcfid %0,%1" : "=f"(f0) : "f"(f1)); PRINT1("fcfid ",i,f0));
ITERATE1F(__asm__ ("fcfid. %0,%1" : "=f"(f0) : "f"(f1)); PRINT1("fcfid. ",i,f0));
ITERATE1D(__asm__ ("fctid %0,%1" : "=f"(d0) : "f"(d1)); PRINT1("fctid ",i,d0));
ITERATE1D(__asm__ ("fctid. %0,%1" : "=f"(d0) : "f"(d1)); PRINT1("fctid. ",i,d0));
ITERATE1F(__asm__ ("fctid %0,%1" : "=f"(f0) : "f"(f1)); PRINT1("fctid ",i,f0));
ITERATE1F(__asm__ ("fctid. %0,%1" : "=f"(f0) : "f"(f1)); PRINT1("fctid. ",i,f0));
ITERATE1D(__asm__ ("fctidz %0,%1" : "=f"(d0) : "f"(d1)); PRINT1("fctidz ",i,d0));
ITERATE1D(__asm__ ("fctidz. %0,%1" : "=f"(d0) : "f"(d1)); PRINT1("fctidz.",i,d0));
ITERATE1F(__asm__ ("fctidz %0,%1" : "=f"(f0) : "f"(f1)); PRINT1("fctidz ",i,f0));
ITERATE1F(__asm__ ("fctidz. %0,%1" : "=f"(f0) : "f"(f1)); PRINT1("fctidz.",i,f0));
ITERATE1D(__asm__ ("fctiw %0,%1" : "=f"(d0) : "f"(d1)); PRINT1("fctiw ",i,d0));
ITERATE1D(__asm__ ("fctiw. %0,%1" : "=f"(d0) : "f"(d1)); PRINT1("fctiw. ",i,d0));
ITERATE1F(__asm__ ("fctiw %0,%1" : "=f"(f0) : "f"(f1)); PRINT1("fctiw ",i,f0));
ITERATE1F(__asm__ ("fctiw. %0,%1" : "=f"(f0) : "f"(f1)); PRINT1("fctiw. ",i,f0));
ITERATE1D(__asm__ ("fctiwz %0,%1" : "=f"(d0) : "f"(d1)); PRINT1("fctiwz ",i,d0));
ITERATE1D(__asm__ ("fctiwz. %0,%1" : "=f"(d0) : "f"(d1)); PRINT1("fctiwz.",i,d0));
ITERATE1F(__asm__ ("fctiwz %0,%1" : "=f"(f0) : "f"(f1)); PRINT1("fctiwz ",i,f0));
ITERATE1F(__asm__ ("fctiwz. %0,%1" : "=f"(f0) : "f"(f1)); PRINT1("fctiwz.",i,f0));
return 0;
}

480
tests/cpu/ppu_float_conversion/ppu_float_conversion.expected Normal file
View File

@ -0,0 +1,480 @@
frsp ([00]) -> 0000000000000000 [00002000 : 00000000]
frsp ([01]) -> 8000000000000000 [00012000 : 00000000]
frsp ([02]) -> 3FF0000000000000 [00004000 : 00000000]
frsp ([03]) -> BFF0000000000000 [00008000 : 00000000]
frsp ([04]) -> 3FF8000000000000 [00004000 : 00000000]
frsp ([05]) -> BFF8000000000000 [00008000 : 00000000]
frsp ([06]) -> 3FF99999A0000000 [82064000 : 00000000]
frsp ([07]) -> BFF99999A0000000 [82068000 : 00000000]
frsp ([08]) -> 3FF6666660000000 [82024000 : 00000000]
frsp ([09]) -> BFF6666660000000 [82028000 : 00000000]
frsp ([10]) -> 4000000000000000 [00004000 : 00000000]
frsp ([11]) -> 7FF8000000000000 [00011000 : 00000000]
frsp ([12]) -> C16312D000000000 [82028000 : 00000000]
frsp ([13]) -> 417312D000000000 [00004000 : 00000000]
frsp ([14]) -> C0D3882000000000 [00008000 : 00000000]
frsp ([15]) -> 40D3882660000000 [82024000 : 00000000]
frsp ([16]) -> 0000000000000000 [8A022000 : 00000000]
frsp ([17]) -> 7FF0000000000000 [92065000 : 00000000]
frsp ([18]) -> 7FF0000000000000 [00005000 : 00000000]
frsp ([19]) -> FFF0000000000000 [00009000 : 00000000]
frsp. ([00]) -> 0000000000000000 [00002000 : 00000000]
frsp. ([01]) -> 8000000000000000 [00012000 : 00000000]
frsp. ([02]) -> 3FF0000000000000 [00004000 : 00000000]
frsp. ([03]) -> BFF0000000000000 [00008000 : 00000000]
frsp. ([04]) -> 3FF8000000000000 [00004000 : 00000000]
frsp. ([05]) -> BFF8000000000000 [00008000 : 00000000]
frsp. ([06]) -> 3FF99999A0000000 [82064000 : 08000000]
frsp. ([07]) -> BFF99999A0000000 [82068000 : 08000000]
frsp. ([08]) -> 3FF6666660000000 [82024000 : 08000000]
frsp. ([09]) -> BFF6666660000000 [82028000 : 08000000]
frsp. ([10]) -> 4000000000000000 [00004000 : 00000000]
frsp. ([11]) -> 7FF8000000000000 [00011000 : 00000000]
frsp. ([12]) -> C16312D000000000 [82028000 : 08000000]
frsp. ([13]) -> 417312D000000000 [00004000 : 00000000]
frsp. ([14]) -> C0D3882000000000 [00008000 : 00000000]
frsp. ([15]) -> 40D3882660000000 [82024000 : 08000000]
frsp. ([16]) -> 0000000000000000 [8A022000 : 08000000]
frsp. ([17]) -> 7FF0000000000000 [92065000 : 09000000]
frsp. ([18]) -> 7FF0000000000000 [00005000 : 00000000]
frsp. ([19]) -> FFF0000000000000 [00009000 : 00000000]
frsp ([00]) -> 0000000000050DB4 [00002000 : 00000000]
frsp ([01]) -> 8000000000050DB4 [00012000 : 00000000]
frsp ([02]) -> 3F80000000050DB4 [00004000 : 00000000]
frsp ([03]) -> BF80000000050DB4 [00008000 : 00000000]
frsp ([04]) -> 3FC0000000050DB4 [00004000 : 00000000]
frsp ([05]) -> BFC0000000050DB4 [00008000 : 00000000]
frsp ([06]) -> 3FCCCCCD00050DB4 [00004000 : 00000000]
frsp ([07]) -> BFCCCCCD00050DB4 [00008000 : 00000000]
frsp ([08]) -> 3FB3333300050DB4 [00004000 : 00000000]
frsp ([09]) -> BFB3333300050DB4 [00008000 : 00000000]
frsp ([10]) -> 4000000000050DB4 [00004000 : 00000000]
frsp ([11]) -> 7FC0000000050DB4 [00011000 : 00000000]
frsp ([12]) -> CB18968000050DB4 [00008000 : 00000000]
frsp ([13]) -> 4B98968000050DB4 [00004000 : 00000000]
frsp ([14]) -> C69C410000050DB4 [00008000 : 00000000]
frsp ([15]) -> 469C413300050DB4 [00004000 : 00000000]
frsp ([16]) -> 0080000000050DB4 [00004000 : 00000000]
frsp ([17]) -> 7F7FFFFF00050DB4 [00004000 : 00000000]
frsp ([18]) -> 7F80000000050DB4 [00005000 : 00000000]
frsp ([19]) -> FF80000000050DB4 [00009000 : 00000000]
frsp. ([00]) -> 0000000000000000 [00002000 : 00000000]
frsp. ([01]) -> 8000000000000000 [00012000 : 00000000]
frsp. ([02]) -> 3F80000000000000 [00004000 : 00000000]
frsp. ([03]) -> BF80000000000000 [00008000 : 00000000]
frsp. ([04]) -> 3FC0000000000000 [00004000 : 00000000]
frsp. ([05]) -> BFC0000000000000 [00008000 : 00000000]
frsp. ([06]) -> 3FCCCCCD00000000 [00004000 : 00000000]
frsp. ([07]) -> BFCCCCCD00000000 [00008000 : 00000000]
frsp. ([08]) -> 3FB3333300000000 [00004000 : 00000000]
frsp. ([09]) -> BFB3333300000000 [00008000 : 00000000]
frsp. ([10]) -> 4000000000000000 [00004000 : 00000000]
frsp. ([11]) -> 7FC0000000000000 [00011000 : 00000000]
frsp. ([12]) -> CB18968000000000 [00008000 : 00000000]
frsp. ([13]) -> 4B98968000000000 [00004000 : 00000000]
frsp. ([14]) -> C69C410000000000 [00008000 : 00000000]
frsp. ([15]) -> 469C413300000000 [00004000 : 00000000]
frsp. ([16]) -> 0080000000000000 [00004000 : 00000000]
frsp. ([17]) -> 7F7FFFFF00000000 [00004000 : 00000000]
frsp. ([18]) -> 7F80000000000000 [00005000 : 00000000]
frsp. ([19]) -> FF80000000000000 [00009000 : 00000000]
fcfid ([00]) -> 0000000000000000 [00002000 : 00000000]
fcfid ([01]) -> C3E0000000000000 [00008000 : 00000000]
fcfid ([02]) -> 43CFF80000000000 [00004000 : 00000000]
fcfid ([03]) -> C3D0040000000000 [00008000 : 00000000]
fcfid ([04]) -> 43CFFC0000000000 [00004000 : 00000000]
fcfid ([05]) -> C3D0020000000000 [00008000 : 00000000]
fcfid ([06]) -> 43CFFCCCCCCCCCCD [82064000 : 00000000]
fcfid ([07]) -> C3D001999999999A [82068000 : 00000000]
fcfid ([08]) -> 43CFFB3333333333 [82024000 : 00000000]
fcfid ([09]) -> C3D0026666666666 [82028000 : 00000000]
fcfid ([10]) -> 43D0000000000000 [00004000 : 00000000]
fcfid ([11]) -> 43DFFE0000000000 [00004000 : 00000000]
fcfid ([12]) -> C3CF4E7697F9999A [82068000 : 00000000]
fcfid ([13]) -> 43D05CC4B4000000 [00004000 : 00000000]
fcfid ([14]) -> C3CF963BF0000000 [00008000 : 00000000]
fcfid ([15]) -> 43D034E20999999A [82064000 : 00000000]
fcfid ([16]) -> 4330000000000000 [00004000 : 00000000]
fcfid ([17]) -> 43DFFC0000000000 [82064000 : 00000000]
fcfid ([18]) -> 43DFFC0000000000 [00004000 : 00000000]
fcfid ([19]) -> C330000000000000 [00008000 : 00000000]
fcfid. ([00]) -> 0000000000000000 [00002000 : 00000000]
fcfid. ([01]) -> C3E0000000000000 [00008000 : 00000000]
fcfid. ([02]) -> 43CFF80000000000 [00004000 : 00000000]
fcfid. ([03]) -> C3D0040000000000 [00008000 : 00000000]
fcfid. ([04]) -> 43CFFC0000000000 [00004000 : 00000000]
fcfid. ([05]) -> C3D0020000000000 [00008000 : 00000000]
fcfid. ([06]) -> 43CFFCCCCCCCCCCD [82064000 : 08000000]
fcfid. ([07]) -> C3D001999999999A [82068000 : 08000000]
fcfid. ([08]) -> 43CFFB3333333333 [82024000 : 08000000]
fcfid. ([09]) -> C3D0026666666666 [82028000 : 08000000]
fcfid. ([10]) -> 43D0000000000000 [00004000 : 00000000]
fcfid. ([11]) -> 43DFFE0000000000 [00004000 : 00000000]
fcfid. ([12]) -> C3CF4E7697F9999A [82068000 : 08000000]
fcfid. ([13]) -> 43D05CC4B4000000 [00004000 : 00000000]
fcfid. ([14]) -> C3CF963BF0000000 [00008000 : 00000000]
fcfid. ([15]) -> 43D034E20999999A [82064000 : 08000000]
fcfid. ([16]) -> 4330000000000000 [00004000 : 00000000]
fcfid. ([17]) -> 43DFFC0000000000 [82064000 : 08000000]
fcfid. ([18]) -> 43DFFC0000000000 [00004000 : 00000000]
fcfid. ([19]) -> C330000000000000 [00008000 : 00000000]
fcfid ([00]) -> 00000000D0010F70 [00002000 : 00000000]
fcfid ([01]) -> DF000000D0010F70 [00008000 : 00000000]
fcfid ([02]) -> 5E7FC000D0010F70 [00004000 : 00000000]
fcfid ([03]) -> DE802000D0010F70 [00008000 : 00000000]
fcfid ([04]) -> 5E7FE000D0010F70 [00004000 : 00000000]
fcfid ([05]) -> DE801000D0010F70 [00008000 : 00000000]
fcfid ([06]) -> 5E7FE666D0010F70 [00004000 : 00000000]
fcfid ([07]) -> DE800CCCD0010F70 [00008000 : 00000000]
fcfid ([08]) -> 5E7FD999D0010F70 [00004000 : 00000000]
fcfid ([09]) -> DE801333D0010F70 [00008000 : 00000000]
fcfid ([10]) -> 5E800000D0010F70 [00004000 : 00000000]
fcfid ([11]) -> 5EFFF000D0010F70 [00004000 : 00000000]
fcfid ([12]) -> DE7A73B4D0010F70 [00008000 : 00000000]
fcfid ([13]) -> 5E82E625D0010F70 [00004000 : 00000000]
fcfid ([14]) -> DE7CB1DFD0010F70 [00008000 : 00000000]
fcfid ([15]) -> 5E81A710D0010F70 [00004000 : 00000000]
fcfid ([16]) -> 5E604000D0010F70 [00004000 : 00000000]
fcfid ([17]) -> 5E8FDFFFD0010F70 [00004000 : 00000000]
fcfid ([18]) -> 5EFFE000D0010F70 [00004000 : 00000000]
fcfid ([19]) -> D9800000D0010F70 [00008000 : 00000000]
fcfid. ([00]) -> 0000000000000000 [00002000 : 00000000]
fcfid. ([01]) -> DF00000000000000 [00008000 : 00000000]
fcfid. ([02]) -> 5E7FC00000000000 [00004000 : 00000000]
fcfid. ([03]) -> DE80200000000000 [00008000 : 00000000]
fcfid. ([04]) -> 5E7FE00000000000 [00004000 : 00000000]
fcfid. ([05]) -> DE80100000000000 [00008000 : 00000000]
fcfid. ([06]) -> 5E7FE66600000000 [00004000 : 00000000]
fcfid. ([07]) -> DE800CCC00000000 [00008000 : 00000000]
fcfid. ([08]) -> 5E7FD99900000000 [00004000 : 00000000]
fcfid. ([09]) -> DE80133300000000 [00008000 : 00000000]
fcfid. ([10]) -> 5E80000000000000 [00004000 : 00000000]
fcfid. ([11]) -> 5EFFF00000000000 [00004000 : 00000000]
fcfid. ([12]) -> DE7A73B400000000 [00008000 : 00000000]
fcfid. ([13]) -> 5E82E62500000000 [00004000 : 00000000]
fcfid. ([14]) -> DE7CB1DF00000000 [00008000 : 00000000]
fcfid. ([15]) -> 5E81A71000000000 [00004000 : 00000000]
fcfid. ([16]) -> 5E60400000000000 [00004000 : 00000000]
fcfid. ([17]) -> 5E8FDFFF00000000 [00004000 : 00000000]
fcfid. ([18]) -> 5EFFE00000000000 [00004000 : 00000000]
fcfid. ([19]) -> D980000000000000 [00008000 : 00000000]
fctid ([00]) -> 0000000000000000 [00000000 : 00000000]
fctid ([01]) -> 0000000000000000 [00000000 : 00000000]
fctid ([02]) -> 0000000000000001 [00000000 : 00000000]
fctid ([03]) -> FFFFFFFFFFFFFFFF [00000000 : 00000000]
fctid ([04]) -> 0000000000000002 [82060000 : 00000000]
fctid ([05]) -> FFFFFFFFFFFFFFFE [82060000 : 00000000]
fctid ([06]) -> 0000000000000002 [82060000 : 00000000]
fctid ([07]) -> FFFFFFFFFFFFFFFE [82060000 : 00000000]
fctid ([08]) -> 0000000000000001 [82020000 : 00000000]
fctid ([09]) -> FFFFFFFFFFFFFFFF [82020000 : 00000000]
fctid ([10]) -> 0000000000000002 [00000000 : 00000000]
fctid ([11]) -> 8000000000000000 [A0000100 : 00000000]
fctid ([12]) -> FFFFFFFFFF676980 [82020000 : 00000000]
fctid ([13]) -> 0000000001312D00 [00000000 : 00000000]
fctid ([14]) -> FFFFFFFFFFFFB1E0 [82020000 : 00000000]
fctid ([15]) -> 0000000000004E21 [82060000 : 00000000]
fctid ([16]) -> 0000000000000000 [82020000 : 00000000]
fctid ([17]) -> 7FFFFFFFFFFFFFFF [A0000100 : 00000000]
fctid ([18]) -> 7FFFFFFFFFFFFFFF [A0000100 : 00000000]
fctid ([19]) -> 8000000000000000 [A0000100 : 00000000]
fctid. ([00]) -> 0000000000000000 [00000000 : 00000000]
fctid. ([01]) -> 0000000000000000 [00000000 : 00000000]
fctid. ([02]) -> 0000000000000001 [00000000 : 00000000]
fctid. ([03]) -> FFFFFFFFFFFFFFFF [00000000 : 00000000]
fctid. ([04]) -> 0000000000000002 [82060000 : 08000000]
fctid. ([05]) -> FFFFFFFFFFFFFFFE [82060000 : 08000000]
fctid. ([06]) -> 0000000000000002 [82060000 : 08000000]
fctid. ([07]) -> FFFFFFFFFFFFFFFE [82060000 : 08000000]
fctid. ([08]) -> 0000000000000001 [82020000 : 08000000]
fctid. ([09]) -> FFFFFFFFFFFFFFFF [82020000 : 08000000]
fctid. ([10]) -> 0000000000000002 [00000000 : 00000000]
fctid. ([11]) -> 8000000000000000 [A0000100 : 0A000000]
fctid. ([12]) -> FFFFFFFFFF676980 [82020000 : 08000000]
fctid. ([13]) -> 0000000001312D00 [00000000 : 00000000]
fctid. ([14]) -> FFFFFFFFFFFFB1E0 [82020000 : 08000000]
fctid. ([15]) -> 0000000000004E21 [82060000 : 08000000]
fctid. ([16]) -> 0000000000000000 [82020000 : 08000000]
fctid. ([17]) -> 7FFFFFFFFFFFFFFF [A0000100 : 0A000000]
fctid. ([18]) -> 7FFFFFFFFFFFFFFF [A0000100 : 0A000000]
fctid. ([19]) -> 8000000000000000 [A0000100 : 0A000000]
fctid ([00]) -> 00000000D0010C80 [00000000 : 00000000]
fctid ([01]) -> 00000000D0010C80 [00000000 : 00000000]
fctid ([02]) -> 00000000D0010C80 [00000000 : 00000000]
fctid ([03]) -> FFFFFFFFD0010C80 [00000000 : 00000000]
fctid ([04]) -> 00000000D0010C80 [82060000 : 00000000]
fctid ([05]) -> FFFFFFFFD0010C80 [82060000 : 00000000]
fctid ([06]) -> 00000000D0010C80 [82060000 : 00000000]
fctid ([07]) -> FFFFFFFFD0010C80 [82060000 : 00000000]
fctid ([08]) -> 00000000D0010C80 [82020000 : 00000000]
fctid ([09]) -> FFFFFFFFD0010C80 [82020000 : 00000000]
fctid ([10]) -> 00000000D0010C80 [00000000 : 00000000]
fctid ([11]) -> 80000000D0010C80 [A0000100 : 00000000]
fctid ([12]) -> FFFFFFFFD0010C80 [00000000 : 00000000]
fctid ([13]) -> 00000000D0010C80 [00000000 : 00000000]
fctid ([14]) -> FFFFFFFFD0010C80 [82020000 : 00000000]
fctid ([15]) -> 00000000D0010C80 [82060000 : 00000000]
fctid ([16]) -> 00000000D0010C80 [82020000 : 00000000]
fctid ([17]) -> 7FFFFFFFD0010C80 [A0000100 : 00000000]
fctid ([18]) -> 7FFFFFFFD0010C80 [A0000100 : 00000000]
fctid ([19]) -> 80000000D0010C80 [A0000100 : 00000000]
fctid. ([00]) -> 0000000000000000 [00000000 : 00000000]
fctid. ([01]) -> 0000000000000000 [00000000 : 00000000]
fctid. ([02]) -> 0000000000000000 [00000000 : 00000000]
fctid. ([03]) -> FFFFFFFF00000000 [00000000 : 00000000]
fctid. ([04]) -> 0000000000000000 [82060000 : 08000000]
fctid. ([05]) -> FFFFFFFF00000000 [82060000 : 08000000]
fctid. ([06]) -> 0000000000000000 [82060000 : 08000000]
fctid. ([07]) -> FFFFFFFF00000000 [82060000 : 08000000]
fctid. ([08]) -> 0000000000000000 [82020000 : 08000000]
fctid. ([09]) -> FFFFFFFF00000000 [82020000 : 08000000]
fctid. ([10]) -> 0000000000000000 [00000000 : 00000000]
fctid. ([11]) -> 8000000000000000 [A0000100 : 0A000000]
fctid. ([12]) -> FFFFFFFF00000000 [00000000 : 00000000]
fctid. ([13]) -> 0000000000000000 [00000000 : 00000000]
fctid. ([14]) -> FFFFFFFF00000000 [82020000 : 08000000]
fctid. ([15]) -> 0000000000000000 [82060000 : 08000000]
fctid. ([16]) -> 0000000000000000 [82020000 : 08000000]
fctid. ([17]) -> 7FFFFFFF00000000 [A0000100 : 0A000000]
fctid. ([18]) -> 7FFFFFFF00000000 [A0000100 : 0A000000]
fctid. ([19]) -> 8000000000000000 [A0000100 : 0A000000]
fctidz ([00]) -> 0000000000000000 [00000000 : 00000000]
fctidz ([01]) -> 0000000000000000 [00000000 : 00000000]
fctidz ([02]) -> 0000000000000001 [00000000 : 00000000]
fctidz ([03]) -> FFFFFFFFFFFFFFFF [00000000 : 00000000]
fctidz ([04]) -> 0000000000000001 [82020000 : 00000000]
fctidz ([05]) -> FFFFFFFFFFFFFFFF [82020000 : 00000000]
fctidz ([06]) -> 0000000000000001 [82020000 : 00000000]
fctidz ([07]) -> FFFFFFFFFFFFFFFF [82020000 : 00000000]
fctidz ([08]) -> 0000000000000001 [82020000 : 00000000]
fctidz ([09]) -> FFFFFFFFFFFFFFFF [82020000 : 00000000]
fctidz ([10]) -> 0000000000000002 [00000000 : 00000000]
fctidz ([11]) -> 8000000000000000 [A0000100 : 00000000]
fctidz ([12]) -> FFFFFFFFFF676980 [82020000 : 00000000]
fctidz ([13]) -> 0000000001312D00 [00000000 : 00000000]
fctidz ([14]) -> FFFFFFFFFFFFB1E0 [82020000 : 00000000]
fctidz ([15]) -> 0000000000004E20 [82020000 : 00000000]
fctidz ([16]) -> 0000000000000000 [82020000 : 00000000]
fctidz ([17]) -> 7FFFFFFFFFFFFFFF [A0000100 : 00000000]
fctidz ([18]) -> 7FFFFFFFFFFFFFFF [A0000100 : 00000000]
fctidz ([19]) -> 8000000000000000 [A0000100 : 00000000]
fctidz.([00]) -> 0000000000000000 [00000000 : 00000000]
fctidz.([01]) -> 0000000000000000 [00000000 : 00000000]
fctidz.([02]) -> 0000000000000001 [00000000 : 00000000]
fctidz.([03]) -> FFFFFFFFFFFFFFFF [00000000 : 00000000]
fctidz.([04]) -> 0000000000000001 [82020000 : 08000000]
fctidz.([05]) -> FFFFFFFFFFFFFFFF [82020000 : 08000000]
fctidz.([06]) -> 0000000000000001 [82020000 : 08000000]
fctidz.([07]) -> FFFFFFFFFFFFFFFF [82020000 : 08000000]
fctidz.([08]) -> 0000000000000001 [82020000 : 08000000]
fctidz.([09]) -> FFFFFFFFFFFFFFFF [82020000 : 08000000]
fctidz.([10]) -> 0000000000000002 [00000000 : 00000000]
fctidz.([11]) -> 8000000000000000 [A0000100 : 0A000000]
fctidz.([12]) -> FFFFFFFFFF676980 [82020000 : 08000000]
fctidz.([13]) -> 0000000001312D00 [00000000 : 00000000]
fctidz.([14]) -> FFFFFFFFFFFFB1E0 [82020000 : 08000000]
fctidz.([15]) -> 0000000000004E20 [82020000 : 08000000]
fctidz.([16]) -> 0000000000000000 [82020000 : 08000000]
fctidz.([17]) -> 7FFFFFFFFFFFFFFF [A0000100 : 0A000000]
fctidz.([18]) -> 7FFFFFFFFFFFFFFF [A0000100 : 0A000000]
fctidz.([19]) -> 8000000000000000 [A0000100 : 0A000000]
fctidz ([00]) -> 0000000000000000 [00000000 : 00000000]
fctidz ([01]) -> 0000000000000000 [00000000 : 00000000]
fctidz ([02]) -> 0000000000000000 [00000000 : 00000000]
fctidz ([03]) -> FFFFFFFF00000000 [00000000 : 00000000]
fctidz ([04]) -> 0000000000000000 [82020000 : 00000000]
fctidz ([05]) -> FFFFFFFF00000000 [82020000 : 00000000]
fctidz ([06]) -> 0000000000000000 [82020000 : 00000000]
fctidz ([07]) -> FFFFFFFF00000000 [82020000 : 00000000]
fctidz ([08]) -> 0000000000000000 [82020000 : 00000000]
fctidz ([09]) -> FFFFFFFF00000000 [82020000 : 00000000]
fctidz ([10]) -> 0000000000000000 [00000000 : 00000000]
fctidz ([11]) -> 8000000000000000 [A0000100 : 00000000]
fctidz ([12]) -> FFFFFFFF00000000 [00000000 : 00000000]
fctidz ([13]) -> 0000000000000000 [00000000 : 00000000]
fctidz ([14]) -> FFFFFFFF00000000 [82020000 : 00000000]
fctidz ([15]) -> 0000000000000000 [82020000 : 00000000]
fctidz ([16]) -> 0000000000000000 [82020000 : 00000000]
fctidz ([17]) -> 7FFFFFFF00000000 [A0000100 : 00000000]
fctidz ([18]) -> 7FFFFFFF00000000 [A0000100 : 00000000]
fctidz ([19]) -> 8000000000000000 [A0000100 : 00000000]
fctidz.([00]) -> 0000000000000000 [00000000 : 00000000]
fctidz.([01]) -> 0000000000000000 [00000000 : 00000000]
fctidz.([02]) -> 0000000000000000 [00000000 : 00000000]
fctidz.([03]) -> FFFFFFFF00000000 [00000000 : 00000000]
fctidz.([04]) -> 0000000000000000 [82020000 : 08000000]
fctidz.([05]) -> FFFFFFFF00000000 [82020000 : 08000000]
fctidz.([06]) -> 0000000000000000 [82020000 : 08000000]
fctidz.([07]) -> FFFFFFFF00000000 [82020000 : 08000000]
fctidz.([08]) -> 0000000000000000 [82020000 : 08000000]
fctidz.([09]) -> FFFFFFFF00000000 [82020000 : 08000000]
fctidz.([10]) -> 0000000000000000 [00000000 : 00000000]
fctidz.([11]) -> 8000000000000000 [A0000100 : 0A000000]
fctidz.([12]) -> FFFFFFFF00000000 [00000000 : 00000000]
fctidz.([13]) -> 0000000000000000 [00000000 : 00000000]
fctidz.([14]) -> FFFFFFFF00000000 [82020000 : 08000000]
fctidz.([15]) -> 0000000000000000 [82020000 : 08000000]
fctidz.([16]) -> 0000000000000000 [82020000 : 08000000]
fctidz.([17]) -> 7FFFFFFF00000000 [A0000100 : 0A000000]
fctidz.([18]) -> 7FFFFFFF00000000 [A0000100 : 0A000000]
fctidz.([19]) -> 8000000000000000 [A0000100 : 0A000000]
fctiw ([00]) -> 0000000000000000 [00000000 : 00000000]
fctiw ([01]) -> 0000000000000000 [00000000 : 00000000]
fctiw ([02]) -> 0000000000000001 [00000000 : 00000000]
fctiw ([03]) -> FFFFFFFFFFFFFFFF [00000000 : 00000000]
fctiw ([04]) -> 0000000000000002 [82060000 : 00000000]
fctiw ([05]) -> FFFFFFFFFFFFFFFE [82060000 : 00000000]
fctiw ([06]) -> 0000000000000002 [82060000 : 00000000]
fctiw ([07]) -> FFFFFFFFFFFFFFFE [82060000 : 00000000]
fctiw ([08]) -> 0000000000000001 [82020000 : 00000000]
fctiw ([09]) -> FFFFFFFFFFFFFFFF [82020000 : 00000000]
fctiw ([10]) -> 0000000000000002 [00000000 : 00000000]
fctiw ([11]) -> FFFFFFFF80000000 [A0000100 : 00000000]
fctiw ([12]) -> FFFFFFFFFF676980 [82020000 : 00000000]
fctiw ([13]) -> 0000000001312D00 [00000000 : 00000000]
fctiw ([14]) -> FFFFFFFFFFFFB1E0 [82020000 : 00000000]
fctiw ([15]) -> 0000000000004E21 [82060000 : 00000000]
fctiw ([16]) -> 0000000000000000 [82020000 : 00000000]
fctiw ([17]) -> 000000007FFFFFFF [A0000100 : 00000000]
fctiw ([18]) -> 000000007FFFFFFF [A0000100 : 00000000]
fctiw ([19]) -> FFFFFFFF80000000 [A0000100 : 00000000]
fctiw. ([00]) -> 0000000000000000 [00000000 : 00000000]
fctiw. ([01]) -> 0000000000000000 [00000000 : 00000000]
fctiw. ([02]) -> 0000000000000001 [00000000 : 00000000]
fctiw. ([03]) -> FFFFFFFFFFFFFFFF [00000000 : 00000000]
fctiw. ([04]) -> 0000000000000002 [82060000 : 08000000]
fctiw. ([05]) -> FFFFFFFFFFFFFFFE [82060000 : 08000000]
fctiw. ([06]) -> 0000000000000002 [82060000 : 08000000]
fctiw. ([07]) -> FFFFFFFFFFFFFFFE [82060000 : 08000000]
fctiw. ([08]) -> 0000000000000001 [82020000 : 08000000]
fctiw. ([09]) -> FFFFFFFFFFFFFFFF [82020000 : 08000000]
fctiw. ([10]) -> 0000000000000002 [00000000 : 00000000]
fctiw. ([11]) -> FFFFFFFF80000000 [A0000100 : 0A000000]
fctiw. ([12]) -> FFFFFFFFFF676980 [82020000 : 08000000]
fctiw. ([13]) -> 0000000001312D00 [00000000 : 00000000]
fctiw. ([14]) -> FFFFFFFFFFFFB1E0 [82020000 : 08000000]
fctiw. ([15]) -> 0000000000004E21 [82060000 : 08000000]
fctiw. ([16]) -> 0000000000000000 [82020000 : 08000000]
fctiw. ([17]) -> 000000007FFFFFFF [A0000100 : 0A000000]
fctiw. ([18]) -> 000000007FFFFFFF [A0000100 : 0A000000]
fctiw. ([19]) -> FFFFFFFF80000000 [A0000100 : 0A000000]
fctiw ([00]) -> 0000000000000000 [00000000 : 00000000]
fctiw ([01]) -> 0000000000000000 [00000000 : 00000000]
fctiw ([02]) -> 0000000000000000 [00000000 : 00000000]
fctiw ([03]) -> FFFFFFFF00000000 [00000000 : 00000000]
fctiw ([04]) -> 0000000000000000 [82060000 : 00000000]
fctiw ([05]) -> FFFFFFFF00000000 [82060000 : 00000000]
fctiw ([06]) -> 0000000000000000 [82060000 : 00000000]
fctiw ([07]) -> FFFFFFFF00000000 [82060000 : 00000000]
fctiw ([08]) -> 0000000000000000 [82020000 : 00000000]
fctiw ([09]) -> FFFFFFFF00000000 [82020000 : 00000000]
fctiw ([10]) -> 0000000000000000 [00000000 : 00000000]
fctiw ([11]) -> FFFFFFFC00000000 [A0000100 : 00000000]
fctiw ([12]) -> FFFFFFFF00000000 [00000000 : 00000000]
fctiw ([13]) -> 0000000000000000 [00000000 : 00000000]
fctiw ([14]) -> FFFFFFFF00000000 [82020000 : 00000000]
fctiw ([15]) -> 0000000000000000 [82060000 : 00000000]
fctiw ([16]) -> 0000000000000000 [82020000 : 00000000]
fctiw ([17]) -> 0000000000000000 [A0000100 : 00000000]
fctiw ([18]) -> 0000000000000000 [A0000100 : 00000000]
fctiw ([19]) -> FFFFFFFC00000000 [A0000100 : 00000000]
fctiw. ([00]) -> 0000000000000000 [00000000 : 00000000]
fctiw. ([01]) -> 0000000000000000 [00000000 : 00000000]
fctiw. ([02]) -> 0000000000000000 [00000000 : 00000000]
fctiw. ([03]) -> FFFFFFFF00000000 [00000000 : 00000000]
fctiw. ([04]) -> 0000000000000000 [82060000 : 08000000]
fctiw. ([05]) -> FFFFFFFF00000000 [82060000 : 08000000]
fctiw. ([06]) -> 0000000000000000 [82060000 : 08000000]
fctiw. ([07]) -> FFFFFFFF00000000 [82060000 : 08000000]
fctiw. ([08]) -> 0000000000000000 [82020000 : 08000000]
fctiw. ([09]) -> FFFFFFFF00000000 [82020000 : 08000000]
fctiw. ([10]) -> 0000000000000000 [00000000 : 00000000]
fctiw. ([11]) -> FFFFFFFC00000000 [A0000100 : 0A000000]
fctiw. ([12]) -> FFFFFFFF00000000 [00000000 : 00000000]
fctiw. ([13]) -> 0000000000000000 [00000000 : 00000000]
fctiw. ([14]) -> FFFFFFFF00000000 [82020000 : 08000000]
fctiw. ([15]) -> 0000000000000000 [82060000 : 08000000]
fctiw. ([16]) -> 0000000000000000 [82020000 : 08000000]
fctiw. ([17]) -> 0000000000000000 [A0000100 : 0A000000]
fctiw. ([18]) -> 0000000000000000 [A0000100 : 0A000000]
fctiw. ([19]) -> FFFFFFFC00000000 [A0000100 : 0A000000]
fctiwz ([00]) -> 0000000000000000 [00000000 : 00000000]
fctiwz ([01]) -> 0000000000000000 [00000000 : 00000000]
fctiwz ([02]) -> 0000000000000001 [00000000 : 00000000]
fctiwz ([03]) -> FFFFFFFFFFFFFFFF [00000000 : 00000000]
fctiwz ([04]) -> 0000000000000001 [82020000 : 00000000]
fctiwz ([05]) -> FFFFFFFFFFFFFFFF [82020000 : 00000000]
fctiwz ([06]) -> 0000000000000001 [82020000 : 00000000]
fctiwz ([07]) -> FFFFFFFFFFFFFFFF [82020000 : 00000000]
fctiwz ([08]) -> 0000000000000001 [82020000 : 00000000]
fctiwz ([09]) -> FFFFFFFFFFFFFFFF [82020000 : 00000000]
fctiwz ([10]) -> 0000000000000002 [00000000 : 00000000]
fctiwz ([11]) -> FFFFFFFF80000000 [A0000100 : 00000000]
fctiwz ([12]) -> FFFFFFFFFF676980 [82020000 : 00000000]
fctiwz ([13]) -> 0000000001312D00 [00000000 : 00000000]
fctiwz ([14]) -> FFFFFFFFFFFFB1E0 [82020000 : 00000000]
fctiwz ([15]) -> 0000000000004E20 [82020000 : 00000000]
fctiwz ([16]) -> 0000000000000000 [82020000 : 00000000]
fctiwz ([17]) -> 000000007FFFFFFF [A0000100 : 00000000]
fctiwz ([18]) -> 000000007FFFFFFF [A0000100 : 00000000]
fctiwz ([19]) -> FFFFFFFF80000000 [A0000100 : 00000000]
fctiwz.([00]) -> 0000000000000000 [00000000 : 00000000]
fctiwz.([01]) -> 0000000000000000 [00000000 : 00000000]
fctiwz.([02]) -> 0000000000000001 [00000000 : 00000000]
fctiwz.([03]) -> FFFFFFFFFFFFFFFF [00000000 : 00000000]
fctiwz.([04]) -> 0000000000000001 [82020000 : 08000000]
fctiwz.([05]) -> FFFFFFFFFFFFFFFF [82020000 : 08000000]
fctiwz.([06]) -> 0000000000000001 [82020000 : 08000000]
fctiwz.([07]) -> FFFFFFFFFFFFFFFF [82020000 : 08000000]
fctiwz.([08]) -> 0000000000000001 [82020000 : 08000000]
fctiwz.([09]) -> FFFFFFFFFFFFFFFF [82020000 : 08000000]
fctiwz.([10]) -> 0000000000000002 [00000000 : 00000000]
fctiwz.([11]) -> FFFFFFFF80000000 [A0000100 : 0A000000]
fctiwz.([12]) -> FFFFFFFFFF676980 [82020000 : 08000000]
fctiwz.([13]) -> 0000000001312D00 [00000000 : 00000000]
fctiwz.([14]) -> FFFFFFFFFFFFB1E0 [82020000 : 08000000]
fctiwz.([15]) -> 0000000000004E20 [82020000 : 08000000]
fctiwz.([16]) -> 0000000000000000 [82020000 : 08000000]
fctiwz.([17]) -> 000000007FFFFFFF [A0000100 : 0A000000]
fctiwz.([18]) -> 000000007FFFFFFF [A0000100 : 0A000000]
fctiwz.([19]) -> FFFFFFFF80000000 [A0000100 : 0A000000]
fctiwz ([00]) -> 00000000D0010F60 [00000000 : 00000000]
fctiwz ([01]) -> 00000000D0010F60 [00000000 : 00000000]
fctiwz ([02]) -> 00000000D0010F60 [00000000 : 00000000]
fctiwz ([03]) -> FFFFFFFFD0010F60 [00000000 : 00000000]
fctiwz ([04]) -> 00000000D0010F60 [82020000 : 00000000]
fctiwz ([05]) -> FFFFFFFFD0010F60 [82020000 : 00000000]
fctiwz ([06]) -> 00000000D0010F60 [82020000 : 00000000]
fctiwz ([07]) -> FFFFFFFFD0010F60 [82020000 : 00000000]
fctiwz ([08]) -> 00000000D0010F60 [82020000 : 00000000]
fctiwz ([09]) -> FFFFFFFFD0010F60 [82020000 : 00000000]
fctiwz ([10]) -> 00000000D0010F60 [00000000 : 00000000]
fctiwz ([11]) -> FFFFFFFCD0010F60 [A0000100 : 00000000]
fctiwz ([12]) -> FFFFFFFFD0010F60 [00000000 : 00000000]
fctiwz ([13]) -> 00000000D0010F60 [00000000 : 00000000]
fctiwz ([14]) -> FFFFFFFFD0010F60 [82020000 : 00000000]
fctiwz ([15]) -> 00000000D0010F60 [82020000 : 00000000]
fctiwz ([16]) -> 00000000D0010F60 [82020000 : 00000000]
fctiwz ([17]) -> 00000000D0010F60 [A0000100 : 00000000]
fctiwz ([18]) -> 00000000D0010F60 [A0000100 : 00000000]
fctiwz ([19]) -> FFFFFFFCD0010F60 [A0000100 : 00000000]
fctiwz.([00]) -> 0000000000000000 [00000000 : 00000000]
fctiwz.([01]) -> 0000000000000000 [00000000 : 00000000]
fctiwz.([02]) -> 0000000000000000 [00000000 : 00000000]
fctiwz.([03]) -> FFFFFFFF00000000 [00000000 : 00000000]
fctiwz.([04]) -> 0000000000000000 [82020000 : 08000000]
fctiwz.([05]) -> FFFFFFFF00000000 [82020000 : 08000000]
fctiwz.([06]) -> 0000000000000000 [82020000 : 08000000]
fctiwz.([07]) -> FFFFFFFF00000000 [82020000 : 08000000]
fctiwz.([08]) -> 0000000000000000 [82020000 : 08000000]
fctiwz.([09]) -> FFFFFFFF00000000 [82020000 : 08000000]
fctiwz.([10]) -> 0000000000000000 [00000000 : 00000000]
fctiwz.([11]) -> FFFFFFFC00000000 [A0000100 : 0A000000]
fctiwz.([12]) -> FFFFFFFF00000000 [00000000 : 00000000]
fctiwz.([13]) -> 0000000000000000 [00000000 : 00000000]
fctiwz.([14]) -> FFFFFFFF00000000 [82020000 : 08000000]
fctiwz.([15]) -> 0000000000000000 [82020000 : 08000000]
fctiwz.([16]) -> 0000000000000000 [82020000 : 08000000]
fctiwz.([17]) -> 0000000000000000 [A0000100 : 0A000000]
fctiwz.([18]) -> 0000000000000000 [A0000100 : 0A000000]
fctiwz.([19]) -> FFFFFFFC00000000 [A0000100 : 0A000000]

BIN
tests/cpu/ppu_float_conversion/ppu_float_conversion.ppu.elf Normal file
View File

Binary file not shown.

BIN
tests/cpu/ppu_float_conversion/ppu_float_conversion.ppu.self Normal file
View File

Binary file not shown.

102
tests/cpu/ppu_float_load/ppu_float_load.cpp Normal file
View File

@ -0,0 +1,102 @@
/**
* (c) 2015 Alexandro Sanchez Bach. All rights reserved.
* Released under GPL v2 license. Read LICENSE for more details.
*/
#include <stdio.h>
#include "../../../common/output.h"
// Instructions: XXX rS,d(rA) without update
#define TEST_LOAD1(instr, addr) { \
double n; \
__asm__ ( \
"mr 11, %1; " /* r11 = addr */ \
instr "; " \
"fmr %0, 0; " /* value = fr0 */ \
: "=f"((double&)n) : "r"(addr)); \
fprintf(handler, instr " -> %016llX\n", (uint64_t&)n); \
}
// Instructions: XXX rS,d(rA) with update
#define TEST_LOAD2(instr, addr) { \
uint64_t res; \
double n; \
__asm__ ( \
"mr 11, %2; " /* r11 = addr */ \
instr "; " \
"fmr %0, 0; " /* value = fr0 */ \
"mr %1, 11; " /* res = r11 */ \
: "=f"((double&)n), "=r"(res) : "r"(addr)); \
fprintf(handler, instr " -> %016llX [%016llX]\n", \
(uint64_t&)n, res - (uint64_t)addr); \
}
// Instructions: XXX rS,rA,rB without update
#define TEST_LOAD3(instr, rA, rB) { \
double n; \
__asm__ ( \
"mr 11, %1; " /* r11 = rA */ \
"mr 12, %2; " /* r12 = rB */ \
instr "; " \
"fmr %0, 0; " /* value = fr0 */ \
: "=f"((double&)n) : "r"(rA), "r"(rB)); \
fprintf(handler, instr " -> %016llX\n", (uint64_t&)n); \
}
// Instructions: XXX rS,rA,rB with update
#define TEST_LOAD4(instr, rA, rB) { \
uint64_t res; \
double n; \
__asm__ ( \
"mr 11, %2; " /* r11 = rA */ \
"mr 12, %3; " /* r12 = rB */ \
instr "; " \
"fmr %0, 0; " /* value = fr0 */ \
"mr %1, 11; " /* res = r11 */ \
: "=f"((double&)n), "=r"(res) : "r"(rA), "r"(rB)); \
fprintf(handler, instr " -> %016llX [%016llX]\n", \
(uint64_t&)n, (res - (uint64_t)rA - (uint64_t)rB)); \
}
int main(void)
{
FILE* handler = fopen("/app_home/" OUTPUT_FILE, "wb");
// Test double data
uint32_t v[3] = {0x3F801234, 0x56789ABC, 0xDEF01234};
// Floating-Point Load Instructions (Single)
TEST_LOAD1("lfs 0, 0(11)", &v[0]);
TEST_LOAD1("lfs 0, 8(11)", &v[0]);
TEST_LOAD1("lfs 0, -4(11)", &v[2]);
TEST_LOAD2("lfsu 0, 0(11)", &v[0]);
TEST_LOAD2("lfsu 0, 8(11)", &v[0]);
TEST_LOAD2("lfsu 0, -4(11)", &v[2]);
TEST_LOAD3("lfsx 0, 11, 12", &v[0], 0);
TEST_LOAD3("lfsx 0, 11, 12", &v[0], 8);
TEST_LOAD3("lfsx 0, 11, 12", &v[2], -4);
TEST_LOAD3("lfsx 0, 11, 12", 0, &v[0]);
TEST_LOAD4("lfsux 0, 11, 12", &v[0], 0);
TEST_LOAD4("lfsux 0, 11, 12", &v[0], 8);
TEST_LOAD4("lfsux 0, 11, 12", &v[2], -4);
TEST_LOAD4("lfsux 0, 11, 12", 0, &v[0]);
// Floating-Point Load Instructions (Double)
TEST_LOAD1("lfd 0, 0(11)", &v[0]);
TEST_LOAD1("lfd 0, 4(11)", &v[0]);
TEST_LOAD1("lfd 0, -4(11)", &v[1]);
TEST_LOAD2("lfdu 0, 0(11)", &v[0]);
TEST_LOAD2("lfdu 0, 4(11)", &v[0]);
TEST_LOAD2("lfdu 0, -4(11)", &v[1]);
TEST_LOAD3("lfdx 0, 11, 12", &v[0], 0);
TEST_LOAD3("lfdx 0, 11, 12", &v[0], 4);
TEST_LOAD3("lfdx 0, 11, 12", &v[2], -4);
TEST_LOAD3("lfdx 0, 11, 12", 0, &v[0]);
TEST_LOAD4("lfdux 0, 11, 12", &v[0], 0);
TEST_LOAD4("lfdux 0, 11, 12", &v[0], 4);
TEST_LOAD4("lfdux 0, 11, 12", &v[2], -4);
TEST_LOAD4("lfdux 0, 11, 12", 0, &v[0]);
return 0;
}

28
tests/cpu/ppu_float_load/ppu_float_load.expected Normal file
View File

@ -0,0 +1,28 @@
lfs 0, 0(11) -> 3FF0024680000000
lfs 0, 8(11) -> C3DE024680000000
lfs 0, -4(11) -> 42CF135780000000
lfsu 0, 0(11) -> 3FF0024680000000 [0000000000000000]
lfsu 0, 8(11) -> C3DE024680000000 [0000000000000008]
lfsu 0, -4(11) -> 42CF135780000000 [FFFFFFFFFFFFFFFC]
lfsx 0, 11, 12 -> 3FF0024680000000
lfsx 0, 11, 12 -> C3DE024680000000
lfsx 0, 11, 12 -> 42CF135780000000
lfsx 0, 11, 12 -> 3FF0024680000000
lfsux 0, 11, 12 -> 3FF0024680000000 [0000000000000000]
lfsux 0, 11, 12 -> C3DE024680000000 [0000000000000000]
lfsux 0, 11, 12 -> 42CF135780000000 [0000000000000000]
lfsux 0, 11, 12 -> 3FF0024680000000 [0000000000000000]
lfd 0, 0(11) -> 3F80123456789ABC
lfd 0, 4(11) -> 56789ABCDEF01234
lfd 0, -4(11) -> 3F80123456789ABC
lfdu 0, 0(11) -> 3F80123456789ABC [0000000000000000]
lfdu 0, 4(11) -> 56789ABCDEF01234 [0000000000000004]
lfdu 0, -4(11) -> 3F80123456789ABC [FFFFFFFFFFFFFFFC]
lfdx 0, 11, 12 -> 3F80123456789ABC
lfdx 0, 11, 12 -> 56789ABCDEF01234
lfdx 0, 11, 12 -> 56789ABCDEF01234
lfdx 0, 11, 12 -> 3F80123456789ABC
lfdux 0, 11, 12 -> 3F80123456789ABC [0000000000000000]
lfdux 0, 11, 12 -> 56789ABCDEF01234 [0000000000000000]
lfdux 0, 11, 12 -> 56789ABCDEF01234 [0000000000000000]
lfdux 0, 11, 12 -> 3F80123456789ABC [0000000000000000]

BIN
tests/cpu/ppu_float_load/ppu_float_load.ppu.elf Normal file
View File

Binary file not shown.

BIN
tests/cpu/ppu_float_load/ppu_float_load.ppu.self Normal file
View File

Binary file not shown.

110
tests/cpu/ppu_float_store/ppu_float_store.cpp Normal file
View File

@ -0,0 +1,110 @@
/**
* (c) 2015 Alexandro Sanchez Bach. All rights reserved.
* Released under GPL v2 license. Read LICENSE for more details.
*/
#include <stdio.h>
#include "../../../common/output.h"
// Instructions: XXX rS,d(rA) without update
#define TEST_STORE1(instr, addr) { \
uint32_t v[3] = {}; \
__asm__ ( \
"fmr 0, %0; " /* fr0 = value */ \
"mr 11, %1; " /* r11 = addr */ \
instr "; " \
: : "f"((double&)n), "r"(addr)); \
fprintf(handler, instr " -> %08X %08X %08X\n", \
v[0], v[1], v[2]); \
}
// Instructions: XXX rS,d(rA) with update
#define TEST_STORE2(instr, addr) { \
uint64_t res; \
uint32_t v[3] = {}; \
__asm__ ( \
"fmr 0, %1; " /* fr0 = value */ \
"mr 11, %2; " /* r11 = addr */ \
instr "; " \
"mr %0, 11; " /* res = r11 */ \
: "=r"(res) : "f"((double&)n), "r"(addr)); \
fprintf(handler, instr " -> %08X %08X %08X [%016llX]\n", \
v[0], v[1], v[2], (res - (uint64_t)addr)); \
}
// Instructions: XXX rS,rA,rB without update
#define TEST_STORE3(instr, rA, rB) { \
uint32_t v[3] = {}; \
__asm__ ( \
"fmr 0, %0; " /* fr0 = value */ \
"mr 11, %1; " /* r11 = rA */ \
"mr 12, %2; " /* r12 = rB */ \
instr "; " \
: : "f"((double&)n), "r"(rA), "r"(rB)); \
fprintf(handler, instr " -> %08X %08X %08X\n", \
v[0], v[1], v[2]); \
}
// Instructions: XXX rS,rA,rB with update
#define TEST_STORE4(instr, rA, rB) { \
uint64_t res; \
uint32_t v[3] = {}; \
__asm__ ( \
"fmr 0, %1; " /* fr0 = value */ \
"mr 11, %2; " /* r11 = rA */ \
"mr 12, %3; " /* r12 = rB */ \
instr "; " \
"mr %0, 11; " /* res = r11 */ \
: "=r"(res) : "f"((double&)n), "r"(rA), "r"(rB)); \
fprintf(handler, instr " -> %08X %08X %08X [%016llX]\n", \
v[0], v[1], v[2], (res - (uint64_t)rA - (uint64_t)rB)); \
}
int main(void)
{
FILE* handler = fopen("/app_home/" OUTPUT_FILE, "wb");
// Test double
uint64_t n = 0x3F80123456789ABCULL;
// Floating-Point Store Instructions (Single)
TEST_STORE1("stfs 0, 0(11)", &v[0]);
TEST_STORE1("stfs 0, 8(11)", &v[0]);
TEST_STORE1("stfs 0, -4(11)", &v[2]);
TEST_STORE2("stfsu 0, 0(11)", &v[0]);
TEST_STORE2("stfsu 0, 8(11)", &v[0]);
TEST_STORE2("stfsu 0, -4(11)", &v[2]);
TEST_STORE3("stfsx 0, 11, 12", &v[0], 0);
TEST_STORE3("stfsx 0, 11, 12", &v[0], 8);
TEST_STORE3("stfsx 0, 11, 12", &v[2], -4);
TEST_STORE3("stfsx 0, 11, 12", 0, &v[0]);
TEST_STORE4("stfsux 0, 11, 12", &v[0], 0);
TEST_STORE4("stfsux 0, 11, 12", &v[0], 8);
TEST_STORE4("stfsux 0, 11, 12", &v[2], -4);
TEST_STORE4("stfsux 0, 11, 12", 0, &v[0]);
// Floating-Point Store Instructions (Double)
TEST_STORE1("stfd 0, 0(11)", &v[0]);
TEST_STORE1("stfd 0, 4(11)", &v[0]);
TEST_STORE1("stfd 0, -4(11)", &v[1]);
TEST_STORE2("stfdu 0, 0(11)", &v[0]);
TEST_STORE2("stfdu 0, 4(11)", &v[0]);
TEST_STORE2("stfdu 0, -4(11)", &v[1]);
TEST_STORE3("stfdx 0, 11, 12", &v[0], 0);
TEST_STORE3("stfdx 0, 11, 12", &v[0], 4);
TEST_STORE3("stfdx 0, 11, 12", &v[2], -4);
TEST_STORE3("stfdx 0, 11, 12", 0, &v[0]);
TEST_STORE4("stfdux 0, 11, 12", &v[0], 0);
TEST_STORE4("stfdux 0, 11, 12", &v[0], 4);
TEST_STORE4("stfdux 0, 11, 12", &v[2], -4);
TEST_STORE4("stfdux 0, 11, 12", 0, &v[0]);
// Floating-Point Store Instructions (Other)
TEST_STORE3("stfiwx 0, 11, 12", &v[0], 0);
TEST_STORE3("stfiwx 0, 11, 12", &v[0], 4);
TEST_STORE3("stfiwx 0, 11, 12", &v[2], -4);
TEST_STORE3("stfiwx 0, 11, 12", 0, &v[0]);
return 0;
}

32
tests/cpu/ppu_float_store/ppu_float_store.expected Normal file
View File

@ -0,0 +1,32 @@
stfs 0, 0(11) -> 3C0091A2 00000000 00000000
stfs 0, 8(11) -> 00000000 00000000 3C0091A2
stfs 0, -4(11) -> 00000000 3C0091A2 00000000
stfsu 0, 0(11) -> 3C0091A2 00000000 00000000 [0000000000000000]
stfsu 0, 8(11) -> 00000000 00000000 3C0091A2 [0000000000000008]
stfsu 0, -4(11) -> 00000000 3C0091A2 00000000 [FFFFFFFFFFFFFFFC]
stfsx 0, 11, 12 -> 3C0091A2 00000000 00000000
stfsx 0, 11, 12 -> 00000000 00000000 3C0091A2
stfsx 0, 11, 12 -> 00000000 3C0091A2 00000000
stfsx 0, 11, 12 -> 3C0091A2 00000000 00000000
stfsux 0, 11, 12 -> 3C0091A2 00000000 00000000 [0000000000000000]
stfsux 0, 11, 12 -> 00000000 00000000 3C0091A2 [0000000000000000]
stfsux 0, 11, 12 -> 00000000 3C0091A2 00000000 [0000000000000000]
stfsux 0, 11, 12 -> 3C0091A2 00000000 00000000 [0000000000000000]
stfd 0, 0(11) -> 3F801234 56789ABC 00000000
stfd 0, 4(11) -> 00000000 3F801234 56789ABC
stfd 0, -4(11) -> 3F801234 56789ABC 00000000
stfdu 0, 0(11) -> 3F801234 56789ABC 00000000 [0000000000000000]
stfdu 0, 4(11) -> 00000000 3F801234 56789ABC [0000000000000004]
stfdu 0, -4(11) -> 3F801234 56789ABC 00000000 [FFFFFFFFFFFFFFFC]
stfdx 0, 11, 12 -> 3F801234 56789ABC 00000000
stfdx 0, 11, 12 -> 00000000 3F801234 56789ABC
stfdx 0, 11, 12 -> 00000000 3F801234 56789ABC
stfdx 0, 11, 12 -> 3F801234 56789ABC 00000000
stfdux 0, 11, 12 -> 3F801234 56789ABC 00000000 [0000000000000000]
stfdux 0, 11, 12 -> 00000000 3F801234 56789ABC [0000000000000000]
stfdux 0, 11, 12 -> 00000000 3F801234 56789ABC [0000000000000000]
stfdux 0, 11, 12 -> 3F801234 56789ABC 00000000 [0000000000000000]
stfiwx 0, 11, 12 -> 56789ABC 00000000 00000000
stfiwx 0, 11, 12 -> 00000000 56789ABC 00000000
stfiwx 0, 11, 12 -> 00000000 56789ABC 00000000
stfiwx 0, 11, 12 -> 56789ABC 00000000 00000000

BIN
tests/cpu/ppu_float_store/ppu_float_store.ppu.elf Normal file
View File

Binary file not shown.

BIN
tests/cpu/ppu_float_store/ppu_float_store.ppu.self Normal file
View File

Binary file not shown.

133
tests/cpu/ppu_integer_arithmetic/ppu_integer_arithmetic.cpp Normal file
View File

@ -0,0 +1,133 @@
/**
* (c) 2015 Alexandro Sanchez Bach. All rights reserved.
* Released under GPL v2 license. Read LICENSE for more details.
*/
#include <stdio.h>
#include "../../../common/output.h"
// Show results
#define PRINT1(name, i, GPR) \
fprintf(handler, name"([%02d]) -> %016llX [%016llX : %08X]\n", i, *(uint64_t*)&GPR, getXER(), getCR());
#define PRINT2(name, i, j, GPR) \
fprintf(handler, name"([%02d],[%02d]) -> %016llX [%016llX : %08X]\n", i, j, *(uint64_t*)&GPR, getXER(), getCR());
#define PRINT3(name, i, j, k, GPR) \
fprintf(handler, name"([%02d],[%02d],[%02d]) -> %016llX [%016llX : %08X]\n", i, j, k, *(uint64_t*)&GPR, getXER(), getCR());
#define PRINT4(name, i, j, k, l, GPR) \
fprintf(handler, name"([%02d],[%02d],[%02d],[%02d]) -> %016llX [%016llX : %08X]\n", i, j, k, l, *(uint64_t*)&GPR, getXER(), getCR());
// Iterate
#define ITERATE1(x) \
for (uint32_t i=0; i<sizeof(testInts64)/sizeof(testInts64[0]); i++) \
{uint64_t r0, r1=testInts64[i]; clearCR(); clearXER(); x;}
#define ITERATE2(x) \
for (uint32_t i=0; i<sizeof(testInts64)/sizeof(testInts64[0]); i++) \
for (uint32_t j=0; j<sizeof(testInts64)/sizeof(testInts64[0]); j++) \
{uint64_t r0, r1=testInts64[i], r2=testInts64[j]; clearCR(); clearXER(); x;}
// Get contents of the CR register
uint32_t getCR()
{
uint32_t CR;
__asm__ ("mfcr %0" : "=r"(CR));
return CR;
};
// Get contents of the XER register
uint64_t getXER()
{
uint64_t XER;
__asm__ ("mfxer %0" : "=r"(XER));
return XER;
};
// Clear CR register
void clearCR()
{
uint32_t CR = 0;
__asm__ ("mtcr %0" : "=r"(CR));
};
// Clear XER register
void clearXER()
{
uint64_t XER = 0;
__asm__ ("mtxer %0" : "=r"(XER));
};
uint64_t testInts64[] = {
0x0000000000000000LL, 0x0000000000000001LL, 0x0000000000000002LL, 0xFFFFFFFFFFFFFFFFLL, // 0 1 2 3
0xFFFFFFFFFFFFFFFELL, 0x0003333300330033LL, 0x000000FFFFF00000LL, 0x1000000000000000LL, // 4 5 6 7
0x1FFFFFFFFFFFFFFFLL, 0x4238572200000000LL, 0x7000000000000000LL, 0x0000000072233411LL, // 8 9 10 11
0x7FFFFFFFFFFFFFFFLL, 0x8000000000000000LL, 0x8000000000000001LL, 0x0123456789ABCDEFLL, // 12 13 14 15
};
int main(void)
{
FILE* handler = fopen("/app_home/" OUTPUT_FILE, "wb");
// Integer Arithmetic Instructions
ITERATE2(__asm__ ("add %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("add ",i,j,r0));
ITERATE2(__asm__ ("add. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("add. ",i,j,r0));
ITERATE2(__asm__ ("addc %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("addc ",i,j,r0));
ITERATE2(__asm__ ("addc. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("addc. ",i,j,r0));
ITERATE2(__asm__ ("adde %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("adde ",i,j,r0));
ITERATE2(__asm__ ("adde. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("adde. ",i,j,r0));
ITERATE1(__asm__ ("addi %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0)); PRINT2("addi ",i,0,r0));
ITERATE1(__asm__ ("addi %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(1)); PRINT2("addi ",i,1,r0));
ITERATE1(__asm__ ("addi %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(-1)); PRINT2("addi ",i,-1,r0));
ITERATE1(__asm__ ("addic %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0)); PRINT2("addic ",i,0,r0));
ITERATE1(__asm__ ("addic %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(1)); PRINT2("addic ",i,1,r0));
ITERATE1(__asm__ ("addic %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(-1)); PRINT2("addic ",i,-1,r0));
ITERATE1(__asm__ ("addic. %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0)); PRINT2("addic. ",i,0,r0));
ITERATE1(__asm__ ("addic. %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(1)); PRINT2("addic. ",i,1,r0));
ITERATE1(__asm__ ("addic. %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(-1)); PRINT2("addic. ",i,-1,r0));
ITERATE1(__asm__ ("addis %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0)); PRINT2("addis ",i,0,r0));
ITERATE1(__asm__ ("addis %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(1)); PRINT2("addis ",i,1,r0));
ITERATE1(__asm__ ("addis %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(-1)); PRINT2("addis ",i,-1,r0));
ITERATE1(__asm__ ("addme %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("addme ",i,r0));
ITERATE1(__asm__ ("addme. %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("addme. ",i,r0));
ITERATE1(__asm__ ("addze %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("addze ",i,r0));
ITERATE1(__asm__ ("addze. %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("addze. ",i,r0));
ITERATE2(__asm__ ("divd %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("divd ",i,j,r0));
ITERATE2(__asm__ ("divd. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("divd. ",i,j,r0));
ITERATE2(__asm__ ("divdu %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("divdu ",i,j,r0));
ITERATE2(__asm__ ("divdu. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("divdu. ",i,j,r0));
ITERATE2(__asm__ ("divw %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("divw ",i,j,r0));
ITERATE2(__asm__ ("divw. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("divw. ",i,j,r0));
ITERATE2(__asm__ ("divwu %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("divwu ",i,j,r0));
ITERATE2(__asm__ ("divwu. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("divwu. ",i,j,r0));
ITERATE2(__asm__ ("mulhd %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("mulhd ",i,j,r0));
ITERATE2(__asm__ ("mulhd. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("mulhd. ",i,j,r0));
ITERATE2(__asm__ ("mulhdu %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("mulhdu ",i,j,r0));
ITERATE2(__asm__ ("mulhdu. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("mulhdu.",i,j,r0));
ITERATE2(__asm__ ("mulhw %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("mulhw ",i,j,r0));
ITERATE2(__asm__ ("mulhw. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("mulhw. ",i,j,r0));
ITERATE2(__asm__ ("mulhwu %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("mulhwu ",i,j,r0));
ITERATE2(__asm__ ("mulhwu. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("mulhwu.",i,j,r0));
ITERATE2(__asm__ ("mulld %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("mulld ",i,j,r0));
ITERATE1(__asm__ ("mulli %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0)); PRINT2("mulli ",i,0,r0));
ITERATE1(__asm__ ("mulli %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(1)); PRINT2("mulli ",i,1,r0));
ITERATE1(__asm__ ("mulli %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(-1)); PRINT2("mulli ",i,-1,r0));
ITERATE2(__asm__ ("mullw %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("mullw ",i,j,r0));
ITERATE2(__asm__ ("mullw. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("mullw. ",i,j,r0));
ITERATE1(__asm__ ("neg %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("neg ",i,r0));
ITERATE1(__asm__ ("neg. %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("neg. ",i,r0));
ITERATE2(__asm__ ("subf %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("subf ",i,j,r0));
ITERATE2(__asm__ ("subf. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("subf. ",i,j,r0));
ITERATE2(__asm__ ("subfc %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("subfc ",i,j,r0));
ITERATE2(__asm__ ("subfc. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("subfc. ",i,j,r0));
ITERATE1(__asm__ ("subfic %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0)); PRINT2("subfic ",i,0,r0));
ITERATE1(__asm__ ("subfic %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(1)); PRINT2("subfic ",i,1,r0));
ITERATE1(__asm__ ("subfic %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(-1)); PRINT2("subfic ",i,-1,r0));
ITERATE2(__asm__ ("subfe %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("subfe ",i,j,r0));
ITERATE2(__asm__ ("subfe. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("subfe. ",i,j,r0));
ITERATE1(__asm__ ("subfme %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("subfme ",i,r0));
ITERATE1(__asm__ ("subfme. %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("subfme.",i,r0));
ITERATE1(__asm__ ("subfze %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("subfze ",i,r0));
ITERATE1(__asm__ ("subfze. %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("subfze.",i,r0));
return 0;
}

8384
tests/cpu/ppu_integer_arithmetic/ppu_integer_arithmetic.expected Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
tests/cpu/ppu_integer_arithmetic/ppu_integer_arithmetic.ppu.elf Normal file
View File

Binary file not shown.

BIN
tests/cpu/ppu_integer_arithmetic/ppu_integer_arithmetic.ppu.self Normal file
View File

Binary file not shown.

87
tests/cpu/ppu_integer_compare/ppu_integer_compare.cpp Normal file
View File

@ -0,0 +1,87 @@
/**
* (c) 2015 Alexandro Sanchez Bach. All rights reserved.
* Released under GPL v2 license. Read LICENSE for more details.
*/
#include <stdio.h>
#include "../../../common/output.h"
// Show results
#define PRINT1(name, i) \
fprintf(handler, name"([%02d]) -> [%08X]\n", i, getCR());
#define PRINT2(name, i, j) \
fprintf(handler, name"([%02d],[%02d]) -> [%08X]\n", i, j, getCR());
#define PRINT3(name, i, j, k) \
fprintf(handler, name"([%02d],[%02d],[%02d]) -> [%08X]\n", i, j, k, getCR());
#define PRINT4(name, i, j, k, l) \
fprintf(handler, name"([%02d],[%02d],[%02d],[%02d]) -> [%08X]\n", i, j, k, l, getCR());
// Iterate
#define ITERATE1(x) \
for (uint32_t i=0; i<sizeof(testInts64)/sizeof(testInts64[0]); i++) \
{uint64_t r1=testInts64[i]; clearCR(); x;}
#define ITERATE2(x) \
for (uint32_t i=0; i<sizeof(testInts64)/sizeof(testInts64[0]); i++) \
for (uint32_t j=0; j<sizeof(testInts64)/sizeof(testInts64[0]); j++) \
{uint64_t r1=testInts64[i], r2=testInts64[j]; clearCR(); x;}
// Get contents of the CR register
uint32_t getCR()
{
uint32_t CR;
__asm__ ("mfcr %0" : "=r"(CR));
return CR;
};
// Clear CR register
void clearCR()
{
uint32_t CR = 0;
__asm__ ("mtcr %0" : "=r"(CR));
};
uint64_t testInts64[] = {
0x0000000000000000LL, 0x0000000000000001LL, 0xFFFFFFFFFFFFFFFFLL, 0x00000000FFFFFFFFLL, // 0 1 2 3
0x7FFFFFFFFFFFFFFFLL, 0x000000007FFFFFFFLL, 0x8000000000000000LL, 0x0000000080000000LL, // 4 5 6 7
0xFFFFFFFF00000000LL, 0x7FFFFFFF00000000LL, 0x0123456789ABCDEFLL, 0x0000000072233411LL, // 8 9 10 11
0x0003333300330033LL, 0x8000000100000001LL, 0x4238572200000000LL, 0x000000FFFFF00000LL, // 12 13 14 15
};
int main(void)
{
FILE* handler = fopen("/app_home/" OUTPUT_FILE, "wb");
// Integer Compare Instructions
ITERATE1(__asm__ ("cmpi cr0,%0,%1,%2" : : "i"(0), "r"(r1), "i"( 0)); PRINT3("cmpi ",0,i, 0));
ITERATE1(__asm__ ("cmpi cr1,%0,%1,%2" : : "i"(0), "r"(r1), "i"( 1)); PRINT3("cmpi ",0,i, 1));
ITERATE1(__asm__ ("cmpi cr2,%0,%1,%2" : : "i"(0), "r"(r1), "i"(-1)); PRINT3("cmpi ",0,i,-1));
ITERATE1(__asm__ ("cmpi cr3,%0,%1,%2" : : "i"(0), "r"(r1), "i"( 32767)); PRINT3("cmpi ",0,i, 32767));
ITERATE1(__asm__ ("cmpi cr4,%0,%1,%2" : : "i"(0), "r"(r1), "i"(-32768)); PRINT3("cmpi ",0,i,-32768));
ITERATE1(__asm__ ("cmpi cr5,%0,%1,%2" : : "i"(0), "r"(r1), "i"(-32767)); PRINT3("cmpi ",0,i,-32767));
ITERATE1(__asm__ ("cmpi cr6,%0,%1,%2" : : "i"(1), "r"(r1), "i"( 0)); PRINT3("cmpi ",1,i, 0));
ITERATE1(__asm__ ("cmpi cr7,%0,%1,%2" : : "i"(1), "r"(r1), "i"( 1)); PRINT3("cmpi ",1,i, 1));
ITERATE1(__asm__ ("cmpi cr0,%0,%1,%2" : : "i"(1), "r"(r1), "i"(-1)); PRINT3("cmpi ",1,i,-1));
ITERATE1(__asm__ ("cmpi cr1,%0,%1,%2" : : "i"(1), "r"(r1), "i"( 32767)); PRINT3("cmpi ",1,i, 32767));
ITERATE1(__asm__ ("cmpi cr2,%0,%1,%2" : : "i"(1), "r"(r1), "i"(-32768)); PRINT3("cmpi ",1,i,-32768));
ITERATE1(__asm__ ("cmpi cr3,%0,%1,%2" : : "i"(1), "r"(r1), "i"(-32767)); PRINT3("cmpi ",1,i,-32767));
ITERATE2(__asm__ ("cmp cr4,%0,%1,%2" : : "i"(0), "r"(r1), "r"(r2)); PRINT3("cmp ",0,i,j));
ITERATE2(__asm__ ("cmp cr5,%0,%1,%2" : : "i"(1), "r"(r1), "r"(r2)); PRINT3("cmp ",1,i,j));
ITERATE1(__asm__ ("cmpli cr6,%0,%1,%2" : : "i"(0), "r"(r1), "i"( 0)); PRINT3("cmpli",0,i, 0));
ITERATE1(__asm__ ("cmpli cr7,%0,%1,%2" : : "i"(0), "r"(r1), "i"( 1)); PRINT3("cmpli",0,i, 1));
ITERATE1(__asm__ ("cmpli cr0,%0,%1,%2" : : "i"(0), "r"(r1), "i"(0xffff)); PRINT3("cmpli",0,i,0xffff));
ITERATE1(__asm__ ("cmpli cr1,%0,%1,%2" : : "i"(0), "r"(r1), "i"(0x7fff)); PRINT3("cmpli",0,i,0x7fff));
ITERATE1(__asm__ ("cmpli cr2,%0,%1,%2" : : "i"(0), "r"(r1), "i"(0x8000)); PRINT3("cmpli",0,i,0x8000));
ITERATE1(__asm__ ("cmpli cr3,%0,%1,%2" : : "i"(0), "r"(r1), "i"(0x8001)); PRINT3("cmpli",0,i,0x8001));
ITERATE1(__asm__ ("cmpli cr4,%0,%1,%2" : : "i"(1), "r"(r1), "i"( 0)); PRINT3("cmpli",1,i, 0));
ITERATE1(__asm__ ("cmpli cr5,%0,%1,%2" : : "i"(1), "r"(r1), "i"( 1)); PRINT3("cmpli",1,i, 1));
ITERATE1(__asm__ ("cmpli cr6,%0,%1,%2" : : "i"(1), "r"(r1), "i"(0xffff)); PRINT3("cmpli",1,i,0xffff));
ITERATE1(__asm__ ("cmpli cr7,%0,%1,%2" : : "i"(1), "r"(r1), "i"(0x7fff)); PRINT3("cmpli",1,i,0x7fff));
ITERATE1(__asm__ ("cmpli cr0,%0,%1,%2" : : "i"(1), "r"(r1), "i"(0x8000)); PRINT3("cmpli",1,i,0x8000));
ITERATE1(__asm__ ("cmpli cr1,%0,%1,%2" : : "i"(1), "r"(r1), "i"(0x8001)); PRINT3("cmpli",1,i,0x8001));
ITERATE2(__asm__ ("cmpl cr2,%0,%1,%2" : : "i"(0), "r"(r1), "r"(r2)); PRINT3("cmpl ",0,i,j));
ITERATE2(__asm__ ("cmpl cr3,%0,%1,%2" : : "i"(1), "r"(r1), "r"(r2)); PRINT3("cmpl ",1,i,j));
return 0;
}

1408
tests/cpu/ppu_integer_compare/ppu_integer_compare.expected Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
tests/cpu/ppu_integer_compare/ppu_integer_compare.ppu.elf Normal file
View File

Binary file not shown.

BIN
tests/cpu/ppu_integer_compare/ppu_integer_compare.ppu.self Normal file
View File

Binary file not shown.

103
tests/cpu/ppu_integer_logical/ppu_integer_logical.cpp Normal file
View File

@ -0,0 +1,103 @@
/**
* (c) 2015 Alexandro Sanchez Bach. All rights reserved.
* Released under GPL v2 license. Read LICENSE for more details.
*/
#include <stdio.h>
#include "../../../common/output.h"
// Show results
#define PRINT1(name, i, GPR) \
fprintf(handler, name"([%02d]) -> %016llX [%08X]\n", i, *(uint64_t*)&GPR, getCR());
#define PRINT2(name, i, j, GPR) \
fprintf(handler, name"([%02d],[%02d]) -> %016llX [%08X]\n", i, j, *(uint64_t*)&GPR, getCR());
#define PRINT3(name, i, j, k, GPR) \
fprintf(handler, name"([%02d],[%02d],[%02d]) -> %016llX [%08X]\n", i, j, k, *(uint64_t*)&GPR, getCR());
#define PRINT4(name, i, j, k, l, GPR) \
fprintf(handler, name"([%02d],[%02d],[%02d],[%02d]) -> %016llX [%08X]\n", i, j, k, l, *(uint64_t*)&GPR, getCR());
// Iterate
#define ITERATE1(x) \
for (uint32_t i=0; i<sizeof(testInts64)/sizeof(testInts64[0]); i++) \
{uint64_t r0, r1=testInts64[i]; clearCR(); x;}
#define ITERATE2(x) \
for (uint32_t i=0; i<sizeof(testInts64)/sizeof(testInts64[0]); i++) \
for (uint32_t j=0; j<sizeof(testInts64)/sizeof(testInts64[0]); j++) \
{uint64_t r0, r1=testInts64[i], r2=testInts64[j]; clearCR(); x;}
// Get contents of the CR register
uint32_t getCR()
{
uint32_t CR;
__asm__ ("mfcr %0" : "=r"(CR));
return CR;
};
// Clear CR register
void clearCR()
{
uint32_t CR = 0;
__asm__ ("mtcr %0" : "=r"(CR));
};
uint64_t testInts64[] = {
0x0000000000000000LL, 0x0000000000000001LL, 0x0000000000000002LL, 0xFFFFFFFFFFFFFFFFLL, // 0 1 2 3
0xFFFFFFFFFFFFFFFELL, 0x0003333300330033LL, 0x000000FFFFF00000LL, 0x1000000000000000LL, // 4 5 6 7
0x1FFFFFFFFFFFFFFFLL, 0x4238572200000000LL, 0x7000000000000000LL, 0x0000000072233411LL, // 8 9 10 11
0x7FFFFFFFFFFFFFFFLL, 0x8000000000000000LL, 0x8000000000000001LL, 0x0123456789ABCDEFLL, // 12 13 14 15
};
int main(void)
{
FILE* handler = fopen("/app_home/" OUTPUT_FILE, "wb");
// Integer Logical Instructions
ITERATE2(__asm__ ("and %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("and ",i,j,r0));
ITERATE2(__asm__ ("and. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("and. ",i,j,r0));
ITERATE2(__asm__ ("andc %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("andc ",i,j,r0));
ITERATE2(__asm__ ("andc. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("andc. ",i,j,r0));
ITERATE1(__asm__ ("andi. %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0x0000)); PRINT2("andi. ",i,0,r0));
ITERATE1(__asm__ ("andi. %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0x0001)); PRINT2("andi. ",i,1,r0));
ITERATE1(__asm__ ("andi. %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0xFFFF)); PRINT2("andi. ",i,0xFFFF,r0));
ITERATE1(__asm__ ("andis. %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0x0000)); PRINT2("andis. ",i,0,r0));
ITERATE1(__asm__ ("andis. %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0x0001)); PRINT2("andis. ",i,1,r0));
ITERATE1(__asm__ ("andis. %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0xFFFF)); PRINT2("andis. ",i,0xFFFF,r0));
ITERATE1(__asm__ ("cntlzd %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("cntlzd ",i,r0));
ITERATE1(__asm__ ("cntlzd. %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("cntlzd.",i,r0));
ITERATE1(__asm__ ("cntlzw %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("cntlzw ",i,r0));
ITERATE1(__asm__ ("cntlzw. %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("cntlzw.",i,r0));
ITERATE2(__asm__ ("eqv %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("eqv ",i,j,r0));
ITERATE2(__asm__ ("eqv. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("eqv. ",i,j,r0));
ITERATE1(__asm__ ("extsb %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("extsb ",i,r0));
ITERATE1(__asm__ ("extsb. %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("extsb. ",i,r0));
ITERATE1(__asm__ ("extsh %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("extsh ",i,r0));
ITERATE1(__asm__ ("extsh. %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("extsh. ",i,r0));
ITERATE1(__asm__ ("extsw %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("extsw ",i,r0));
ITERATE1(__asm__ ("extsw. %0,%1" : "=r"(r0) : "r"(r1)); PRINT1("extsw. ",i,r0));
ITERATE2(__asm__ ("nand %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("nand ",i,j,r0));
ITERATE2(__asm__ ("nand. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("nand. ",i,j,r0));
ITERATE2(__asm__ ("nor %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("nor ",i,j,r0));
ITERATE2(__asm__ ("nor. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("nor. ",i,j,r0));
ITERATE2(__asm__ ("or %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("or ",i,j,r0));
ITERATE2(__asm__ ("or. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("or. ",i,j,r0));
ITERATE2(__asm__ ("orc %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("orc ",i,j,r0));
ITERATE2(__asm__ ("orc. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("orc. ",i,j,r0));
ITERATE1(__asm__ ("ori %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0x0000)); PRINT2("ori ",i,0,r0));
ITERATE1(__asm__ ("ori %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0x0001)); PRINT2("ori ",i,1,r0));
ITERATE1(__asm__ ("ori %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0xFFFF)); PRINT2("ori ",i,0xFFFF,r0));
ITERATE1(__asm__ ("oris %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0x0000)); PRINT2("oris ",i,0,r0));
ITERATE1(__asm__ ("oris %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0x0001)); PRINT2("oris ",i,1,r0));
ITERATE1(__asm__ ("oris %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0xFFFF)); PRINT2("oris ",i,0xFFFF,r0));
ITERATE2(__asm__ ("xor %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("xor ",i,j,r0));
ITERATE2(__asm__ ("xor. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("xor. ",i,j,r0));
ITERATE1(__asm__ ("xori %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0x0000)); PRINT2("xori ",i,0,r0));
ITERATE1(__asm__ ("xori %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0x0001)); PRINT2("xori ",i,1,r0));
ITERATE1(__asm__ ("xori %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0xFFFF)); PRINT2("xori ",i,0xFFFF,r0));
ITERATE1(__asm__ ("xoris %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0x0000)); PRINT2("xoris ",i,0,r0));
ITERATE1(__asm__ ("xoris %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0x0001)); PRINT2("xoris ",i,1,r0));
ITERATE1(__asm__ ("xoris %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0xFFFF)); PRINT2("xoris ",i,0xFFFF,r0));
return 0;
}

4544
tests/cpu/ppu_integer_logical/ppu_integer_logical.expected Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
tests/cpu/ppu_integer_logical/ppu_integer_logical.ppu.elf Normal file
View File

Binary file not shown.

BIN
tests/cpu/ppu_integer_logical/ppu_integer_logical.ppu.self Normal file
View File

Binary file not shown.

177
tests/cpu/ppu_integer_rotate/ppu_integer_rotate.cpp Normal file
View File

@ -0,0 +1,177 @@
/**
* (c) 2015 Alexandro Sanchez Bach. All rights reserved.
* Released under GPL v2 license. Read LICENSE for more details.
*/
#include <stdio.h>
#include "../../../common/output.h"
// Show results
#define PRINT1(name, i, GPR) \
fprintf(handler, name"([%02d]) -> %016llX [%08X]\n", i, *(uint64_t*)&GPR, getCR());
#define PRINT2(name, i, j, GPR) \
fprintf(handler, name"([%02d],[%02d]) -> %016llX [%08X]\n", i, j, *(uint64_t*)&GPR, getCR());
#define PRINT3(name, i, j, k, GPR) \
fprintf(handler, name"([%02d],[%02d],[%02d]) -> %016llX [%08X]\n", i, j, k, *(uint64_t*)&GPR, getCR());
#define PRINT4(name, i, j, k, l, GPR) \
fprintf(handler, name"([%02d],[%02d],[%02d],[%02d]) -> %016llX [%08X]\n", i, j, k, l, *(uint64_t*)&GPR, getCR());
// Pair-wise coverage for 3 arguments
#define PAIRWISE3(name, a, b, c) \
ITERATE1(__asm__ (name " %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "i"(a), "i"(a), "i"(a)); PRINT4(name, i, a, a, a, r0)); \
ITERATE1(__asm__ (name " %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "i"(b), "i"(b), "i"(a)); PRINT4(name, i, b, b, a, r0)); \
ITERATE1(__asm__ (name " %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "i"(c), "i"(c), "i"(a)); PRINT4(name, i, c, c, a, r0)); \
ITERATE1(__asm__ (name " %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "i"(b), "i"(a), "i"(b)); PRINT4(name, i, b, a, b, r0)); \
ITERATE1(__asm__ (name " %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "i"(c), "i"(b), "i"(b)); PRINT4(name, i, c, b, b, r0)); \
ITERATE1(__asm__ (name " %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "i"(a), "i"(c), "i"(b)); PRINT4(name, i, a, c, b, r0)); \
ITERATE1(__asm__ (name " %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "i"(c), "i"(a), "i"(c)); PRINT4(name, i, c, a, c, r0)); \
ITERATE1(__asm__ (name " %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "i"(a), "i"(b), "i"(c)); PRINT4(name, i, a, b, c, r0)); \
ITERATE1(__asm__ (name " %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "i"(b), "i"(c), "i"(c)); PRINT4(name, i, b, c, c, r0));
// Iterate
#define ITERATE1(x) \
for (uint32_t i=0; i<sizeof(testInts64)/sizeof(testInts64[0]); i++) \
{uint64_t r0, r1=testInts64[i]; clearCR(); x;}
#define ITERATE2(x) \
for (uint32_t i=0; i<sizeof(testInts64)/sizeof(testInts64[0]); i++) \
for (uint32_t j=0; j<sizeof(testInts64)/sizeof(testInts64[0]); j++) \
{uint64_t r0, r1=testInts64[i], r2=testInts64[j]; clearCR(); x;}
// Get contents of the CR register
uint32_t getCR()
{
uint32_t CR;
__asm__ ("mfcr %0" : "=r"(CR));
return CR;
};
// Clear CR register
void clearCR()
{
uint32_t CR = 0;
__asm__ ("mtcr %0" : "=r"(CR));
};
uint64_t testInts64[] = {
0x0000000000000000LL, 0x0000000000000001LL, 0x0000000000000002LL, 0xFFFFFFFFFFFFFFFFLL, // 0 1 2 3
0xFFFFFFFFFFFFFFFELL, 0x0003333300330033LL, 0x000000FFFFF00000LL, 0x1000000000000000LL, // 4 5 6 7
0x1FFFFFFFFFFFFFFFLL, 0x4238572200000000LL, 0x7000000000000000LL, 0x0000000072233411LL, // 8 9 10 11
0x7FFFFFFFFFFFFFFFLL, 0x8000000000000000LL, 0x8000000000000001LL, 0x0123456789ABCDEFLL, // 12 13 14 15
};
int main(void)
{
FILE* handler = fopen("/app_home/" OUTPUT_FILE, "wb");
// Integer Rotate Instructions
ITERATE2(__asm__ ("rldcl %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "r"(r2), "i"(0)); PRINT3("rldcl ",i,j,0,r0));
ITERATE2(__asm__ ("rldcl %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "r"(r2), "i"(1)); PRINT3("rldcl ",i,j,1,r0));
ITERATE2(__asm__ ("rldcl %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "r"(r2), "i"(63)); PRINT3("rldcl ",i,j,63,r0));
ITERATE2(__asm__ ("rldcl. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "r"(r2), "i"(0)); PRINT3("rldcl. ",i,j,0,r0));
ITERATE2(__asm__ ("rldcl. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "r"(r2), "i"(1)); PRINT3("rldcl. ",i,j,1,r0));
ITERATE2(__asm__ ("rldcl. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "r"(r2), "i"(63)); PRINT3("rldcl. ",i,j,63,r0));
ITERATE2(__asm__ ("rldcr %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "r"(r2), "i"(0)); PRINT3("rldcr ",i,j,0,r0));
ITERATE2(__asm__ ("rldcr %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "r"(r2), "i"(1)); PRINT3("rldcr ",i,j,1,r0));
ITERATE2(__asm__ ("rldcr %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "r"(r2), "i"(63)); PRINT3("rldcr ",i,j,63,r0));
ITERATE2(__asm__ ("rldcr. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "r"(r2), "i"(0)); PRINT3("rldcr. ",i,j,0,r0));
ITERATE2(__asm__ ("rldcr. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "r"(r2), "i"(1)); PRINT3("rldcr. ",i,j,1,r0));
ITERATE2(__asm__ ("rldcr. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "r"(r2), "i"(63)); PRINT3("rldcr. ",i,j,63,r0));
ITERATE1(__asm__ ("rldic %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(0)); PRINT3("rldic ",i,0,0,r0));
ITERATE1(__asm__ ("rldic %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(1)); PRINT3("rldic ",i,0,1,r0));
ITERATE1(__asm__ ("rldic %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(63)); PRINT3("rldic ",i,0,63,r0));
ITERATE1(__asm__ ("rldic %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(0)); PRINT3("rldic ",i,1,0,r0));
ITERATE1(__asm__ ("rldic %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(1)); PRINT3("rldic ",i,1,1,r0));
ITERATE1(__asm__ ("rldic %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(63)); PRINT3("rldic ",i,1,63,r0));
ITERATE1(__asm__ ("rldic %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(0)); PRINT3("rldic ",i,63,0,r0));
ITERATE1(__asm__ ("rldic %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(1)); PRINT3("rldic ",i,63,1,r0));
ITERATE1(__asm__ ("rldic %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(63)); PRINT3("rldic ",i,63,63,r0));
ITERATE1(__asm__ ("rldic. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(0)); PRINT3("rldic. ",i,0,0,r0));
ITERATE1(__asm__ ("rldic. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(1)); PRINT3("rldic. ",i,0,1,r0));
ITERATE1(__asm__ ("rldic. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(63)); PRINT3("rldic. ",i,0,63,r0));
ITERATE1(__asm__ ("rldic. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(0)); PRINT3("rldic. ",i,1,0,r0));
ITERATE1(__asm__ ("rldic. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(1)); PRINT3("rldic. ",i,1,1,r0));
ITERATE1(__asm__ ("rldic. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(63)); PRINT3("rldic. ",i,1,63,r0));
ITERATE1(__asm__ ("rldic. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(0)); PRINT3("rldic. ",i,63,0,r0));
ITERATE1(__asm__ ("rldic. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(1)); PRINT3("rldic. ",i,63,1,r0));
ITERATE1(__asm__ ("rldic. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(63)); PRINT3("rldic. ",i,63,63,r0));
ITERATE1(__asm__ ("rldicl %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(0)); PRINT3("rldicl ",i,0,0,r0));
ITERATE1(__asm__ ("rldicl %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(1)); PRINT3("rldicl ",i,0,1,r0));
ITERATE1(__asm__ ("rldicl %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(63)); PRINT3("rldicl ",i,0,63,r0));
ITERATE1(__asm__ ("rldicl %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(0)); PRINT3("rldicl ",i,1,0,r0));
ITERATE1(__asm__ ("rldicl %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(1)); PRINT3("rldicl ",i,1,1,r0));
ITERATE1(__asm__ ("rldicl %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(63)); PRINT3("rldicl ",i,1,63,r0));
ITERATE1(__asm__ ("rldicl %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(0)); PRINT3("rldicl ",i,63,0,r0));
ITERATE1(__asm__ ("rldicl %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(1)); PRINT3("rldicl ",i,63,1,r0));
ITERATE1(__asm__ ("rldicl %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(63)); PRINT3("rldicl ",i,63,63,r0));
ITERATE1(__asm__ ("rldicl. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(0)); PRINT3("rldicl.",i,0,0,r0));
ITERATE1(__asm__ ("rldicl. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(1)); PRINT3("rldicl.",i,0,1,r0));
ITERATE1(__asm__ ("rldicl. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(63)); PRINT3("rldicl.",i,0,63,r0));
ITERATE1(__asm__ ("rldicl. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(0)); PRINT3("rldicl.",i,1,0,r0));
ITERATE1(__asm__ ("rldicl. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(1)); PRINT3("rldicl.",i,1,1,r0));
ITERATE1(__asm__ ("rldicl. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(63)); PRINT3("rldicl.",i,1,63,r0));
ITERATE1(__asm__ ("rldicl. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(0)); PRINT3("rldicl.",i,63,0,r0));
ITERATE1(__asm__ ("rldicl. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(1)); PRINT3("rldicl.",i,63,1,r0));
ITERATE1(__asm__ ("rldicl. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(63)); PRINT3("rldicl.",i,63,63,r0));
ITERATE1(__asm__ ("rldicr %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(0)); PRINT3("rldicr ",i,0,0,r0));
ITERATE1(__asm__ ("rldicr %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(1)); PRINT3("rldicr ",i,0,1,r0));
ITERATE1(__asm__ ("rldicr %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(63)); PRINT3("rldicr ",i,0,63,r0));
ITERATE1(__asm__ ("rldicr %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(0)); PRINT3("rldicr ",i,1,0,r0));
ITERATE1(__asm__ ("rldicr %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(1)); PRINT3("rldicr ",i,1,1,r0));
ITERATE1(__asm__ ("rldicr %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(63)); PRINT3("rldicr ",i,1,63,r0));
ITERATE1(__asm__ ("rldicr %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(0)); PRINT3("rldicr ",i,63,0,r0));
ITERATE1(__asm__ ("rldicr %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(1)); PRINT3("rldicr ",i,63,1,r0));
ITERATE1(__asm__ ("rldicr %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(63)); PRINT3("rldicr ",i,63,63,r0));
ITERATE1(__asm__ ("rldicr. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(0)); PRINT3("rldicr.",i,0,0,r0));
ITERATE1(__asm__ ("rldicr. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(1)); PRINT3("rldicr.",i,0,1,r0));
ITERATE1(__asm__ ("rldicr. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(63)); PRINT3("rldicr.",i,0,63,r0));
ITERATE1(__asm__ ("rldicr. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(0)); PRINT3("rldicr.",i,1,0,r0));
ITERATE1(__asm__ ("rldicr. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(1)); PRINT3("rldicr.",i,1,1,r0));
ITERATE1(__asm__ ("rldicr. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(63)); PRINT3("rldicr.",i,1,63,r0));
ITERATE1(__asm__ ("rldicr. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(0)); PRINT3("rldicr.",i,63,0,r0));
ITERATE1(__asm__ ("rldicr. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(1)); PRINT3("rldicr.",i,63,1,r0));
ITERATE1(__asm__ ("rldicr. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(63)); PRINT3("rldicr.",i,63,63,r0));
ITERATE1(__asm__ ("rldimi %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(0)); PRINT3("rldimi ",i,0,0,r0));
ITERATE1(__asm__ ("rldimi %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(1)); PRINT3("rldimi ",i,0,1,r0));
ITERATE1(__asm__ ("rldimi %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(63)); PRINT3("rldimi ",i,0,63,r0));
ITERATE1(__asm__ ("rldimi %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(0)); PRINT3("rldimi ",i,1,0,r0));
ITERATE1(__asm__ ("rldimi %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(1)); PRINT3("rldimi ",i,1,1,r0));
ITERATE1(__asm__ ("rldimi %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(63)); PRINT3("rldimi ",i,1,63,r0));
ITERATE1(__asm__ ("rldimi %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(0)); PRINT3("rldimi ",i,63,0,r0));
ITERATE1(__asm__ ("rldimi %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(1)); PRINT3("rldimi ",i,63,1,r0));
ITERATE1(__asm__ ("rldimi %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(63)); PRINT3("rldimi ",i,63,63,r0));
ITERATE1(__asm__ ("rldimi. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(0)); PRINT3("rldimi.",i,0,0,r0));
ITERATE1(__asm__ ("rldimi. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(1)); PRINT3("rldimi.",i,0,1,r0));
ITERATE1(__asm__ ("rldimi. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(0), "i"(63)); PRINT3("rldimi.",i,0,63,r0));
ITERATE1(__asm__ ("rldimi. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(0)); PRINT3("rldimi.",i,1,0,r0));
ITERATE1(__asm__ ("rldimi. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(1)); PRINT3("rldimi.",i,1,1,r0));
ITERATE1(__asm__ ("rldimi. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(1), "i"(63)); PRINT3("rldimi.",i,1,63,r0));
ITERATE1(__asm__ ("rldimi. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(0)); PRINT3("rldimi.",i,63,0,r0));
ITERATE1(__asm__ ("rldimi. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(1)); PRINT3("rldimi.",i,63,1,r0));
ITERATE1(__asm__ ("rldimi. %0,%1,%2,%3" : "=r"(r0) : "r"(r1), "i"(63), "i"(63)); PRINT3("rldimi.",i,63,63,r0));
PAIRWISE3("rlwimi ", 0, 1, 31);
PAIRWISE3("rlwimi.", 0, 1, 31);
PAIRWISE3("rlwinm ", 0, 1, 31);
PAIRWISE3("rlwinm.", 0, 1, 31);
ITERATE2(__asm__ ("rlwnm %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"( 0), "i"( 0)); PRINT4("rlwnm ",i,j, 0, 0, r0));
ITERATE2(__asm__ ("rlwnm %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"( 0), "i"( 1)); PRINT4("rlwnm ",i,j, 0, 1, r0));
ITERATE2(__asm__ ("rlwnm %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"( 0), "i"(31)); PRINT4("rlwnm ",i,j, 0,31, r0));
ITERATE2(__asm__ ("rlwnm %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"( 1), "i"( 0)); PRINT4("rlwnm ",i,j, 1, 0, r0));
ITERATE2(__asm__ ("rlwnm %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"( 1), "i"( 1)); PRINT4("rlwnm ",i,j, 1, 1, r0));
ITERATE2(__asm__ ("rlwnm %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"( 1), "i"(31)); PRINT4("rlwnm ",i,j, 1,31, r0));
ITERATE2(__asm__ ("rlwnm %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"(31), "i"( 0)); PRINT4("rlwnm ",i,j,31, 0, r0));
ITERATE2(__asm__ ("rlwnm %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"(31), "i"( 1)); PRINT4("rlwnm ",i,j,31, 1, r0));
ITERATE2(__asm__ ("rlwnm %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"(31), "i"(31)); PRINT4("rlwnm ",i,j,31,31, r0));
ITERATE2(__asm__ ("rlwnm. %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"( 0), "i"( 0)); PRINT4("rlwnm. ",i,j, 0, 0, r0));
ITERATE2(__asm__ ("rlwnm. %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"( 0), "i"( 1)); PRINT4("rlwnm. ",i,j, 0, 1, r0));
ITERATE2(__asm__ ("rlwnm. %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"( 0), "i"(31)); PRINT4("rlwnm. ",i,j, 0,31, r0));
ITERATE2(__asm__ ("rlwnm. %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"( 1), "i"( 0)); PRINT4("rlwnm. ",i,j, 1, 0, r0));
ITERATE2(__asm__ ("rlwnm. %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"( 1), "i"( 1)); PRINT4("rlwnm. ",i,j, 1, 1, r0));
ITERATE2(__asm__ ("rlwnm. %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"( 1), "i"(31)); PRINT4("rlwnm. ",i,j, 1,31, r0));
ITERATE2(__asm__ ("rlwnm. %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"(31), "i"( 0)); PRINT4("rlwnm. ",i,j,31, 0, r0));
ITERATE2(__asm__ ("rlwnm. %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"(31), "i"( 1)); PRINT4("rlwnm. ",i,j,31, 1, r0));
ITERATE2(__asm__ ("rlwnm. %0,%1,%2,%3,%4" : "=r"(r0) : "r"(r1), "r"(r2), "i"(31), "i"(31)); PRINT4("rlwnm. ",i,j,31,31, r0));
return 0;
}

9408
tests/cpu/ppu_integer_rotate/ppu_integer_rotate.expected Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
tests/cpu/ppu_integer_rotate/ppu_integer_rotate.ppu.elf Normal file
View File

Binary file not shown.

BIN
tests/cpu/ppu_integer_rotate/ppu_integer_rotate.ppu.self Normal file
View File

Binary file not shown.

83
tests/cpu/ppu_integer_shift/ppu_integer_shift.cpp Normal file
View File

@ -0,0 +1,83 @@
/**
* (c) 2015 Alexandro Sanchez Bach. All rights reserved.
* Released under GPL v2 license. Read LICENSE for more details.
*/
#include <stdio.h>
#include "../../../common/output.h"
// Show results
#define PRINT1(name, i, GPR) \
fprintf(handler, name"([%02d]) -> %016llX [%08X]\n", i, *(uint64_t*)&GPR, getCR());
#define PRINT2(name, i, j, GPR) \
fprintf(handler, name"([%02d],[%02d]) -> %016llX [%08X]\n", i, j, *(uint64_t*)&GPR, getCR());
#define PRINT3(name, i, j, k, GPR) \
fprintf(handler, name"([%02d],[%02d],[%02d]) -> %016llX [%08X]\n", i, j, k, *(uint64_t*)&GPR, getCR());
#define PRINT4(name, i, j, k, l, GPR) \
fprintf(handler, name"([%02d],[%02d],[%02d],[%02d]) -> %016llX [%08X]\n", i, j, k, l, *(uint64_t*)&GPR, getCR());
// Iterate
#define ITERATE1(x) \
for (uint32_t i=0; i<sizeof(testInts64)/sizeof(testInts64[0]); i++) \
{uint64_t r0, r1=testInts64[i]; clearCR(); x;}
#define ITERATE2(x) \
for (uint32_t i=0; i<sizeof(testInts64)/sizeof(testInts64[0]); i++) \
for (uint32_t j=0; j<sizeof(testInts64)/sizeof(testInts64[0]); j++) \
{uint64_t r0, r1=testInts64[i], r2=testInts64[j]; clearCR(); x;}
// Get contents of the CR register
uint32_t getCR()
{
uint32_t CR;
__asm__ ("mfcr %0" : "=r"(CR));
return CR;
};
// Clear CR register
void clearCR()
{
uint32_t CR = 0;
__asm__ ("mtcr %0" : "=r"(CR));
};
uint64_t testInts64[] = {
0x0000000000000000LL, 0x0000000000000001LL, 0x0000000000000002LL, 0xFFFFFFFFFFFFFFFFLL, // 0 1 2 3
0xFFFFFFFFFFFFFFFELL, 0x0003333300330033LL, 0x000000FFFFF00000LL, 0x1000000000000000LL, // 4 5 6 7
0x1FFFFFFFFFFFFFFFLL, 0x4238572200000000LL, 0x7000000000000000LL, 0x0000000072233411LL, // 8 9 10 11
0x7FFFFFFFFFFFFFFFLL, 0x8000000000000000LL, 0x8000000000000001LL, 0x0123456789ABCDEFLL, // 12 13 14 15
};
int main(void)
{
FILE* handler = fopen("/app_home/" OUTPUT_FILE, "wb");
// Integer Shift Instructions
ITERATE2(__asm__ ("sld %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("sld ",i,j,r0));
ITERATE2(__asm__ ("sld. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("sld. ",i,j,r0));
ITERATE2(__asm__ ("slw %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("slw ",i,j,r0));
ITERATE2(__asm__ ("slw. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("slw. ",i,j,r0));
ITERATE2(__asm__ ("srd %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("srd ",i,j,r0));
ITERATE2(__asm__ ("srd. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("srd. ",i,j,r0));
ITERATE2(__asm__ ("srw %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("srw ",i,j,r0));
ITERATE2(__asm__ ("srw. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("srw. ",i,j,r0));
ITERATE1(__asm__ ("sradi %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0)); PRINT2("sradi ",i,0,r0));
ITERATE1(__asm__ ("sradi %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(1)); PRINT2("sradi ",i,1,r0));
ITERATE1(__asm__ ("sradi %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(63)); PRINT2("sradi ",i,63,r0));
ITERATE1(__asm__ ("sradi. %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0)); PRINT2("sradi. ",i,0,r0));
ITERATE1(__asm__ ("sradi. %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(1)); PRINT2("sradi. ",i,1,r0));
ITERATE1(__asm__ ("sradi. %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(63)); PRINT2("sradi. ",i,63,r0));
ITERATE1(__asm__ ("srawi %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0)); PRINT2("srawi ",i,0,r0));
ITERATE1(__asm__ ("srawi %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(1)); PRINT2("srawi ",i,1,r0));
ITERATE1(__asm__ ("srawi %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(31)); PRINT2("srawi ",i,31,r0));
ITERATE1(__asm__ ("srawi. %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(0)); PRINT2("srawi. ",i,0,r0));
ITERATE1(__asm__ ("srawi. %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(1)); PRINT2("srawi. ",i,1,r0));
ITERATE1(__asm__ ("srawi. %0,%1,%2" : "=r"(r0) : "r"(r1), "i"(31)); PRINT2("srawi. ",i,31,r0));
ITERATE2(__asm__ ("srad %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("srad ",i,j,r0));
ITERATE2(__asm__ ("srad. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("srad. ",i,j,r0));
ITERATE2(__asm__ ("sraw %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("sraw ",i,j,r0));
ITERATE2(__asm__ ("sraw. %0,%1,%2" : "=r"(r0) : "r"(r1), "r"(r2)); PRINT2("sraw. ",i,j,r0));
return 0;
}

3264
tests/cpu/ppu_integer_shift/ppu_integer_shift.expected Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
tests/cpu/ppu_integer_shift/ppu_integer_shift.ppu.elf Normal file
View File

Binary file not shown.

BIN
tests/cpu/ppu_integer_shift/ppu_integer_shift.ppu.self Normal file
View File

Binary file not shown.

123
tests/cpu/ppu_vector_integer_arithmetic/ppu_vector_integer_arithmetic.cpp Normal file
View File

@ -0,0 +1,123 @@
/**
* (c) 2015 Alexandro Sanchez Bach. All rights reserved.
* Released under GPL v2 license. Read LICENSE for more details.
*/
#include <float.h>
#include <math.h>
#include <stdio.h>
#include <altivec.h>
#include "../../../common/output.h"
// Show results
#define PRINT1(name, i, VPR) \
fprintf(handler, name"([%02d]) -> %08X %08X %08X %08X [%08X]\n", i, \
((vec_int4)VPR)[0], ((vec_int4)VPR)[1], ((vec_int4)VPR)[2], ((vec_int4)VPR)[3], getVSCR());
#define PRINT2(name, i, j, VPR) \
fprintf(handler, name"([%02d],[%02d]) -> %08X %08X %08X %08X [%08X]\n", i, j, \
((vec_int4)VPR)[0], ((vec_int4)VPR)[1], ((vec_int4)VPR)[2], ((vec_int4)VPR)[3], getVSCR());
#define PRINT3(name, i, j, k, GPR) \
fprintf(handler, name"([%02d],[%02d],[%02d]) -> %08X %08X %08X %08X [%08X]\n", i, j, k, \
((vec_int4)VPR)[0], ((vec_int4)VPR)[1], ((vec_int4)VPR)[2], ((vec_int4)VPR)[3], getVSCR());
#define PRINT4(name, i, j, k, l, GPR) \
fprintf(handler, name"([%02d],[%02d],[%02d],[%02d]) -> %08X %08X %08X %08X [%08X]\n", i, j, k, l, \
((vec_int4)VPR)[0], ((vec_int4)VPR)[1], ((vec_int4)VPR)[2], ((vec_int4)VPR)[3], getVSCR());
// Iterate
#define ITERATE2I(x) \
for (uint32_t i=0; i<sizeof(testInts)/sizeof(testInts[0]); i++) \
for (uint32_t j=0; j<sizeof(testInts)/sizeof(testInts[0]); j++) \
{vec_int4 v1sw = (vec_int4)(testInts[i]); \
vec_int4 v2sw = (vec_int4)(testInts[j], testInts[j], 0.0, 0.0); \
vec_short8 v1sh = *(vec_short8 *)&v1sw; \
vec_short8 v2sh = *(vec_short8 *)&v2sw; \
vec_char16 v1sb = *(vec_char16 *)&v1sw; \
vec_char16 v2sb = *(vec_char16 *)&v2sw; \
vec_uint4 v1uw = (vec_uint4)(testInts[i]); \
vec_uint4 v2uw = (vec_uint4)(testInts[j], testInts[j], 0.0, 0.0); \
vec_ushort8 v1uh = *(vec_ushort8 *)&v1uw; \
vec_ushort8 v2uh = *(vec_ushort8 *)&v2uw; \
vec_uchar16 v1ub = *(vec_uchar16 *)&v1uw; \
vec_uchar16 v2ub = *(vec_uchar16 *)&v2uw; \
clearVSCR(); x;}
// Get contents of the VSCR register
uint32_t getVSCR()
{
return ((vec_int4)vec_mfvscr())[3];
};
// Clear VSCR register
void clearVSCR()
{
vec_ushort8 VSCR = (vec_ushort8)();
vec_mtvscr(VSCR);
};
const uint32_t testInts[] = {
0x00000000, 0x00000001, 0x00000002, 0xffffffff, // 0 1 2 3
0xfffffffe, 0xfffffffd, 0x00033333, 0x00fffff0, // 4 5 6 7
0x10000000, 0x12345678, 0x1fffffff, 0x42385722, // 8 9 10 11
0x7fffffff, 0x80000000, 0x80000001, 0x8fffffff, // 12 13 14 15
};
int main(void)
{
FILE* handler = fopen("/app_home/" OUTPUT_FILE, "wb");
// Vector Integer Arithmetic Instructions
ITERATE2I(PRINT2("vaddsbs ", i, j, vec_vaddsbs(v1sb,v2sb)));
ITERATE2I(PRINT2("vaddshs ", i, j, vec_vaddshs(v1sh,v2sh)));
ITERATE2I(PRINT2("vaddsws ", i, j, vec_vaddsws(v1sw,v2sw)));
ITERATE2I(PRINT2("vaddubm ", i, j, vec_vaddubm(v1ub,v2ub)));
ITERATE2I(PRINT2("vadduhm ", i, j, vec_vadduhm(v1uh,v2uh)));
ITERATE2I(PRINT2("vadduwm ", i, j, vec_vadduwm(v1uw,v2uw)));
ITERATE2I(PRINT2("vaddubs ", i, j, vec_vaddubs(v1ub,v2ub)));
ITERATE2I(PRINT2("vadduhs ", i, j, vec_vadduhs(v1uh,v2uh)));
ITERATE2I(PRINT2("vadduws ", i, j, vec_vadduws(v1uw,v2uw)));
ITERATE2I(PRINT2("vaddcuw ", i, j, vec_vaddcuw(v1uw,v2uw)));
ITERATE2I(PRINT2("vsubsbs ", i, j, vec_vsubsbs(v1sb,v2sb)));
ITERATE2I(PRINT2("vsubshs ", i, j, vec_vsubshs(v1sh,v2sh)));
ITERATE2I(PRINT2("vsubsws ", i, j, vec_vsubsws(v1sw,v2sw)));
ITERATE2I(PRINT2("vsububm ", i, j, vec_vsububm(v1ub,v2ub)));
ITERATE2I(PRINT2("vsubuhm ", i, j, vec_vsubuhm(v1uh,v2uh)));
ITERATE2I(PRINT2("vsubuwm ", i, j, vec_vsubuwm(v1uw,v2uw)));
ITERATE2I(PRINT2("vsububs ", i, j, vec_vsububs(v1ub,v2ub)));
ITERATE2I(PRINT2("vsubuhs ", i, j, vec_vsubuhs(v1uh,v2uh)));
ITERATE2I(PRINT2("vsubuws ", i, j, vec_vsubuws(v1uw,v2uw)));
ITERATE2I(PRINT2("vsubcuw ", i, j, vec_vsubcuw(v1uw,v2uw)));
ITERATE2I(PRINT2("vmuloub ", i, j, vec_vmuloub(v1ub,v2ub)));
ITERATE2I(PRINT2("vmulouh ", i, j, vec_vmulouh(v1uh,v2uh)));
ITERATE2I(PRINT2("vmulosb ", i, j, vec_vmulosb(v1sb,v2sb)));
ITERATE2I(PRINT2("vmulosh ", i, j, vec_vmulosh(v1sh,v2sh)));
ITERATE2I(PRINT2("vmuleub ", i, j, vec_vmuleub(v1ub,v2ub)));
ITERATE2I(PRINT2("vmuleuh ", i, j, vec_vmuleuh(v1uh,v2uh)));
ITERATE2I(PRINT2("vmulesb ", i, j, vec_vmulesb(v1sb,v2sb)));
ITERATE2I(PRINT2("vmulesh ", i, j, vec_vmulesh(v1sh,v2sh)));
ITERATE2I(PRINT2("vsumsws ", i, j, vec_vsumsws(v1sw,v2sw)));
ITERATE2I(PRINT2("vsum2sws ", i, j, vec_vsum2sws(v1sw,v2sw)));
ITERATE2I(PRINT2("vsum4ubs ", i, j, vec_vsum4ubs(v1ub,v2uw)));
ITERATE2I(PRINT2("vsum4sbs ", i, j, vec_vsum4sbs(v1sb,v2sw)));
ITERATE2I(PRINT2("vsum4shs ", i, j, vec_vsum4shs(v1sh,v2sw)));
ITERATE2I(PRINT2("vavgub ", i, j, vec_vavgub(v1ub,v2ub)));
ITERATE2I(PRINT2("vavguh ", i, j, vec_vavguh(v1uh,v2uh)));
ITERATE2I(PRINT2("vavguw ", i, j, vec_vavguw(v1uw,v2uw)));
ITERATE2I(PRINT2("vavgsb ", i, j, vec_vavgsb(v1sb,v2sb)));
ITERATE2I(PRINT2("vavgsh ", i, j, vec_vavgsh(v1sh,v2sh)));
ITERATE2I(PRINT2("vavgsw ", i, j, vec_vavgsw(v1sw,v2sw)));
ITERATE2I(PRINT2("vmaxub ", i, j, vec_vmaxub(v1ub,v2ub)));
ITERATE2I(PRINT2("vmaxuh ", i, j, vec_vmaxuh(v1uh,v2uh)));
ITERATE2I(PRINT2("vmaxuw ", i, j, vec_vmaxuw(v1uw,v2uw)));
ITERATE2I(PRINT2("vmaxsb ", i, j, vec_vmaxsb(v1sb,v2sb)));
ITERATE2I(PRINT2("vmaxsh ", i, j, vec_vmaxsh(v1sh,v2sh)));
ITERATE2I(PRINT2("vmaxsw ", i, j, vec_vmaxsw(v1sw,v2sw)));
ITERATE2I(PRINT2("vminub ", i, j, vec_vminub(v1ub,v2ub)));
ITERATE2I(PRINT2("vminuh ", i, j, vec_vminuh(v1uh,v2uh)));
ITERATE2I(PRINT2("vminuw ", i, j, vec_vminuw(v1uw,v2uw)));
ITERATE2I(PRINT2("vminsb ", i, j, vec_vminsb(v1sb,v2sb)));
ITERATE2I(PRINT2("vminsh ", i, j, vec_vminsh(v1sh,v2sh)));
ITERATE2I(PRINT2("vminsw ", i, j, vec_vminsw(v1sw,v2sw)));
return 0;
}

13056
tests/cpu/ppu_vector_integer_arithmetic/ppu_vector_integer_arithmetic.expected Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
tests/cpu/ppu_vector_integer_arithmetic/ppu_vector_integer_arithmetic.ppu.self Normal file
View File

Binary file not shown.

114
tests/rsx/methods_pfifo_puller/methods_pfifo_puller.cpp Normal file
View File

@ -0,0 +1,114 @@
#include <stdio.h>
#include <stdlib.h>
#include <cell/gcm.h>
#include "../../../common/output.h"
// Writing on FIFO buffer
#define METHOD(offset, count) \
(((count) << 18) | (offset))
#define PUT \
*(uint32_t*)(LPAR_DMA_CONTROL_ADDR + 0x40)
#define COMMAND \
((uint32_t*)((uint32_t)ioAddress + PUT))
// TODO: Do the same without hardcoding the addresses
#define DEVICE_ADDR 0x40000000
#define DEVICE_SIZE 0x1000
#define LPAR_DMA_CONTROL_ADDR 0x40100000
#define LPAR_DMA_CONTROL_SIZE 0x1000
#define LPAR_DRIVER_INFO_ADDR 0x40200000
#define LPAR_DRIVER_INFO_SIZE 0x4000
#define LPAR_REPORTS_ADDR 0x40300000
#define LPAR_REPORTS_SIZE 0x10000
int main(void)
{
FILE* handler = fopen("/app_home/" OUTPUT_FILE, "wb");
// cellGcmInit
const uint32_t cmdSize = 0x10000;
const uint32_t ioSize = 1*1024*1024;
const void *ioAddress = memalign(1*1024*1024, ioSize);
cellGcmInit(cmdSize, ioSize, ioAddress);
// Test: NV406E_SET_REFERENCE (0x0050)
uint32_t* ref = (uint32_t*)(LPAR_DMA_CONTROL_ADDR + 0x48);
*ref = 0;
// Set REF to 0x12345678
COMMAND[0] = METHOD(0x50, 1);
COMMAND[1] = 0x12345678;
PUT += 8;
sys_timer_usleep(1000);
fprintf(handler, "Reference: 0x%08X\n", *ref);
// Test: NV406E_*_SEMAPHORE_* (0x0060, 0x0064, 0x0068, 0x006C)
uint32_t* sem0x10 = (uint32_t*)(LPAR_REPORTS_ADDR + 0x10);
uint32_t* sem0x20 = (uint32_t*)(LPAR_REPORTS_ADDR + 0x20);
// Set both semaphores to 0x0
COMMAND[0] = METHOD(0x60, 1);
COMMAND[1] = 0x66616661;
COMMAND[2] = METHOD(0x64, 1);
COMMAND[3] = 0x10;
COMMAND[4] = METHOD(0x6C, 1);
COMMAND[5] = 0x0;
COMMAND[6] = METHOD(0x64, 1);
COMMAND[7] = 0x20;
COMMAND[8] = METHOD(0x6C, 1);
COMMAND[9] = 0x0;
PUT += 40;
sys_timer_usleep(1000);
fprintf(handler, "Semaphore 1: 0x%08X\n", *sem0x10);
fprintf(handler, "Semaphore 2: 0x%08X\n", *sem0x20);
// Set 1st semaphore to 0x1
COMMAND[0] = METHOD(0x64, 1);
COMMAND[1] = 0x10;
COMMAND[2] = METHOD(0x6C, 1);
COMMAND[3] = 0x1;
PUT += 16;
sys_timer_usleep(1000);
fprintf(handler, "Semaphore 1: 0x%08X\n", *sem0x10);
// Set 2nd semaphore to 0xFFFFFFFF
COMMAND[0] = METHOD(0x64, 1);
COMMAND[1] = 0x20;
COMMAND[2] = METHOD(0x6C, 1);
COMMAND[3] = 0xFFFFFFFF;
PUT += 16;
sys_timer_usleep(1000);
fprintf(handler, "Semaphore 2: 0x%08X\n", *sem0x20);
// Make 1st semaphore wait for 0x2, and try to set the 2nd semaphore to 1
COMMAND[0] = METHOD(0x64, 1);
COMMAND[1] = 0x10;
COMMAND[2] = METHOD(0x68, 1);
COMMAND[3] = 0x2;
COMMAND[4] = METHOD(0x64, 1);
COMMAND[5] = 0x20;
COMMAND[6] = METHOD(0x6C, 1);
COMMAND[7] = 0x1;
PUT += 32;
// Set 2nd semaphore to 0x0 and the 1st one to 0x2 (manually)
sys_timer_usleep(1000);
*sem0x20 = 0;
*sem0x10 = 2;
// The previous commands should made the PFIFO puller wait. The 2nd semaphore should be 0x1
sys_timer_usleep(1000);
fprintf(handler, "Semaphore 1: 0x%08X\n", *sem0x10);
fprintf(handler, "Semaphore 2: 0x%08X\n", *sem0x20);
fclose(handler);
return 0;
}

7
tests/rsx/methods_pfifo_puller/methods_pfifo_puller.expected Normal file
View File

@ -0,0 +1,7 @@
Reference: 0x12345678
Semaphore 1: 0x00000000
Semaphore 2: 0x00000000
Semaphore 1: 0x00000001
Semaphore 2: 0xFFFFFFFF
Semaphore 1: 0x00000002
Semaphore 2: 0x00000001

BIN
tests/rsx/methods_pfifo_puller/methods_pfifo_puller.ppu.self Normal file
View File

Binary file not shown.

97
tests/rsx/methods_sce_driver/methods_sce_driver.cpp Normal file
View File

@ -0,0 +1,97 @@
#include <stdio.h>
#include <stdlib.h>
#include <cell/gcm.h>
#include "../../../common/output.h"
// Writing on FIFO buffer
#define METHOD(offset, count) \
(((count) << 18) | (offset))
#define PUT \
*(uint32_t*)(LPAR_DMA_CONTROL_ADDR + 0x40)
#define COMMAND \
((uint32_t*)((uint32_t)ioAddress + PUT))
// TODO: Do the same without hardcoding the addresses
#define DEVICE_ADDR 0x40000000
#define DEVICE_SIZE 0x1000
#define LPAR_DMA_CONTROL_ADDR 0x40100000
#define LPAR_DMA_CONTROL_SIZE 0x1000
#define LPAR_DRIVER_INFO_ADDR 0x40200000
#define LPAR_DRIVER_INFO_SIZE 0x4000
#define LPAR_REPORTS_ADDR 0x40300000
#define LPAR_REPORTS_SIZE 0x10000
// Flip Status location
#define FLIP_STATUS(head) *(uint32_t*)(LPAR_DRIVER_INFO_ADDR + 0x10C0 + 0x40 * head)
int main(void)
{
FILE* handler = fopen("/app_home/" OUTPUT_FILE, "wb");
// cellGcmInit
const uint32_t cmdSize = 0x10000;
const uint32_t ioSize = 1*1024*1024;
const void *ioAddress = memalign(1*1024*1024, ioSize);
cellGcmInit(cmdSize, ioSize, ioAddress);
/**
* Test: SCE_DRIVER_QUEUE (0xE940:0xE95C)
*/
// Resetting status
for (int head = 0; head < 8; head++) {
FLIP_STATUS(head) = 0x00000000;
}
// Test for each head
for (int head = 0; head < 8; head++) {
fprintf(handler, "SCE_DRIVER_QUEUE [0x%04X]:\n", 0xE940 + 4*head);
// Queuing one at a time (and resetting status)
for (int parameter = 0; parameter < 32; parameter++) {
COMMAND[0] = METHOD(0xE940 + 4 * head, 1);
COMMAND[1] = parameter;
PUT += 8;
sys_timer_usleep(1000);
fprintf(handler, "Flip Status [DRIVER_INFO @ 0x%04X]: 0x%08X\n", 0x10C0 + 0x40 * head, FLIP_STATUS(head));
FLIP_STATUS(head) = 0x00000000;
}
// Queueing all at once
for (int parameter = 0; parameter < 32; parameter++) {
COMMAND[0] = METHOD(0xE940 + 4 * head, 1);
COMMAND[1] = parameter;
PUT += 8;
sys_timer_usleep(1000);
fprintf(handler, "Flip Status [DRIVER_INFO @ 0x%04X]: 0x%08X\n", 0x10C0 + 0x40 * head, FLIP_STATUS(head));
}
// Reset status
FLIP_STATUS(head) = 0x00000000;
// Queue invalid ones
COMMAND[0] = METHOD(0xE940 + 4 * head, 1);
COMMAND[1] = 32;
PUT += 8;
COMMAND[0] = METHOD(0xE940 + 4 * head, 1);
COMMAND[1] = 0xFFFFFFFF;
PUT += 8;
sys_timer_usleep(1000);
fprintf(handler, "Flip Status [DRIVER_INFO @ 0x%04X]: 0x%08X\n", 0x10C0 + 0x40 * head - 4, *(uint32_t*)(LPAR_DRIVER_INFO_ADDR + 0x10C0 + 0x40 * head - 4));
fprintf(handler, "Flip Status [DRIVER_INFO @ 0x%04X]: 0x%08X\n", 0x10C0 + 0x40 * head + 0, *(uint32_t*)(LPAR_DRIVER_INFO_ADDR + 0x10C0 + 0x40 * head + 0));
fprintf(handler, "Flip Status [DRIVER_INFO @ 0x%04X]: 0x%08X\n", 0x10C0 + 0x40 * head + 4, *(uint32_t*)(LPAR_DRIVER_INFO_ADDR + 0x10C0 + 0x40 * head + 4));
}
/**
* TODO: Test SCE_DRIVER_FLIP (0xE920:0xE924)
*/
fclose(handler);
return 0;
}

544
tests/rsx/methods_sce_driver/methods_sce_driver.expected Normal file
View File

@ -0,0 +1,544 @@
SCE_DRIVER_QUEUE [0xE940]:
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000001
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000002
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000004
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000008
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000010
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000020
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000040
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000080
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000100
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000200
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000400
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000800
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40001000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40002000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40004000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40008000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40010000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40020000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40040000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40080000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40100000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40200000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40400000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40800000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x41000000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x42000000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x44000000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x48000000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x50000000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x60000000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000000
Flip Status [DRIVER_INFO @ 0x10C0]: 0xC0000000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000001
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000003
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000007
Flip Status [DRIVER_INFO @ 0x10C0]: 0x4000000F
Flip Status [DRIVER_INFO @ 0x10C0]: 0x4000001F
Flip Status [DRIVER_INFO @ 0x10C0]: 0x4000003F
Flip Status [DRIVER_INFO @ 0x10C0]: 0x4000007F
Flip Status [DRIVER_INFO @ 0x10C0]: 0x400000FF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x400001FF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x400003FF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x400007FF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000FFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40001FFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40003FFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40007FFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x4000FFFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x4001FFFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x4003FFFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x4007FFFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x400FFFFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x401FFFFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x403FFFFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x407FFFFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40FFFFFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x41FFFFFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x43FFFFFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x47FFFFFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x4FFFFFFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x5FFFFFFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x7FFFFFFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0x7FFFFFFF
Flip Status [DRIVER_INFO @ 0x10C0]: 0xFFFFFFFF
Flip Status [DRIVER_INFO @ 0x10BC]: 0x00000000
Flip Status [DRIVER_INFO @ 0x10C0]: 0x40000000
Flip Status [DRIVER_INFO @ 0x10C4]: 0x00000000
SCE_DRIVER_QUEUE [0xE944]:
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000001
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000002
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000004
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000008
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000010
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000020
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000040
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000080
Flip Status [DRIVER_INFO @ 0x1100]: 0x00000100
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000200
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000400
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000800
Flip Status [DRIVER_INFO @ 0x1100]: 0x40001000
Flip Status [DRIVER_INFO @ 0x1100]: 0x40002000
Flip Status [DRIVER_INFO @ 0x1100]: 0x40004000
Flip Status [DRIVER_INFO @ 0x1100]: 0x40008000
Flip Status [DRIVER_INFO @ 0x1100]: 0x40010000
Flip Status [DRIVER_INFO @ 0x1100]: 0x40020000
Flip Status [DRIVER_INFO @ 0x1100]: 0x40040000
Flip Status [DRIVER_INFO @ 0x1100]: 0x40080000
Flip Status [DRIVER_INFO @ 0x1100]: 0x40100000
Flip Status [DRIVER_INFO @ 0x1100]: 0x40200000
Flip Status [DRIVER_INFO @ 0x1100]: 0x40400000
Flip Status [DRIVER_INFO @ 0x1100]: 0x40800000
Flip Status [DRIVER_INFO @ 0x1100]: 0x01000000
Flip Status [DRIVER_INFO @ 0x1100]: 0x42000000
Flip Status [DRIVER_INFO @ 0x1100]: 0x44000000
Flip Status [DRIVER_INFO @ 0x1100]: 0x48000000
Flip Status [DRIVER_INFO @ 0x1100]: 0x50000000
Flip Status [DRIVER_INFO @ 0x1100]: 0x60000000
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000000
Flip Status [DRIVER_INFO @ 0x1100]: 0xC0000000
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000001
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000003
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000007
Flip Status [DRIVER_INFO @ 0x1100]: 0x4000000F
Flip Status [DRIVER_INFO @ 0x1100]: 0x4000001F
Flip Status [DRIVER_INFO @ 0x1100]: 0x4000003F
Flip Status [DRIVER_INFO @ 0x1100]: 0x4000007F
Flip Status [DRIVER_INFO @ 0x1100]: 0x400000FF
Flip Status [DRIVER_INFO @ 0x1100]: 0x400001FF
Flip Status [DRIVER_INFO @ 0x1100]: 0x000003FF
Flip Status [DRIVER_INFO @ 0x1100]: 0x400007FF
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000FFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x40001FFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x40003FFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x40007FFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x4000FFFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x4001FFFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x4003FFFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x4007FFFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x400FFFFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x401FFFFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x403FFFFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x407FFFFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x40FFFFFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x41FFFFFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x03FFFFFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x47FFFFFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x4FFFFFFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x5FFFFFFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x7FFFFFFF
Flip Status [DRIVER_INFO @ 0x1100]: 0x7FFFFFFF
Flip Status [DRIVER_INFO @ 0x1100]: 0xFFFFFFFF
Flip Status [DRIVER_INFO @ 0x10FC]: 0x00000000
Flip Status [DRIVER_INFO @ 0x1100]: 0x40000000
Flip Status [DRIVER_INFO @ 0x1104]: 0x00000000
SCE_DRIVER_QUEUE [0xE948]:
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000001
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000002
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000004
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000008
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000010
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000020
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000040
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000080
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000100
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000200
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000400
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000800
Flip Status [DRIVER_INFO @ 0x1140]: 0x40001000
Flip Status [DRIVER_INFO @ 0x1140]: 0x40002000
Flip Status [DRIVER_INFO @ 0x1140]: 0x40004000
Flip Status [DRIVER_INFO @ 0x1140]: 0x40008000
Flip Status [DRIVER_INFO @ 0x1140]: 0x40010000
Flip Status [DRIVER_INFO @ 0x1140]: 0x40020000
Flip Status [DRIVER_INFO @ 0x1140]: 0x40040000
Flip Status [DRIVER_INFO @ 0x1140]: 0x40080000
Flip Status [DRIVER_INFO @ 0x1140]: 0x40100000
Flip Status [DRIVER_INFO @ 0x1140]: 0x40200000
Flip Status [DRIVER_INFO @ 0x1140]: 0x40400000
Flip Status [DRIVER_INFO @ 0x1140]: 0x40800000
Flip Status [DRIVER_INFO @ 0x1140]: 0x41000000
Flip Status [DRIVER_INFO @ 0x1140]: 0x42000000
Flip Status [DRIVER_INFO @ 0x1140]: 0x44000000
Flip Status [DRIVER_INFO @ 0x1140]: 0x48000000
Flip Status [DRIVER_INFO @ 0x1140]: 0x50000000
Flip Status [DRIVER_INFO @ 0x1140]: 0x60000000
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000000
Flip Status [DRIVER_INFO @ 0x1140]: 0xC0000000
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000001
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000003
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000007
Flip Status [DRIVER_INFO @ 0x1140]: 0x4000000F
Flip Status [DRIVER_INFO @ 0x1140]: 0x4000001F
Flip Status [DRIVER_INFO @ 0x1140]: 0x4000003F
Flip Status [DRIVER_INFO @ 0x1140]: 0x4000007F
Flip Status [DRIVER_INFO @ 0x1140]: 0x400000FF
Flip Status [DRIVER_INFO @ 0x1140]: 0x400001FF
Flip Status [DRIVER_INFO @ 0x1140]: 0x400003FF
Flip Status [DRIVER_INFO @ 0x1140]: 0x400007FF
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000FFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x40001FFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x40003FFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x40007FFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x4000FFFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x4001FFFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x4003FFFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x4007FFFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x400FFFFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x401FFFFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x403FFFFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x407FFFFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x40FFFFFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x41FFFFFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x43FFFFFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x47FFFFFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x4FFFFFFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x5FFFFFFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x7FFFFFFF
Flip Status [DRIVER_INFO @ 0x1140]: 0x7FFFFFFF
Flip Status [DRIVER_INFO @ 0x1140]: 0xFFFFFFFF
Flip Status [DRIVER_INFO @ 0x113C]: 0x00000000
Flip Status [DRIVER_INFO @ 0x1140]: 0x40000000
Flip Status [DRIVER_INFO @ 0x1144]: 0x00000000
SCE_DRIVER_QUEUE [0xE94C]:
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000001
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000002
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000004
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000008
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000010
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000020
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000040
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000080
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000100
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000200
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000400
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000800
Flip Status [DRIVER_INFO @ 0x1180]: 0x40001000
Flip Status [DRIVER_INFO @ 0x1180]: 0x40002000
Flip Status [DRIVER_INFO @ 0x1180]: 0x40004000
Flip Status [DRIVER_INFO @ 0x1180]: 0x40008000
Flip Status [DRIVER_INFO @ 0x1180]: 0x40010000
Flip Status [DRIVER_INFO @ 0x1180]: 0x40020000
Flip Status [DRIVER_INFO @ 0x1180]: 0x40040000
Flip Status [DRIVER_INFO @ 0x1180]: 0x40080000
Flip Status [DRIVER_INFO @ 0x1180]: 0x40100000
Flip Status [DRIVER_INFO @ 0x1180]: 0x40200000
Flip Status [DRIVER_INFO @ 0x1180]: 0x40400000
Flip Status [DRIVER_INFO @ 0x1180]: 0x40800000
Flip Status [DRIVER_INFO @ 0x1180]: 0x41000000
Flip Status [DRIVER_INFO @ 0x1180]: 0x42000000
Flip Status [DRIVER_INFO @ 0x1180]: 0x44000000
Flip Status [DRIVER_INFO @ 0x1180]: 0x48000000
Flip Status [DRIVER_INFO @ 0x1180]: 0x50000000
Flip Status [DRIVER_INFO @ 0x1180]: 0x60000000
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000000
Flip Status [DRIVER_INFO @ 0x1180]: 0xC0000000
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000001
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000003
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000007
Flip Status [DRIVER_INFO @ 0x1180]: 0x4000000F
Flip Status [DRIVER_INFO @ 0x1180]: 0x4000001F
Flip Status [DRIVER_INFO @ 0x1180]: 0x4000003F
Flip Status [DRIVER_INFO @ 0x1180]: 0x4000007F
Flip Status [DRIVER_INFO @ 0x1180]: 0x400000FF
Flip Status [DRIVER_INFO @ 0x1180]: 0x400001FF
Flip Status [DRIVER_INFO @ 0x1180]: 0x400003FF
Flip Status [DRIVER_INFO @ 0x1180]: 0x400007FF
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000FFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x40001FFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x40003FFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x40007FFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x4000FFFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x4001FFFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x4003FFFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x4007FFFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x400FFFFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x401FFFFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x403FFFFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x407FFFFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x40FFFFFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x41FFFFFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x43FFFFFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x47FFFFFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x4FFFFFFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x5FFFFFFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x7FFFFFFF
Flip Status [DRIVER_INFO @ 0x1180]: 0x7FFFFFFF
Flip Status [DRIVER_INFO @ 0x1180]: 0xFFFFFFFF
Flip Status [DRIVER_INFO @ 0x117C]: 0x00000000
Flip Status [DRIVER_INFO @ 0x1180]: 0x40000000
Flip Status [DRIVER_INFO @ 0x1184]: 0x00000000
SCE_DRIVER_QUEUE [0xE950]:
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000001
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000002
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000004
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000008
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000010
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000020
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000040
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000080
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000100
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000200
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000400
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000800
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40001000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40002000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40004000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40008000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40010000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40020000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40040000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40080000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40100000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40200000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40400000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40800000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x41000000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x42000000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x44000000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x48000000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x50000000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x60000000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000000
Flip Status [DRIVER_INFO @ 0x11C0]: 0xC0000000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000001
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000003
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000007
Flip Status [DRIVER_INFO @ 0x11C0]: 0x4000000F
Flip Status [DRIVER_INFO @ 0x11C0]: 0x4000001F
Flip Status [DRIVER_INFO @ 0x11C0]: 0x4000003F
Flip Status [DRIVER_INFO @ 0x11C0]: 0x4000007F
Flip Status [DRIVER_INFO @ 0x11C0]: 0x400000FF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x400001FF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x400003FF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x400007FF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000FFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40001FFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40003FFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40007FFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x4000FFFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x4001FFFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x4003FFFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x4007FFFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x400FFFFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x401FFFFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x403FFFFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x407FFFFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40FFFFFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x41FFFFFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x43FFFFFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x47FFFFFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x4FFFFFFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x5FFFFFFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x7FFFFFFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0x7FFFFFFF
Flip Status [DRIVER_INFO @ 0x11C0]: 0xFFFFFFFF
Flip Status [DRIVER_INFO @ 0x11BC]: 0x00000000
Flip Status [DRIVER_INFO @ 0x11C0]: 0x40000000
Flip Status [DRIVER_INFO @ 0x11C4]: 0x00000000
SCE_DRIVER_QUEUE [0xE954]:
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000001
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000002
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000004
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000008
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000010
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000020
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000040
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000080
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000100
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000200
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000400
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000800
Flip Status [DRIVER_INFO @ 0x1200]: 0x40001000
Flip Status [DRIVER_INFO @ 0x1200]: 0x40002000
Flip Status [DRIVER_INFO @ 0x1200]: 0x40004000
Flip Status [DRIVER_INFO @ 0x1200]: 0x40008000
Flip Status [DRIVER_INFO @ 0x1200]: 0x40010000
Flip Status [DRIVER_INFO @ 0x1200]: 0x40020000
Flip Status [DRIVER_INFO @ 0x1200]: 0x40040000
Flip Status [DRIVER_INFO @ 0x1200]: 0x40080000
Flip Status [DRIVER_INFO @ 0x1200]: 0x40100000
Flip Status [DRIVER_INFO @ 0x1200]: 0x40200000
Flip Status [DRIVER_INFO @ 0x1200]: 0x40400000
Flip Status [DRIVER_INFO @ 0x1200]: 0x40800000
Flip Status [DRIVER_INFO @ 0x1200]: 0x41000000
Flip Status [DRIVER_INFO @ 0x1200]: 0x42000000
Flip Status [DRIVER_INFO @ 0x1200]: 0x44000000
Flip Status [DRIVER_INFO @ 0x1200]: 0x48000000
Flip Status [DRIVER_INFO @ 0x1200]: 0x50000000
Flip Status [DRIVER_INFO @ 0x1200]: 0x60000000
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000000
Flip Status [DRIVER_INFO @ 0x1200]: 0xC0000000
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000001
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000003
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000007
Flip Status [DRIVER_INFO @ 0x1200]: 0x4000000F
Flip Status [DRIVER_INFO @ 0x1200]: 0x4000001F
Flip Status [DRIVER_INFO @ 0x1200]: 0x4000003F
Flip Status [DRIVER_INFO @ 0x1200]: 0x4000007F
Flip Status [DRIVER_INFO @ 0x1200]: 0x400000FF
Flip Status [DRIVER_INFO @ 0x1200]: 0x400001FF
Flip Status [DRIVER_INFO @ 0x1200]: 0x400003FF
Flip Status [DRIVER_INFO @ 0x1200]: 0x400007FF
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000FFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x40001FFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x40003FFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x40007FFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x4000FFFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x4001FFFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x4003FFFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x4007FFFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x400FFFFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x401FFFFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x403FFFFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x407FFFFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x40FFFFFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x41FFFFFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x43FFFFFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x47FFFFFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x4FFFFFFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x5FFFFFFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x7FFFFFFF
Flip Status [DRIVER_INFO @ 0x1200]: 0x7FFFFFFF
Flip Status [DRIVER_INFO @ 0x1200]: 0xFFFFFFFF
Flip Status [DRIVER_INFO @ 0x11FC]: 0x00000000
Flip Status [DRIVER_INFO @ 0x1200]: 0x40000000
Flip Status [DRIVER_INFO @ 0x1204]: 0x00000000
SCE_DRIVER_QUEUE [0xE958]:
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000001
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000002
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000004
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000008
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000010
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000020
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000040
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000080
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000100
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000200
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000400
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000800
Flip Status [DRIVER_INFO @ 0x1240]: 0x40001000
Flip Status [DRIVER_INFO @ 0x1240]: 0x40002000
Flip Status [DRIVER_INFO @ 0x1240]: 0x40004000
Flip Status [DRIVER_INFO @ 0x1240]: 0x40008000
Flip Status [DRIVER_INFO @ 0x1240]: 0x40010000
Flip Status [DRIVER_INFO @ 0x1240]: 0x40020000
Flip Status [DRIVER_INFO @ 0x1240]: 0x40040000
Flip Status [DRIVER_INFO @ 0x1240]: 0x40080000
Flip Status [DRIVER_INFO @ 0x1240]: 0x40100000
Flip Status [DRIVER_INFO @ 0x1240]: 0x40200000
Flip Status [DRIVER_INFO @ 0x1240]: 0x40400000
Flip Status [DRIVER_INFO @ 0x1240]: 0x40800000
Flip Status [DRIVER_INFO @ 0x1240]: 0x41000000
Flip Status [DRIVER_INFO @ 0x1240]: 0x42000000
Flip Status [DRIVER_INFO @ 0x1240]: 0x44000000
Flip Status [DRIVER_INFO @ 0x1240]: 0x48000000
Flip Status [DRIVER_INFO @ 0x1240]: 0x50000000
Flip Status [DRIVER_INFO @ 0x1240]: 0x60000000
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000000
Flip Status [DRIVER_INFO @ 0x1240]: 0xC0000000
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000001
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000003
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000007
Flip Status [DRIVER_INFO @ 0x1240]: 0x4000000F
Flip Status [DRIVER_INFO @ 0x1240]: 0x4000001F
Flip Status [DRIVER_INFO @ 0x1240]: 0x4000003F
Flip Status [DRIVER_INFO @ 0x1240]: 0x4000007F
Flip Status [DRIVER_INFO @ 0x1240]: 0x400000FF
Flip Status [DRIVER_INFO @ 0x1240]: 0x400001FF
Flip Status [DRIVER_INFO @ 0x1240]: 0x400003FF
Flip Status [DRIVER_INFO @ 0x1240]: 0x400007FF
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000FFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x40001FFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x40003FFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x40007FFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x4000FFFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x4001FFFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x4003FFFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x4007FFFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x400FFFFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x401FFFFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x403FFFFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x407FFFFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x40FFFFFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x41FFFFFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x43FFFFFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x47FFFFFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x4FFFFFFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x5FFFFFFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x7FFFFFFF
Flip Status [DRIVER_INFO @ 0x1240]: 0x7FFFFFFF
Flip Status [DRIVER_INFO @ 0x1240]: 0xFFFFFFFF
Flip Status [DRIVER_INFO @ 0x123C]: 0x00000000
Flip Status [DRIVER_INFO @ 0x1240]: 0x40000000
Flip Status [DRIVER_INFO @ 0x1244]: 0x00000000
SCE_DRIVER_QUEUE [0xE95C]:
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000001
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000002
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000004
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000008
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000010
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000020
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000040
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000080
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000100
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000200
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000400
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000800
Flip Status [DRIVER_INFO @ 0x1280]: 0x40001000
Flip Status [DRIVER_INFO @ 0x1280]: 0x40002000
Flip Status [DRIVER_INFO @ 0x1280]: 0x40004000
Flip Status [DRIVER_INFO @ 0x1280]: 0x40008000
Flip Status [DRIVER_INFO @ 0x1280]: 0x40010000
Flip Status [DRIVER_INFO @ 0x1280]: 0x40020000
Flip Status [DRIVER_INFO @ 0x1280]: 0x40040000
Flip Status [DRIVER_INFO @ 0x1280]: 0x40080000
Flip Status [DRIVER_INFO @ 0x1280]: 0x40100000
Flip Status [DRIVER_INFO @ 0x1280]: 0x40200000
Flip Status [DRIVER_INFO @ 0x1280]: 0x40400000
Flip Status [DRIVER_INFO @ 0x1280]: 0x40800000
Flip Status [DRIVER_INFO @ 0x1280]: 0x41000000
Flip Status [DRIVER_INFO @ 0x1280]: 0x42000000
Flip Status [DRIVER_INFO @ 0x1280]: 0x44000000
Flip Status [DRIVER_INFO @ 0x1280]: 0x48000000
Flip Status [DRIVER_INFO @ 0x1280]: 0x50000000
Flip Status [DRIVER_INFO @ 0x1280]: 0x60000000
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000000
Flip Status [DRIVER_INFO @ 0x1280]: 0xC0000000
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000001
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000003
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000007
Flip Status [DRIVER_INFO @ 0x1280]: 0x4000000F
Flip Status [DRIVER_INFO @ 0x1280]: 0x4000001F
Flip Status [DRIVER_INFO @ 0x1280]: 0x4000003F
Flip Status [DRIVER_INFO @ 0x1280]: 0x4000007F
Flip Status [DRIVER_INFO @ 0x1280]: 0x400000FF
Flip Status [DRIVER_INFO @ 0x1280]: 0x400001FF
Flip Status [DRIVER_INFO @ 0x1280]: 0x400003FF
Flip Status [DRIVER_INFO @ 0x1280]: 0x400007FF
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000FFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x40001FFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x40003FFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x40007FFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x4000FFFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x4001FFFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x4003FFFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x4007FFFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x400FFFFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x401FFFFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x403FFFFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x407FFFFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x40FFFFFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x41FFFFFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x43FFFFFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x47FFFFFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x4FFFFFFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x5FFFFFFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x7FFFFFFF
Flip Status [DRIVER_INFO @ 0x1280]: 0x7FFFFFFF
Flip Status [DRIVER_INFO @ 0x1280]: 0xFFFFFFFF
Flip Status [DRIVER_INFO @ 0x127C]: 0x00000000
Flip Status [DRIVER_INFO @ 0x1280]: 0x40000000
Flip Status [DRIVER_INFO @ 0x1284]: 0x00000000

BIN
tests/rsx/methods_sce_driver/methods_sce_driver.ppu.self Normal file
View File

Binary file not shown.