Index: test/Transforms/InstCombine/nsw_preserve.ll
===================================================================
--- test/Transforms/InstCombine/nsw_preserve.ll	(revision 0)
+++ test/Transforms/InstCombine/nsw_preserve.ll	(revision 0)
@@ -0,0 +1,45 @@
+; RUN: opt < %s -instcombine -S | FileCheck %s
+
+; CHECK: @test1
+; CHECK: br i1 true, label %if.then, label %if.else
+define i32 @test1(i32 %x) nounwind {
+entry:
+  %retval = alloca i32, align 4
+  %add = add nsw i32 %x, 2
+  %add3 = add nsw i32 %add, 3
+  %cmp = icmp slt i32 %add, %add3
+  br i1 %cmp, label %if.then, label %if.else
+if.then:                                          
+  store i32 1, i32* %retval
+  br label %return
+
+if.else:                                          
+  store i32 0, i32* %retval
+  br label %return
+
+return:                                           
+  %0 = load i32* %retval
+  ret i32 %0
+}
+
+; CHECK: @test2
+; CHECK: br i1 %cmp, label %if.then, label %if.else
+define i8 @test2(i8 %x) nounwind {
+entry:
+  %retval = alloca i8, align 4
+  %add = add nsw i8 %x, 127
+  %add3 = add nsw i8 %add, 3
+  %cmp = icmp slt i8 %add, %add3
+  br i1 %cmp, label %if.then, label %if.else
+if.then:                                          
+  store i8 1, i8* %retval
+  br label %return
+
+if.else:                                          
+  store i8 0, i8* %retval
+  br label %return
+
+return:                                           
+  %0 = load i8* %retval
+  ret i8 %0
+}
Index: lib/Transforms/InstCombine/InstructionCombining.cpp
===================================================================
--- lib/Transforms/InstCombine/InstructionCombining.cpp	(revision 137258)
+++ lib/Transforms/InstCombine/InstructionCombining.cpp	(working copy)
@@ -107,8 +107,45 @@
   
   return true;
 }
+// Return true, if No Signed Wrap should be maintained for I.
+// The No Signed Wrap flag can be kept if the operation "B (I.getOpcode) C",
+// where both B and C should be ConstantInts, results in a constant that does
+// not overflow. This function only handles the Add and Sub opcodes. For
+// all other opcodes, the function conservatively returns false.
+static bool MaintainNoSignedWrap(BinaryOperator &I, Value *B, Value *C) {
+  OverflowingBinaryOperator *OBO = dyn_cast<OverflowingBinaryOperator>(&I);
+  if (!OBO || !OBO->hasNoSignedWrap()) {
+    return false;
+  }
 
+  // We reason about Add and Sub Only.
+  Instruction::BinaryOps Opcode = I.getOpcode();
+  if (Opcode != Instruction::Add && 
+      Opcode != Instruction::Sub) {
+    return false;
+  }
 
+  ConstantInt *CB = dyn_cast<ConstantInt>(B);
+  ConstantInt *CC = dyn_cast<ConstantInt>(C);
+
+  if (!CB || !CC) {
+    return false;
+  }
+
+  const APInt &BVal = CB->getValue();
+  const APInt &CVal = CC->getValue();
+  bool Overflow = false;
+
+  if (Opcode == Instruction::Add) {
+    BVal.sadd_ov(CVal, Overflow);
+  } else {
+    BVal.ssub_ov(CVal, Overflow);
+  }
+
+  return !Overflow;
+}
+
+
 /// SimplifyAssociativeOrCommutative - This performs a few simplifications for
 /// operators which are associative or commutative:
 //
@@ -159,7 +196,13 @@
           I.setOperand(1, V);
           // Conservatively clear the optional flags, since they may not be
           // preserved by the reassociation.
+          if (MaintainNoSignedWrap(I, B, C)) {
           I.clearSubclassOptionalData();
+          I.setHasNoSignedWrap(true);
+          } else {
+            I.clearSubclassOptionalData();
+          }
+            
           Changed = true;
           ++NumReassoc;
           continue;
@@ -241,14 +284,21 @@
         Constant *C2 = cast<Constant>(Op1->getOperand(1));
 
         Constant *Folded = ConstantExpr::get(Opcode, C1, C2);
-        Instruction *New = BinaryOperator::Create(Opcode, A, B);
+        BinaryOperator *New = BinaryOperator::Create(Opcode, A, B);
         InsertNewInstWith(New, I);
         New->takeName(Op1);
         I.setOperand(0, New);
         I.setOperand(1, Folded);
         // Conservatively clear the optional flags, since they may not be
         // preserved by the reassociation.
-        I.clearSubclassOptionalData();
+        if (MaintainNoSignedWrap(I, C1, C2)) {
+          I.clearSubclassOptionalData();
+          I.setHasNoSignedWrap(true);
+          New->setHasNoSignedWrap(true);
+        } else {
+          I.clearSubclassOptionalData();
+        }
+
         Changed = true;
         continue;
       }