[APInt] Simplify the zext and sext methods

[craig.topper]

Summary

This replaces a hand written copy loop with a call to memcpy for both zext and sext.

For sext, it replaces multiple if/else blocks propagating sign information forward. Now we just do a copy, a sign extension on the last copied word, a memset, and clearUnusedBits.

[RKSimon]

APInt.cpp is very inconsistent with where it uses std::mem* and where it doesn't bother with std:: - is your plan to move over entirely to std::mem* ?

[craig.topper]

@RKSimon I hadn't given it much thought but I can do an NFC commit to change everything to std:: if you want.

[RKSimon]

In D32417#735426, @craig.topper wrote:

@RKSimon I hadn't given it much thought but I can do an NFC commit to change everything to std:: if you want.

Its more to do with (a) the file is already inconsistent and (b) you're changing some but not all

[craig.topper]

What is the project prefered way of writing memcpy/memset/memmove? A quick grep shows that they are far more often used without std::

[hans]

In D32417#735496, @craig.topper wrote:

What is the project prefered way of writing memcpy/memset/memmove? A quick grep shows that they are far more often used without std::

I don't think the project has a prefered way. I see both plain "memcpy", "std::memcpy" and "::memcpy".

I like the "std::" variant and think it's the most correct one, but I also don't think this matters much.

lgtm

lib/Support/APInt.cpp

955

nit: spaces around -

lib/Support/APInt.cpp

APInt APInt::trunc(unsigned width) const {
   unsigned bits = (0 - width) % APINT_BITS_PER_WORD;
   if (bits != 0)
     Result.pVal[i] = pVal[i] << bits >> bits;
 
   return Result;
 }
 
 // Sign extend to a new width.
-APInt APInt::sext(unsigned width) const {
-  assert(width > BitWidth && "Invalid APInt SignExtend request");
+APInt APInt::sext(unsigned Width) const {
+  assert(Width > BitWidth && "Invalid APInt SignExtend request");
 
-  if (width <= APINT_BITS_PER_WORD)
-    return APInt(width, SignExtend64(VAL, BitWidth));
-
-  APInt Result(getMemory(getNumWords(width)), width);
+  if (Width <= APINT_BITS_PER_WORD)
+    return APInt(Width, SignExtend64(VAL, BitWidth));
 
-  // Copy full words.
-  unsigned i;
-  uint64_t word = 0;
-  for (i = 0; i != BitWidth / APINT_BITS_PER_WORD; i++) {
-    word = getRawData()[i];
-    Result.pVal[i] = word;
-  }
+  APInt Result(getMemory(getNumWords(Width)), Width);
 
-  // Read and sign-extend any partial word.
-  unsigned bits = (0 - BitWidth) % APINT_BITS_PER_WORD;
-  if (bits != 0)
-    word = (int64_t)getRawData()[i] << bits >> bits;
-  else
-    word = (int64_t)word >> (APINT_BITS_PER_WORD - 1);
-
-  // Write remaining full words.
-  for (; i != width / APINT_BITS_PER_WORD; i++) {
-    Result.pVal[i] = word;
-    word = (int64_t)word >> (APINT_BITS_PER_WORD - 1);
-  }
-
-  // Write any partial word.
-  bits = (0 - width) % APINT_BITS_PER_WORD;
-  if (bits != 0)
-    Result.pVal[i] = word << bits >> bits;
+  // Copy words.
+  std::memcpy(Result.pVal, getRawData(), getNumWords() * APINT_WORD_SIZE);
 
+  // Sign extend the last word since there may be unused bits in the input.
+  Result.pVal[getNumWords() - 1] = SignExtend64(Result.pVal[getNumWords() - 1],
+                                      ((BitWidth-1) % APINT_BITS_PER_WORD) + 1);
+
+  // Fill with sign bits.
+  std::memset(Result.pVal + getNumWords(), isNegative() ? -1 : 0,
+              (Result.getNumWords() - getNumWords()) * APINT_WORD_SIZE);
+  Result.clearUnusedBits();
   return Result;
 }
 
 //  Zero extend to a new width.
 APInt APInt::zext(unsigned width) const {
   assert(width > BitWidth && "Invalid APInt ZeroExtend request");
 
   if (width <= APINT_BITS_PER_WORD)
     return APInt(width, VAL);
 
   APInt Result(getMemory(getNumWords(width)), width);
 
   // Copy words.
-  unsigned i;
-  for (i = 0; i != getNumWords(); i++)
-    Result.pVal[i] = getRawData()[i];
+  std::memcpy(Result.pVal, getRawData(), getNumWords() * APINT_WORD_SIZE);
 
   // Zero remaining words.
-  memset(&Result.pVal[i], 0, (Result.getNumWords() - i) * APINT_WORD_SIZE);
+  std::memset(Result.pVal + getNumWords(), 0,
+              (Result.getNumWords() - getNumWords()) * APINT_WORD_SIZE);
 
   return Result;
 }
 
 APInt APInt::zextOrTrunc(unsigned width) const {
   if (BitWidth < width)
     return zext(width);
   if (BitWidth > width)