Merge lp:~epics-core/epics-base/fix-calc-bit-manipulation into lp:~epics-core/epics-base/3.14

[Ralph Lange]

Fix for bug lp:1514520

- Pulls a backport of a 3.15 change to the calc engine, setting the internal integer format to the size-fixed epicsInt32 type.
- Adds tests that show the behavior described in the bug report.
- Applies the original patch by Dirk from that bug report.

To be able to apply this to 3.14, I had to backport the change to the sized-fixed integers. For sanity.

When applying to 3.15, that first commit has to be omitted.

One thing that I am not sure of: left shifts (zeroes filled in) are handled different than right shifts (ones filled in, assuming a signed integer operation).
The documentation (AppDevGuide) leaves it open.

[lp:~epics-core/epics-base/fix-calc-bit-manipulation]

12614. By Andrew Johnson on 2016-02-19

Fixed conversion overflows in tests

Minor tidying-up, added comments about casting for bitwise operations.

[Andrew Johnson (anj)]

Added an epicsUInt32 utop variable to calcPerform() to reduce the number of casts, and added some code comments.

Previous versions have always handled shifts as signed quantities, so the sign bit is extended on right-shifts. I changed the left-shift code to match, although it doesn't actually make any difference.

The shift operators also need to have their shift count limited to avoid Undefined Behavior; I see 2 realistic possibilities: ANDing the shift count with 31; or return 0 on shift-overflow but when right-shifting a negative quantity return -1 on shift-overflow. The first is the fastest and simplest to code, but the second one might be regarded as be more logical. Any preferences or alternative suggestions? I have implemented the first option for now.

The large positive decimal values in your tests are causing the same overflows when converted from double to integer that Dirk originally reported, they always convert to 0x80000000 on my RHEL systems so some tests fail. The paragraph before Dirk's "The fix is:" line explains that you have to use negative values for bit 31 to be set, which my tests agree with. The negative versions that work are 0xaaaaaaaa = -1431655766, 0xffff0000 = -65536. Note that postfix() compiles double literals into a LITERAL_INT op-code if the value can be safely held in an epicsInt32, so adding ".0" has no effect; but using ".1" instead does work, the fraction gets truncated.

Also fixed some minor white-space issues.

review: Approve

[Ralph Lange (ralph-lange)]

> Added an epicsUInt32 utop variable to calcPerform() to reduce the number of
> casts, and added some code comments.

Looks good, thanks.

> Previous versions have always handled shifts as signed quantities, so the sign
> bit is extended on right-shifts.

Fine with me. I was just seeing the asymmetry.

> The shift operators also need to have their shift count limited to avoid
> Undefined Behavior; I see 2 realistic possibilities: ANDing the shift count
> with 31; or return 0 / -1 on shift-overflow [...]
> I have implemented the first option for now.

Fine with me. We don't have to fix the holes in the definition.

> The large positive decimal values in your tests are causing the same overflows
> when converted from double to integer that Dirk originally reported, they
> always convert to 0x80000000 on my RHEL systems so some tests fail.

Interesting. Is that a compiler or a size dependency? My Debian 64bit gcc5 machine was testing them fine.

Thanks a lot!

[Andrew Johnson (anj)]

> Is that a compiler or a size dependency? My Debian 64bit gcc5 machine was testing them fine.

Don't know, I was testing on RHEL 6.7 with both 64 and 32-bit builds. Let me boot my Ubuntu VM to see what that does...
No difference; I'm doing manual checks on an IOC with a single calc record loaded.

This is with an unfixed 3.14 IOC, 64-bit:
tux% caget -lx anj:calc.CALC anj:calc
anj:calc.CALC a:=2863311530.0; a >> 8
anj:calc 0xAAAAAA

This is a 3.15 IOC, 64-bit:
tux% caget -lx anj:calc.CALC anj:calc
anj:calc.CALC a:=2863311530.0; a >> 8
anj:calc 0xFFFFFFFFFF800000

Then with this branch, 64-bit:
tux% caget -lx anj:calc.CALC anj:calc
anj:calc.CALC a:=2863311530.0; a >> 8
anj:calc 0xFFFFFFFFFFAAAAAA

The difference between 3.14 and 3.15 is because the bit-wise expressions were changed from long to epicsInt32, which fixed the shift to make them sign-extend properly, but show the broken value conversions. The final result above is correct (the sign extension on the results above are being done by caget -lx on 64-bit). I can get the right result from 3.15 using the negative value instead:
tux% caget -lx anj:calc.CALC anj:calc
anj:calc.CALC a:=-1431655766.1; a >> 8
anj:calc 0xFFFFFFFFFFAAAAAA

I think I got a bit confused when I was working on this last week; the negative value is evidently not (and maybe shouldn't be) necessary with the proper fix, so maybe I didn't need to change those tests. However I have just rewritten the double tests to check that we do convert the arguments properly for every bit-wise operator instead of duplicating the earlier integer tests:

    // converting double values (add 0.1 to force as double)
    // 0xaaaaaaaa = -1431655766 or 2863311530u
    testUInt32Calc("-1431655766.1 OR 0", 0xaaaaaaaau);
    testUInt32Calc("2863311530.1 OR 0", 0xaaaaaaaau);
    testUInt32Calc("0 OR -1431655766.1", 0xaaaaaaaau);
    testUInt32Calc("0 OR 2863311530.1", 0xaaaaaaaau);
    testUInt32Calc("-1431655766.1 XOR 0", 0xaaaaaaaau);
    testUInt32Calc("2863311530.1 XOR 0", 0xaaaaaaaau);
    testUInt32Calc("0 XOR -1431655766.1", 0xaaaaaaaau);
    testUInt32Calc("0 XOR 2863311530.1", 0xaaaaaaaau);
    testUInt32Calc("-1431655766.1 AND 0xffffffff", 0xaaaaaaaau);
    testUInt32Calc("2863311530.1 AND 0xffffffff", 0xaaaaaaaau);
    testUInt32Calc("0xffffffff AND -1431655766.1", 0xaaaaaaaau);
    testUInt32Calc("0xffffffff AND 2863311530.1", 0xaaaaaaaau);
    testUInt32Calc("~ -1431655766.1", 0x55555555u);
    testUInt32Calc("~ 2863311530.1", 0x55555555u);
    testUInt32Calc("-1431655766.1 >> 0", 0xaaaaaaaau);
    testUInt32Calc("2863311530.1 >> 0", 0xaaaaaaaau);
    testUInt32Calc("-1431655766.1 >> 0.1", 0xaaaaaaaau);
    testUInt32Calc("2863311530.1 >> 0.1", 0xaaaaaaaau);
    testUInt32Calc("-1431655766.1 << 0", 0xaaaaaaaau);
    testUInt32Calc("2863311530.1 << 0", 0xaaaaaaaau);
    testUInt32Calc("-1431655766.1 << 0.1", 0xaaaaaaaau);
    testUInt32Calc("2863311530.1 << 0.1", 0xaaaaaaaau);

Hmm, I just copied the resulting epicsCalcTest.cpp file into an unmodified 3.14 branch, where it happily...

review: Needs Information

[Ralph Lange (ralph-lange)]

That's a nice one, eh?! When working on it last week, I got knots in my brain.

First of all, I set a narrow scope: I decided that I wanted to fix the calc engine, not the calc(out) record. To achieve that, I based the main tests on setting fields to double values before doing the operation, as this gets as close as possible to what the calc record does.
The other tests (using literals and setting fields to integers) were added later when I saw different failure patterns between them and the main tests.

On plain 3.14, the operations completely depend on sizeof(long). On 64bit things work fine (as setting bit31 is *not* setting the sign bit), on 32bit things fail.

To get a more reproducible situation, I first backported the change in the calc engine that changes all operations to work on fixed 32bit size types. With that change, I had the tests consistently failing in a pattern that matched Dirk's report.

After applying Dirk's patch, all tests passed. That's the state I pushed to LaunchPad.

I never tested in a real IOC using Dirk's database.
Having a test producing the same failure pattern that Dirk saw using his database, and his fix passing all my tests and (as per Dirk's report) his database testing seemed good enough to me.

[Ralph Lange (ralph-lange)]

Note that your caget based tests add another conversion (CA server converting from the calc record's double VAL field to integer).

Too many chained conversions in one test, for my taste.

[lp:~epics-core/epics-base/fix-calc-bit-manipulation]

12615. By Andrew Johnson on 2016-02-23

Test each bitwise cast individually for overflow

[Andrew Johnson (anj)]

Ok, so I wasn't testing against 3.14 on 32-bit, my bad — the tests do indeed fail there, thanks for pointing that out.

I have committed my changes to the double value tests that I posted yesterday, they are designed to check each cast in the bit-wise operator implementation individually for not overflowing with either +ve or -ve double values that have bit 31 set.

I agree that my caget technique introduced another conversion, I was trying to allow for that in my understanding of what's actually going on. Your testUInt32Calc() routine does the same conversion though:
    uresult = (epicsUInt32) result;
We could avoid that completely by doing the test comparisons inside the expression being tested:
- testUInt32Calc("0xaaaaaaaa AND 0xffff0000", 0xaaaa0000u);
+ testCalc("(0xaaaaaaaa AND 0xffff0000) == 0xaaaa0000", 1);
However the returned result is less useful for diagnosing overflow problems, so I'm happy to keep what we have now.

If you're happy with this I will merge it.

review: Approve

[Ralph Lange (ralph-lange)]

I am happy with it!

review: Approve

=== modified file 'src/libCom/calc/calcPerform.c'
--- src/libCom/calc/calcPerform.c	2010-10-07 19:16:24 +0000
+++ src/libCom/calc/calcPerform.c	2016-02-23 18:42:17 +0000
@@ -21,6 +21,7 @@
 #include "osiUnistd.h"
 #include "dbDefs.h"
 #include "epicsMath.h"
+#include "epicsTypes.h"
 #include "errlog.h"
 #include "postfix.h"
 #include "postfixPvt.h"
@@ -43,7 +44,8 @@
     double stack[CALCPERFORM_STACK+1];	/* zero'th entry not used */
     double *ptop;			/* stack pointer */
     double top; 			/* value from top of stack */
-    int itop;				/* integer from top of stack */
+    epicsInt32 itop;			/* integer from top of stack */
+    epicsUInt32 utop;			/* unsigned integer from top of stack */
     int op;
     int nargs;
 
@@ -55,14 +57,14 @@
 	switch (op){
 
 	case LITERAL_DOUBLE:
-	    memcpy((void *)++ptop, pinst, sizeof(double));
+	    memcpy(++ptop, pinst, sizeof(double));
 	    pinst += sizeof(double);
 	    break;
 
 	case LITERAL_INT:
-	    memcpy(&itop, pinst, sizeof(int));
+	    memcpy(&itop, pinst, sizeof(epicsInt32));
 	    *++ptop = itop;
-	    pinst += sizeof(int);
+	    pinst += sizeof(epicsInt32);
 	    break;
 
 	case FETCH_VAL:
@@ -136,11 +138,11 @@
 	    break;
 
 	case MODULO:
-	    itop = (long) *ptop--;
+	    itop = (epicsInt32) *ptop--;
 	    if (itop)
-		*ptop = (long) *ptop % itop;
+		*ptop = (epicsInt32) *ptop % itop;
 	    else
-		*ptop = epicsNAN;   /* NaN */
+		*ptop = epicsNAN;
 	    break;
 
 	case POWER:
@@ -261,7 +263,7 @@
 
 	case NINT:
 	    top = *ptop;
-	    *ptop = (double)(long)(top >= 0 ? top + 0.5 : top - 0.5);
+	    *ptop = (epicsInt32) (top >= 0 ? top + 0.5 : top - 0.5);
 	    break;
 
 	case RANDOM:
@@ -282,34 +284,45 @@
 	    *ptop = ! *ptop;
 	    break;
 
+        /* For bitwise operations on values with bit 31 set, double values
+         * must first be cast to unsigned to correctly set that bit; the
+         * double value must be negative in that case. The result must be
+         * cast to a signed integer before converting to the double result.
+         */
+
 	case BIT_OR:
-	    itop = (long) *ptop--;
-	    *ptop = (long) *ptop | itop;
+	    utop = *ptop--;
+	    *ptop = (epicsInt32) ((epicsUInt32) *ptop | utop);
 	    break;
 
 	case BIT_AND:
-	    itop = (long) *ptop--;
-	    *ptop = (long) *ptop & itop;
+	    utop = *ptop--;
+	    *ptop = (epicsInt32) ((epicsUInt32) *ptop & utop);
 	    break;
 
 	case BIT_EXCL_OR:
-	    itop = (long) *ptop--;
-	    *ptop = (long) *ptop ^ itop;
+	    utop = *ptop--;
+	    *ptop = (epicsInt32) ((epicsUInt32) *ptop ^ utop);
 	    break;
 
 	case BIT_NOT:
-	    itop = (long) *ptop;
-	    *ptop = ~itop;
+	    utop = *ptop;
+	    *ptop = (epicsInt32) ~utop;
 	    break;
 
+        /* The shift operators use signed integers, so a right-shift will
+         * extend the sign bit into the left-hand end of the value. The
+         * double-casting through unsigned here is important, see above.
+         */
+
 	case RIGHT_SHIFT:
-	    itop = (long) *ptop--;
-	    *ptop = (long) *ptop >> itop;
+	    utop = *ptop--;
+	    *ptop = ((epicsInt32) (epicsUInt32) *ptop) >> (utop & 31);
 	    break;
 
 	case LEFT_SHIFT:
-	    itop = (long) *ptop--;
-	    *ptop = (long) *ptop << itop;
+	    utop = *ptop--;
+	    *ptop = ((epicsInt32) (epicsUInt32) *ptop) << (utop & 31);
 	    break;
 
 	case NOT_EQ:
@@ -381,7 +394,7 @@
 	    pinst += sizeof(double);
 	    break;
 	case LITERAL_INT:
-	    pinst += sizeof(int);
+	    pinst += sizeof(epicsInt32);
 	    break;
 	case MIN:
 	case MAX:
@@ -468,7 +481,7 @@
 	    pinst += sizeof(double);
 	    break;
 	case LITERAL_INT:
-	    pinst += sizeof(int);
+	    pinst += sizeof(epicsInt32);
 	    break;
 	case MIN:
 	case MAX:
 
=== modified file 'src/libCom/calc/postfix.c'
--- src/libCom/calc/postfix.c	2013-11-19 21:26:22 +0000
+++ src/libCom/calc/postfix.c	2016-02-23 18:42:17 +0000
@@ -22,6 +22,7 @@
 #include "dbDefs.h"
 #include "epicsStdlib.h"
 #include "epicsString.h"
+#include "epicsTypes.h"
 #include "postfix.h"
 #include "postfixPvt.h"
 #include "shareLib.h"
@@ -216,7 +217,7 @@
     char * const pdest = pout;
     char *pnext;
     double lit_d;
-    int lit_i;
+    epicsInt32 lit_i;
 
     if (psrc == NULL || *psrc == '\0' ||
 	pout == NULL || perror == NULL) {
@@ -249,27 +250,29 @@
                     goto bad;
                 }
                 psrc = pnext;
-                lit_i = (int) lit_d;
+                lit_i = (epicsInt32) lit_d;
                 if (lit_d != (double) lit_i) {
                     *pout++ = pel->code;
-                    memcpy(pout, (void *)&lit_d, sizeof(double));
+                    memcpy(pout, &lit_d, sizeof(double));
                     pout += sizeof(double);
                 } else {
                     *pout++ = LITERAL_INT;
-                    memcpy(pout, (void *)&lit_i, sizeof(int));
-                    pout += sizeof(int);
+                    memcpy(pout, &lit_i, sizeof(epicsInt32));
+                    pout += sizeof(epicsInt32);
                 }
             }
             else {
-                lit_i = strtoul(psrc, &pnext, 0);
+                epicsUInt32 lit_ui;
+
+                lit_ui = (epicsUInt32) strtoul(psrc, &pnext, 0);
                 if (pnext == psrc) {
                     *perror = CALC_ERR_BAD_LITERAL;
                     goto bad;
                 }
                 psrc = pnext;
                 *pout++ = LITERAL_INT;
-                memcpy(pout, (void *)&lit_i, sizeof(int));
-                pout += sizeof(int);
+                memcpy(pout, &lit_ui, sizeof(epicsUInt32));
+                pout += sizeof(epicsUInt32);
             }
 
             operand_needed = FALSE;
@@ -594,18 +597,18 @@
     };
     char op;
     double lit_d;
-    int lit_i;
+    epicsInt32 lit_i;
     
     while ((op = *pinst) != END_EXPRESSION) {
 	switch (op) {
 	case LITERAL_DOUBLE:
-	    memcpy((void *)&lit_d, ++pinst, sizeof(double));
+	    memcpy(&lit_d, ++pinst, sizeof(double));
 	    printf("\tDouble %g\n", lit_d);
 	    pinst += sizeof(double);
 	    break;
 	case LITERAL_INT:
-	    memcpy((void *)&lit_i, ++pinst, sizeof(int));
-	    printf("\tInteger %d\n", lit_i);
+	    memcpy(&lit_i, ++pinst, sizeof(epicsInt32));
+	    printf("\tInteger %d (0x%x)\n", lit_i, lit_i);
 	    pinst += sizeof(int);
 	    break;
 	case MIN:
 
=== modified file 'src/libCom/test/epicsCalcTest.cpp'
--- src/libCom/test/epicsCalcTest.cpp	2015-02-17 22:21:13 +0000
+++ src/libCom/test/epicsCalcTest.cpp	2016-02-23 18:42:17 +0000
@@ -8,6 +8,7 @@
 //	Author: Andrew Johnson
 
 #include "epicsUnitTest.h"
+#include "epicsTypes.h"
 #include "epicsMath.h"
 #include "epicsAlgorithm.h"
 #include "postfix.h"
@@ -38,32 +39,59 @@
     /* Evaluate expression, test against expected result */
     bool pass = false;
     double args[CALCPERFORM_NARGS] = {
-	1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0
+        1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0
     };
     char rpn[MAX_POSTFIX_SIZE];
     short err;
     double result = 0.0;
     result /= result;  /* Start as NaN */
-    
+
     if (postfix(expr, rpn, &err)) {
-	testDiag("postfix: %s in expression '%s'", calcErrorStr(err), expr);
+        testDiag("postfix: %s in expression '%s'", calcErrorStr(err), expr);
     } else
-	if (calcPerform(args, &result, rpn) && finite(result)) {
-	    testDiag("calcPerform: error evaluating '%s'", expr);
-	}
-    
+        if (calcPerform(args, &result, rpn) && finite(result)) {
+            testDiag("calcPerform: error evaluating '%s'", expr);
+        }
+
     if (finite(expected) && finite(result)) {
-	pass = fabs(expected - result) < 1e-8;
+        pass = fabs(expected - result) < 1e-8;
     } else if (isnan(expected)) {
-	pass = (bool) isnan(result);
+        pass = (bool) isnan(result);
     } else {
-	pass = (result == expected);
-    }
-    if (!testOk(pass, "%s", expr)) {
-	testDiag("Expected result is %g, actually got %g", expected, result);
-	calcExprDump(rpn);
-    }
-    return;
+        pass = (result == expected);
+    }
+    if (!testOk(pass, "%s", expr)) {
+        testDiag("Expected result is %g, actually got %g", expected, result);
+        calcExprDump(rpn);
+    }
+}
+
+void testUInt32Calc(const char *expr, epicsUInt32 expected) {
+    /* Evaluate expression, test against expected result */
+    bool pass = false;
+    double args[CALCPERFORM_NARGS] = {
+        1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0
+    };
+    char rpn[MAX_POSTFIX_SIZE];
+    short err;
+    epicsUInt32 uresult;
+    double result = 0.0;
+    result /= result;  /* Start as NaN */
+
+    if (postfix(expr, rpn, &err)) {
+        testDiag("postfix: %s in expression '%s'", calcErrorStr(err), expr);
+    } else
+        if (calcPerform(args, &result, rpn) && finite(result)) {
+            testDiag("calcPerform: error evaluating '%s'", expr);
+        }
+
+    uresult = (epicsUInt32) result;
+    pass = (uresult == expected);
+    if (!testOk(pass, "%s", expr)) {
+        testDiag("Expected result is 0x%x (%u), actually got 0x%x (%u)",
+                 expected, expected, uresult, uresult);
+        calcExprDump(rpn);
+    }
 }
 
 void testArgs(const char *expr, unsigned long einp, unsigned long eout) {
@@ -238,8 +266,8 @@
     const double a=1.0, b=2.0, c=3.0, d=4.0, e=5.0, f=6.0,
 		 g=7.0, h=8.0, i=9.0, j=10.0, k=11.0, l=12.0;
     
-    testPlan(577);
-    
+    testPlan(613);
+
     /* LITERAL_OPERAND elements */
     testExpr(0);
     testExpr(1);
@@ -883,7 +911,51 @@
     testBadExpr("1?", CALC_ERR_CONDITIONAL);
     testBadExpr("1?1", CALC_ERR_CONDITIONAL);
     testBadExpr(":1", CALC_ERR_SYNTAX);
-    
+
+    // Bit manipulations wrt bit 31 (bug lp:1514520)
+    //   using integer literals
+    testUInt32Calc("0xaaaaaaaa AND 0xffff0000", 0xaaaa0000u);
+    testUInt32Calc("0xaaaaaaaa OR 0xffff0000", 0xffffaaaau);
+    testUInt32Calc("0xaaaaaaaa XOR 0xffff0000", 0x5555aaaau);
+    testUInt32Calc("~0xaaaaaaaa", 0x55555555u);
+    testUInt32Calc("~~0xaaaaaaaa", 0xaaaaaaaau);
+    testUInt32Calc("0xaaaaaaaa >> 8", 0xffaaaaaau);
+    testUInt32Calc("0xaaaaaaaa << 8", 0xaaaaaa00u);
+    //   using integer literals assigned to variables
+    testUInt32Calc("a:=0xaaaaaaaa; b:=0xffff0000; a AND b", 0xaaaa0000u);
+    testUInt32Calc("a:=0xaaaaaaaa; b:=0xffff0000; a OR b", 0xffffaaaau);
+    testUInt32Calc("a:=0xaaaaaaaa; b:=0xffff0000; a XOR b", 0x5555aaaau);
+    testUInt32Calc("a:=0xaaaaaaaa; ~a", 0x55555555u);
+    testUInt32Calc("a:=0xaaaaaaaa; ~~a", 0xaaaaaaaau);
+    testUInt32Calc("a:=0xaaaaaaaa; a >> 8", 0xffaaaaaau);
+    testUInt32Calc("a:=0xaaaaaaaa; a << 8", 0xaaaaaa00u);
+
+    // Test proper conversion of double values (+ 0.1 enforces double literal)
+    // when used as inputs to the bitwise operations.
+    //      0xaaaaaaaa = -1431655766 or 2863311530u
+    testUInt32Calc("-1431655766.1 OR 0", 0xaaaaaaaau);
+    testUInt32Calc("2863311530.1 OR 0", 0xaaaaaaaau);
+    testUInt32Calc("0 OR -1431655766.1", 0xaaaaaaaau);
+    testUInt32Calc("0 OR 2863311530.1", 0xaaaaaaaau);
+    testUInt32Calc("-1431655766.1 XOR 0", 0xaaaaaaaau);
+    testUInt32Calc("2863311530.1 XOR 0", 0xaaaaaaaau);
+    testUInt32Calc("0 XOR -1431655766.1", 0xaaaaaaaau);
+    testUInt32Calc("0 XOR 2863311530.1", 0xaaaaaaaau);
+    testUInt32Calc("-1431655766.1 AND 0xffffffff", 0xaaaaaaaau);
+    testUInt32Calc("2863311530.1 AND 0xffffffff", 0xaaaaaaaau);
+    testUInt32Calc("0xffffffff AND -1431655766.1", 0xaaaaaaaau);
+    testUInt32Calc("0xffffffff AND 2863311530.1", 0xaaaaaaaau);
+    testUInt32Calc("~ -1431655766.1", 0x55555555u);
+    testUInt32Calc("~ 2863311530.1", 0x55555555u);
+    testUInt32Calc("-1431655766.1 >> 0", 0xaaaaaaaau);
+    testUInt32Calc("2863311530.1 >> 0", 0xaaaaaaaau);
+    testUInt32Calc("-1431655766.1 >> 0.1", 0xaaaaaaaau);
+    testUInt32Calc("2863311530.1 >> 0.1", 0xaaaaaaaau);
+    testUInt32Calc("-1431655766.1 << 0", 0xaaaaaaaau);
+    testUInt32Calc("2863311530.1 << 0", 0xaaaaaaaau);
+    testUInt32Calc("-1431655766.1 << 0.1", 0xaaaaaaaau);
+    testUInt32Calc("2863311530.1 << 0.1", 0xaaaaaaaau);
+
     return testDone();
 }