[clang][Interp] Fix left-/right-shifting more than sizeof(unsigned)

[tbaeder]

Summary

We were just casting to `unsigned` before, so that caused problems when
shifting more bits than `unsigned` has.

[shafik]

clang/test/AST/Interp/shifts.cpp

149

Can we add a test for left shift as well.

clang/lib/AST/Interp/Integral.h

static bool neg(Integral A, Integral *R) {
     return false;
   }
 
   static bool comp(Integral A, Integral *R) {
     *R = Integral(~A.V);
     return false;
   }
 
+  template <unsigned RHSBits, bool RHSSign>
+  static void shiftLeft(const Integral A, const Integral<RHSBits, RHSSign> B,
+                        unsigned OpBits, Integral *R) {
+    *R = Integral::from(A.V << B.V, OpBits);
+  }
+
+  template <unsigned RHSBits, bool RHSSign>
+  static void shiftRight(const Integral A, const Integral<RHSBits, RHSSign> B,
+                         unsigned OpBits, Integral *R) {
+    *R = Integral::from(A.V >> B.V, OpBits);
+  }
+
 private:
   template <typename T> static bool CheckAddUB(T A, T B, T &R) {
     if constexpr (std::is_signed_v<T>) {
       return llvm::AddOverflow<T>(A, B, R);
     } else {
       R = A + B;
       return false;
     }

clang/lib/AST/Interp/Interp.h

inline bool Shr(InterpState &S, CodePtr OpPC) {
   using RT = typename PrimConv<NameR>::T;
   const auto &RHS = S.Stk.pop<RT>();
   const auto &LHS = S.Stk.pop<LT>();
   const unsigned Bits = LHS.bitWidth();
 
   if (!CheckShift<RT>(S, OpPC, RHS, Bits))
     return false;
 
-  unsigned URHS = static_cast<unsigned>(RHS);
-  S.Stk.push<LT>(LT::from(static_cast<unsigned>(LHS) >> URHS, LHS.bitWidth()));
+  Integral<LT::bitWidth(), false> R;
+  Integral<LT::bitWidth(), false>::shiftRight(LHS.toUnsigned(), RHS, Bits, &R);
+  S.Stk.push<LT>(R);
   return true;
 }
 
 template <PrimType NameL, PrimType NameR>
 inline bool Shl(InterpState &S, CodePtr OpPC) {
   using LT = typename PrimConv<NameL>::T;
   using RT = typename PrimConv<NameR>::T;
   const auto &RHS = S.Stk.pop<RT>();
   const auto &LHS = S.Stk.pop<LT>();
   const unsigned Bits = LHS.bitWidth();
 
   if (!CheckShift<RT>(S, OpPC, RHS, Bits))
     return false;
 
-  unsigned URHS = static_cast<unsigned>(RHS);
-  S.Stk.push<LT>(LT::from(static_cast<unsigned>(LHS) << URHS, LHS.bitWidth()));
-
+  Integral<LT::bitWidth(), false> R;
+  Integral<LT::bitWidth(), false>::shiftLeft(LHS.toUnsigned(), RHS, Bits, &R);
+  S.Stk.push<LT>(R);
   return true;
 }
 
 //===----------------------------------------------------------------------===//
 // NoRet
 //===----------------------------------------------------------------------===//
 
 inline bool NoRet(InterpState &S, CodePtr OpPC) {

clang/test/AST/Interp/shifts.cpp

constexpr int i2 = 1 << (__INT_WIDTH__ + 1); // expected-error {{must be initialized by a constant expression}} \
                                                // cxx17-note {{>= width of type}} \
                                                // ref-error {{must be initialized by a constant expression}} \
                                                // ref-note {{>= width of type}} \
                                                // ref-cxx17-error {{must be initialized by a constant expression}} \
                                                // ref-cxx17-note {{>= width of type}}
 
   constexpr char c2 = 1;
   constexpr int i3 = c2 << (__CHAR_BIT__ + 1); // Not ill-formed
+
+  constexpr signed long int L = 1;
+  constexpr signed int R = 62;
+  constexpr decltype(L) M = L << R;
+  constexpr decltype(L) M2 = L >> R;
 };