lcc: not promoting unsigned short to int when sizes are equal

[kervinck]

From http://www.homebrewcpu.com/retargeting_lcc.htm:

7/4/2007 - Fixed what I believe to be a bug in the handling of ANSI
integral promotion. There are some odd rules about promoting
unsigned integer types to signed in ANSI C that are somewhat different
than standard C. When an unsigned short type is widened to an
int, it is changed from unsigned to signed. LCC does this - but
when the sizeof(short) is the same as sizeof(int), the change of
sign should not happen. LCC made this change anyway, which broke
some code in Minix (and pretty much rendered unsigned short useless).
My fix was to add an if clause to binary() that allows an unsigned
short to remain unsigned iff short and int widths are the same.

The actual fix to binary() in src/expr.c is not listed on the page.

1. We have to consider if we want the same treatment.
2. Also consider the other types for as long as their sizes are equal to their own higher ranking type.
3. The fix for unsigned short can be restricted to the &IR == &gt1IR condition.

[kervinck]

1. This should work, at the end of binary():

+       if (xty->size == yty->size)
+               if (xty == unsignedshort || yty == unsignedshort)
+                       return unsignedtype;
        return inttype;

2. These cases seem to be handled ok already
3. Better not restrict. This looks like a genuine LCC bug

We shouldn't fix this without a test, so keep on hold for now

[kervinck]

Low priority

[kervinck]

Feedback from Bill Buzbee (Magic-1) in the comment section of "Magic-1 at 16 years old" https://www.youtube.com/watch?v=qOcSnaK0yBw

13 hours ago
I suspect there is a more general way to do this, but here is my post-hack binary(). If I recall, this is an issue that only arose because I declared Magic-1's integer type to be 16 bits - the same width as short.

For those following along, here's the webpage on my lcc retargeting:
http://www.homebrewcpu.com/retargeting_lcc.htm

The biggest trick I used with lcc was to lie to it and tell it I had 4 32-bit integer registers, 4 32-bit float registers and 4 64-bit double registers. These were actually mapped to frame memory. At the end of one of the passes, I looked to see if any were used. If so, I allocated space on the stack and then changed the name of the register to the stack offset. It worked surprisingly well.

Anyway, here's my binary() hack:

Type binary(Type xty, Type yty) {
#define xx(t) if (xty == t || yty == t) return t
xx(longdouble);
xx(doubletype);
xx(floattype);
xx(unsignedlonglong);
xx(longlong);
xx(unsignedlong);
if (xty == longtype && yty == unsignedtype
|| xty == unsignedtype && yty == longtype)
if (longtype->size > unsignedtype->size)
return longtype;
else
return unsignedlong;
xx(longtype);
xx(unsignedtype);
// WBB fix - integral promotion rules allow
// unsigned to stay unsigned when
// width of short is same as width of int
if (inttype->size == shorttype->size) {
xx(unsignedshort);
}
// WBB end fix
return inttype;
#undef xx
}

[lb3361]

This issue should be closed since glcc fixes it.