From e63dda51c2b230215837063dba73e9299f8c0aba Mon Sep 17 00:00:00 2001 From: Owen Anderson Date: Fri, 17 Dec 2010 18:08:00 +0000 Subject: [PATCH] Reapply r121905 (automatic synthesis of @llvm.sadd.with.overflow) with a fix for a bug that manifested itself on the DragonEgg self-host bot. Unfortunately, the testcase is pretty messy and doesn't reduce well due to interactions with other parts of InstCombine. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@122072 91177308-0d34-0410-b5e6-96231b3b80d8 --- .../InstCombine/InstCombineCompares.cpp | 73 +++++++++++++++++++ test/Transforms/InstCombine/overflow.ll | 27 +++++++ 2 files changed, 100 insertions(+) create mode 100644 test/Transforms/InstCombine/overflow.ll diff --git a/lib/Transforms/InstCombine/InstCombineCompares.cpp b/lib/Transforms/InstCombine/InstCombineCompares.cpp index d2841af8bc6..41eea27f003 100644 --- a/lib/Transforms/InstCombine/InstCombineCompares.cpp +++ b/lib/Transforms/InstCombine/InstCombineCompares.cpp @@ -1657,6 +1657,79 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) { if (ConstantInt *CI = dyn_cast(Op1)) { Value *A = 0, *B = 0; + // Match the following pattern, which is a common idiom when writing + // overflow-safe integer arithmetic function. The source performs an + // addition in wider type, and explicitly checks for overflow using + // comparisons against INT_MIN and INT_MAX. Simplify this by using the + // sadd_with_overflow intrinsic. + // FIXME: This could probably be generalized to handle other overflow-safe + // operations if we worked out the formulas to compute the appropriate + // magic constants. + // + // INT64 : a, b, sum = a + b + // if sum < INT32_MIN || sum > INT_MAX then + // ... + // else + // ... + { + ConstantInt *CI2; + + // I = icmp ugt (add (add A B) CI2) CI + if (I.getPredicate() == ICmpInst::ICMP_UGT && + match(Op0, m_Add(m_Add(m_Value(A), m_Value(B)), + m_ConstantInt(CI2)))) { + const IntegerType *WideType = cast(CI->getType()); + unsigned WideWidth = WideType->getBitWidth(); + unsigned NarrowWidth = WideWidth / 2; + const IntegerType *NarrowType = + IntegerType::get(CI->getContext(), NarrowWidth); + + // NarrowAllOnes and NarrowSignBit are the magic constants used to + // perform an overflow check in the wider type: 0x00..00FF..FF and + // 0x00..0010..00 respectively, where the highest set bit in each is + // what would be the sign bit in the narrower type. + ConstantInt *NarrowAllOnes = cast(ConstantInt::get(WideType, + APInt::getAllOnesValue(NarrowWidth).zext(WideWidth))); + APInt SignBit(WideWidth, 0); + SignBit.setBit(NarrowWidth-1); + ConstantInt *NarrowSignBit = + cast(ConstantInt::get(WideType, SignBit)); + + if (CI == NarrowAllOnes && CI2 == NarrowSignBit) { + Module *M = I.getParent()->getParent()->getParent(); + + const Type *IntrinsicType = NarrowType; + Value *F = Intrinsic::getDeclaration(M, Intrinsic::sadd_with_overflow, + &IntrinsicType, 1); + + BasicBlock *InitialBlock = Builder->GetInsertBlock(); + BasicBlock::iterator InitialInsert = Builder->GetInsertPoint(); + + // If the pattern matches, truncate the inputs to the narrower type and + // use the sadd_with_overflow intrinsic to efficiently compute both the + // result and the overflow bit. + Instruction *OrigAdd = + cast(cast(I.getOperand(0))->getOperand(0)); + Builder->SetInsertPoint(OrigAdd->getParent(), + BasicBlock::iterator(OrigAdd)); + + Value *TruncA = Builder->CreateTrunc(A, NarrowType, A->getName()); + Value *TruncB = Builder->CreateTrunc(B, NarrowType, B->getName()); + CallInst *Call = Builder->CreateCall2(F, TruncA, TruncB); + Value *Add = Builder->CreateExtractValue(Call, 0); + Value *ZExt = Builder->CreateZExt(Add, WideType); + + // The inner add was the result of the narrow add, zero extended to the + // wider type. Replace it with the result computed by the intrinsic. + OrigAdd->replaceAllUsesWith(ZExt); + + Builder->SetInsertPoint(InitialBlock, InitialInsert); + + return ExtractValueInst::Create(Call, 1); + } + } + } + // (icmp ne/eq (sub A B) 0) -> (icmp ne/eq A, B) if (I.isEquality() && CI->isZero() && match(Op0, m_Sub(m_Value(A), m_Value(B)))) { diff --git a/test/Transforms/InstCombine/overflow.ll b/test/Transforms/InstCombine/overflow.ll new file mode 100644 index 00000000000..f3f8ca3d61d --- /dev/null +++ b/test/Transforms/InstCombine/overflow.ll @@ -0,0 +1,27 @@ +; RUN: opt -S -instcombine < %s | FileCheck %s +; + +; CHECK: @test1 +define i32 @test1(i32 %a, i32 %b) nounwind ssp { +entry: +; CHECK-NOT: sext + %conv = sext i32 %a to i64 + %conv2 = sext i32 %b to i64 + %add = add nsw i64 %conv2, %conv + %add.off = add i64 %add, 2147483648 +; CHECK: llvm.sadd.with.overflow + %0 = icmp ugt i64 %add.off, 4294967295 + br i1 %0, label %if.then, label %if.end + +if.then: + %call = tail call i32 (...)* @throwAnExceptionOrWhatever() nounwind + br label %if.end + +if.end: +; CHECK-NOT: trunc + %conv9 = trunc i64 %add to i32 +; CHECK: ret i32 + ret i32 %conv9 +} + +declare i32 @throwAnExceptionOrWhatever(...)