Macintosh-Tools/dingusppc
1
0
Fork 0
mirror of https://github.com/dingusdev/dingusppc.git synced 2024-12-28 06:29:42 +00:00
Code Issues Projects Releases Wiki Activity
456a96042f
dingusppc/cpu/ppc/test/genppctests.py

449 lines
22 KiB
Python
Raw Normal View History

ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
import re
Initial PPC emulation tests.
2020-01-31 03:10:53 +00:00
def gen_ppc_opcode(opc_str, imm):
if opc_str == "ADD":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x10A << 1)
elif opc_str == "ADD.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x10A << 1) + 1
elif opc_str == "ADDC":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0xA << 1)
elif opc_str == "ADDC.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0xA << 1) + 1
elif opc_str == "ADDCO":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x20A << 1)
elif opc_str == "ADDCO.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x20A << 1) + 1
elif opc_str == "ADDO":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x30A << 1)
elif opc_str == "ADDO.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x30A << 1) + 1
elif opc_str == "ADDE":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x8A << 1)
elif opc_str == "ADDE.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x8A << 1) + 1
elif opc_str == "ADDEO":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x28A << 1)
elif opc_str == "ADDEO.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x28A << 1) + 1
elif opc_str == "ADDI":
return (0x0E << 26) + (3 << 21) + (3 << 16) + (imm & 0xFFFF)
elif opc_str == "ADDIC":
return (0x0C << 26) + (3 << 21) + (3 << 16) + (imm & 0xFFFF)
Complete tests for the integer instructions.
2020-02-08 22:23:58 +00:00
elif opc_str == "ADDIC.":
return (0x0D << 26) + (3 << 21) + (3 << 16) + (imm & 0xFFFF)
Initial PPC emulation tests.
2020-01-31 03:10:53 +00:00
elif opc_str == "ADDIS":
return (0x0F << 26) + (3 << 21) + (3 << 16) + (imm & 0xFFFF)
elif opc_str == "ADDME":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0xEA << 1)
elif opc_str == "ADDME.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0xEA << 1) + 1
elif opc_str == "ADDMEO":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x2EA << 1)
elif opc_str == "ADDMEO.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x2EA << 1) + 1
elif opc_str == "ADDZE":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0xCA << 1)
elif opc_str == "ADDZE.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0xCA << 1) + 1
elif opc_str == "ADDZEO":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x2CA << 1)
elif opc_str == "ADDZEO.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x2CA << 1) + 1
More PPC instruction tests.
2020-01-31 17:04:50 +00:00
elif opc_str == "AND":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x1C << 1)
elif opc_str == "AND.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x1C << 1) + 1
elif opc_str == "ANDC":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x3C << 1)
elif opc_str == "ANDC.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x3C << 1) + 1
elif opc_str == "ANDI.":
return (0x1C << 26) + (3 << 21) + (3 << 16) + (imm & 0xFFFF)
elif opc_str == "ANDIS.":
return (0x1D << 26) + (3 << 21) + (3 << 16) + (imm & 0xFFFF)
elif opc_str == "CMP":
return (0x1F << 26) + (3 << 16) + (4 << 11)
elif opc_str == "CMPI":
return (0x0B << 26) + (0 << 21) + (3 << 16) + (imm & 0xFFFF)
elif opc_str == "CMPL":
return (0x1F << 26) + (3 << 16) + (4 << 11) + (0x20 << 1)
elif opc_str == "CMPLI":
return (0x0A << 26) + (0 << 21) + (3 << 16) + (imm & 0xFFFF)
elif opc_str == "CNTLZW":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x1A << 1)
elif opc_str == "CNTLZW.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x1A << 1) + 1
Fix ppctests.cpp and add more instructions.
2020-01-31 20:53:02 +00:00
elif opc_str == "DIVW":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x1EB << 1)
elif opc_str == "DIVW.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x1EB << 1) + 1
elif opc_str == "DIVWO":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x3EB << 1)
elif opc_str == "DIVWO.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x3EB << 1) + 1
elif opc_str == "DIVWU":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x1CB << 1)
elif opc_str == "DIVWU.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x1CB << 1) + 1
elif opc_str == "DIVWUO":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x3CB << 1)
elif opc_str == "DIVWUO.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x3CB << 1) + 1
elif opc_str == "EQV":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x11C << 1)
elif opc_str == "EQV.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x11C << 1) + 1
elif opc_str == "EXTSB":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x3BA << 1)
elif opc_str == "EXTSB.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x3BA << 1) + 1
elif opc_str == "EXTSH":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x39A << 1)
elif opc_str == "EXTSH.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x39A << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FABS":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (0 << 16) + (4 << 11) + (0x108 << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FABS.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (0 << 16) + (4 << 11) + (0x108 << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FADD":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (0x15 << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FADD.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (0x15 << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FADDS":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (0x15 << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FADDS.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (0x15 << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FCMPO":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (4 << 21) + (4 << 16) + (5 << 11) + (0x20 << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FCMPU":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (4 << 21) + (4 << 16) + (5 << 11)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FCTIW":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (0 << 16) + (4 << 11) + (0xE << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FCTIW.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (0 << 16) + (4 << 11) + (0xE << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FCTIWZ":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (0 << 16) + (4 << 11) + (0xF << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FCTIWZ.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (0 << 16) + (4 << 11) + (0xF << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FDIV":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (0x12 << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FDIV.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (0x12 << 1) + 1
Fixed floating-point test generation
2021-10-14 14:19:04 +00:00
elif opc_str == "FDIVS":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (0x12 << 1)
Fixed floating-point test generation
2021-10-14 14:19:04 +00:00
elif opc_str == "FDIVS.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (0x12 << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FMADD":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (6 << 6) + (0x1D << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FMADD.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (6 << 6) + (0x1D << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FMADDS":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (6 << 6) + (0x1D << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FMADDS.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (6 << 6) + (0x1D << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FMUL":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 16) + (6 << 6) + (0x19 << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FMUL.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 16) + (6 << 6) + (0x19 << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FMULS":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 16) + (6 << 6) + (0x19 << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FMULS.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 16) + (6 << 6) + (0x19 << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FNABS":
Fixing FP mul ops & tests
2021-10-23 20:05:20 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 11) + (0x88 << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FNABS.":
Fixing FP mul ops & tests
2021-10-23 20:05:20 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 11) + (0x88 << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FNEG":
FP comp tests & various fixes
2021-10-24 21:00:35 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 11) + (0x28 << 1)
Fixing FP mul ops & tests
2021-10-23 20:05:20 +00:00
elif opc_str == "FNEG.":
FP comp tests & various fixes
2021-10-24 21:00:35 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 11) + (0x28 << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FMSUB":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (6 << 6) + (0x1C << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FMSUB.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (6 << 6) + (0x1C << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FMSUBS":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (6 << 6) + (0x1C << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FMSUBS.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (6 << 6) + (0x1C << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FNMADD":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (6 << 6) + (0x1F << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FNMADD.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (6 << 6) + (0x1F << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FNMADDS":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (6 << 6) + (0x1F << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FNMADDS.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (6 << 6) + (0x1F << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FNMSUB":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (6 << 6) + (0x1E << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FNMSUB.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (6 << 6) + (0x1E << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FNMSUBS":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (6 << 6) + (0x1E << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FNMSUBS.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (6 << 6) + (0x1E << 1) + 1
FP Opcode Test Fixes
2021-10-30 23:43:13 +00:00
elif opc_str == "FRES":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 11) + (0x18 << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FSUB":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (0x14 << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FSUB.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3F << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (0x14 << 1) + 1
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FSUBS":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (0x14 << 1)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
elif opc_str == "FSUBS.":
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
return (0x3B << 26) + (3 << 21) + (4 << 16) + (5 << 11) + (0x14 << 1) + 1
Fix ppctests.cpp and add more instructions.
2020-01-31 20:53:02 +00:00
elif opc_str == "MULHW":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x4B << 1)
elif opc_str == "MULHW.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x4B << 1) + 1
elif opc_str == "MULHWU":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0xB << 1)
elif opc_str == "MULHWU.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0xB << 1) + 1
elif opc_str == "MULLI":
return (0x07 << 26) + (3 << 21) + (3 << 16) + (imm & 0xFFFF)
elif opc_str == "MULLW":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0xEB << 1)
elif opc_str == "MULLW.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0xEB << 1) + 1
elif opc_str == "MULLWO":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x2EB << 1)
elif opc_str == "MULLWO.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x2EB << 1) + 1
elif opc_str == "NAND":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x1DC << 1)
elif opc_str == "NAND.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x1DC << 1) + 1
elif opc_str == "NEG":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x68 << 1)
elif opc_str == "NEG.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x68 << 1) + 1
elif opc_str == "NEGO":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x268 << 1)
elif opc_str == "NEGO.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x268 << 1) + 1
elif opc_str == "NOR":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x7C << 1)
elif opc_str == "NOR.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x7C << 1) + 1
elif opc_str == "OR":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x1BC << 1)
elif opc_str == "OR.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x1BC << 1) + 1
elif opc_str == "ORC":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x19C << 1)
elif opc_str == "ORC.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x19C << 1) + 1
elif opc_str == "ORI":
return (0x18 << 26) + (3 << 21) + (3 << 16) + (imm & 0xFFFF)
elif opc_str == "ORIS":
Fix ORIS bug in the test suite.
2020-01-31 23:42:57 +00:00
return (0x19 << 26) + (3 << 21) + (3 << 16) + (imm & 0xFFFF)
Add tests for shifts and fix their emulation.
2020-02-03 19:36:22 +00:00
elif opc_str == "SLW":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x18 << 1)
elif opc_str == "SLW.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x18 << 1) + 1
elif opc_str == "SRAW":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x318 << 1)
elif opc_str == "SRAW.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x318 << 1) + 1
elif opc_str == "SRAWI":
return (0x1F << 26) + (3 << 21) + (3 << 16) + ((imm & 0x1F) << 11) + (0x338 << 1)
Complete tests for the integer instructions.
2020-02-08 22:23:58 +00:00
elif opc_str == "SRAWI.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + ((imm & 0x1F) << 11) + (0x338 << 1) + 1
Add tests for shifts and fix their emulation.
2020-02-03 19:36:22 +00:00
elif opc_str == "SRW":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x218 << 1)
elif opc_str == "SRW.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x218 << 1) + 1
Add tests for all subtraction variants.
2020-02-04 00:00:37 +00:00
elif opc_str == "SUBF":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x28 << 1)
elif opc_str == "SUBF.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x28 << 1) + 1
elif opc_str == "SUBFO":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x228 << 1)
elif opc_str == "SUBFO.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x228 << 1) + 1
elif opc_str == "SUBFC":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x8 << 1)
elif opc_str == "SUBFC.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x8 << 1) + 1
elif opc_str == "SUBFCO":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x208 << 1)
elif opc_str == "SUBFCO.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x208 << 1) + 1
elif opc_str == "SUBFE":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x88 << 1)
elif opc_str == "SUBFE.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x88 << 1) + 1
elif opc_str == "SUBFEO":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x288 << 1)
elif opc_str == "SUBFEO.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x288 << 1) + 1
elif opc_str == "SUBFIC":
return (0x08 << 26) + (3 << 21) + (3 << 16) + (imm & 0xFFFF)
elif opc_str == "SUBFME":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0xE8 << 1)
elif opc_str == "SUBFME.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0xE8 << 1) + 1
elif opc_str == "SUBFMEO":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x2E8 << 1)
elif opc_str == "SUBFMEO.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x2E8 << 1) + 1
elif opc_str == "SUBFZE":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0xC8 << 1)
elif opc_str == "SUBFZE.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0xC8 << 1) + 1
elif opc_str == "SUBFZEO":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x2C8 << 1)
elif opc_str == "SUBFZEO.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (0x2C8 << 1) + 1
Complete tests for the integer instructions.
2020-02-08 22:23:58 +00:00
elif opc_str == "XOR":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x13C << 1)
elif opc_str == "XOR.":
return (0x1F << 26) + (3 << 21) + (3 << 16) + (4 << 11) + (0x13C << 1) + 1
elif opc_str == "XORI":
return (0x1A << 26) + (3 << 21) + (3 << 16) + (imm & 0xFFFF)
elif opc_str == "XORIS":
return (0x1B << 26) + (3 << 21) + (3 << 16) + (imm & 0xFFFF)
Initial PPC emulation tests.
2020-01-31 03:10:53 +00:00
Add tests for shifts and fix their emulation.
2020-02-03 19:36:22 +00:00
def gen_rot_opcode(opc_str, sh, mb, me):
if opc_str == "RLWIMI":
return (0x14 << 26) + (4 << 21) + (3 << 16) + (sh << 11) + (mb << 6) + (me << 1)
Complete tests for the integer instructions.
2020-02-08 22:23:58 +00:00
elif opc_str == "RLWIMI.":
return (0x14 << 26) + (4 << 21) + (3 << 16) + (sh << 11) + (mb << 6) + (me << 1) + 1
elif opc_str == "RLWINM":
return (0x15 << 26) + (4 << 21) + (3 << 16) + (sh << 11) + (mb << 6) + (me << 1)
elif opc_str == "RLWINM.":
return (0x15 << 26) + (4 << 21) + (3 << 16) + (sh << 11) + (mb << 6) + (me << 1) + 1
Initial PPC emulation tests.
2020-01-31 03:10:53 +00:00
Add tests for shifts and fix their emulation.
2020-02-03 19:36:22 +00:00
def extract_imm(line):
Initial PPC emulation tests.
2020-01-31 03:10:53 +00:00
pos = 12
while pos < len(line):
reg_id = line[pos:pos+4]
Add tests for shifts and fix their emulation.
2020-02-03 19:36:22 +00:00
if reg_id.startswith("rD") or reg_id.startswith("rA"):
pos += 16
elif reg_id.startswith("rB"):
Initial PPC emulation tests.
2020-01-31 03:10:53 +00:00
pos += 16
elif reg_id.startswith("XER:"):
pos += 18
elif reg_id.startswith("CR:"):
pos += 17
elif reg_id.startswith("imm"):
return int(line[pos+4:pos+14], base=16)
return 0
Add tests for shifts and fix their emulation.
2020-02-03 19:36:22 +00:00
def extract_rot_params(line):
pos = 12
sh = 0
mb = 0
me = 0
while pos < len(line):
reg_id = line[pos:pos+4]
if reg_id.startswith("rD") or reg_id.startswith("rA") or reg_id.startswith("rB") or reg_id.startswith("rS"):
pos += 16
elif reg_id.startswith("XER:"):
pos += 18
elif reg_id.startswith("CR:"):
pos += 17
elif reg_id.startswith("SH"):
sh = int(line[pos+3:pos+13], base=16)
pos += 16
Complete tests for the integer instructions.
2020-02-08 22:23:58 +00:00
elif reg_id.startswith("MB"):
mb = int(line[pos+3:pos+13], base=16)
pos += 16
elif reg_id.startswith("ME"):
me = int(line[pos+3:pos+13], base=16)
pos += 16
Add tests for shifts and fix their emulation.
2020-02-03 19:36:22 +00:00
return (sh, mb, me)
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
if __name__ == "__main__":
with open("ppcinttest.txt", "r") as in_file:
with open("ppcinttests.csv", "w") as out_file:
lineno = 0
for line in in_file:
lineno += 1
Add tests for shifts and fix their emulation.
2020-02-03 19:36:22 +00:00
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
line = line.strip()
opcode = (line[0:8]).rstrip().upper()
out_file.write(opcode + ",")
Initial PPC emulation tests.
2020-01-31 03:10:53 +00:00
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
if opcode.startswith("RLWI"):
sh, mb, me = extract_rot_params(line)
out_file.write("0x{:X}".format(gen_rot_opcode(opcode, sh, mb, me)))
else:
imm = extract_imm(line)
out_file.write("0x{:X}".format(gen_ppc_opcode(opcode, imm)))
pos = 12
while pos < len(line):
reg_id = line[pos:pos+4]
if reg_id.startswith("rD"):
out_file.write(",rD=" + line[pos+3:pos+13])
pos += 16
elif reg_id.startswith("rA"):
out_file.write(",rA=" + line[pos+3:pos+13])
pos += 16
elif reg_id.startswith("rB") or reg_id.startswith("rS"):
out_file.write(",rB=" + line[pos+3:pos+13])
pos += 16
elif reg_id.startswith("XER:"):
out_file.write(",XER=" + line[pos+5:pos+15])
pos += 18
elif reg_id.startswith("CR:"):
out_file.write(",CR=" + line[pos+4:pos+14])
pos += 17
elif reg_id.startswith("imm"):
pos += 17 # ignore immediate operands
elif reg_id.startswith("SH"):
pos += 16
elif reg_id.startswith("MB") or reg_id.startswith("ME"):
pos += 16
else:
out_file.write("Unknown reg ID" + reg_id)
break
out_file.write("\n")
Initial PPC emulation tests.
2020-01-31 03:10:53 +00:00
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
floatRE = re.compile('^([\w]+\.?) +(?:\((\w+)\) )?:: (?:(fr[ABCD]) +([^ ]+) \| )?(?:(fr[ABCD]) +([^ ]+) \| )?(?:(fr[ABCD]) +([^ ]+) \| )?(?:(fr[ABCD]) +([^ ]+) \| )?FPSCR: (0x\w+) \| CR: (0x\w+)$')
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
with open("ppcfloattest.txt", "r") as in_file:
with open("ppcfloattests.csv", "w") as out_file:
lineno = 0
for line in in_file:
lineno += 1
Initial PPC emulation tests.
2020-01-31 03:10:53 +00:00
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
line = line.strip()
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
p = floatRE.match(line)
if p:
opcode = p.group(1).upper();
out_file.write(opcode+ ",")
out_file.write("0x{:X}".format(gen_ppc_opcode(opcode, 0)))
Preliminary work on floating point tests
2021-06-26 04:20:53 +00:00
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
if p.group(2) == "RTNI":
out_file.write(",round=RNI")
elif p.group(2) == "RTN":
out_file.write(",round=RTN")
elif p.group(2) == "RTZ":
Fixed floating-point test generation
2021-10-14 14:19:04 +00:00
out_file.write(",round=RTZ")
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
elif p.group(2) == "RTPI":
Fixed floating-point test generation
2021-10-14 14:19:04 +00:00
out_file.write(",round=RPI")
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
elif p.group(2) == "VE":
Fixed floating-point test generation
2021-10-14 14:19:04 +00:00
out_file.write(",round=VEN")
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
elif p.group(2) != None:
print("Warning: line: [%d] unknown round \"%s\"\n" % (lineno, p.group(2)))
Fixed floating-point test generation
2021-10-14 14:19:04 +00:00
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
if p.group(3) != None:
out_file.write(",%s=%s" % (p.group(3), p.group(4)))
if p.group(5) != None:
out_file.write(",%s=%s" % (p.group(5), p.group(6)))
if p.group(7) != None:
out_file.write(",%s=%s" % (p.group(7), p.group(8)))
if p.group(9) != None:
out_file.write(",%s=%s" % (p.group(9), p.group(10)))
Fixed floating-point test generation
2021-10-14 14:19:04 +00:00
ppctest: Fix floating-point tests. genppctests.py - Fix incorrect bits for some floating-point instruction opcodes or fields. - Use separate register for FP results like DolphinPPCTests does. - Remove extra FMULS. - Use a regular expression for parsing ppcfloattest.txt. Don't parse the values, just put them in the output ppcloattests.csv file. ppcfloattest.txt - Clear crf0 and crf7 because we only care about crf1. - Use values from DolphinPPCTests (0.0, 0.5, 1.0, 3.5, DBL_MAX, FLT_MAX, 2.4679999352, 4.9359998704, etc.). Some of the values were rounded. This will un-round them. Specify snan or qnan instead of nan. - One of the FCMPO and FCMPU tests had qnan instead of snan input values. ppcfloattest.csv - Regenerate this file using the updated genppctests.py which uses the updated ppcfloattest.txt. ppctests - Update double_from_string to be able to parse the new values (snan, qnan, FLT_MAX, DBL_MAX).
2024-01-14 12:46:43 +00:00
out_file.write(",FPSCR=%s" % p.group(11))
out_file.write(",CR=%s" % p.group(12))
out_file.write("\n")
else:
print("Warning: line: [%d] \"%s\"\n" % (lineno, line))
Reference in New Issue Copy Permalink