Make tblgen a little smarter about constants smaller than i32. Currently,

tblgen will complain if a sign-extended constant does not fit into a
data type smaller than i32, e.g., i16. This causes a problem when certain
hex constants are used, such as 0xff for byte masks or immediate xor
values.

tblgen will try the sign-extended value first and, if the sign extended
value would overflow, it tries to see if the unsigned value will fit.
Consequently, a software developer can now safely incant:

	(XORHIr16 R16C:$rA, 0xffff)

which is somewhat clearer and more informative than incanting:

	(XORHIr16 R16C:$rA, (i16 -1))

even if the two are bitwise equivalent.

Tblgen also outputs the 64-bit unsigned constant in the generated ISel code
when getTargetConstant() is invoked.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@47188 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/ADT/StringExtras.h b/include/llvm/ADT/StringExtras.h
index 2a01c5f2d34e4f4c1ebad931dbb0ec0e723d78a1..e4c941007d82d0f2b843b116228191d169bc6513 100644 (file)
--- a/include/llvm/ADT/StringExtras.h
+++ b/include/llvm/ADT/StringExtras.h
@@ -85,6 +85,10 @@ static inline std::string itostr(int64_t X) {
     return utostr(static_cast<uint64_t>(X));
 }
 
+static inline std::string itohexstr(int64_t X) {
+  return utohexstr(static_cast<uint64_t>(X));
+}
+
 static inline std::string ftostr(double V) {
   char Buffer[200];
   sprintf(Buffer, "%20.6e", V);

diff --git a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
index 1f013aa6796e11e89824c3f0700c10cdff8075b1..b50591873d85eb539e4ffaf16fe993e09d7bea37 100644 (file)
--- a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
+++ b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
@@ -3852,6 +3852,13 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) {
     case Expand: assert(0 && "Shouldn't need to expand other operators here!");
     case Legal:
       Tmp1 = LegalizeOp(Node->getOperand(0));
+      if (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0)) ==
+          TargetLowering::Custom) {
+        Tmp2 = TLI.LowerOperation(Result, DAG);
+        if (Tmp2.Val) {
+          Tmp1 = Tmp2;
+        }
+      }
       Result = DAG.UpdateNodeOperands(Result, Tmp1);
       break;
     case Promote:

diff --git a/utils/TableGen/CodeGenDAGPatterns.cpp b/utils/TableGen/CodeGenDAGPatterns.cpp
index 146488e507baaff058a8ef8f01e21e94d22c52c4..ddfaaac5782853047a18bbb6a42ae0ee4f2d769e 100644 (file)
--- a/utils/TableGen/CodeGenDAGPatterns.cpp
+++ b/utils/TableGen/CodeGenDAGPatterns.cpp
@@ -702,10 +702,17 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
           // Make sure that the value is representable for this type.
           if (Size < 32) {
             int Val = (II->getValue() << (32-Size)) >> (32-Size);
-            if (Val != II->getValue())
-              TP.error("Sign-extended integer value '" + itostr(II->getValue())+
-                       "' is out of range for type '" + 
-                       getEnumName(getTypeNum(0)) + "'!");
+            if (Val != II->getValue()) {
+             // If sign-extended doesn't fit, does it fit as unsigned?
+             unsigned ValueMask = unsigned(MVT::getIntVTBitMask(VT));
+             unsigned UnsignedVal = unsigned(II->getValue());
+
+             if ((ValueMask & UnsignedVal) != UnsignedVal) {
+               TP.error("Integer value '" + itostr(II->getValue())+
+                        "' is out of range for type '" + 
+                        getEnumName(getTypeNum(0)) + "'!");
+             }
+           }
           }
         }
       }

diff --git a/utils/TableGen/DAGISelEmitter.cpp b/utils/TableGen/DAGISelEmitter.cpp
index 472edbccbe0fd6149a7cdd03cf889b49adad176a..bdf6b64205df6a7dde540e80fc026a2b82c839ef 100644 (file)
--- a/utils/TableGen/DAGISelEmitter.cpp
+++ b/utils/TableGen/DAGISelEmitter.cpp
@@ -730,8 +730,11 @@ public:
       const std::string &VarName = N->getName();
       std::string Val = VariableMap[VarName];
       bool ModifiedVal = false;
-      assert(!Val.empty() &&
-             "Variable referenced but not defined and not caught earlier!");
+      if (Val.empty()) {
+       cerr << "Variable '" << VarName << " referenced but not defined "
+            << "and not caught earlier!\n";
+       abort();
+      }
       if (Val[0] == 'T' && Val[1] == 'm' && Val[2] == 'p') {
         // Already selected this operand, just return the tmpval.
         NodeOps.push_back(Val);
@@ -858,8 +861,8 @@ public:
         unsigned ResNo = TmpNo++;
         assert(N->getExtTypes().size() == 1 && "Multiple types not handled!");
         emitCode("SDOperand Tmp" + utostr(ResNo) + 
-                 " = CurDAG->getTargetConstant(" + itostr(II->getValue()) +
-                 ", " + getEnumName(N->getTypeNum(0)) + ");");
+                 " = CurDAG->getTargetConstant(0x" + itohexstr(II->getValue()) +
+                 "ULL, " + getEnumName(N->getTypeNum(0)) + ");");
         NodeOps.push_back("Tmp" + utostr(ResNo));
         return NodeOps;
       }