False warning C4389 with Microsoft compiler

Question

 UINT uLong = 0;
 WORD byVal = 1;
 WORD byVal1 = 3;
 if (uLong != (byVal * byVal1))
  printf("Correct");
 else
  printf("Incorrect");
Above code gives me "warning C4389: '!=' : signed/unsigned mismatch"
As all the variables involved in expression are unsigned how can it result in this warning. BTW this happens only on Microsoft compiler and not on GCC.
Is it a bug in Microsoft compiler, if not can anyone let me know how to fix this in my code?
I am using Microsoft Visual Studio Premium Version 12.0.21005.1 REL.
Thanks & Regards,
Amit Kulkarni.

Answer 1

"But reading it carefully it looks like a guideline and not the rule. It says  "can be"
so it's not compulsory."
Yes, integral promotions aren't compulsory. But in this particular case they are, see the standard quotes provided by Igor Tandetnik.
And it seems that you have missed the "otherwise" part:
"can be converted to a prvalue of type int if int can represent all the values of the source type; otherwise, the source prvalue can be converted to a prvalue of type unsigned int"
Given that all "unsigned short" values can be represented by "int" there's no way this text would allow conversion to "unsigned int".
"Why compiler need to convert it to a signed value when originally it is unsigned?"
Why wouldn't it do that? How is promoting to "unsigned int" better than promoting to "signed int"?
The C89 Rationale document mentions this debate and gives a (not very detailed) reason for this choice:
"The unsigned preserving rules greatly increase the number of situations where unsigned int confronts signed int to yield a questionably signed result, whereas the value preserving rules minimize such confrontations.   Thus, the value preserving
rules were considered to be safer for the novice, or unwary, programmer.   After much discussion, the Committee decided in favor of value preserving rules, despite the fact that the UNIX C compilers had evolved in the direction of unsigned preserving."
In short, "signed int" was deemed to be more common than "unsigned int".
Interesting facts about other languages:
C# follows the same rule but avoids the signed/unsigned comparison issue by promoting both operands to long. And if you try to compare long with ulong it gives up and rejects the code.
Java doesn't have this issue to begin with, it doesn't have unsigned integral types.