6502/cc65
1
0
Fork 0
mirror of https://github.com/cc65/cc65.git synced 2024-11-19 21:32:19 +00:00
Code Issues Projects Releases Wiki Activity
022935320c
cc65/test/val/bug1348.c

55 lines
1.2 KiB
C
Raw Normal View History

Fixed the cc65 code that optimizes 16-bit compares when the high bytes are known to be equal. Only the low bytes are compared. Originally, signed 16-bit compares were optimized into signed 8-bit compares. But, the sign bits are in the high bytes; and, they're equal. Therefore, the low bytes always must be compared as unsigned numbers. Fixes #1348.
2020-12-24 17:27:09 +00:00
/* bug #1348, wrongly optimized integer promotion in comparison */
testcase for issue #1348
2020-11-19 22:12:16 +00:00
#include <stdio.h>
Fixed the cc65 code that optimizes 16-bit compares when the high bytes are known to be equal. Only the low bytes are compared. Originally, signed 16-bit compares were optimized into signed 8-bit compares. But, the sign bits are in the high bytes; and, they're equal. Therefore, the low bytes always must be compared as unsigned numbers. Fixes #1348.
2020-12-24 17:27:09 +00:00
static const int notrandtab[] = {
testcase for issue #1348
2020-11-19 22:12:16 +00:00
0xffff, 0x7fff, 0x3fff, 0x1fff,
0x0fff, 0x07ff, 0x03ff, 0x01ff,
0x00ff, 0x007f, 0x003f, 0x001f,
0x000f, 0x0007, 0x0003, 0x0001
};
Fixed the cc65 code that optimizes 16-bit compares when the high bytes are known to be equal. Only the low bytes are compared. Originally, signed 16-bit compares were optimized into signed 8-bit compares. But, the sign bits are in the high bytes; and, they're equal. Therefore, the low bytes always must be compared as unsigned numbers. Fixes #1348.
2020-12-24 17:27:09 +00:00
static unsigned char notrandcount = 0;
testcase for issue #1348
2020-11-19 22:12:16 +00:00
Fixed the cc65 code that optimizes 16-bit compares when the high bytes are known to be equal. Only the low bytes are compared. Originally, signed 16-bit compares were optimized into signed 8-bit compares. But, the sign bits are in the high bytes; and, they're equal. Therefore, the low bytes always must be compared as unsigned numbers. Fixes #1348.
2020-12-24 17:27:09 +00:00
static int notrand(void)
testcase for issue #1348
2020-11-19 22:12:16 +00:00
{
return notrandtab[notrandcount & 0x0f];
}
Fixed the cc65 code that optimizes 16-bit compares when the high bytes are known to be equal. Only the low bytes are compared. Originally, signed 16-bit compares were optimized into signed 8-bit compares. But, the sign bits are in the high bytes; and, they're equal. Therefore, the low bytes always must be compared as unsigned numbers. Fixes #1348.
2020-12-24 17:27:09 +00:00
static unsigned char n1, n2;
static unsigned char i, ii, s;
static unsigned char err = 0;
testcase for issue #1348
2020-11-19 22:12:16 +00:00
Fixed the cc65 code that optimizes 16-bit compares when the high bytes are known to be equal. Only the low bytes are compared. Originally, signed 16-bit compares were optimized into signed 8-bit compares. But, the sign bits are in the high bytes; and, they're equal. Therefore, the low bytes always must be compared as unsigned numbers. Fixes #1348.
2020-12-24 17:27:09 +00:00
static const unsigned char cmptab[] = {
testcase for issue #1348
2020-11-19 22:12:16 +00:00
0xff, 0x7f, 0x3f, 0x1f,
0x0f, 0x07, 0x03, 0x01,
0x80, 0x40, 0x20, 0x10,
0x08, 0x04, 0x02, 0x01
};
int main(void)
{
for (ii = 0; ii < 16; ++ii) {
s = cmptab[ii];
for (i = 0; i < 16; ++i) {
n1 = n2 = 0;
if ((notrand() & 0xff) > s) {
n1 = 1;
}
if ((notrand() & 0xffu) > s) {
n2 = 1;
}
Fixed the cc65 code that optimizes 16-bit compares when the high bytes are known to be equal. Only the low bytes are compared. Originally, signed 16-bit compares were optimized into signed 8-bit compares. But, the sign bits are in the high bytes; and, they're equal. Therefore, the low bytes always must be compared as unsigned numbers. Fixes #1348.
2020-12-24 17:27:09 +00:00
printf("%5d > %3d %u(%02x) %u(%02x) %s\n",
notrandtab[i], s,
testcase for issue #1348
2020-11-19 22:12:16 +00:00
n1, (notrand() & 0xff),
n2, (notrand() & 0xffu),
Fixed the cc65 code that optimizes 16-bit compares when the high bytes are known to be equal. Only the low bytes are compared. Originally, signed 16-bit compares were optimized into signed 8-bit compares. But, the sign bits are in the high bytes; and, they're equal. Therefore, the low bytes always must be compared as unsigned numbers. Fixes #1348.
2020-12-24 17:27:09 +00:00
n1 == n2 ? "=" : "!=");
if (n1 != n2) {
err = 1;
}
testcase for issue #1348
2020-11-19 22:12:16 +00:00
notrandcount++;
}
}
return err;
}
Reference in New Issue Copy Permalink