Optimization bug

[Hyman Rosen]

Not to long ago, someone posted a patch for optimization problems with
respect to partial word comparisons. This patch never seems to have made
it into release, since the latest snapshot still exhibits the problems.

Here is the test code again. It produces no output when compiled without
optimization, but many failures when compiled with optimization.

/************************************************************************/
#include <stdio.h>

struct a {
        char a, b;
        short c;
};

int
a1()
{
        static struct a x = { 1, 2, ~1 }, y = { 65, 2, ~2 };

        return (x.a == (y.a & ~64) && x.b == y.b);
}

int
a2()
{
        static struct a x = { 1, 66, ~1 }, y = { 1, 2, ~2 };

        return (x.a == y.a && (x.b & ~64) == y.b);
}

int
a3()
{
        static struct a x = { 9, 66, ~1 }, y = { 33, 18, ~2 };

        return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16));
}

struct b {
        int c;
        short b, a;
};

int
b1()
{
        static struct b x = { ~1, 2, 1 }, y = { ~2, 2, 65 };

        return (x.a == (y.a & ~64) && x.b == y.b);
}

int
b2()
{
        static struct b x = { ~1, 66, 1 }, y = { ~2, 2, 1 };

        return (x.a == y.a && (x.b & ~64) == y.b);
}

int
b3()
{
        static struct b x = { ~1, 66, 9 }, y = { ~2, 18, 33 };

        return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16));
}

struct c {
        unsigned int c:4, b:14, a:14;
};

int
c1()
{
        static struct c x = { ~1, 2, 1 }, y = { ~2, 2, 65 };

        return (x.a == (y.a & ~64) && x.b == y.b);
}

int
c2()
{
        static struct c x = { ~1, 66, 1 }, y = { ~2, 2, 1 };

        return (x.a == y.a && (x.b & ~64) == y.b);
}

int
c3()
{
        static struct c x = { ~1, 66, 9 }, y = { ~2, 18, 33 };

        return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16));
}

struct d {
        unsigned int a:14, b:14, c:4;
};

int
d1()
{
        static struct d x = { 1, 2, ~1 }, y = { 65, 2, ~2 };

        return (x.a == (y.a & ~64) && x.b == y.b);
}

int
d2()
{
        static struct d x = { 1, 66, ~1 }, y = { 1, 2, ~2 };

        return (x.a == y.a && (x.b & ~64) == y.b);
}

int
d3()
{
        static struct d x = { 9, 66, ~1 }, y = { 33, 18, ~2 };

        return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16));
}

struct e {
        int c:4, b:14, a:14;
};

int
e1()
{
        static struct e x = { ~1, -2, -65 }, y = { ~2, -2, -1 };

        return (x.a == (y.a & ~64) && x.b == y.b);
}

int
e2()
{
        static struct e x = { ~1, -2, -1 }, y = { ~2, -66, -1 };

        return (x.a == y.a && (x.b & ~64) == y.b);
}

int
e3()
{
        static struct e x = { ~1, -18, -33 }, y = { ~2, -66, -9 };

        return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16));
}

struct f {
        int a:14, b:14, c:4;
};

int
f1()
{
        static struct f x = { -65, -2, ~1 }, y = { -1, -2, ~2 };

        return (x.a == (y.a & ~64) && x.b == y.b);
}

int
f2()
{
        static struct f x = { -1, -2, ~1 }, y = { -1, -66, ~2 };

        return (x.a == y.a && (x.b & ~64) == y.b);
}

int
f3()
{
        static struct f x = { -33, -18, ~1 }, y = { -9, -66, ~2 };

        return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16));
}

struct gx {
        int c:4, b:14, a:14;
};
struct gy {
        int b:14, a:14, c:4;
};

int
g1()
{
        static struct gx x = { ~1, -2, -65 };
        static struct gy y = { -2, -1, ~2 };

        return (x.a == (y.a & ~64) && x.b == y.b);
}

int
g2()
{
        static struct gx x = { ~1, -2, -1 };
        static struct gy y = { -66, -1, ~2 };

        return (x.a == y.a && (x.b & ~64) == y.b);
}

int
g3()
{
        static struct gx x = { ~1, -18, -33 };
        static struct gy y = { -66, -9, ~2 };

        return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16));
}

int
g4()
{
        static struct gx x = { ~1, 0x0020, 0x0010 };
        static struct gy y = { 0x0200, 0x0100, ~2 };

        return!((x.a & 0x00f0) == (y.a & 0x0f00) &&
                (x.b & 0x00f0) == (y.b & 0x0f00));
}

int
g5()
{
        static struct gx x = { ~1, 0x0200, 0x0100 };
        static struct gy y = { 0x0020, 0x0010, ~2 };

        return!((x.a & 0x0f00) == (y.a & 0x00f0) &&
                (x.b & 0x0f00) == (y.b & 0x00f0));
}

int
g6()
{
        static struct gx x = { ~1, 0xfe20, 0xfd10 };
        static struct gy y = { 0xc22f, 0xc11f, ~2 };

        return ((x.a & 0x03ff) == (y.a & 0x3ff0) &&
                (x.b & 0x03ff) == (y.b & 0x3ff0));
}

int
g7()
{
        static struct gx x = { ~1, 0xc22f, 0xc11f };
        static struct gy y = { 0xfe20, 0xfd10, ~2 };

        return ((x.a & 0x3ff0) == (y.a & 0x03ff) &&
                (x.b & 0x3ff0) == (y.b & 0x03ff));
}

struct hx {
        int a:14, b:14, c:4;
};
struct hy {
        int c:4, a:14, b:14;
};

int
h1()
{
        static struct hx x = { -65, -2, ~1 };
        static struct hy y = { ~2, -1, -2 };

        return (x.a == (y.a & ~64) && x.b == y.b);
}

int
h2()
{
        static struct hx x = { -1, -2, ~1 };
        static struct hy y = { ~2, -1, -66 };

        return (x.a == y.a && (x.b & ~64) == y.b);
}

int
h3()
{
        static struct hx x = { -33, -18, ~1 };
        static struct hy y = { ~2, -9, -66 };

        return ((x.a & ~8) == (y.a & ~32) && (x.b & ~64) == (y.b & ~16));
}

int
h4()
{
        static struct hx x = { 0x0010, 0x0020, ~1 };
        static struct hy y = { ~2, 0x0100, 0x0200 };

        return!((x.a & 0x00f0) == (y.a & 0x0f00) &&
                (x.b & 0x00f0) == (y.b & 0x0f00));
}

int
h5()
{
        static struct hx x = { 0x0100, 0x0200, ~1 };
        static struct hy y = { ~2, 0x0010, 0x0020 };

        return!((x.a & 0x0f00) == (y.a & 0x00f0) &&
                (x.b & 0x0f00) == (y.b & 0x00f0));
}

int
h6()
{
        static struct hx x = { 0xfd10, 0xfe20, ~1 };
        static struct hy y = { ~2, 0xc11f, 0xc22f };

        return ((x.a & 0x03ff) == (y.a & 0x3ff0) &&
                (x.b & 0x03ff) == (y.b & 0x3ff0));
}

int
h7()
{
        static struct hx x = { 0xc11f, 0xc22f, ~1 };
        static struct hy y = { ~2, 0xfd10, 0xfe20 };

        return ((x.a & 0x3ff0) == (y.a & 0x03ff) &&
                (x.b & 0x3ff0) == (y.b & 0x03ff));
}

int
main()
{
        if (!a1()) printf("a1 FAIL\n");
        if (!a2()) printf("a2 FAIL\n");
        if (!a3()) printf("a3 FAIL\n");
        if (!b1()) printf("b1 FAIL\n");
        if (!b2()) printf("b2 FAIL\n");
        if (!b3()) printf("b3 FAIL\n");
        if (!c1()) printf("c1 FAIL\n");
        if (!c2()) printf("c2 FAIL\n");
        if (!c3()) printf("c3 FAIL\n");
        if (!d1()) printf("d1 FAIL\n");
        if (!d2()) printf("d2 FAIL\n");
        if (!d3()) printf("d3 FAIL\n");
        if (!e1()) printf("e1 FAIL\n");
        if (!e2()) printf("e2 FAIL\n");
        if (!e3()) printf("e3 FAIL\n");
        if (!f1()) printf("f1 FAIL\n");
        if (!f2()) printf("f2 FAIL\n");
        if (!f3()) printf("f3 FAIL\n");
        if (!g1()) printf("g1 FAIL\n");
        if (!g2()) printf("g2 FAIL\n");
        if (!g3()) printf("g3 FAIL\n");
        if (!g4()) printf("g4 FAIL\n");
        if (!g5()) printf("g5 FAIL\n");
        if (!g6()) printf("g6 FAIL\n");
        if (!g7()) printf("g7 FAIL\n");
        if (!h1()) printf("h1 FAIL\n");
        if (!h2()) printf("h2 FAIL\n");
        if (!h3()) printf("h3 FAIL\n");
        if (!h4()) printf("h4 FAIL\n");
        if (!h5()) printf("h5 FAIL\n");
        if (!h6()) printf("h6 FAIL\n");
        if (!h7()) printf("h7 FAIL\n");
}