Author: Fangrui Song Date: 2022-12-05T04:30:54Z New Revision: 3dfacc0a56e9d5718f51b1d3ce63070e79fc2608
URL: https://github.com/llvm/llvm-project/commit/3dfacc0a56e9d5718f51b1d3ce63070e79fc2608 DIFF: https://github.com/llvm/llvm-project/commit/3dfacc0a56e9d5718f51b1d3ce63070e79fc2608.diff LOG: CheckedArithmetic: llvm::Optional => std::optional Added: Modified: lldb/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp llvm/include/llvm/Analysis/VectorUtils.h llvm/include/llvm/Support/CheckedArithmetic.h llvm/lib/FileCheck/FileCheck.cpp llvm/unittests/Support/CheckedArithmeticTest.cpp Removed: ################################################################################ diff --git a/lldb/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp b/lldb/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp index 3fc529ae20281..25042b12f1939 100644 --- a/lldb/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp +++ b/lldb/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp @@ -560,7 +560,7 @@ uint64_t EmulateInstructionARM64:: AddWithCarry(uint32_t N, uint64_t x, uint64_t y, bit carry_in, EmulateInstructionARM64::ProcState &proc_state) { uint64_t unsigned_sum = UInt(x) + UInt(y) + UInt(carry_in); - llvm::Optional<int64_t> signed_sum = llvm::checkedAdd(SInt(x), SInt(y)); + std::optional<int64_t> signed_sum = llvm::checkedAdd(SInt(x), SInt(y)); bool overflow = !signed_sum; if (!overflow) overflow |= !llvm::checkedAdd(*signed_sum, SInt(carry_in)); diff --git a/llvm/include/llvm/Analysis/VectorUtils.h b/llvm/include/llvm/Analysis/VectorUtils.h index 0f2346cf7c57e..02271d5780c82 100644 --- a/llvm/include/llvm/Analysis/VectorUtils.h +++ b/llvm/include/llvm/Analysis/VectorUtils.h @@ -641,7 +641,7 @@ template <typename InstTy> class InterleaveGroup { /// \returns false if the instruction doesn't belong to the group. bool insertMember(InstTy *Instr, int32_t Index, Align NewAlign) { // Make sure the key fits in an int32_t. - Optional<int32_t> MaybeKey = checkedAdd(Index, SmallestKey); + std::optional<int32_t> MaybeKey = checkedAdd(Index, SmallestKey); if (!MaybeKey) return false; int32_t Key = *MaybeKey; @@ -664,7 +664,7 @@ template <typename InstTy> class InterleaveGroup { } else if (Key < SmallestKey) { // Make sure the largest index fits in an int32_t. - Optional<int32_t> MaybeLargestIndex = checkedSub(LargestKey, Key); + std::optional<int32_t> MaybeLargestIndex = checkedSub(LargestKey, Key); if (!MaybeLargestIndex) return false; diff --git a/llvm/include/llvm/Support/CheckedArithmetic.h b/llvm/include/llvm/Support/CheckedArithmetic.h index c9db239672d36..5bfc551b2cc5b 100644 --- a/llvm/include/llvm/Support/CheckedArithmetic.h +++ b/llvm/include/llvm/Support/CheckedArithmetic.h @@ -15,8 +15,8 @@ #define LLVM_SUPPORT_CHECKEDARITHMETIC_H #include "llvm/ADT/APInt.h" -#include "llvm/ADT/Optional.h" +#include <optional> #include <type_traits> namespace { @@ -26,7 +26,7 @@ namespace { /// \return Empty optional if the operation overflows, or result otherwise. template <typename T, typename F> std::enable_if_t<std::is_integral<T>::value && sizeof(T) * 8 <= 64, - llvm::Optional<T>> + std::optional<T>> checkedOp(T LHS, T RHS, F Op, bool Signed = true) { llvm::APInt ALHS(sizeof(T) * 8, LHS, Signed); llvm::APInt ARHS(sizeof(T) * 8, RHS, Signed); @@ -44,7 +44,7 @@ namespace llvm { /// \return Optional of sum if no signed overflow occurred, /// \c None otherwise. template <typename T> -std::enable_if_t<std::is_signed<T>::value, llvm::Optional<T>> +std::enable_if_t<std::is_signed<T>::value, std::optional<T>> checkedAdd(T LHS, T RHS) { return checkedOp(LHS, RHS, &llvm::APInt::sadd_ov); } @@ -53,7 +53,7 @@ checkedAdd(T LHS, T RHS) { /// \return Optional of sum if no signed overflow occurred, /// \c None otherwise. template <typename T> -std::enable_if_t<std::is_signed<T>::value, llvm::Optional<T>> +std::enable_if_t<std::is_signed<T>::value, std::optional<T>> checkedSub(T LHS, T RHS) { return checkedOp(LHS, RHS, &llvm::APInt::ssub_ov); } @@ -62,7 +62,7 @@ checkedSub(T LHS, T RHS) { /// \return Optional of product if no signed overflow occurred, /// \c None otherwise. template <typename T> -std::enable_if_t<std::is_signed<T>::value, llvm::Optional<T>> +std::enable_if_t<std::is_signed<T>::value, std::optional<T>> checkedMul(T LHS, T RHS) { return checkedOp(LHS, RHS, &llvm::APInt::smul_ov); } @@ -71,7 +71,7 @@ checkedMul(T LHS, T RHS) { /// \return Optional of result if no signed overflow occurred, /// \c None otherwise. template <typename T> -std::enable_if_t<std::is_signed<T>::value, llvm::Optional<T>> +std::enable_if_t<std::is_signed<T>::value, std::optional<T>> checkedMulAdd(T A, T B, T C) { if (auto Product = checkedMul(A, B)) return checkedAdd(*Product, C); @@ -82,7 +82,7 @@ checkedMulAdd(T A, T B, T C) { /// \return Optional of sum if no unsigned overflow occurred, /// \c None otherwise. template <typename T> -std::enable_if_t<std::is_unsigned<T>::value, llvm::Optional<T>> +std::enable_if_t<std::is_unsigned<T>::value, std::optional<T>> checkedAddUnsigned(T LHS, T RHS) { return checkedOp(LHS, RHS, &llvm::APInt::uadd_ov, /*Signed=*/false); } @@ -91,7 +91,7 @@ checkedAddUnsigned(T LHS, T RHS) { /// \return Optional of product if no unsigned overflow occurred, /// \c None otherwise. template <typename T> -std::enable_if_t<std::is_unsigned<T>::value, llvm::Optional<T>> +std::enable_if_t<std::is_unsigned<T>::value, std::optional<T>> checkedMulUnsigned(T LHS, T RHS) { return checkedOp(LHS, RHS, &llvm::APInt::umul_ov, /*Signed=*/false); } @@ -100,7 +100,7 @@ checkedMulUnsigned(T LHS, T RHS) { /// \return Optional of result if no unsigned overflow occurred, /// \c None otherwise. template <typename T> -std::enable_if_t<std::is_unsigned<T>::value, llvm::Optional<T>> +std::enable_if_t<std::is_unsigned<T>::value, std::optional<T>> checkedMulAddUnsigned(T A, T B, T C) { if (auto Product = checkedMulUnsigned(A, B)) return checkedAddUnsigned(*Product, C); diff --git a/llvm/lib/FileCheck/FileCheck.cpp b/llvm/lib/FileCheck/FileCheck.cpp index f428e3f448ac1..e2cc6dc6763bb 100644 --- a/llvm/lib/FileCheck/FileCheck.cpp +++ b/llvm/lib/FileCheck/FileCheck.cpp @@ -206,7 +206,7 @@ Expected<ExpressionValue> llvm::operator+(const ExpressionValue &LeftOperand, if (LeftOperand.isNegative() && RightOperand.isNegative()) { int64_t LeftValue = cantFail(LeftOperand.getSignedValue()); int64_t RightValue = cantFail(RightOperand.getSignedValue()); - Optional<int64_t> Result = checkedAdd<int64_t>(LeftValue, RightValue); + std::optional<int64_t> Result = checkedAdd<int64_t>(LeftValue, RightValue); if (!Result) return make_error<OverflowError>(); @@ -224,7 +224,7 @@ Expected<ExpressionValue> llvm::operator+(const ExpressionValue &LeftOperand, // Both values are positive at this point. uint64_t LeftValue = cantFail(LeftOperand.getUnsignedValue()); uint64_t RightValue = cantFail(RightOperand.getUnsignedValue()); - Optional<uint64_t> Result = + std::optional<uint64_t> Result = checkedAddUnsigned<uint64_t>(LeftValue, RightValue); if (!Result) return make_error<OverflowError>(); @@ -241,7 +241,7 @@ Expected<ExpressionValue> llvm::operator-(const ExpressionValue &LeftOperand, // Result <= -1 - (max int64_t) which overflows on 1- and 2-complement. if (RightValue > (uint64_t)std::numeric_limits<int64_t>::max()) return make_error<OverflowError>(); - Optional<int64_t> Result = + std::optional<int64_t> Result = checkedSub(LeftValue, static_cast<int64_t>(RightValue)); if (!Result) return make_error<OverflowError>(); @@ -306,7 +306,7 @@ Expected<ExpressionValue> llvm::operator*(const ExpressionValue &LeftOperand, // Result will be positive and can overflow. uint64_t LeftValue = cantFail(LeftOperand.getUnsignedValue()); uint64_t RightValue = cantFail(RightOperand.getUnsignedValue()); - Optional<uint64_t> Result = + std::optional<uint64_t> Result = checkedMulUnsigned<uint64_t>(LeftValue, RightValue); if (!Result) return make_error<OverflowError>(); diff --git a/llvm/unittests/Support/CheckedArithmeticTest.cpp b/llvm/unittests/Support/CheckedArithmeticTest.cpp index eae54eb1c0cba..0e331b2a31eb4 100644 --- a/llvm/unittests/Support/CheckedArithmeticTest.cpp +++ b/llvm/unittests/Support/CheckedArithmeticTest.cpp @@ -11,7 +11,7 @@ TEST(CheckedArithmetic, CheckedAdd) { EXPECT_EQ(checkedAdd<int64_t>(Max, Max), std::nullopt); EXPECT_EQ(checkedAdd<int64_t>(Min, -1), std::nullopt); EXPECT_EQ(checkedAdd<int64_t>(Max, 1), std::nullopt); - EXPECT_EQ(checkedAdd<int64_t>(10, 1), Optional<int64_t>(11)); + EXPECT_EQ(checkedAdd<int64_t>(10, 1), std::optional<int64_t>(11)); } TEST(CheckedArithmetic, CheckedAddSmall) { @@ -20,7 +20,7 @@ TEST(CheckedArithmetic, CheckedAddSmall) { EXPECT_EQ(checkedAdd<int16_t>(Max, Max), std::nullopt); EXPECT_EQ(checkedAdd<int16_t>(Min, -1), std::nullopt); EXPECT_EQ(checkedAdd<int16_t>(Max, 1), std::nullopt); - EXPECT_EQ(checkedAdd<int16_t>(10, 1), Optional<int64_t>(11)); + EXPECT_EQ(checkedAdd<int16_t>(10, 1), std::optional<int64_t>(11)); } TEST(CheckedArithmetic, CheckedMul) { @@ -29,7 +29,7 @@ TEST(CheckedArithmetic, CheckedMul) { EXPECT_EQ(checkedMul<int64_t>(Max, 2), std::nullopt); EXPECT_EQ(checkedMul<int64_t>(Max, Max), std::nullopt); EXPECT_EQ(checkedMul<int64_t>(Min, 2), std::nullopt); - EXPECT_EQ(checkedMul<int64_t>(10, 2), Optional<int64_t>(20)); + EXPECT_EQ(checkedMul<int64_t>(10, 2), std::optional<int64_t>(20)); } TEST(CheckedArithmetic, CheckedMulAdd) { @@ -38,7 +38,7 @@ TEST(CheckedArithmetic, CheckedMulAdd) { EXPECT_EQ(checkedMulAdd<int64_t>(Max, 1, 2), std::nullopt); EXPECT_EQ(checkedMulAdd<int64_t>(1, 1, Max), std::nullopt); EXPECT_EQ(checkedMulAdd<int64_t>(1, -1, Min), std::nullopt); - EXPECT_EQ(checkedMulAdd<int64_t>(10, 2, 3), Optional<int64_t>(23)); + EXPECT_EQ(checkedMulAdd<int64_t>(10, 2, 3), std::optional<int64_t>(23)); } TEST(CheckedArithmetic, CheckedMulSmall) { @@ -47,7 +47,7 @@ TEST(CheckedArithmetic, CheckedMulSmall) { EXPECT_EQ(checkedMul<int16_t>(Max, 2), std::nullopt); EXPECT_EQ(checkedMul<int16_t>(Max, Max), std::nullopt); EXPECT_EQ(checkedMul<int16_t>(Min, 2), std::nullopt); - EXPECT_EQ(checkedMul<int16_t>(10, 2), Optional<int16_t>(20)); + EXPECT_EQ(checkedMul<int16_t>(10, 2), std::optional<int16_t>(20)); } TEST(CheckedArithmetic, CheckedMulAddSmall) { @@ -56,28 +56,28 @@ TEST(CheckedArithmetic, CheckedMulAddSmall) { EXPECT_EQ(checkedMulAdd<int16_t>(Max, 1, 2), std::nullopt); EXPECT_EQ(checkedMulAdd<int16_t>(1, 1, Max), std::nullopt); EXPECT_EQ(checkedMulAdd<int16_t>(1, -1, Min), std::nullopt); - EXPECT_EQ(checkedMulAdd<int16_t>(10, 2, 3), Optional<int16_t>(23)); + EXPECT_EQ(checkedMulAdd<int16_t>(10, 2, 3), std::optional<int16_t>(23)); } TEST(CheckedArithmetic, CheckedAddUnsigned) { const uint64_t Max = std::numeric_limits<uint64_t>::max(); EXPECT_EQ(checkedAddUnsigned<uint64_t>(Max, Max), std::nullopt); EXPECT_EQ(checkedAddUnsigned<uint64_t>(Max, 1), std::nullopt); - EXPECT_EQ(checkedAddUnsigned<uint64_t>(10, 1), Optional<uint64_t>(11)); + EXPECT_EQ(checkedAddUnsigned<uint64_t>(10, 1), std::optional<uint64_t>(11)); } TEST(CheckedArithmetic, CheckedMulUnsigned) { const uint64_t Max = std::numeric_limits<uint64_t>::max(); EXPECT_EQ(checkedMulUnsigned<uint64_t>(Max, 2), std::nullopt); EXPECT_EQ(checkedMulUnsigned<uint64_t>(Max, Max), std::nullopt); - EXPECT_EQ(checkedMulUnsigned<uint64_t>(10, 2), Optional<uint64_t>(20)); + EXPECT_EQ(checkedMulUnsigned<uint64_t>(10, 2), std::optional<uint64_t>(20)); } TEST(CheckedArithmetic, CheckedMulAddUnsigned) { const uint64_t Max = std::numeric_limits<uint64_t>::max(); EXPECT_EQ(checkedMulAddUnsigned<uint64_t>(Max, 1, 2), std::nullopt); EXPECT_EQ(checkedMulAddUnsigned<uint64_t>(1, 1, Max), std::nullopt); - EXPECT_EQ(checkedMulAddUnsigned<uint64_t>(10, 2, 3), Optional<uint64_t>(23)); + EXPECT_EQ(checkedMulAddUnsigned<uint64_t>(10, 2, 3), std::optional<uint64_t>(23)); } _______________________________________________ lldb-commits mailing list lldb-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
