[ADT] Add signed and unsigned mulh to APInt #84719

Atousa · 2024-03-11T05:01:31Z

llvmbot · 2024-03-11T05:02:06Z

@llvm/pr-subscribers-mlir
@llvm/pr-subscribers-mlir-arith
@llvm/pr-subscribers-mlir-spirv
@llvm/pr-subscribers-llvm-selectiondag
@llvm/pr-subscribers-llvm-support

@llvm/pr-subscribers-llvm-adt

Author: Atousa Duprat (Atousa)

Changes

This addresses issue #84207

Full diff: https://github.com/llvm/llvm-project/pull/84719.diff

4 Files Affected:

(modified) llvm/include/llvm/ADT/APInt.h (+12)
(modified) llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp (+5-13)
(modified) llvm/lib/Support/APInt.cpp (+28)
(modified) llvm/unittests/ADT/APIntTest.cpp (+84)

diff --git a/llvm/include/llvm/ADT/APInt.h b/llvm/include/llvm/ADT/APInt.h
index 1fc3c7b2236a17..e3ce01af20e7c6 100644
--- a/llvm/include/llvm/ADT/APInt.h
+++ b/llvm/include/llvm/ADT/APInt.h
@@ -2193,6 +2193,18 @@ inline const APInt absdiff(const APInt &A, const APInt &B) {
   return A.uge(B) ? (A - B) : (B - A);
 }
 
+/// Return the high bits of the signed multiplication of C1 and C2
+APInt mulHiS(const APInt &C1, const APInt &C2);
+
+/// Return the high bits of the unsigned multiplication of C1 and C2
+APInt mulHiU(const APInt &C1, const APInt &C2);
+
+/// Return the low bits of the signed multiplication of C1 and C2
+APInt mulLoS(const APInt &C1, const APInt &C2);
+
+/// Return the low bits of the unsigned multiplication of C1 and C2
+APInt mulLoU(const APInt &C1, const APInt &C2);
+
 /// Compute GCD of two unsigned APInt values.
 ///
 /// This function returns the greatest common divisor of the two APInt values
diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
index f7ace79e8c51d4..53697e1ffb5b71 100644
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
@@ -6009,18 +6009,10 @@ static std::optional<APInt> FoldValue(unsigned Opcode, const APInt &C1,
     if (!C2.getBoolValue())
       break;
     return C1.srem(C2);
-  case ISD::MULHS: {
-    unsigned FullWidth = C1.getBitWidth() * 2;
-    APInt C1Ext = C1.sext(FullWidth);
-    APInt C2Ext = C2.sext(FullWidth);
-    return (C1Ext * C2Ext).extractBits(C1.getBitWidth(), C1.getBitWidth());
-  }
-  case ISD::MULHU: {
-    unsigned FullWidth = C1.getBitWidth() * 2;
-    APInt C1Ext = C1.zext(FullWidth);
-    APInt C2Ext = C2.zext(FullWidth);
-    return (C1Ext * C2Ext).extractBits(C1.getBitWidth(), C1.getBitWidth());
-  }
+  case ISD::MULHS:
+    return APIntOps::mulHiS(C1, C2);
+  case ISD::MULHU:
+    return APIntOps::mulHiU(C1, C2);
   case ISD::AVGFLOORS: {
     unsigned FullWidth = C1.getBitWidth() + 1;
     APInt C1Ext = C1.sext(FullWidth);
@@ -6706,8 +6698,8 @@ SDValue SelectionDAG::getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
     break;
   case ISD::UDIV:
   case ISD::UREM:
-  case ISD::MULHU:
   case ISD::MULHS:
+  case ISD::MULHU:
   case ISD::SDIV:
   case ISD::SREM:
   case ISD::SADDSAT:
diff --git a/llvm/lib/Support/APInt.cpp b/llvm/lib/Support/APInt.cpp
index e686b976523302..46c469cafa88cc 100644
--- a/llvm/lib/Support/APInt.cpp
+++ b/llvm/lib/Support/APInt.cpp
@@ -3094,3 +3094,31 @@ void llvm::LoadIntFromMemory(APInt &IntVal, const uint8_t *Src,
     memcpy(Dst + sizeof(uint64_t) - LoadBytes, Src, LoadBytes);
   }
 }
+
+APInt APIntOps::mulHiS(const APInt &C1, const APInt &C2) {
+  unsigned FullWidth = C1.getBitWidth() * 2;
+  APInt C1Ext = C1.sext(FullWidth);
+  APInt C2Ext = C2.sext(FullWidth);
+  return (C1Ext * C2Ext).extractBits(C1.getBitWidth(), C1.getBitWidth());
+}
+
+APInt APIntOps::mulHiU(const APInt &C1, const APInt &C2) {
+  unsigned FullWidth = C1.getBitWidth() * 2;
+  APInt C1Ext = C1.zext(FullWidth);
+  APInt C2Ext = C2.zext(FullWidth);
+  return (C1Ext * C2Ext).extractBits(C1.getBitWidth(), C1.getBitWidth());
+}
+
+APInt APIntOps::mulLoS(const APInt &C1, const APInt &C2) {
+  unsigned FullWidth = C1.getBitWidth() * 2;
+  APInt C1Ext = C1.sext(FullWidth);
+  APInt C2Ext = C2.sext(FullWidth);
+  return (C1Ext * C2Ext).trunc(C1.getBitWidth());
+}
+
+APInt APIntOps::mulLoU(const APInt &C1, const APInt &C2) {
+  unsigned FullWidth = C1.getBitWidth() * 2;
+  APInt C1Ext = C1.zext(FullWidth);
+  APInt C2Ext = C2.zext(FullWidth);
+  return (C1Ext * C2Ext).trunc(C1.getBitWidth());
+}
diff --git a/llvm/unittests/ADT/APIntTest.cpp b/llvm/unittests/ADT/APIntTest.cpp
index 24324822356bf6..1597ac6f331d47 100644
--- a/llvm/unittests/ADT/APIntTest.cpp
+++ b/llvm/unittests/ADT/APIntTest.cpp
@@ -10,6 +10,7 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Alignment.h"
 #include "gtest/gtest.h"
@@ -2805,6 +2806,89 @@ TEST(APIntTest, multiply) {
   EXPECT_EQ(64U, i96.countr_zero());
 }
 
+TEST(APIntOpsTest, MulHiLo) {
+
+  // Unsigned
+
+  // 32 bits
+  APInt i32a(32, 0x0001'E235);
+  APInt i32b(32, 0xF623'55AD);
+  EXPECT_EQ(0x0001'CFA1, APIntOps::mulHiU(i32a, i32b));
+  EXPECT_EQ(0x7CA0'76D1, APIntOps::mulLoU(i32a, i32b));
+
+  // 64 bits
+  APInt i64a(64, 0x1234'5678'90AB'CDEF);
+  APInt i64b(64, 0xFEDC'BA09'8765'4321);
+  EXPECT_EQ(0x121F'A000'A372'3A57, APIntOps::mulHiU(i64a, i64b));
+  EXPECT_EQ(0xC24A'442F'E556'18CF, APIntOps::mulLoU(i64a, i64b));
+
+  // 128 bits
+  APInt i128a(128, "1234567890ABCDEF1234567890ABCDEF", 16);
+  APInt i128b(128, "FEDCBA0987654321FEDCBA0987654321", 16);
+  APInt i128ResHi = APIntOps::mulHiU(i128a, i128b);
+  std::string strResHi = toString(i128ResHi, 16, false, true, true, true);
+  EXPECT_STREQ("0x121F'A000'A372'3A57'E689'8431'2C3A'8D7E", strResHi.c_str());
+  APInt i128ResLo = APIntOps::mulLoU(i128a, i128b);
+  std::string strResLo = toString(i128ResLo, 16, false, true, true, true);
+  EXPECT_STREQ("0x96B4'2860'6E1E'6BF5'C24A'442F'E556'18CF", strResLo.c_str());
+
+  // Signed
+
+  // 32 bits
+  APInt i32c(32, 0x1234'5678); // +ve
+  APInt i32d(32, 0x10AB'CDEF); // +ve
+  APInt i32e(32, 0xFEDC'BA09); // -ve
+
+  EXPECT_EQ(0x012F'7D02, APIntOps::mulHiS(i32c, i32d));
+  EXPECT_EQ(0x2A42'D208, APIntOps::mulLoS(i32c, i32d));
+
+  EXPECT_EQ(0xFFEB'4988, APIntOps::mulHiS(i32c, i32e));
+  EXPECT_EQ(0x09CA'3A38, APIntOps::mulLoS(i32c, i32e));
+
+  EXPECT_EQ(0x0001'4B68, APIntOps::mulHiS(i32e, i32e));
+  EXPECT_EQ(0x22A9'1451, APIntOps::mulLoS(i32e, i32e));
+
+  // 64 bits
+  APInt i64c(64, 0x1234'5678'90AB'CDEF); // +ve
+  APInt i64d(64, 0x1234'5678'90FE'DCBA); // +ve
+  APInt i64e(64, 0xFEDC'BA09'8765'4321); // -ve
+
+  EXPECT_EQ(0x014B'66DC'328E'10C1, APIntOps::mulHiS(i64c, i64d));
+  EXPECT_EQ(0xFB99'7041'84EF'03A6, APIntOps::mulLoS(i64c, i64d));
+
+  EXPECT_EQ(0xFFEB'4988'12C6'6C68, APIntOps::mulHiS(i64c, i64e));
+  EXPECT_EQ(0xC24A'442F'E556'18CF, APIntOps::mulLoS(i64c, i64e));
+
+  EXPECT_EQ(0x0001'4B68'2174'FA18, APIntOps::mulHiS(i64e, i64e));
+  EXPECT_EQ(0xCEFE'A12C'D7A4'4A41, APIntOps::mulLoS(i64e, i64e));
+
+  // 128 bits
+  APInt i128c(128, "1234567890ABCDEF1234567890ABCDEF", 16); // +ve
+  APInt i128d(128, "1234567890FEDCBA1234567890FEDCBA", 16); // +ve
+  APInt i128e(128, "FEDCBA0987654321FEDCBA0987654321", 16); // -ve
+
+  i128ResHi = APIntOps::mulHiS(i128c, i128d);
+  strResHi = toString(i128ResHi, 16, false, true, true, true);
+  EXPECT_STREQ("0x14B'66DC'328E'10C1'FE30'3DF9'EA0B'2529", strResHi.c_str());
+  i128ResLo = APIntOps::mulLoS(i128c, i128d);
+  strResLo = toString(i128ResLo, 16, false, true, true, true);
+  EXPECT_STREQ("0xF87E'475F'3C6C'180D'FB99'7041'84EF'03A6", strResLo.c_str());
+
+  i128ResHi = APIntOps::mulHiS(i128c, i128e);
+  strResHi = toString(i128ResHi, 16, false, true, true, true);
+  EXPECT_STREQ("0xFFEB'4988'12C6'6C68'D455'2DB8'9B8E'BF8F", strResHi.c_str());
+  i128ResLo = APIntOps::mulLoS(i128c, i128e);
+  strResLo = toString(i128ResLo, 16, false, true, true, true);
+  EXPECT_STREQ("0x96B4'2860'6E1E'6BF5'C24A'442F'E556'18CF", strResLo.c_str());
+
+  i128ResHi = APIntOps::mulHiS(i128e, i128e);
+  strResHi = toString(i128ResHi, 16, false, true, true, true);
+  EXPECT_STREQ("0x1'4B68'2174'FA18'CCBA'AC10'2958'C4B5", strResHi.c_str());
+  i128ResLo = APIntOps::mulLoS(i128e, i128e);
+  strResLo = toString(i128ResLo, 16, false, true, true, true);
+  EXPECT_STREQ("0x9BB8'01D4'DF88'14DC'CEFE'A12C'D7A4'4A41", strResLo.c_str());
+}
+
 TEST(APIntTest, RoundingUDiv) {
   for (uint64_t Ai = 1; Ai <= 255; Ai++) {
     APInt A(8, Ai);

topperc · 2024-03-11T05:41:58Z

llvm/lib/Support/APInt.cpp

+  return (C1Ext * C2Ext).extractBits(C1.getBitWidth(), C1.getBitWidth());
+}
+
+APInt APIntOps::mulLoS(const APInt &C1, const APInt &C2) {


Isn't this equivalent to mul? The lower bits of the result don't care about the extension at all.

arsenm · 2024-03-11T05:43:16Z

llvm/unittests/ADT/APIntTest.cpp

+  APInt i128b(128, "FEDCBA0987654321FEDCBA0987654321", 16);
+  APInt i128ResHi = APIntOps::mulHiU(i128a, i128b);
+  std::string strResHi = toString(i128ResHi, 16, false, true, true, true);
+  EXPECT_STREQ("0x121F'A000'A372'3A57'E689'8431'2C3A'8D7E", strResHi.c_str());


Why not regular EXPECT_EQ and avoid the .c_str?

topperc · 2024-03-11T05:47:44Z

llvm/unittests/ADT/APIntTest.cpp

+  APInt i128b(128, "FEDCBA0987654321FEDCBA0987654321", 16);
+  APInt i128ResHi = APIntOps::mulHiU(i128a, i128b);
+  std::string strResHi = toString(i128ResHi, 16, false, true, true, true);
+  EXPECT_STREQ("0x121F'A000'A372'3A57'E689'8431'2C3A'8D7E", strResHi.c_str());


Why are we comparing strings? Why not create a 128-bit APInt for the expected result and compare that?

jayfoad

Please remove the "lo" functions as they are identical to operator*. For the "hi" functions I'd prefer the names mulhu and mulhs, since these names are already used elsewhere in LLVM (in KnownBits and in SelectionDAG).

RKSimon

Please can you update the KnownBitsTest mulhu/mulhs exhaustive tests to use these for the APInt references

RKSimon · 2024-03-11T10:44:52Z

llvm/include/llvm/ADT/APInt.h

+APInt mulHiS(const APInt &C1, const APInt &C2);
+
+/// Return the high bits of the unsigned multiplication of C1 and C2
+APInt mulHiU(const APInt &C1, const APInt &C2);


use the mulhs/mulhu names - as thats the names we already use elsewhere (KnownBIts, ISD etc.)

RKSimon · 2024-03-11T10:45:18Z

llvm/include/llvm/ADT/APInt.h

+APInt mulLoS(const APInt &C1, const APInt &C2);
+
+/// Return the low bits of the unsigned multiplication of C1 and C2
+APInt mulLoU(const APInt &C1, const APInt &C2);


These are just mul - which we already have - remove them

RKSimon · 2024-03-11T10:46:18Z

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

  case ISD::MULHS:
+  case ISD::MULHU:


Superfluous - remove it

jayfoad · 2024-03-12T08:23:35Z

llvm/include/llvm/ADT/APInt.h

@@ -2193,6 +2193,12 @@ inline const APInt absdiff(const APInt &A, const APInt &B) {
  return A.uge(B) ? (A - B) : (B - A);
 }

+/// Return the high bits of the signed multiplication of C1 and C2


Uber-nit: comments should be full sentences, per coding standards.

Suggested change

/// Return the high bits of the signed multiplication of C1 and C2

/// Return the high bits of the signed multiplication of C1 and C2.

jayfoad · 2024-03-12T08:25:34Z

llvm/unittests/ADT/APIntTest.cpp

@@ -10,6 +10,7 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringExtras.h"


Is this still needed?

jayfoad

Thanks - LGTM overall, just a couple of nits inline.

RKSimon · 2024-03-12T09:09:13Z

llvm/lib/Support/APInt.cpp

@@ -3094,3 +3094,19 @@ void llvm::LoadIntFromMemory(APInt &IntVal, const uint8_t *Src,
    memcpy(Dst + sizeof(uint64_t) - LoadBytes, Src, LoadBytes);
  }
 }
+
+APInt APIntOps::mulhs(const APInt &C1, const APInt &C2) {
+  assert(C1.getBitWidth() >= C2.getBitWidth());


(style) Assertions should include a message string as well:

assert(C1.getBitWidth() >= C2.getBitWidth() && "BitWidth mismatch");

Why is this >= instead of ==? I really don't like that! Perhaps there is a bug somewhere else that should be fixed first?

The DivisionByConstantTest code allows different bitwidths - which isn't great - we should probably drop the DivisionByConstantTest diff and assert for == - we could then fix DivisionByConstantTest in a future patch?

Yes I'd prefer that. If the bit widths don't match then it is no longer clear (to me) what these functions are supposed to do.

Please raise a ticket for the DivisionByConstantTest. Thanks!

kuhar

Could you also address things I raised on the other PR for mulh?
#84609 (review) and the other comments that follow

RKSimon

One final minor

RKSimon · 2024-03-13T10:13:30Z

llvm/lib/Support/APInt.cpp

@@ -3094,3 +3094,19 @@ void llvm::LoadIntFromMemory(APInt &IntVal, const uint8_t *Src,
    memcpy(Dst + sizeof(uint64_t) - LoadBytes, Src, LoadBytes);
  }
 }
+
+APInt APIntOps::mulhs(const APInt &C1, const APInt &C2) {
+  assert(C1.getBitWidth() == C2.getBitWidth());


(style) Assertion message: assert(C1.getBitWidth() == C2.getBitWidth() && "Unequal bitwidths");

RKSimon · 2024-03-13T10:13:33Z

llvm/lib/Support/APInt.cpp

+}
+
+APInt APIntOps::mulhu(const APInt &C1, const APInt &C2) {
+  assert(C1.getBitWidth() == C2.getBitWidth());


(style) Assertion message: assert(C1.getBitWidth() == C2.getBitWidth() && "Unequal bitwidths");

kuhar

The PR subject line doesn't match the function names anymore. Could you update it?

Thanks for all the fixes so far. In general looks good, my only remaining comments are related to the documentation.

kuhar · 2024-03-13T19:56:28Z

llvm/include/llvm/ADT/APInt.h

+/// Return the high bits of the signed multiplication of C1 and C2.
+APInt mulhs(const APInt &C1, const APInt &C2);
+
+/// Return the high bits of the unsigned multiplication of C1 and C2.
+APInt mulhu(const APInt &C1, const APInt &C2);


I think this could use some more explanation about what this actually calculates. See #84609 (comment) and #84609 (comment).

Also, I think we could make the first line of description a little bit more precise, e.g.:

Suggested change

/// Return the high bits of the signed multiplication of C1 and C2.

APInt mulhs(const APInt &C1, const APInt &C2);

/// Return the high bits of the unsigned multiplication of C1 and C2.

APInt mulhu(const APInt &C1, const APInt &C2);

/// Performs (2*N)-bit multiplication on sign-extended operands.

/// Returns the high N bits of the multiplication result.

APInt mulhs(const APInt &C1, const APInt &C2);

/// Performs (2*N)-bit multiplication on zero-extended operands.

/// Returns the high N bits of the multiplication result.

APInt mulhu(const APInt &C1, const APInt &C2);

See https://mlir.llvm.org/docs/Dialects/ArithOps/#arithmulsi_extended-arithmulsiextendedop

Atousa · 2024-03-14T05:30:05Z

@arsenm @kuhar @RKSimon @jayfoad @topperc Thank you all!

RKSimon

LGTM - cheers!

RKSimon · 2024-03-14T09:58:28Z

@kuhar Are you happy with the mlir changes?

jayfoad · 2024-03-14T11:13:41Z

mlir/lib/Dialect/Arith/IR/ArithOps.cpp

@@ -434,9 +434,7 @@ arith::MulSIExtendedOp::fold(FoldAdaptor adaptor,
    // Invoke the constant fold helper again to calculate the 'high' result.
    Attribute highAttr = constFoldBinaryOp<IntegerAttr>(
        adaptor.getOperands(), [](const APInt &a, const APInt &b) {


Maybe this can just be ...(adaptor.getOperands(), llvm::APIntOps::mulhs);?

Maybe this can just be ...(adaptor.getOperands(), llvm::APIntOps::mulhs);?

Not sure, I think it is clear as it is.

I'd recommend any further refactor changes like that as followups for somebody (not necessarily @Atousa) - to ensure the changes in this PR are just the move to the APIntOps::mulh* helpers.

kuhar

LGTM, thanks for the changes.

Note that this could also be implement without btiwidth extension, similar to #85212. I don't know if the performance of the implementation matters much here, these functions are not on any fast path on the MLIR side. If you need a faster implementation, I wrote one for WebGPU:

llvm-project/mlir/lib/Dialect/SPIRV/Transforms/SPIRVWebGPUTransforms.cpp

Line 50 in 22eb800

Value lowerExtendedMultiplication(Operation *mulOp, PatternRewriter &rewriter,

RKSimon

Please can you rebase now that the #84431 has landed

RKSimon · 2024-03-19T18:12:15Z

ping @Atousa

Atousa · 2024-03-28T18:17:49Z

ping @Atousa

I missed that. I thought it has been merged.

Atousa · 2024-03-29T13:55:17Z

ping @Atousa

I missed that. I thought it has been merged.

@RKSimon

RKSimon

@Atousa Please can you add back the KnownBitsTest.cpp change?

This addresses issue llvm#84207

Atousa · 2024-04-02T15:12:32Z

@RKSimon I don't know why Linux build failed ?

RKSimon · 2024-04-02T16:08:31Z

@RKSimon I don't know why Linux build failed ?

I think it was just a ccache failure - I've merged the patch and will keep an eye on it for failures

Atousa marked this pull request as ready for review March 11, 2024 05:01

llvmbot added llvm:support llvm:SelectionDAG SelectionDAGISel as well llvm:adt labels Mar 11, 2024

kuhar self-requested a review March 11, 2024 05:04

topperc reviewed Mar 11, 2024

View reviewed changes

arsenm reviewed Mar 11, 2024

View reviewed changes

topperc reviewed Mar 11, 2024

View reviewed changes

jayfoad requested changes Mar 11, 2024

View reviewed changes

RKSimon reviewed Mar 11, 2024

View reviewed changes

Atousa force-pushed the issue-84207 branch from d1d00dd to ea764b7 Compare March 12, 2024 07:52

jayfoad reviewed Mar 12, 2024

View reviewed changes

jayfoad approved these changes Mar 12, 2024

View reviewed changes

RKSimon reviewed Mar 12, 2024

View reviewed changes

kuhar requested changes Mar 12, 2024

View reviewed changes

Atousa force-pushed the issue-84207 branch from ea764b7 to 1126436 Compare March 13, 2024 04:57

Atousa requested a review from antiagainst as a code owner March 13, 2024 04:57

llvmbot added mlir:spirv mlir mlir:arith labels Mar 13, 2024

RKSimon reviewed Mar 13, 2024

View reviewed changes

kuhar reviewed Mar 13, 2024

View reviewed changes

Atousa changed the title ~~[ADT] Add signed and unsigned mulHi and mulLo to APInt~~ [ADT] Add signed and unsigned mulh to APInt Mar 14, 2024

Atousa force-pushed the issue-84207 branch 2 times, most recently from 97544fd to a062515 Compare March 14, 2024 05:24

RKSimon approved these changes Mar 14, 2024

View reviewed changes

jayfoad reviewed Mar 14, 2024

View reviewed changes

kuhar approved these changes Mar 14, 2024

View reviewed changes

Atousa force-pushed the issue-84207 branch 2 times, most recently from 3a2283a to cf7985f Compare March 15, 2024 05:31

RKSimon requested changes Mar 15, 2024

View reviewed changes

Atousa force-pushed the issue-84207 branch from cf7985f to 85d1442 Compare March 29, 2024 05:07

RKSimon reviewed Apr 1, 2024

View reviewed changes

[ADT] Add signed and unsigned mulh to APInt

e9ad79c

This addresses issue llvm#84207

Atousa force-pushed the issue-84207 branch from 85d1442 to e9ad79c Compare April 1, 2024 16:00

RKSimon merged commit 4aba595 into llvm:main Apr 2, 2024

	/// Return the high bits of the signed multiplication of C1 and C2
	/// Return the high bits of the signed multiplication of C1 and C2.

[ADT] Add signed and unsigned mulh to APInt #84719

[ADT] Add signed and unsigned mulh to APInt #84719

Conversation

Atousa commented Mar 11, 2024 • edited by RKSimon Loading

llvmbot commented Mar 11, 2024 • edited Loading

topperc Mar 11, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jayfoad left a comment

Choose a reason for hiding this comment

RKSimon left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jayfoad left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

kuhar left a comment

Choose a reason for hiding this comment

RKSimon left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

kuhar left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Atousa commented Mar 14, 2024

RKSimon left a comment

Choose a reason for hiding this comment

RKSimon commented Mar 14, 2024

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

kuhar left a comment • edited Loading

Choose a reason for hiding this comment

RKSimon left a comment

Choose a reason for hiding this comment

RKSimon commented Mar 19, 2024

Atousa commented Mar 28, 2024

Atousa commented Mar 29, 2024

RKSimon left a comment

Choose a reason for hiding this comment

Atousa commented Apr 2, 2024

RKSimon commented Apr 2, 2024

Atousa commented Mar 11, 2024 •

edited by RKSimon

Loading

llvmbot commented Mar 11, 2024 •

edited

Loading

topperc Mar 11, 2024 •

edited

Loading

kuhar left a comment •

edited

Loading