[builtins][NFC] Replace the constants better matching readability in udivmodti4

[danlark]

Correctness

compiler-rt/lib/builtins/udivmodti4.c

 // Taken and adjusted from libdivide libdivide_128_div_64_to_64 division
 // fallback. For a correctness proof see the reference for this algorithm
 // in Knuth, Volume 2, section 4.3.1, Algorithm D.
 UNUSED
 static inline du_int udiv128by64to64default(du_int u1, du_int u0, du_int v,
                                             du_int *r) {
   const unsigned n_udword_bits = sizeof(du_int) * CHAR_BIT;
   const du_int b = (1ULL << (n_udword_bits / 2)); // Number base (32 bits)
+  const du_int mask =
+      (~0ULL >> (n_udword_bits / 2));             // Lower bits mask (32 bits)
   du_int un1, un0;                                // Norm. dividend LSD's
   du_int vn1, vn0;                                // Norm. divisor digits
   du_int q1, q0;                                  // Quotient digits
   du_int un64, un21, un10;                        // Dividend digit pairs
   du_int rhat;                                    // A remainder
   si_int s;                                       // Shift amount for normalization
 
   s = __builtin_clzll(v);
   if (s > 0) {
     // Normalize the divisor.
     v = v << s;
     un64 = (u1 << s) | (u0 >> (n_udword_bits - s));
     un10 = u0 << s; // Shift dividend left
   } else {
     // Avoid undefined behavior of (u0 >> 64).
     un64 = u1;
     un10 = u0;
   }
 
   // Break divisor up into two 32-bit digits.
   vn1 = v >> (n_udword_bits / 2);
-  vn0 = v & 0xFFFFFFFF;
+  vn0 = v & mask;
 
   // Break right half of dividend into two digits.
   un1 = un10 >> (n_udword_bits / 2);
-  un0 = un10 & 0xFFFFFFFF;
+  un0 = un10 & mask;
 
   // Compute the first quotient digit, q1.
   q1 = un64 / vn1;
   rhat = un64 - q1 * vn1;
 
   // q1 has at most error 2. No more than 2 iterations.
   while (q1 >= b || q1 * vn0 > b * rhat + un1) {
     q1 = q1 - 1;