6502/cc65
1
0
Fork 0
mirror of https://github.com/cc65/cc65.git synced 2024-12-23 04:30:10 +00:00
Code Issues Projects Releases Wiki Activity

added various tests related to bug #1045

Browse Source
This commit is contained in:
mrdudz 2020-06-23 00:46:12 +02:00
parent aaecf3cfec
commit 6e6ce4e5ee
16 changed files with 1375 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
test/val/postdec-16-16.c Normal file
View File

@ -0,0 +1,86 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef __C64__
#include <conio.h>
#endif
/* apparently we dont trigger the bug when not using absolute addresses? */
#ifdef __C64__
#define TARGETMEM 0x4c8
#define SOURCEMEM 0x702
#elif __SIM6502__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#elif __SIM65C02__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#else
static unsigned char mem[0x10];
#define TARGETMEM &mem[0]
#define SOURCEMEM &mem[8]
#endif
/* do not put at pos. 1, and 1 byte apart - so we can eventually notice
off-by-one errors */
static unsigned short u16w = 3;
static unsigned short u16r = 5;
static unsigned char target[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char source[8] = { 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static unsigned char expect[8] = { 0x0, 0x1, 0xc, 0xd, 0x4, 0x5, 0x6, 0x7 };
static unsigned char i;
static unsigned char err = EXIT_SUCCESS;
void test1(void)
{
((unsigned char*)TARGETMEM)[u16w--] = ((unsigned char*)SOURCEMEM)[u16r--];
}
void dotest(void)
{
memcpy(TARGETMEM, target, 8);
memcpy(SOURCEMEM, source, 8);
test1();
memcpy(target, TARGETMEM, 8);
memcpy(source, SOURCEMEM, 8);
#ifdef __C64__
clrscr();
#endif
printf("source:");
for(i = 0; i < 8; ++i) {
printf("%0x ", source[i]);
}
printf("\n\rtarget:");
for(i = 0; i < 8; ++i) {
printf("%0x ", target[i]);
}
printf("\n\r");
printf("u16w: %d\n\r", u16w);
printf("u16r: %d\n\r", u16r);
}
int main(void)
{
dotest();
dotest();
if (memcmp(target, expect, 8) != 0) {
printf("buffer data error\n\r");
err = EXIT_FAILURE;
}
if (u16w != 1) {
err = EXIT_FAILURE;
}
if (u16r != 3) {
err = EXIT_FAILURE;
}
printf("return: %d\n\r", err);
return err;
}

86
test/val/postdec-16-8.c Normal file
View File

@ -0,0 +1,86 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef __C64__
#include <conio.h>
#endif
/* apparently we dont trigger the bug when not using absolute addresses? */
#ifdef __C64__
#define TARGETMEM 0x4c8
#define SOURCEMEM 0x702
#elif __SIM6502__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#elif __SIM65C02__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#else
static unsigned char mem[0x10];
#define TARGETMEM &mem[0]
#define SOURCEMEM &mem[8]
#endif
/* do not put at pos. 1, and 1 byte apart - so we can eventually notice
off-by-one errors */
static unsigned short u16w = 3;
static unsigned char u8r = 5;
static unsigned char target[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char source[8] = { 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static unsigned char expect[8] = { 0x0, 0x1, 0xc, 0xd, 0x4, 0x5, 0x6, 0x7 };
static unsigned char i;
static unsigned char err = EXIT_SUCCESS;
void test1(void)
{
((unsigned char*)TARGETMEM)[u16w--] = ((unsigned char*)SOURCEMEM)[u8r--];
}
void dotest(void)
{
memcpy(TARGETMEM, target, 8);
memcpy(SOURCEMEM, source, 8);
test1();
memcpy(target, TARGETMEM, 8);
memcpy(source, SOURCEMEM, 8);
#ifdef __C64__
clrscr();
#endif
printf("source:");
for(i = 0; i < 8; ++i) {
printf("%0x ", source[i]);
}
printf("\n\rtarget:");
for(i = 0; i < 8; ++i) {
printf("%0x ", target[i]);
}
printf("\n\r");
printf("u16w: %d\n\r", u16w);
printf("u8r: %d\n\r", u8r);
}
int main(void)
{
dotest();
dotest();
if (memcmp(target, expect, 8) != 0) {
printf("buffer data error\n\r");
err = EXIT_FAILURE;
}
if (u16w != 1) {
err = EXIT_FAILURE;
}
if (u8r != 3) {
err = EXIT_FAILURE;
}
printf("return: %d\n\r", err);
return err;
}

86
test/val/postdec-8-16.c Normal file
View File

@ -0,0 +1,86 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef __C64__
#include <conio.h>
#endif
/* apparently we dont trigger the bug when not using absolute addresses? */
#ifdef __C64__
#define TARGETMEM 0x4c8
#define SOURCEMEM 0x702
#elif __SIM6502__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#elif __SIM65C02__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#else
static unsigned char mem[0x10];
#define TARGETMEM &mem[0]
#define SOURCEMEM &mem[8]
#endif
/* do not put at pos. 1, and 1 byte apart - so we can eventually notice
off-by-one errors */
static unsigned char u8w = 3;
static unsigned short u16r = 5;
static unsigned char target[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char source[8] = { 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static unsigned char expect[8] = { 0x0, 0x1, 0xc, 0xd, 0x4, 0x5, 0x6, 0x7 };
static unsigned char i;
static unsigned char err = EXIT_SUCCESS;
void test1(void)
{
((unsigned char*)TARGETMEM)[u8w--] = ((unsigned char*)SOURCEMEM)[u16r--];
}
void dotest(void)
{
memcpy(TARGETMEM, target, 8);
memcpy(SOURCEMEM, source, 8);
test1();
memcpy(target, TARGETMEM, 8);
memcpy(source, SOURCEMEM, 8);
#ifdef __C64__
clrscr();
#endif
printf("source:");
for(i = 0; i < 8; ++i) {
printf("%0x ", source[i]);
}
printf("\n\rtarget:");
for(i = 0; i < 8; ++i) {
printf("%0x ", target[i]);
}
printf("\n\r");
printf("u8w: %d\n\r", u8w);
printf("u16r: %d\n\r", u16r);
}
int main(void)
{
dotest();
dotest();
if (memcmp(target, expect, 8) != 0) {
printf("buffer data error\n\r");
err = EXIT_FAILURE;
}
if (u8w != 1) {
err = EXIT_FAILURE;
}
if (u16r != 3) {
err = EXIT_FAILURE;
}
printf("return: %d\n\r", err);
return err;
}

86
test/val/postdec-8-8.c Normal file
View File

@ -0,0 +1,86 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef __C64__
#include <conio.h>
#endif
/* apparently we dont trigger the bug when not using absolute addresses? */
#ifdef __C64__
#define TARGETMEM 0x4c8
#define SOURCEMEM 0x702
#elif __SIM6502__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#elif __SIM65C02__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#else
static unsigned char mem[0x10];
#define TARGETMEM &mem[0]
#define SOURCEMEM &mem[8]
#endif
/* do not put at pos. 1, and 1 byte apart - so we can eventually notice
off-by-one errors */
static unsigned char u8w = 3;
static unsigned char u8r = 5;
static unsigned char target[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char source[8] = { 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static unsigned char expect[8] = { 0x0, 0x1, 0xc, 0xd, 0x4, 0x5, 0x6, 0x7 };
static unsigned char i;
static unsigned char err = EXIT_SUCCESS;
void test1(void)
{
((unsigned char*)TARGETMEM)[u8w--] = ((unsigned char*)SOURCEMEM)[u8r--];
}
void dotest(void)
{
memcpy(TARGETMEM, target, 8);
memcpy(SOURCEMEM, source, 8);
test1();
memcpy(target, TARGETMEM, 8);
memcpy(source, SOURCEMEM, 8);
#ifdef __C64__
clrscr();
#endif
printf("source:");
for(i = 0; i < 8; ++i) {
printf("%0x ", source[i]);
}
printf("\n\rtarget:");
for(i = 0; i < 8; ++i) {
printf("%0x ", target[i]);
}
printf("\n\r");
printf("u8w: %d\n\r", u8w);
printf("u8r: %d\n\r", u8r);
}
int main(void)
{
dotest();
dotest();
if (memcmp(target, expect, 8) != 0) {
printf("buffer data error\n\r");
err = EXIT_FAILURE;
}
if (u8w != 1) {
err = EXIT_FAILURE;
}
if (u8r != 3) {
err = EXIT_FAILURE;
}
printf("return: %d\n\r", err);
return err;
}

86
test/val/postinc-16-16.c Normal file
View File

@ -0,0 +1,86 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef __C64__
#include <conio.h>
#endif
/* apparently we dont trigger the bug when not using absolute addresses? */
#ifdef __C64__
#define TARGETMEM 0x4c8
#define SOURCEMEM 0x702
#elif __SIM6502__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#elif __SIM65C02__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#else
static unsigned char mem[0x10];
#define TARGETMEM &mem[0]
#define SOURCEMEM &mem[8]
#endif
/* do not put at pos. 1, and 1 byte apart - so we can eventually notice
off-by-one errors */
static unsigned short u16w = 1;
static unsigned short u16r = 3;
static unsigned char target[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char source[8] = { 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static unsigned char expect[8] = { 0x0, 0xb, 0xc, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char i;
static unsigned char err = EXIT_SUCCESS;
void test1(void)
{
((unsigned char*)TARGETMEM)[u16w++] = ((unsigned char*)SOURCEMEM)[u16r++];
}
void dotest(void)
{
memcpy(TARGETMEM, target, 8);
memcpy(SOURCEMEM, source, 8);
test1();
memcpy(target, TARGETMEM, 8);
memcpy(source, SOURCEMEM, 8);
#ifdef __C64__
clrscr();
#endif
printf("source:");
for(i = 0; i < 8; ++i) {
printf("%0x ", source[i]);
}
printf("\n\rtarget:");
for(i = 0; i < 8; ++i) {
printf("%0x ", target[i]);
}
printf("\n\r");
printf("u16w: %d\n\r", u16w);
printf("u16r: %d\n\r", u16r);
}
int main(void)
{
dotest();
dotest();
if (memcmp(target, expect, 8) != 0) {
printf("buffer data error\n\r");
err = EXIT_FAILURE;
}
if (u16w != 3) {
err = EXIT_FAILURE;
}
if (u16r != 5) {
err = EXIT_FAILURE;
}
printf("return: %d\n\r", err);
return err;
}

85
test/val/postinc-16-8.c Normal file
View File

@ -0,0 +1,85 @@
#include <stdio.h>
#include <string.h>
#ifdef __C64__
#include <conio.h>
#endif
/* apparently we dont trigger the bug when not using absolute addresses? */
#ifdef __C64__
#define TARGETMEM 0x4c8
#define SOURCEMEM 0x702
#elif __SIM6502__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#elif __SIM65C02__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#else
static unsigned char mem[0x10];
#define TARGETMEM &mem[0]
#define SOURCEMEM &mem[8]
#endif
/* do not put at pos. 1, and 1 byte apart - so we can eventually notice
off-by-one errors */
static unsigned short u16w = 1;
static unsigned char u8r = 3;
static unsigned char target[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char source[8] = { 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static unsigned char expect[8] = { 0x0, 0xb, 0xc, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char i;
static unsigned char err = 0;
void test1(void)
{
((unsigned char*)TARGETMEM)[u16w++] = ((unsigned char*)SOURCEMEM)[u8r++];
}
void dotest(void)
{
memcpy(TARGETMEM, target, 8);
memcpy(SOURCEMEM, source, 8);
test1();
memcpy(target, TARGETMEM, 8);
memcpy(source, SOURCEMEM, 8);
#ifdef __C64__
clrscr();
#endif
printf("source:");
for(i = 0; i < 8; ++i) {
printf("%0x ", source[i]);
}
printf("\n\rtarget:");
for(i = 0; i < 8; ++i) {
printf("%0x ", target[i]);
}
printf("\n\r");
printf("u16w: %d\n\r", u16w);
printf("u8r: %d\n\r", u8r);
}
int main(void)
{
dotest();
dotest();
if (memcmp(target, expect, 8) != 0) {
printf("buffer data error\n\r");
err = 1;
}
if (u16w != 3) {
err = 1;
}
if (u8r != 5) {
err = 1;
}
printf("return: %d\n\r", err);
return err;
}

86
test/val/postinc-8-16.c Normal file
View File

@ -0,0 +1,86 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef __C64__
#include <conio.h>
#endif
/* apparently we dont trigger the bug when not using absolute addresses? */
#ifdef __C64__
#define TARGETMEM 0x4c8
#define SOURCEMEM 0x702
#elif __SIM6502__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#elif __SIM65C02__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#else
static unsigned char mem[0x10];
#define TARGETMEM &mem[0]
#define SOURCEMEM &mem[8]
#endif
/* do not put at pos. 1, and 1 byte apart - so we can eventually notice
off-by-one errors */
static unsigned char u8w = 1;
static unsigned short u16r = 3;
static unsigned char target[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char source[8] = { 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static unsigned char expect[8] = { 0x0, 0xb, 0xc, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char i;
static unsigned char err = EXIT_SUCCESS;
void test1(void)
{
((unsigned char*)TARGETMEM)[u8w++] = ((unsigned char*)SOURCEMEM)[u16r++];
}
void dotest(void)
{
memcpy(TARGETMEM, target, 8);
memcpy(SOURCEMEM, source, 8);
test1();
memcpy(target, TARGETMEM, 8);
memcpy(source, SOURCEMEM, 8);
#ifdef __C64__
clrscr();
#endif
printf("source:");
for(i = 0; i < 8; ++i) {
printf("%0x ", source[i]);
}
printf("\n\rtarget:");
for(i = 0; i < 8; ++i) {
printf("%0x ", target[i]);
}
printf("\n\r");
printf("u8w: %d\n\r", u8w);
printf("u16r: %d\n\r", u16r);
}
int main(void)
{
dotest();
dotest();
if (memcmp(target, expect, 8) != 0) {
printf("buffer data error\n\r");
err = EXIT_FAILURE;
}
if (u8w != 3) {
err = EXIT_FAILURE;
}
if (u16r != 5) {
err = EXIT_FAILURE;
}
printf("return: %d\n\r", err);
return err;
}

86
test/val/postinc-8-8.c Normal file
View File

@ -0,0 +1,86 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef __C64__
#include <conio.h>
#endif
/* apparently we dont trigger the bug when not using absolute addresses? */
#ifdef __C64__
#define TARGETMEM 0x4c8
#define SOURCEMEM 0x702
#elif __SIM6502__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#elif __SIM65C02__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#else
static unsigned char mem[0x10];
#define TARGETMEM &mem[0]
#define SOURCEMEM &mem[8]
#endif
/* do not put at pos. 1, and 1 byte apart - so we can eventually notice
off-by-one errors */
static unsigned char u8w = 1;
static unsigned char u8r = 3;
static unsigned char target[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char source[8] = { 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static unsigned char expect[8] = { 0x0, 0xb, 0xc, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char i;
static unsigned char err = EXIT_SUCCESS;
void test1(void)
{
((unsigned char*)TARGETMEM)[u8w++] = ((unsigned char*)SOURCEMEM)[u8r++];
}
void dotest(void)
{
memcpy(TARGETMEM, target, 8);
memcpy(SOURCEMEM, source, 8);
test1();
memcpy(target, TARGETMEM, 8);
memcpy(source, SOURCEMEM, 8);
#ifdef __C64__
clrscr();
#endif
printf("source:");
for(i = 0; i < 8; ++i) {
printf("%0x ", source[i]);
}
printf("\n\rtarget:");
for(i = 0; i < 8; ++i) {
printf("%0x ", target[i]);
}
printf("\n\r");
printf("u8w: %d\n\r", u8w);
printf("u8r: %d\n\r", u8r);
}
int main(void)
{
dotest();
dotest();
if (memcmp(target, expect, 8) != 0) {
printf("buffer data error\n\r");
err = EXIT_FAILURE;
}
if (u8w != 3) {
err = EXIT_FAILURE;
}
if (u8r != 5) {
err = EXIT_FAILURE;
}
printf("return: %d\n\r", err);
return err;
}

86
test/val/predec-16-16.c Normal file
View File

@ -0,0 +1,86 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef __C64__
#include <conio.h>
#endif
/* apparently we dont trigger the bug when not using absolute addresses? */
#ifdef __C64__
#define TARGETMEM 0x4c8
#define SOURCEMEM 0x702
#elif __SIM6502__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#elif __SIM65C02__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#else
static unsigned char mem[0x10];
#define TARGETMEM &mem[0]
#define SOURCEMEM &mem[8]
#endif
/* do not put at pos. 1, and 1 byte apart - so we can eventually notice
off-by-one errors */
static unsigned short u16w = 3;
static unsigned short u16r = 5;
static unsigned char target[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char source[8] = { 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static unsigned char expect[8] = { 0x0, 0xb, 0xc, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char i;
static unsigned char err = EXIT_SUCCESS;
void test1(void)
{
((unsigned char*)TARGETMEM)[--u16w] = ((unsigned char*)SOURCEMEM)[--u16r];
}
void dotest(void)
{
memcpy(TARGETMEM, target, 8);
memcpy(SOURCEMEM, source, 8);
test1();
memcpy(target, TARGETMEM, 8);
memcpy(source, SOURCEMEM, 8);
#ifdef __C64__
clrscr();
#endif
printf("source:");
for(i = 0; i < 8; ++i) {
printf("%0x ", source[i]);
}
printf("\n\rtarget:");
for(i = 0; i < 8; ++i) {
printf("%0x ", target[i]);
}
printf("\n\r");
printf("u16w: %d\n\r", u16w);
printf("u16r: %d\n\r", u16r);
}
int main(void)
{
dotest();
dotest();
if (memcmp(target, expect, 8) != 0) {
printf("buffer data error\n\r");
err = EXIT_FAILURE;
}
if (u16w != 1) {
err = EXIT_FAILURE;
}
if (u16r != 3) {
err = EXIT_FAILURE;
}
printf("return: %d\n\r", err);
return err;
}

86
test/val/predec-16-8.c Normal file
View File

@ -0,0 +1,86 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef __C64__
#include <conio.h>
#endif
/* apparently we dont trigger the bug when not using absolute addresses? */
#ifdef __C64__
#define TARGETMEM 0x4c8
#define SOURCEMEM 0x702
#elif __SIM6502__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#elif __SIM65C02__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#else
static unsigned char mem[0x10];
#define TARGETMEM &mem[0]
#define SOURCEMEM &mem[8]
#endif
/* do not put at pos. 1, and 1 byte apart - so we can eventually notice
off-by-one errors */
static unsigned short u16w = 3;
static unsigned char u8r = 5;
static unsigned char target[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char source[8] = { 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static unsigned char expect[8] = { 0x0, 0xb, 0xc, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char i;
static unsigned char err = EXIT_SUCCESS;
void test1(void)
{
((unsigned char*)TARGETMEM)[--u16w] = ((unsigned char*)SOURCEMEM)[--u8r];
}
void dotest(void)
{
memcpy(TARGETMEM, target, 8);
memcpy(SOURCEMEM, source, 8);
test1();
memcpy(target, TARGETMEM, 8);
memcpy(source, SOURCEMEM, 8);
#ifdef __C64__
clrscr();
#endif
printf("source:");
for(i = 0; i < 8; ++i) {
printf("%0x ", source[i]);
}
printf("\n\rtarget:");
for(i = 0; i < 8; ++i) {
printf("%0x ", target[i]);
}
printf("\n\r");
printf("u16w: %d\n\r", u16w);
printf("u8r: %d\n\r", u8r);
}
int main(void)
{
dotest();
dotest();
if (memcmp(target, expect, 8) != 0) {
printf("buffer data error\n\r");
err = EXIT_FAILURE;
}
if (u16w != 1) {
err = EXIT_FAILURE;
}
if (u8r != 3) {
err = EXIT_FAILURE;
}
printf("return: %d\n\r", err);
return err;
}

86
test/val/predec-8-16.c Normal file
View File

@ -0,0 +1,86 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef __C64__
#include <conio.h>
#endif
/* apparently we dont trigger the bug when not using absolute addresses? */
#ifdef __C64__
#define TARGETMEM 0x4c8
#define SOURCEMEM 0x702
#elif __SIM6502__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#elif __SIM65C02__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#else
static unsigned char mem[0x10];
#define TARGETMEM &mem[0]
#define SOURCEMEM &mem[8]
#endif
/* do not put at pos. 1, and 1 byte apart - so we can eventually notice
off-by-one errors */
static unsigned char u8w = 3;
static unsigned short u16r = 5;
static unsigned char target[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char source[8] = { 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static unsigned char expect[8] = { 0x0, 0xb, 0xc, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char i;
static unsigned char err = EXIT_SUCCESS;
void test1(void)
{
((unsigned char*)TARGETMEM)[--u8w] = ((unsigned char*)SOURCEMEM)[--u16r];
}
void dotest(void)
{
memcpy(TARGETMEM, target, 8);
memcpy(SOURCEMEM, source, 8);
test1();
memcpy(target, TARGETMEM, 8);
memcpy(source, SOURCEMEM, 8);
#ifdef __C64__
clrscr();
#endif
printf("source:");
for(i = 0; i < 8; ++i) {
printf("%0x ", source[i]);
}
printf("\n\rtarget:");
for(i = 0; i < 8; ++i) {
printf("%0x ", target[i]);
}
printf("\n\r");
printf("u8w: %d\n\r", u8w);
printf("u16r: %d\n\r", u16r);
}
int main(void)
{
dotest();
dotest();
if (memcmp(target, expect, 8) != 0) {
printf("buffer data error\n\r");
err = EXIT_FAILURE;
}
if (u8w != 1) {
err = EXIT_FAILURE;
}
if (u16r != 3) {
err = EXIT_FAILURE;
}
printf("return: %d\n\r", err);
return err;
}

86
test/val/predec-8-8.c Normal file
View File

@ -0,0 +1,86 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef __C64__
#include <conio.h>
#endif
/* apparently we dont trigger the bug when not using absolute addresses? */
#ifdef __C64__
#define TARGETMEM 0x4c8
#define SOURCEMEM 0x702
#elif __SIM6502__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#elif __SIM65C02__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#else
static unsigned char mem[0x10];
#define TARGETMEM &mem[0]
#define SOURCEMEM &mem[8]
#endif
/* do not put at pos. 1, and 1 byte apart - so we can eventually notice
off-by-one errors */
static unsigned char u8w = 3;
static unsigned char u8r = 5;
static unsigned char target[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char source[8] = { 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static unsigned char expect[8] = { 0x0, 0xb, 0xc, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char i;
static unsigned char err = EXIT_SUCCESS;
void test1(void)
{
((unsigned char*)TARGETMEM)[--u8w] = ((unsigned char*)SOURCEMEM)[--u8r];
}
void dotest(void)
{
memcpy(TARGETMEM, target, 8);
memcpy(SOURCEMEM, source, 8);
test1();
memcpy(target, TARGETMEM, 8);
memcpy(source, SOURCEMEM, 8);
#ifdef __C64__
clrscr();
#endif
printf("source:");
for(i = 0; i < 8; ++i) {
printf("%0x ", source[i]);
}
printf("\n\rtarget:");
for(i = 0; i < 8; ++i) {
printf("%0x ", target[i]);
}
printf("\n\r");
printf("u8w: %d\n\r", u8w);
printf("u8r: %d\n\r", u8r);
}
int main(void)
{
dotest();
dotest();
if (memcmp(target, expect, 8) != 0) {
printf("buffer data error\n\r");
err = EXIT_FAILURE;
}
if (u8w != 1) {
err = EXIT_FAILURE;
}
if (u8r != 3) {
err = EXIT_FAILURE;
}
printf("return: %d\n\r", err);
return err;
}

86
test/val/preinc-16-16.c Normal file
View File

@ -0,0 +1,86 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef __C64__
#include <conio.h>
#endif
/* apparently we dont trigger the bug when not using absolute addresses? */
#ifdef __C64__
#define TARGETMEM 0x4c8
#define SOURCEMEM 0x702
#elif __SIM6502__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#elif __SIM65C02__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#else
static unsigned char mem[0x10];
#define TARGETMEM &mem[0]
#define SOURCEMEM &mem[8]
#endif
/* do not put at pos. 1, and 1 byte apart - so we can eventually notice
off-by-one errors */
static unsigned short u16w = 3;
static unsigned short u16r = 5;
static unsigned char target[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char source[8] = { 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static unsigned char expect[8] = { 0x0, 0x1, 0x2, 0x3, 0xe, 0xf, 0x6, 0x7 };
static unsigned char i;
static unsigned char err = EXIT_SUCCESS;
void test1(void)
{
((unsigned char*)TARGETMEM)[++u16w] = ((unsigned char*)SOURCEMEM)[++u16r];
}
void dotest(void)
{
memcpy(TARGETMEM, target, 8);
memcpy(SOURCEMEM, source, 8);
test1();
memcpy(target, TARGETMEM, 8);
memcpy(source, SOURCEMEM, 8);
#ifdef __C64__
clrscr();
#endif
printf("source:");
for(i = 0; i < 8; ++i) {
printf("%0x ", source[i]);
}
printf("\n\rtarget:");
for(i = 0; i < 8; ++i) {
printf("%0x ", target[i]);
}
printf("\n\r");
printf("u16w: %d\n\r", u16w);
printf("u16r: %d\n\r", u16r);
}
int main(void)
{
dotest();
dotest();
if (memcmp(target, expect, 8) != 0) {
printf("buffer data error\n\r");
err = EXIT_FAILURE;
}
if (u16w != 5) {
err = EXIT_FAILURE;
}
if (u16r != 7) {
err = EXIT_FAILURE;
}
printf("return: %d\n\r", err);
return err;
}

86
test/val/preinc-16-8.c Normal file
View File

@ -0,0 +1,86 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef __C64__
#include <conio.h>
#endif
/* apparently we dont trigger the bug when not using absolute addresses? */
#ifdef __C64__
#define TARGETMEM 0x4c8
#define SOURCEMEM 0x702
#elif __SIM6502__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#elif __SIM65C02__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#else
static unsigned char mem[0x10];
#define TARGETMEM &mem[0]
#define SOURCEMEM &mem[8]
#endif
/* do not put at pos. 1, and 1 byte apart - so we can eventually notice
off-by-one errors */
static unsigned short u16w = 3;
static unsigned char u8r = 5;
static unsigned char target[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char source[8] = { 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static unsigned char expect[8] = { 0x0, 0x1, 0x2, 0x3, 0xe, 0xf, 0x6, 0x7 };
static unsigned char i;
static unsigned char err = EXIT_SUCCESS;
void test1(void)
{
((unsigned char*)TARGETMEM)[++u16w] = ((unsigned char*)SOURCEMEM)[++u8r];
}
void dotest(void)
{
memcpy(TARGETMEM, target, 8);
memcpy(SOURCEMEM, source, 8);
test1();
memcpy(target, TARGETMEM, 8);
memcpy(source, SOURCEMEM, 8);
#ifdef __C64__
clrscr();
#endif
printf("source:");
for(i = 0; i < 8; ++i) {
printf("%0x ", source[i]);
}
printf("\n\rtarget:");
for(i = 0; i < 8; ++i) {
printf("%0x ", target[i]);
}
printf("\n\r");
printf("u16w: %d\n\r", u16w);
printf("u8r: %d\n\r", u8r);
}
int main(void)
{
dotest();
dotest();
if (memcmp(target, expect, 8) != 0) {
printf("buffer data error\n\r");
err = EXIT_FAILURE;
}
if (u16w != 5) {
err = EXIT_FAILURE;
}
if (u8r != 7) {
err = EXIT_FAILURE;
}
printf("return: %d\n\r", err);
return err;
}

86
test/val/preinc-8-16.c Normal file
View File

@ -0,0 +1,86 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef __C64__
#include <conio.h>
#endif
/* apparently we dont trigger the bug when not using absolute addresses? */
#ifdef __C64__
#define TARGETMEM 0x4c8
#define SOURCEMEM 0x702
#elif __SIM6502__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#elif __SIM65C02__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#else
static unsigned char mem[0x10];
#define TARGETMEM &mem[0]
#define SOURCEMEM &mem[8]
#endif
/* do not put at pos. 1, and 1 byte apart - so we can eventually notice
off-by-one errors */
static unsigned char u8w = 3;
static unsigned short u16r = 5;
static unsigned char target[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char source[8] = { 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static unsigned char expect[8] = { 0x0, 0x1, 0x2, 0x3, 0xe, 0xf, 0x6, 0x7 };
static unsigned char i;
static unsigned char err = EXIT_SUCCESS;
void test1(void)
{
((unsigned char*)TARGETMEM)[++u8w] = ((unsigned char*)SOURCEMEM)[++u16r];
}
void dotest(void)
{
memcpy(TARGETMEM, target, 8);
memcpy(SOURCEMEM, source, 8);
test1();
memcpy(target, TARGETMEM, 8);
memcpy(source, SOURCEMEM, 8);
#ifdef __C64__
clrscr();
#endif
printf("source:");
for(i = 0; i < 8; ++i) {
printf("%0x ", source[i]);
}
printf("\n\rtarget:");
for(i = 0; i < 8; ++i) {
printf("%0x ", target[i]);
}
printf("\n\r");
printf("u8w: %d\n\r", u8w);
printf("u16r: %d\n\r", u16r);
}
int main(void)
{
dotest();
dotest();
if (memcmp(target, expect, 8) != 0) {
printf("buffer data error\n\r");
err = EXIT_FAILURE;
}
if (u8w != 5) {
err = EXIT_FAILURE;
}
if (u16r != 7) {
err = EXIT_FAILURE;
}
printf("return: %d\n\r", err);
return err;
}

86
test/val/preinc-8-8.c Normal file
View File

@ -0,0 +1,86 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef __C64__
#include <conio.h>
#endif
/* apparently we dont trigger the bug when not using absolute addresses? */
#ifdef __C64__
#define TARGETMEM 0x4c8
#define SOURCEMEM 0x702
#elif __SIM6502__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#elif __SIM65C02__
#define TARGETMEM 0xc4c8
#define SOURCEMEM 0xc702
#else
static unsigned char mem[0x10];
#define TARGETMEM &mem[0]
#define SOURCEMEM &mem[8]
#endif
/* do not put at pos. 1, and 1 byte apart - so we can eventually notice
off-by-one errors */
static unsigned char u8w = 3;
static unsigned char u8r = 5;
static unsigned char target[8] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
static unsigned char source[8] = { 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static unsigned char expect[8] = { 0x0, 0x1, 0x2, 0x3, 0xe, 0xf, 0x6, 0x7 };
static unsigned char i;
static unsigned char err = EXIT_SUCCESS;
void test1(void)
{
((unsigned char*)TARGETMEM)[++u8w] = ((unsigned char*)SOURCEMEM)[++u8r];
}
void dotest(void)
{
memcpy(TARGETMEM, target, 8);
memcpy(SOURCEMEM, source, 8);
test1();
memcpy(target, TARGETMEM, 8);
memcpy(source, SOURCEMEM, 8);
#ifdef __C64__
clrscr();
#endif
printf("source:");
for(i = 0; i < 8; ++i) {
printf("%0x ", source[i]);
}
printf("\n\rtarget:");
for(i = 0; i < 8; ++i) {
printf("%0x ", target[i]);
}
printf("\n\r");
printf("u8w: %d\n\r", u8w);
printf("u8r: %d\n\r", u8r);
}
int main(void)
{
dotest();
dotest();
if (memcmp(target, expect, 8) != 0) {
printf("buffer data error\n\r");
err = EXIT_FAILURE;
}
if (u8w != 5) {
err = EXIT_FAILURE;
}
if (u8r != 7) {
err = EXIT_FAILURE;
}
printf("return: %d\n\r", err);
return err;
}