Only in clang-2.9: clang-2.9.patch
Only in clang/docs: html.tar.gz
Only in clang/docs/tools: clang.1
Only in clang/docs/tools: clang.html
Only in clang/docs/tools: clang.ps
Only in clang/docs/tools: pod2htmd.tmp
Only in clang/docs/tools: pod2htmi.tmp
Only in clang/include/clang/AST: AttrImpl.inc
Only in clang/include/clang/AST: Attrs.inc
Only in clang/include/clang/AST: DeclNodes.inc
Only in clang/include/clang/AST: Release
Only in clang/include/clang/AST: StmtNodes.inc
Only in clang/include/clang/Basic: arm_neon.inc
Only in clang/include/clang/Basic: AttrList.inc
diff -ura clang-2.9/include/clang/Basic/Attr.td clang/include/clang/Basic/Attr.td
--- clang-2.9/include/clang/Basic/Attr.td	2011-04-08 00:48:25.972444476 -0600
+++ clang/include/clang/Basic/Attr.td	2011-04-07 12:09:19.868444426 -0600
@@ -331,6 +331,11 @@
   let Namespaces = ["", "std"];
 }
 
+def NoIntegerCheck : InheritableAttr {
+  let Spellings = ["nointegercheck"];
+  let Subjects = [Function];
+}
+
 def NoInstrumentFunction : InheritableAttr {
   let Spellings = ["no_instrument_function"];
   let Subjects = [Function];
Only in clang/include/clang/Basic: DiagnosticAnalysisKinds.inc
Only in clang/include/clang/Basic: DiagnosticASTKinds.inc
Only in clang/include/clang/Basic: DiagnosticCommonKinds.inc
Only in clang/include/clang/Basic: DiagnosticDriverKinds.inc
Only in clang/include/clang/Basic: DiagnosticFrontendKinds.inc
Only in clang/include/clang/Basic: DiagnosticGroups.inc
Only in clang/include/clang/Basic: DiagnosticLexKinds.inc
Only in clang/include/clang/Basic: DiagnosticParseKinds.inc
Only in clang/include/clang/Basic: DiagnosticSemaKinds.inc
diff -ura clang-2.9/include/clang/Basic/LangOptions.h clang/include/clang/Basic/LangOptions.h
--- clang-2.9/include/clang/Basic/LangOptions.h	2011-04-08 00:48:25.972444476 -0600
+++ clang/include/clang/Basic/LangOptions.h	2011-04-07 12:09:19.868444426 -0600
@@ -107,6 +107,20 @@
   unsigned ElideConstructors : 1; // Whether C++ copy constructors should be
                                   // elided if possible.
   unsigned CatchUndefined    : 1; // Generate code to check for undefined ops.
+  unsigned CatchUndefinedAnsiC    : 1; // Generate checks for arithmetic 
+                                       // ops of C program upon AnsiC standard.
+  unsigned CatchUndefinedC99    : 1; // Generate checks for arithmetic 
+                                     // ops of C program upon C99 standard.
+  unsigned CatchUndefinedCXX0X    : 1; // Generate checks for arithmetic 
+                                       // ops of C++ program upon CXX0X.
+  unsigned CatchUndefinedCXX98    : 1; // Generate checks for arithmetic 
+                                       // ops of C++ program upon CXX98.
+  unsigned CatchNonArithUndefined    : 1; // Generate checks for 
+                                          // non-arithmetic ops.
+  unsigned UseIntrinsic    : 1; // Use intrinsic overflow checks.
+  unsigned HandlerProvidesValue    : 1; // Use values returned by trap handler 
+                                  // as arithmetic operations' results.
+  unsigned ChecksNum    : 1; // Output the number of instrumented checks. 
   unsigned DumpRecordLayouts : 1; /// Dump the layout of IRgen'd records.
   unsigned DumpVTableLayouts : 1; /// Dump the layouts of emitted vtables.
   unsigned NoConstantCFStrings : 1;  // Do not do CF strings
@@ -211,6 +225,14 @@
     ShortWChar = 0;
     ShortEnums = 0;
     CatchUndefined = 0;
+    CatchUndefinedAnsiC = 0;
+    CatchUndefinedC99 = 0;
+    CatchUndefinedCXX0X = 0;
+    CatchUndefinedCXX98 = 0;
+    CatchNonArithUndefined = 0;
+    UseIntrinsic = 0;
+    HandlerProvidesValue = 0;
+    ChecksNum = 0;
     DumpRecordLayouts = 0;
     DumpVTableLayouts = 0;
     SpellChecking = 1;
Only in clang/include/clang/Basic: Release
Only in clang/include/clang/Basic: Version.inc
Only in clang/include/clang/Driver: CC1AsOptions.inc
Only in clang/include/clang/Driver: CC1Options.inc
diff -ura clang-2.9/include/clang/Driver/CC1Options.td clang/include/clang/Driver/CC1Options.td
--- clang-2.9/include/clang/Driver/CC1Options.td	2011-04-08 00:48:25.972444476 -0600
+++ clang/include/clang/Driver/CC1Options.td	2011-04-07 23:08:10.936444311 -0600
@@ -112,7 +112,23 @@
   HelpText<"The string to embed in the Dwarf debug flags record.">;
 def g : Flag<"-g">, HelpText<"Generate source level debug information">;
 def fcatch_undefined_behavior : Flag<"-fcatch-undefined-behavior">,
-    HelpText<"Generate runtime checks for undefined behavior.">;
+    HelpText<"Generate runtime checks for undefined behaviors.">;
+def fcatch_undefined_ansic_behavior : Flag<"-fcatch-undefined-ansic-behavior">,
+    HelpText<"Generate runtime checks for undefined behaviors upon ansic standard.">;
+def fcatch_undefined_c99_behavior : Flag<"-fcatch-undefined-c99-behavior">,
+    HelpText<"Generate runtime checks for undefined behaviors upon c99 standard.">;
+def fcatch_undefined_cxx0x_behavior : Flag<"-fcatch-undefined-cxx0x-behavior">,
+    HelpText<"Generate runtime checks for undefined behaviors upon c++0x standard.">;
+def fcatch_undefined_cxx98_behavior : Flag<"-fcatch-undefined-cxx98-behavior">,
+    HelpText<"Generate runtime checks for undefined behaviors upon c++98 standard.">;
+def fcatch_undefined_nonarith_behavior : Flag<"-fcatch-undefined-nonarith-behavior">,
+    HelpText<"Generate runtime checks for undefined behaviors for non-arithmetic operations.">;
+def fcatch_undefined_use_intrinsic : Flag<"-fcatch-undefined-use-intrinsic">,
+    HelpText<"Use LLVM's intrinsic checks to detect overflow.">;
+def fhandler_provides_value : Flag<"-fhandler-provides-value">,
+    HelpText<"Use random values returned by trap handler as arithmetic operations' results.">;
+def fchecks_num : Flag<"-fchecks-num">,
+    HelpText<"Output the number of instrumented number.">;
 def flimit_debug_info : Flag<"-flimit-debug-info">,
   HelpText<"Limit debug information produced to reduce size of debug binary">;
 def fno_common : Flag<"-fno-common">,
Only in clang/include/clang/Driver: Options.inc
diff -ura clang-2.9/include/clang/Driver/Options.td clang/include/clang/Driver/Options.td
--- clang-2.9/include/clang/Driver/Options.td	2011-04-08 00:48:25.976444553 -0600
+++ clang/include/clang/Driver/Options.td	2011-04-08 00:42:17.200444323 -0600
@@ -256,7 +256,30 @@
 def fbuiltin : Flag<"-fbuiltin">, Group<f_Group>;
 def fcaret_diagnostics : Flag<"-fcaret-diagnostics">, Group<f_Group>;
 def fcatch_undefined_behavior : Flag<"-fcatch-undefined-behavior">,
-    Group<f_Group>, HelpText<"Generate runtime checks for undefined behavior.">;
+    Group<f_Group>, HelpText<"Generate runtime checks for undefined behaviors.">;
+def fcatch_undefined_ansic_behavior : Flag<"-fcatch-undefined-ansic-behavior">,
+    Group<f_Group>, 
+    HelpText<"Generate runtime checks for undefined behaviors upon ansic standard.">;
+def fcatch_undefined_c99_behavior : Flag<"-fcatch-undefined-c99-behavior">,
+    Group<f_Group>, 
+    HelpText<"Generate runtime checks for undefined behaviors upon c99 standard.">;
+def fcatch_undefined_cxx0x_behavior : Flag<"-fcatch-undefined-cxx0x-behavior">,
+    Group<f_Group>, 
+    HelpText<"Generate runtime checks for undefined behaviors upon c++0x standard.">;
+def fcatch_undefined_cxx98_behavior : Flag<"-fcatch-undefined-cxx98-behavior">,
+    Group<f_Group>, 
+    HelpText<"Generate runtime checks for undefined behaviors upon c++98 standard.">;
+def fcatch_undefined_nonarith_behavior : Flag<"-fcatch-undefined-nonarith-behavior">,
+    Group<f_Group>, 
+    HelpText<"Generate runtime checks for undefined behaviors for non-arithmetic operations.">;
+def fcatch_undefined_use_intrinsic : Flag<"-fcatch-undefined-use-intrinsic">,
+    Group<f_Group>, 
+    HelpText<"Use LLVM's intrinsic checks to detect overflow.">;
+def fhandler_provides_value : Flag<"-fhandler-provides-value">,
+    Group<f_Group>, 
+    HelpText<"Use random values returned by trap handler as arithmetic operations' results.">;
+def fchecks_num : Flag<"-fchecks-num">,
+    Group<f_Group>, HelpText<"Output the number of instrumented number.">;
 def fclasspath_EQ : Joined<"-fclasspath=">, Group<f_Group>;
 def fcolor_diagnostics : Flag<"-fcolor-diagnostics">, Group<f_Group>;
 def fcommon : Flag<"-fcommon">, Group<f_Group>;
diff -ura clang-2.9/include/clang/Driver/OptTable.h clang/include/clang/Driver/OptTable.h
--- clang-2.9/include/clang/Driver/OptTable.h	2011-04-08 00:48:25.976444553 -0600
+++ clang/include/clang/Driver/OptTable.h	2011-04-07 12:18:10.276444342 -0600
@@ -142,6 +142,9 @@
       return getInfo(id).MetaVar;
     }
 
+    Arg *ParseOneArgTrap(const ArgList &Args, unsigned &Index,
+                         const char *Str) const;
+
     /// ParseOneArg - Parse a single argument; returning the new argument and
     /// updating Index.
     ///
Only in clang/include/clang/Driver: Release
Only in clang/include/clang/Lex: AttrSpellings.inc
Only in clang/include/clang/Lex: Release
diff -ura clang-2.9/include/clang/Sema/AttributeList.h clang/include/clang/Sema/AttributeList.h
--- clang-2.9/include/clang/Sema/AttributeList.h	2011-04-08 00:48:25.976444553 -0600
+++ clang/include/clang/Sema/AttributeList.h	2011-04-07 12:09:19.868444426 -0600
@@ -122,6 +122,7 @@
     AT_nocommon,
     AT_nonnull,
     AT_noreturn,
+    AT_nointegercheck,
     AT_nothrow,
     AT_nsobject,
     AT_objc_exception,
Only in clang/include/clang/Serialization: AttrPCHRead.inc
Only in clang/include/clang/Serialization: AttrPCHWrite.inc
Only in clang/include/clang/Serialization: Release
Only in clang/lib/Analysis: Release
Only in clang/lib/AST: Release
Only in clang/lib/Basic: Release
diff -ura clang-2.9/lib/CodeGen/CGBlocks.cpp clang/lib/CodeGen/CGBlocks.cpp
--- clang-2.9/lib/CodeGen/CGBlocks.cpp	2011-04-08 00:48:25.976444553 -0600
+++ clang/lib/CodeGen/CGBlocks.cpp	2011-04-07 17:19:05.300444259 -0600
@@ -866,6 +866,18 @@
   return llvm::ConstantExpr::getBitCast(literal, requiredType);
 }
 
+void CodeGenFunction::CXXThisIsNull() {
+  llvm::BasicBlock *Cont = createBasicBlock("this.cont");
+  CreateTrapBB();
+  std::string tmpRule = "'this' refers to NULL!";
+  ATEI.setAll(0, 0, 0, Cont, tmpRule, 0);
+  llvm::Value *thisNull = llvm::Constant::getNullValue(CXXThisValue->getType());
+  Builder.CreateCondBr(Builder.CreateICmpEQ(CXXThisValue, thisNull), 
+                       getSoleTrapBB(), Cont);
+  EmitTrapBB();
+  EmitBlock(Cont);
+}
+
 llvm::Function *
 CodeGenFunction::GenerateBlockFunction(GlobalDecl GD,
                                        const CGBlockInfo &blockInfo,
diff -ura clang-2.9/lib/CodeGen/CGBuiltin.cpp clang/lib/CodeGen/CGBuiltin.cpp
--- clang-2.9/lib/CodeGen/CGBuiltin.cpp	2011-04-08 00:48:25.976444553 -0600
+++ clang/lib/CodeGen/CGBuiltin.cpp	2011-04-07 12:09:19.908444208 -0600
@@ -358,7 +358,7 @@
     return RValue::get(Builder.CreateCall(F));
   }
   case Builtin::BI__builtin_unreachable: {
-    if (CatchUndefined)
+    if ((catchArithUndefined()||catchNonArithUndefined()) && HaveInsertPoint())
       EmitBranch(getTrapBB());
     else
       Builder.CreateUnreachable();
diff -ura clang-2.9/lib/CodeGen/CGCall.cpp clang/lib/CodeGen/CGCall.cpp
--- clang-2.9/lib/CodeGen/CGCall.cpp	2011-04-08 00:48:25.980444365 -0600
+++ clang/lib/CodeGen/CGCall.cpp	2011-04-07 12:09:19.908444208 -0600
@@ -710,6 +710,8 @@
 
     if (TargetDecl->hasAttr<NoReturnAttr>())
       FuncAttrs |= llvm::Attribute::NoReturn;
+    if (TargetDecl->hasAttr<NoIntegerCheckAttr>())
+      FuncAttrs |= llvm::Attribute::NoIntegerCheck;
     if (TargetDecl->hasAttr<ConstAttr>())
       FuncAttrs |= llvm::Attribute::ReadNone;
     else if (TargetDecl->hasAttr<PureAttr>())
diff -ura clang-2.9/lib/CodeGen/CGExpr.cpp clang/lib/CodeGen/CGExpr.cpp
--- clang-2.9/lib/CodeGen/CGExpr.cpp	2011-04-08 00:48:25.980444365 -0600
+++ clang/lib/CodeGen/CGExpr.cpp	2011-04-07 17:21:07.460444361 -0600
@@ -23,6 +23,7 @@
 #include "llvm/Intrinsics.h"
 #include "clang/Frontend/CodeGenOptions.h"
 #include "llvm/Target/TargetData.h"
+#include "clang/Basic/SourceManager.h"
 using namespace clang;
 using namespace CodeGen;
 
@@ -393,7 +394,7 @@
 }
 
 void CodeGenFunction::EmitCheck(llvm::Value *Address, unsigned Size) {
-  if (!CatchUndefined)
+  if (!catchNonArithUndefined())
     return;
 
   // This needs to be to the standard address space.
@@ -405,15 +406,21 @@
   // In time, people may want to control this and use a 1 here.
   llvm::Value *Arg = Builder.getFalse();
   llvm::Value *C = Builder.CreateCall2(F, Address, Arg);
-  llvm::BasicBlock *Cont = createBasicBlock();
-  llvm::BasicBlock *Check = createBasicBlock();
+  llvm::BasicBlock *Cont = createBasicBlock("obj.cont");
+  llvm::BasicBlock *Check = createBasicBlock("obj.check");
   llvm::Value *NegativeOne = llvm::ConstantInt::get(IntPtrTy, -1ULL);
   Builder.CreateCondBr(Builder.CreateICmpEQ(C, NegativeOne), Cont, Check);
     
   EmitBlock(Check);
+  CreateTrapBB();
+  std::string tmpRule;
+  tmpRule = "An object has its stored value accessed by an lvalue ";
+  tmpRule += "of an allowable type!";
+  ATEI.setAll(0, 0, 0, Cont, tmpRule, 0);
   Builder.CreateCondBr(Builder.CreateICmpUGE(C,
                                         llvm::ConstantInt::get(IntPtrTy, Size)),
-                       Cont, getTrapBB());
+                       Cont, getSoleTrapBB());
+  EmitTrapBB();
   EmitBlock(Cont);
 }
 
@@ -493,9 +500,11 @@
 
 LValue CodeGenFunction::EmitCheckedLValue(const Expr *E) {
   LValue LV = EmitLValue(E);
-  if (!isa<DeclRefExpr>(E) && !LV.isBitField() && LV.isSimple())
+  if (!isa<DeclRefExpr>(E) && !LV.isBitField() && LV.isSimple()) {
+    NonArithSL = E->getExprLoc();
     EmitCheck(LV.getAddress(), 
               getContext().getTypeSizeInChars(E->getType()).getQuantity());
+  }
   return LV;
 }
 
@@ -1328,6 +1337,279 @@
   }
 }
 
+// 0(000): unsigned 8-bit integer ; 1(001): unsigned 16-bit integer 
+// 2(010): unsigned 32-bit integer ; 3(011): unsigned 64-bit integer 
+// 4(100): signed 8-bit integer ; 5(101): signed 16-bit integer 
+// 6(110): signed 32-bit integer ; 7(111): signed 64-bit integer 
+// 8: float ; 9: double ; 10: Unrecognized type
+static unsigned checkValueType(QualType opType, const llvm::Value *value) {
+  unsigned valueTy = 15;
+  if (value) {
+    if (opType->isIntegerType()) {
+      if (opType->isSignedIntegerType()) {
+        if (value->getType()->isIntegerTy(8))
+          valueTy = 5;
+        if (value->getType()->isIntegerTy(16))
+          valueTy = 6;
+        if (value->getType()->isIntegerTy(32))
+          valueTy = 7;
+        if (value->getType()->isIntegerTy(64))
+          valueTy = 8;
+        if (value->getType()->getScalarSizeInBits() > 64)
+          valueTy = 9;
+      }
+      else {
+        if (value->getType()->isIntegerTy(8))
+          valueTy = 0;
+        if (value->getType()->isIntegerTy(16))  
+          valueTy = 1;
+        if (value->getType()->isIntegerTy(32))
+          valueTy = 2;
+        if (value->getType()->isIntegerTy(64))  
+          valueTy = 3;
+        if (value->getType()->getScalarSizeInBits() > 64)
+          valueTy = 4;
+      }
+    }
+    else {
+      // Except the integer type, only float type left...
+      if (value->getType()->isFloatTy())
+        valueTy = 10;
+      if (value->getType()->isDoubleTy())
+        valueTy = 11;
+      if (value->getType()->getScalarSizeInBits() > 64)
+        valueTy = 12;
+    }
+  }
+  return valueTy;
+}
+
+bool CodeGenFunction::catchArithUndefined() const{
+   return (!CurFuncDecl || !(CurFuncDecl->hasAttr<NoIntegerCheckAttr>()))
+          && ((CatchUndefined == true) ||
+             (CatchUndefinedAnsiC == true) ||
+                (CatchUndefinedC99 == true) ||
+                    (CatchUndefinedCXX0X == true) ||
+                       (CatchUndefinedCXX98 == true));
+}
+
+bool CodeGenFunction::catchNonArithUndefined() const {
+   return (!CurFuncDecl || !(CurFuncDecl->hasAttr<NoIntegerCheckAttr>()))
+          && ((CatchUndefined == true) ||
+              (CatchNonArithUndefined == true));
+}
+
+// get the trap handler function, and return a value dumped by
+// __ub_trap_handler...
+void CodeGenFunction::invokeTrapHandlerFunction() {
+  const char *fileName;
+  unsigned int line = 0;
+  unsigned int column = 0;
+  const BinaryOperator *BOP = 0;
+  const UnaryOperator *UOP = 0;
+  const char *opcodeStr;
+  clang::SourceLocation SL;
+
+  if (ATEI.getOp()) {
+    if (isa<BinaryOperator>(ATEI.getOp())) {
+      BOP = cast<BinaryOperator>(ATEI.getOp()); 
+      opcodeStr = clang::BinaryOperator::getOpcodeStr(BOP->getOpcode());
+      SL = BOP->getOperatorLoc();
+    }
+    else {
+      UOP = cast<UnaryOperator>(ATEI.getOp()); 
+      opcodeStr = clang::UnaryOperator::getOpcodeStr(UOP->getOpcode());
+      SL = UOP->getOperatorLoc();
+    }
+  }
+  else {
+    // For non-arithmetic operation, opcodeStr is unnecessary, 
+    // use "no opstr" instead...
+    opcodeStr = "no opstr"; 
+    SL = NonArithSL;
+  }
+
+  if (!SL.isValid()) {
+    fileName = "unknown file name";
+    line = 0;
+    column = 0;
+  }
+  else {
+    SourceManager &SM = getContext().getSourceManager();
+    PresumedLoc PLoc = SM.getPresumedLoc(SL);
+
+    if (PLoc.isValid()) {
+      fileName = PLoc.getFilename();
+      line = PLoc.getLine();
+      column = PLoc.getColumn();
+    }
+    else {
+      fileName = "unknown file name";
+      line = 0;
+      column = 0;
+    }
+  }
+  // File name argument  
+  llvm::Value *fileNameArg = Builder.CreateGlobalStringPtr(fileName);
+  // Operator code argument  
+  llvm::Value *opStrArg = Builder.CreateGlobalStringPtr(opcodeStr);
+  // Rule argument
+  llvm::Value *ruleStrArg = Builder.CreateGlobalStringPtr(
+                                              ATEI.getRule().data());
+
+  std::vector<const llvm::Type*> handlerArgTypes;
+  const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(getLLVMContext());
+  handlerArgTypes.push_back(Int32Ty);
+  handlerArgTypes.push_back(Int32Ty);
+  handlerArgTypes.push_back(Int8PtrTy);
+  handlerArgTypes.push_back(Int8PtrTy);
+  handlerArgTypes.push_back(Int8PtrTy);
+  handlerArgTypes.push_back(Int8Ty);
+  handlerArgTypes.push_back(Int8Ty);
+  handlerArgTypes.push_back(Int8Ty);
+  handlerArgTypes.push_back(Int8Ty);
+  // two unsigned 64-bits integer 
+  // as types of left and right operands...
+  handlerArgTypes.push_back(Int64Ty);
+  handlerArgTypes.push_back(Int64Ty);
+
+  // The function type of trap handler...
+  llvm::FunctionType *handlerTy = 
+	llvm::FunctionType::get(Int64Ty, handlerArgTypes, false);
+  llvm::PointerType *unqualPtrType = llvm::PointerType::getUnqual(handlerTy);
+  llvm::Value *handlerFunction = 
+	CGM.getModule().getOrInsertGlobal("__ub_trap_handler", unqualPtrType);
+  handlerFunction = Builder.CreateLoad(handlerFunction);
+
+  std::vector<llvm::Value*> handlerArgValues;
+  handlerArgValues.push_back(llvm::ConstantInt::get(Int32Ty, line));
+  handlerArgValues.push_back(llvm::ConstantInt::get(Int32Ty, column));
+  handlerArgValues.push_back(fileNameArg);
+  handlerArgValues.push_back(opStrArg);
+  handlerArgValues.push_back(ruleStrArg);
+  handlerArgValues.push_back(llvm::ConstantInt::get(Int8Ty, ATEI.getMark()));
+
+  // exprMark determines how many operands are involved in.
+  // 3: Non-arithmetic operation; 
+  // 2: Binary arithmetic operation; 
+  // 1: Unary arithmetic operation 
+  unsigned exprMark;
+  unsigned lvalue_mark, rvalue_mark;
+  if (BOP) { 
+    exprMark = 2;
+    lvalue_mark = checkValueType(BOP->getType(), ATEI.getLValue());
+    rvalue_mark = checkValueType(BOP->getType(), ATEI.getRValue());
+  }
+  else if (UOP) {
+    exprMark = 1; 
+    lvalue_mark = checkValueType(UOP->getType(), ATEI.getLValue()); 
+    rvalue_mark = checkValueType(UOP->getType(), ATEI.getRValue()); 
+  }
+  else {
+    exprMark = 3;
+    lvalue_mark = 6; 
+    rvalue_mark = 6; 
+  }
+  handlerArgValues.push_back(llvm::ConstantInt::get(Int8Ty, exprMark));
+  handlerArgValues.push_back(llvm::ConstantInt::get(Int8Ty, lvalue_mark));
+  handlerArgValues.push_back(llvm::ConstantInt::get(Int8Ty, rvalue_mark));
+     
+  for (unsigned LRSwitch = 0; LRSwitch < 2; LRSwitch++) { 
+    if ((LRSwitch == 0)? ATEI.getLValue() : ATEI.getRValue()) {
+      switch ((LRSwitch == 0)? lvalue_mark : rvalue_mark) { 
+      case 0:
+      case 1:
+      case 2:
+      case 3:
+        handlerArgValues.push_back(Builder.CreateZExt(
+                         (LRSwitch == 0)? ATEI.getLValue() : ATEI.getRValue(),
+                         Int64Ty));
+        break;
+      case 5:
+      case 6:
+      case 7:
+      case 8:
+        handlerArgValues.push_back(Builder.CreateSExt(
+                         (LRSwitch == 0)? ATEI.getLValue() : ATEI.getRValue(),
+                         Int64Ty));
+        break;
+      case 4:
+      case 9:
+        handlerArgValues.push_back(Builder.CreateTrunc(
+                         (LRSwitch == 0)? ATEI.getLValue() : ATEI.getRValue(),
+                         Int64Ty));
+        break;
+      case 10:
+      case 11:
+      case 12:
+        handlerArgValues.push_back(Builder.CreateFPToUI(
+                         (LRSwitch == 0)? ATEI.getLValue() : ATEI.getRValue(),
+                         Int64Ty));
+        break;
+      default:
+        // Except for the integer, float, double types, seems 
+        // there exist no other types for simple scalar arithmetic 
+        // operations. If there are, just use the zero to represent them.
+        handlerArgValues.push_back(llvm::ConstantInt::get(Int64Ty, 0, true));
+        break;
+      }
+    }
+    else {
+      handlerArgValues.push_back(llvm::ConstantInt::get(Int64Ty, 0, true));
+    }
+  }
+   
+  // Execute the concrete trap handler...
+  trapHandlerResult = Builder.CreateCall(handlerFunction, 
+					 handlerArgValues.begin(), 
+					 handlerArgValues.end());
+  if (rvOpTy && HandlerProvidesValue) {
+    if (rvOpTy->isIntegerTy()) {
+      // interger type...
+      if (rvOpTy->getScalarSizeInBits() <= 64)
+        trapHandlerResult = Builder.CreateTrunc(trapHandlerResult, rvOpTy);
+      else {
+        // is that possible?? 
+        trapHandlerResult = Builder.CreateZExt(trapHandlerResult, rvOpTy);
+      }
+    }
+    else {
+      trapHandlerResult = Builder.CreateUIToFP(trapHandlerResult, rvOpTy);
+    }
+  }
+}
+
+void CodeGenFunction::CreateTrapBB() {
+  TrapBB = createBasicBlock("trap");
+}
+
+llvm::BasicBlock *CodeGenFunction::getSoleTrapBB() {
+  assert(TrapBB && "TrapBB in getSoleTrapBB is NULL!");
+  return TrapBB; 
+}
+
+void CodeGenFunction::EmitTrapBB() {
+  assert(TrapBB && "TrapBB in EmitTrapBB is NULL!");
+  EmitBlock(TrapBB);
+
+  if(ChecksNum) {
+     llvm::outs() << "The total number of instrumented checks:" 
+                  << CGM.getChecksNum() << "\n";
+  }
+
+  // Invoke the trap handler function...
+  // Unnecessary to get the returned value
+  invokeTrapHandlerFunction();
+
+  if (ATEI.getTrapNextBB()) {
+     EmitBranch(ATEI.getTrapNextBB());
+     ATEI.clearAll(); 
+  }
+  else {
+     Builder.CreateUnreachable();
+  }
+}
+
 llvm::BasicBlock *CodeGenFunction::getTrapBB() {
   const CodeGenOptions &GCO = CGM.getCodeGenOpts();
 
@@ -1395,17 +1677,25 @@
     Idx = Builder.CreateIntCast(Idx, IntPtrTy, IdxSigned, "idxprom");
   
   // FIXME: As llvm implements the object size checking, this can come out.
-  if (CatchUndefined) {
+  if (catchNonArithUndefined()) {
     if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E->getBase())){
       if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) {
         if (ICE->getCastKind() == CK_ArrayToPointerDecay) {
           if (const ConstantArrayType *CAT
               = getContext().getAsConstantArrayType(DRE->getType())) {
             llvm::APInt Size = CAT->getSize();
-            llvm::BasicBlock *Cont = createBasicBlock("cont");
+            CreateTrapBB();
+            llvm::BasicBlock *Cont = createBasicBlock("array.cont");
+            std::string str;
+            llvm::raw_string_ostream os(str);
+            os << "The current index is greater than array size: " 
+                                                      << Size.getZExtValue();
+            NonArithSL = E->getExprLoc();
+            ATEI.setAll(0, 0, 0, Cont, os.str(), 0);
             Builder.CreateCondBr(Builder.CreateICmpULE(Idx,
                                   llvm::ConstantInt::get(Idx->getType(), Size)),
-                                 Cont, getTrapBB());
+                                 Cont, getSoleTrapBB());
+            EmitTrapBB();
             EmitBlock(Cont);
           }
         }
diff -ura clang-2.9/lib/CodeGen/CGExprCXX.cpp clang/lib/CodeGen/CGExprCXX.cpp
--- clang-2.9/lib/CodeGen/CGExprCXX.cpp	2011-04-08 00:48:25.980444365 -0600
+++ clang/lib/CodeGen/CGExprCXX.cpp	2011-04-07 17:24:47.440444342 -0600
@@ -48,6 +48,22 @@
   EmitCallArgs(Args, FPT, ArgBeg, ArgEnd);
 
   QualType ResultType = FPT->getResultType();
+
+  if (catchNonArithUndefined()) {
+    llvm::BasicBlock *Cont = createBasicBlock("this.cont");
+    CreateTrapBB();
+    std::string str;
+    llvm::raw_string_ostream os(str);
+    os << "The object calling member function: " << MD->getNameAsString()
+       << " is NULL!";
+    ATEI.setAll(0, 0, 0, Cont, os.str(), 0);
+    llvm::Value *thisNull = llvm::Constant::getNullValue(This->getType());
+    Builder.CreateCondBr(Builder.CreateICmpEQ(This, thisNull), 
+                         getSoleTrapBB(), Cont);
+    EmitTrapBB();
+    EmitBlock(Cont);
+  }
+
   return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args,
                                                  FPT->getExtInfo()),
                   Callee, ReturnValue, Args, MD);
@@ -144,6 +160,7 @@
   if (isa<BinaryOperator>(CE->getCallee()->IgnoreParens())) 
     return EmitCXXMemberPointerCallExpr(CE, ReturnValue);
       
+  NonArithSL = CE->getExprLoc();
   const MemberExpr *ME = cast<MemberExpr>(CE->getCallee()->IgnoreParens());
   const CXXMethodDecl *MD = cast<CXXMethodDecl>(ME->getMemberDecl());
 
diff -ura clang-2.9/lib/CodeGen/CGExprScalar.cpp clang/lib/CodeGen/CGExprScalar.cpp
--- clang-2.9/lib/CodeGen/CGExprScalar.cpp	2011-04-08 00:48:25.984444262 -0600
+++ clang/lib/CodeGen/CGExprScalar.cpp	2011-04-07 17:08:22.840444475 -0600
@@ -30,6 +30,7 @@
 #include "llvm/Support/CFG.h"
 #include "llvm/Target/TargetData.h"
 #include <cstdarg>
+#include "clang/Basic/SourceManager.h"
 
 using namespace clang;
 using namespace CodeGen;
@@ -245,9 +246,6 @@
     return EmitLoadOfLValue(E);
   }
   Value *VisitObjCMessageExpr(ObjCMessageExpr *E) {
-    if (E->getMethodDecl() && 
-        E->getMethodDecl()->getResultType()->isReferenceType())
-      return EmitLoadOfLValue(E);
     return CGF.EmitObjCMessageExpr(E).getScalarVal();
   }
 
@@ -396,6 +394,12 @@
     if (Ops.Ty->hasSignedIntegerRepresentation()) {
       switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) {
       case LangOptions::SOB_Undefined:
+        if (CGF.catchArithUndefined()) {
+          if (CGF.UseIntrinsic)
+	    return UndefinedBehaviorOverflowCheck(Ops);
+          else
+            return UndefinedBehaviorMulCheck(Ops); 
+        }
         return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
       case LangOptions::SOB_Defined:
         return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
@@ -415,6 +419,15 @@
   /// Create a binary op that checks for overflow.
   /// Currently only supports +, - and *.
   Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops);
+  Value *getNormalAdditionValue(const BinOpInfo &Ops, unsigned addMark);
+  Value *UndefinedBehaviorAddCheck(const BinOpInfo &Ops, unsigned addMark);
+  Value *UndefinedBehaviorSubCheck(const BinOpInfo &Ops);
+  Value *UndefinedBehaviorMulCheck(const BinOpInfo &Ops);
+  Value *UndefinedBehaviorOverflowCheck(const BinOpInfo &Ops);
+  void UndefinedBehaviorDivAndRemCheck(const BinOpInfo &Ops, 
+                                       llvm::BasicBlock* normalBlock, 
+                                       llvm::BasicBlock* finalBlock, 
+                                       llvm::Value *Zero, bool isDiv);
   // Emit the overflow BB when -ftrapv option is activated. 
   void EmitOverflowBB(llvm::BasicBlock *overflowBB) {
     Builder.SetInsertPoint(overflowBB);
@@ -425,6 +438,7 @@
   // Check for undefined division and modulus behaviors.
   void EmitUndefinedBehaviorIntegerDivAndRemCheck(const BinOpInfo &Ops, 
                                                   llvm::Value *Zero,bool isDiv);
+
   Value *EmitDiv(const BinOpInfo &Ops);
   Value *EmitRem(const BinOpInfo &Ops);
   Value *EmitAdd(const BinOpInfo &Ops);
@@ -1237,7 +1251,23 @@
                                 llvm::Value *NextVal, bool IsInc) {
   switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) {
   case LangOptions::SOB_Undefined:
-    return Builder.CreateNSWAdd(InVal, NextVal, IsInc ? "inc" : "dec");
+    if (CGF.catchArithUndefined()) {
+      BinOpInfo BinOp;
+      BinOp.LHS = InVal;
+      BinOp.RHS = NextVal;
+      BinOp.Ty = E->getType();
+      BinOp.Opcode = BO_Add;
+      BinOp.E = E; 
+      if (CGF.UseIntrinsic) {
+        llvm::outs() << "Execute here!\n";
+        return UndefinedBehaviorOverflowCheck(BinOp);
+      }
+      else
+        return UndefinedBehaviorAddCheck(BinOp, IsInc ? 1 : 2);
+    }
+    else {
+      return Builder.CreateNSWAdd(InVal, NextVal, IsInc ? "inc" : "dec");
+    }
     break;
   case LangOptions::SOB_Defined:
     return Builder.CreateAdd(InVal, NextVal, IsInc ? "inc" : "dec");
@@ -1699,20 +1729,113 @@
   Builder.SetInsertPoint(contBB);
 }
 
-Value *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) {
-  if (isTrapvOverflowBehavior()) { 
-    llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
+void ScalarExprEmitter::UndefinedBehaviorDivAndRemCheck(
+                                         const BinOpInfo &Ops, 
+                                         llvm::BasicBlock* normalBlock,
+                                         llvm::BasicBlock* finalBlock, 
+                                         llvm::Value *Zero, bool isDiv) {
+  std::string tmpRule;
+  CGF.CreateTrapBB();
+  if (Ops.Ty->hasSignedIntegerRepresentation()) {
+    const llvm::IntegerType *Ty = cast<llvm::IntegerType>(Zero->getType());
+    llvm::Value *IntMin = 
+      llvm::ConstantInt::get(VMContext,
+                             llvm::APInt::getSignedMinValue(Ty->getBitWidth()));
+    llvm::Value *NegOne = llvm::ConstantInt::get(Ty, -1ULL);
 
-    if (Ops.Ty->isIntegerType())
-      EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, true);
+    if (isDiv) {
+      tmpRule = "Signed Division: Divisor is 0 ";
+      tmpRule += "|| dividend is INT_MIN, divisor is -1";
+    }
+    else {
+      tmpRule = "Signed Modulus: The second operand is 0 ";
+      tmpRule += "|| The first operand: INT_MIN, the second operand: -1";
+    }
+    CGF.ATEI.setAll(Ops.LHS, Ops.RHS, Ops.E, finalBlock, tmpRule, 0);
+    llvm::Value *Cond1 = Builder.CreateICmpEQ(Ops.RHS, Zero); 
+    llvm::Value *LHSCmp = Builder.CreateICmpEQ(Ops.LHS, IntMin);
+    llvm::Value *RHSCmp = Builder.CreateICmpEQ(Ops.RHS, NegOne);
+    llvm::Value *Cond2 = Builder.CreateAnd(LHSCmp, RHSCmp, "and");
+    CGF.Builder.CreateCondBr(Builder.CreateOr(Cond1, Cond2, "or"), 
+           	             CGF.getSoleTrapBB(), 
+                             CGF.HandlerProvidesValue? normalBlock : finalBlock);
+  }
+  else {
+    if (isDiv)
+      tmpRule = "Unsigned Division: Divisor is 0";
+    else
+      tmpRule = "Unsigned Modulus: The second operand is 0";
+    CGF.ATEI.setAll(Ops.LHS, Ops.RHS, Ops.E, finalBlock, tmpRule, 0);
+    CGF.Builder.CreateCondBr(Builder.CreateICmpEQ(Ops.RHS, Zero), 
+			     CGF.getSoleTrapBB(), 
+			     CGF.HandlerProvidesValue? normalBlock : finalBlock);
+  }
+  CGF.EmitTrapBB();
+}
+
+Value *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) {
+  if (CGF.catchArithUndefined() || isTrapvOverflowBehavior()) {
+    std::string tmpRule;
+    bool AddedCheck = false;
+    CGF.rvOpTy = ConvertType(Ops.Ty);
+    llvm::Value *Zero = llvm::Constant::getNullValue(CGF.rvOpTy);
+    llvm::BasicBlock *DivNormalEnd = CGF.createBasicBlock("div.norm");
+    llvm::BasicBlock *DivFinalEnd = CGF.createBasicBlock("div.final");
+
+    if (Ops.Ty->isIntegerType()) {
+      if (isTrapvOverflowBehavior())
+        EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, true);
+      else if (CGF.catchArithUndefined()) {
+        UndefinedBehaviorDivAndRemCheck(Ops, DivNormalEnd, 
+				        DivFinalEnd, Zero, true);
+        AddedCheck = true;
+      }
+    }
     else if (Ops.Ty->isRealFloatingType()) {
-      llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow",
-                                                          CGF.CurFn);
-      llvm::BasicBlock *DivCont = CGF.createBasicBlock("div.cont", CGF.CurFn);
-      CGF.Builder.CreateCondBr(Builder.CreateFCmpOEQ(Ops.RHS, Zero), 
-                               overflowBB, DivCont);
-      EmitOverflowBB(overflowBB);
-      Builder.SetInsertPoint(DivCont);
+      if (isTrapvOverflowBehavior()) {
+        llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow",
+                                                            CGF.CurFn);
+        llvm::BasicBlock *DivCont = CGF.createBasicBlock("div.cont", CGF.CurFn);
+        CGF.Builder.CreateCondBr(Builder.CreateFCmpOEQ(Ops.RHS, Zero), 
+                                 overflowBB, DivCont);
+        EmitOverflowBB(overflowBB);
+        Builder.SetInsertPoint(DivCont);
+      }
+      else if (CGF.catchArithUndefined()) {
+        CGF.CreateTrapBB();
+        tmpRule = "Floating Division: Divisor is 0";
+        CGF.ATEI.setAll(Ops.LHS, Ops.RHS, Ops.E, DivFinalEnd, tmpRule, 0);
+        CGF.Builder.CreateCondBr(Builder.CreateFCmpOEQ(Ops.RHS, Zero), 
+	  	                 CGF.getSoleTrapBB(), 
+			         CGF.HandlerProvidesValue? DivNormalEnd : DivFinalEnd);
+        CGF.EmitTrapBB();
+        AddedCheck = true;
+      }
+    }
+  
+    if (CGF.catchArithUndefined() && AddedCheck) {
+      llvm::Value *result = 0;
+      
+      if (CGF.HandlerProvidesValue) {
+        CGF.EmitBlock(DivNormalEnd);
+        if (Ops.LHS->getType()->isFPOrFPVectorTy())
+          result = Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div");
+        else if (Ops.Ty->hasUnsignedIntegerRepresentation())
+          result = Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div");
+        else
+          result = Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div");
+        CGF.EmitBranch(DivFinalEnd);
+      }
+
+      CGF.EmitBlock(DivFinalEnd);
+
+      if (CGF.HandlerProvidesValue) { 
+        llvm::PHINode *phi = Builder.CreatePHI(CGF.rvOpTy);
+        phi->reserveOperandSpace(2);
+        phi->addIncoming(CGF.trapHandlerResult, CGF.getSoleTrapBB());
+        phi->addIncoming(result, DivNormalEnd);
+        return phi;
+      }
     }
   }
   if (Ops.LHS->getType()->isFPOrFPVectorTy())
@@ -1725,11 +1848,44 @@
 
 Value *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) {
   // Rem in C can't be a floating point type: C99 6.5.5p2.
-  if (isTrapvOverflowBehavior()) {
-    llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
+  if (CGF.catchArithUndefined() || isTrapvOverflowBehavior()) { 
+    bool AddedCheck = false;
+    CGF.rvOpTy = ConvertType(Ops.Ty);
+    llvm::Value *Zero = llvm::Constant::getNullValue(CGF.rvOpTy);
+    llvm::BasicBlock *RemNormalEnd = CGF.createBasicBlock("rem.norm.end");
+    llvm::BasicBlock *RemFinalEnd = CGF.createBasicBlock("rem.final.end");
+
+    if (Ops.Ty->isIntegerType()){ 
+      if (isTrapvOverflowBehavior())
+        EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, false);
+      else if (CGF.catchArithUndefined()) {
+        UndefinedBehaviorDivAndRemCheck(Ops, RemNormalEnd, 
+                                        RemFinalEnd, Zero, true);
+        AddedCheck = true;
+      }
+    }
+  
+    if (CGF.catchArithUndefined() && AddedCheck) {
+      llvm::Value *result = 0;
+      if (CGF.HandlerProvidesValue) {
+        CGF.EmitBlock(RemNormalEnd);
+        if (Ops.Ty->isUnsignedIntegerType())
+          result = Builder.CreateURem(Ops.LHS, Ops.RHS, "rem");
+        else
+          result = Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem");
+        CGF.EmitBranch(RemFinalEnd);
+      }
+
+      CGF.EmitBlock(RemFinalEnd);
 
-    if (Ops.Ty->isIntegerType()) 
-      EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, false);
+      if (CGF.HandlerProvidesValue) { 
+        llvm::PHINode *phi = Builder.CreatePHI(CGF.rvOpTy);
+        phi->reserveOperandSpace(2);
+        phi->addIncoming(CGF.trapHandlerResult, CGF.getSoleTrapBB());
+        phi->addIncoming(result, RemNormalEnd);
+        return phi;
+      }
+    }
   }
 
   if (Ops.Ty->isUnsignedIntegerType())
@@ -1826,11 +1982,337 @@
   return phi;
 }
 
+Value *ScalarExprEmitter::UndefinedBehaviorOverflowCheck(const BinOpInfo &Ops) {
+  unsigned IID;
+  unsigned OpID = 0;
+  std::string tmpRule;
+
+  switch (Ops.Opcode) {
+  case BO_Add:
+  case BO_AddAssign:
+    OpID = 1;
+    tmpRule = "Signed Addition Overflow";
+    IID = llvm::Intrinsic::sadd_with_overflow;
+    break;
+  case BO_Sub:
+  case BO_SubAssign:
+    OpID = 2;
+    tmpRule = "Signed Subtraction Overflow";
+    IID = llvm::Intrinsic::ssub_with_overflow;
+    break;
+  case BO_Mul:
+  case BO_MulAssign:
+    OpID = 3;
+    tmpRule = "Signed Multiplication Overflow";
+    IID = llvm::Intrinsic::smul_with_overflow;
+    break;
+  default:
+    assert(false && "Unsupported operation for overflow detection");
+    IID = 0;
+  }
+  OpID <<= 1;
+  OpID |= 1;
+
+  const llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty);
+  CGF.rvOpTy = opTy;
+  llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, &opTy, 1);
+
+  llvm::Value *resultAndOverflow = Builder.CreateCall2(intrinsic, Ops.LHS, Ops.RHS);
+  llvm::Value *result = 0;
+  llvm::Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1);
+  llvm::BasicBlock *contNormalBB = CGF.createBasicBlock("overflow.norm.cont");
+  llvm::BasicBlock *contFinalBB = CGF.createBasicBlock("overflow.final.cont");
+
+  CGF.CreateTrapBB();
+  CGF.ATEI.setAll(Ops.LHS, Ops.RHS, Ops.E, contFinalBB, tmpRule, 0);
+  CGF.Builder.CreateCondBr(overflow, CGF.getSoleTrapBB(), 
+                           CGF.HandlerProvidesValue? contNormalBB : contFinalBB);
+  CGF.EmitTrapBB();
+
+  if (CGF.HandlerProvidesValue) {
+    CGF.EmitBlock(contNormalBB);
+    result = Builder.CreateExtractValue(resultAndOverflow, 0);
+    CGF.EmitBranch(contFinalBB);
+  }
+
+  CGF.EmitBlock(contFinalBB);
+
+  if (CGF.HandlerProvidesValue) {
+    llvm::PHINode *phi = Builder.CreatePHI(opTy);
+    phi->reserveOperandSpace(2);
+    phi->addIncoming(CGF.trapHandlerResult, CGF.getSoleTrapBB());
+    phi->addIncoming(result, contNormalBB);
+    return phi;
+  }
+  return Builder.CreateExtractValue(resultAndOverflow, 0);
+}
+
+Value *ScalarExprEmitter::getNormalAdditionValue(const BinOpInfo &Ops, 
+    						 unsigned addMark) {
+  llvm::Value *value = 0;
+  switch(addMark) {
+    case 0:
+      value = Builder.CreateNSWAdd(Ops.LHS, Ops.RHS, "add");
+      break;
+    case 1: 
+      value = Builder.CreateNSWAdd(Ops.LHS, Ops.RHS, "inc");
+      break;
+    case 2:
+      value = Builder.CreateNSWAdd(Ops.LHS, Ops.RHS, "dec");
+      break;
+  }
+  return value;
+}
+
+// (((si1>0) && (si2>0) && (si1 > (INT_MAX-si2))) 
+// || ((si1<0) && (si2<0) && (si1 < (INT_MIN-si2))))
+Value *ScalarExprEmitter::UndefinedBehaviorAddCheck(const BinOpInfo &Ops, 
+					            unsigned addMark) {
+  CGF.rvOpTy = ConvertType(Ops.Ty);
+  if (CGF.rvOpTy->isVectorTy()) {
+    return getNormalAdditionValue(Ops, addMark);
+  }
+  const llvm::IntegerType *Ty = cast<llvm::IntegerType>(CGF.rvOpTy);
+  llvm::Value *IntMax = llvm::ConstantInt::get(VMContext,
+                        llvm::APInt::getSignedMaxValue(Ty->getBitWidth()));
+  llvm::Value *IntMin = llvm::ConstantInt::get(VMContext,
+                        llvm::APInt::getSignedMinValue(Ty->getBitWidth()));
+
+  std::string tmpRule;
+  llvm::Value *Zero = llvm::Constant::getNullValue(CGF.rvOpTy);
+        
+  llvm::BasicBlock *TrueBB1 = CGF.createBasicBlock("add.true");
+  llvm::BasicBlock *FalseBB1 = CGF.createBasicBlock("add.false");
+  llvm::BasicBlock *AddNormalEnd = CGF.createBasicBlock("add.norm.end");
+  llvm::BasicBlock *AddFinalEnd = CGF.createBasicBlock("add.final.end");
+
+  CGF.Builder.CreateCondBr(Builder.CreateAnd(
+                             Builder.CreateICmpSGT(Ops.LHS, Zero), 
+                               Builder.CreateICmpSGT(Ops.RHS, Zero), "and"), 
+                           TrueBB1, FalseBB1);
+  CGF.EmitBlock(TrueBB1);
+
+  CGF.CreateTrapBB();
+  tmpRule = "Signed Addition Overflow";
+  CGF.ATEI.setAll(Ops.LHS, Ops.RHS, Ops.E, AddFinalEnd, tmpRule, 0);
+  CGF.Builder.CreateCondBr(Builder.CreateICmpSGT(Ops.LHS, 
+                             Builder.CreateNSWSub(IntMax, Ops.RHS, "sub")), 
+                           CGF.getSoleTrapBB(), 
+                           CGF.HandlerProvidesValue? AddNormalEnd : AddFinalEnd); 
+  CGF.EmitTrapBB();
+
+  CGF.EmitBlock(FalseBB1);
+  llvm::BasicBlock *TrueBB2 = CGF.createBasicBlock("add.true");
+  CGF.Builder.CreateCondBr(Builder.CreateAnd(
+                             Builder.CreateICmpSLT(Ops.LHS, Zero), 
+                               Builder.CreateICmpSLT(Ops.RHS, Zero), "and"), 
+                           TrueBB2, 
+                           CGF.HandlerProvidesValue? AddNormalEnd : AddFinalEnd); 
+
+  CGF.EmitBlock(TrueBB2);
+  CGF.Builder.CreateCondBr(Builder.CreateICmpSLT(Ops.LHS, 
+                             Builder.CreateNSWSub(IntMin, Ops.RHS, "sub")), 
+                           CGF.getSoleTrapBB(), 
+                           CGF.HandlerProvidesValue? AddNormalEnd : AddFinalEnd); 
+
+  llvm::Value * result = 0;
+  if (CGF.HandlerProvidesValue) {
+    CGF.EmitBlock(AddNormalEnd);
+    result = getNormalAdditionValue(Ops, addMark);
+    CGF.EmitBranch(AddFinalEnd);
+  }
+  
+  CGF.EmitBlock(AddFinalEnd);
+
+  if (CGF.HandlerProvidesValue) {
+    llvm::PHINode *phi = Builder.CreatePHI(CGF.rvOpTy);
+    phi->reserveOperandSpace(2);
+    phi->addIncoming(CGF.trapHandlerResult, CGF.getSoleTrapBB());
+    phi->addIncoming(result, AddNormalEnd);
+    return phi;
+  }
+  return getNormalAdditionValue(Ops, addMark);
+}
+
+// si2 < 0 ? si1 > INT_MAX + si2 : si1 < INT_MIN + si2
+Value *ScalarExprEmitter::UndefinedBehaviorSubCheck(const BinOpInfo &Ops) {
+  CGF.rvOpTy = ConvertType(Ops.Ty);
+  if (CGF.rvOpTy->isVectorTy()) {
+    return Builder.CreateNSWSub(Ops.LHS, Ops.RHS, "sub");
+  }
+  const llvm::IntegerType *Ty = cast<llvm::IntegerType>(CGF.rvOpTy);
+  llvm::Value *IntMax = llvm::ConstantInt::get(VMContext,
+                        llvm::APInt::getSignedMaxValue(Ty->getBitWidth()));
+  llvm::Value *IntMin = llvm::ConstantInt::get(VMContext,
+                        llvm::APInt::getSignedMinValue(Ty->getBitWidth()));
+
+  std::string tmpRule;
+  llvm::Value *Zero = llvm::Constant::getNullValue(CGF.rvOpTy);
+
+  llvm::BasicBlock *TrueBB1 = CGF.createBasicBlock("sub.true");
+  llvm::BasicBlock *FalseBB1 = CGF.createBasicBlock("sub.false");
+  llvm::BasicBlock *SubNormalEnd = CGF.createBasicBlock("sub.norm.end");
+  llvm::BasicBlock *SubFinalEnd = CGF.createBasicBlock("sub.final.end");
+
+  CGF.Builder.CreateCondBr(Builder.CreateICmpSLT(Ops.RHS, Zero), 
+                           TrueBB1, FalseBB1);
+  CGF.EmitBlock(TrueBB1);
+
+  CGF.CreateTrapBB();
+  tmpRule = "Signed Subtraction Overflow";
+  CGF.ATEI.setAll(Ops.LHS, Ops.RHS, Ops.E, SubFinalEnd, tmpRule, 0);
+  CGF.Builder.CreateCondBr(Builder.CreateICmpSGT(Ops.LHS, 
+                             Builder.CreateNSWAdd(IntMax, Ops.RHS, "add")), 
+                           CGF.getSoleTrapBB(), 
+                           CGF.HandlerProvidesValue? SubNormalEnd : SubFinalEnd);  
+  CGF.EmitTrapBB();
+
+  CGF.EmitBlock(FalseBB1);  
+  llvm::BasicBlock *TrueBB2 = CGF.createBasicBlock("sub.true");
+  CGF.Builder.CreateCondBr(Builder.CreateICmpSGT(Ops.RHS, Zero), 
+                           TrueBB2, 
+                           CGF.HandlerProvidesValue? SubNormalEnd : SubFinalEnd);
+
+  CGF.EmitBlock(TrueBB2);
+  CGF.Builder.CreateCondBr(Builder.CreateICmpSLT(Ops.LHS, 
+                             Builder.CreateNSWAdd(IntMin, Ops.RHS, "add")), 
+                           CGF.getSoleTrapBB(), 
+                           CGF.HandlerProvidesValue? SubNormalEnd : SubFinalEnd);  
+
+  llvm::Value *result = 0;
+  if (CGF.HandlerProvidesValue) {
+    CGF.EmitBlock(SubNormalEnd);
+    result = Builder.CreateNSWSub(Ops.LHS, Ops.RHS, "sub");
+    CGF.EmitBranch(SubFinalEnd);
+  }
+
+  CGF.EmitBlock(SubFinalEnd);
+
+  if (CGF.HandlerProvidesValue) {
+    llvm::PHINode *phi = Builder.CreatePHI(CGF.rvOpTy);
+    phi->reserveOperandSpace(2);
+    phi->addIncoming(CGF.trapHandlerResult, CGF.getSoleTrapBB());
+    phi->addIncoming(result, SubNormalEnd);
+    return phi;
+  }
+  return Builder.CreateNSWSub(Ops.LHS, Ops.RHS, "sub");
+}
+
+// (((si1 > 0) && (si2 > 0) && (si1 > (INT_MAX / si2))) 
+// || ((si1 > 0) && (si2 <= 0) && (si2 < (INT_MIN / si1))) 
+// || ((si1 <= 0) && (si2 > 0) && (si1 < (INT_MIN / si2))) 
+// || ((si1 <= 0) && (si2 <= 0) && (si1 != 0) && (si2 < (INT_MAX / si1))))
+Value *ScalarExprEmitter::UndefinedBehaviorMulCheck(const BinOpInfo &Ops) {
+  CGF.rvOpTy = ConvertType(Ops.Ty);
+  if (CGF.rvOpTy->isVectorTy()) {
+    return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
+  }
+  const llvm::IntegerType *Ty = cast<llvm::IntegerType>(CGF.rvOpTy);
+  llvm::Value *IntMax = llvm::ConstantInt::get(VMContext,
+                        llvm::APInt::getSignedMaxValue(Ty->getBitWidth()));
+  llvm::Value *IntMin = llvm::ConstantInt::get(VMContext,
+                        llvm::APInt::getSignedMinValue(Ty->getBitWidth()));
+
+  std::string tmpRule;
+  llvm::Value *Zero = llvm::Constant::getNullValue(CGF.rvOpTy);
+  
+  // Cond1: (si1 > 0) && (si2 > 0) && (si1 > (INT_MAX / si2))
+  llvm::BasicBlock *TrueBB1 = CGF.createBasicBlock("mul.true");
+  llvm::BasicBlock *FalseBB1 = CGF.createBasicBlock("mul.false");
+  llvm::BasicBlock *MulNormalEnd = CGF.createBasicBlock("mul.norm.end");
+  llvm::BasicBlock *MulFinalEnd = CGF.createBasicBlock("mul.final.end");
+
+  CGF.Builder.CreateCondBr(Builder.CreateAnd(
+                             Builder.CreateICmpSGT(Ops.LHS, Zero), 
+                               Builder.CreateICmpSGT(Ops.RHS, Zero), "and"),
+                           TrueBB1, FalseBB1);
+  CGF.EmitBlock(TrueBB1);
+  CGF.CreateTrapBB();
+  tmpRule = "Signed Multiplication Overflow";
+  CGF.ATEI.setAll(Ops.LHS, Ops.RHS, Ops.E, MulFinalEnd, tmpRule, 0);
+  CGF.Builder.CreateCondBr(Builder.CreateICmpSGT(Ops.LHS, 
+                             Builder.CreateSDiv(IntMax, Ops.RHS, "div")), 
+                           CGF.getSoleTrapBB(), 
+                           CGF.HandlerProvidesValue? MulNormalEnd : MulFinalEnd);
+  CGF.EmitTrapBB();
+
+  CGF.EmitBlock(FalseBB1);
+  // Cond2: (si1 > 0) && (si2 < 0) && (si2 < (INT_MIN / si1)) 
+  llvm::BasicBlock *TrueBB2 = CGF.createBasicBlock("mul.true");
+  llvm::BasicBlock *FalseBB2 = CGF.createBasicBlock("mul.false");
+
+  CGF.Builder.CreateCondBr(Builder.CreateAnd(
+                             Builder.CreateICmpSGT(Ops.LHS, Zero), 
+                               Builder.CreateICmpSLT(Ops.RHS, Zero), "and"), 
+                           TrueBB2, FalseBB2);
+
+  CGF.EmitBlock(TrueBB2);
+  CGF.Builder.CreateCondBr(Builder.CreateICmpSLT(Ops.RHS,
+                             Builder.CreateSDiv(IntMin, Ops.LHS, "div")), 
+                           CGF.getSoleTrapBB(), 
+                           CGF.HandlerProvidesValue? MulNormalEnd : MulFinalEnd);
+
+  CGF.EmitBlock(FalseBB2);
+  // Cond3: (si1 < 0) && (si2 > 0) && (si1 < (INT_MIN / si2)) 
+  llvm::BasicBlock *TrueBB3 = CGF.createBasicBlock("mul.true");
+  llvm::BasicBlock *FalseBB3 = CGF.createBasicBlock("mul.false");
+
+  CGF.Builder.CreateCondBr(Builder.CreateAnd(
+                             Builder.CreateICmpSLT(Ops.LHS, Zero), 
+                               Builder.CreateICmpSGT(Ops.RHS, Zero), "and"), 
+			   TrueBB3, FalseBB3);
+
+  CGF.EmitBlock(TrueBB3);
+  CGF.Builder.CreateCondBr(Builder.CreateICmpSLT(Ops.LHS, 
+                             Builder.CreateSDiv(IntMin, Ops.RHS, "div")), 
+			     CGF.getSoleTrapBB(), 
+			     CGF.HandlerProvidesValue? MulNormalEnd : MulFinalEnd);
+
+  CGF.EmitBlock(FalseBB3);
+  // Cond4: (si1 < 0) && (si2 < 0) && (si2 < (INT_MAX / si1)) 
+  llvm::BasicBlock *TrueBB4 = CGF.createBasicBlock("mul.true");
+
+  CGF.Builder.CreateCondBr(Builder.CreateAnd(
+                             Builder.CreateICmpSLT(Ops.LHS, Zero), 
+                               Builder.CreateICmpSLT(Ops.RHS, Zero), "and"), 
+                           TrueBB4, 
+                           CGF.HandlerProvidesValue? MulNormalEnd : MulFinalEnd);
+
+  CGF.EmitBlock(TrueBB4);
+  CGF.Builder.CreateCondBr(Builder.CreateICmpSLT(Ops.RHS, 
+                             Builder.CreateSDiv(IntMax, Ops.LHS, "div")), 
+                           CGF.getSoleTrapBB(), 
+                           CGF.HandlerProvidesValue? MulNormalEnd : MulFinalEnd);
+
+  llvm::Value *result = 0;
+  if (CGF.HandlerProvidesValue) {
+    CGF.EmitBlock(MulNormalEnd);
+    result = Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
+    CGF.EmitBranch(MulFinalEnd);
+  }
+  CGF.EmitBlock(MulFinalEnd);
+
+  if (CGF.HandlerProvidesValue) { 
+    llvm::PHINode *phi = Builder.CreatePHI(CGF.rvOpTy);
+    phi->reserveOperandSpace(2);
+    phi->addIncoming(CGF.trapHandlerResult, CGF.getSoleTrapBB());
+    phi->addIncoming(result, MulNormalEnd);
+    return phi;
+  }
+  return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
+}
+
 Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) {
   if (!Ops.Ty->isAnyPointerType()) {
     if (Ops.Ty->hasSignedIntegerRepresentation()) {
       switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) {
-      case LangOptions::SOB_Undefined:
+      case LangOptions::SOB_Undefined: 
+        if (CGF.catchArithUndefined()) {
+          if (CGF.UseIntrinsic)
+            return UndefinedBehaviorOverflowCheck(Ops);
+          else
+            return UndefinedBehaviorAddCheck(Ops, 0); 
+        }
         return Builder.CreateNSWAdd(Ops.LHS, Ops.RHS, "add");
       case LangOptions::SOB_Defined:
         return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add");
@@ -1916,6 +2398,12 @@
     if (Ops.Ty->hasSignedIntegerRepresentation()) {
       switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) {
       case LangOptions::SOB_Undefined:
+        if (CGF.catchArithUndefined()) {
+          if (CGF.UseIntrinsic)
+	    return UndefinedBehaviorOverflowCheck(Ops);
+          else
+            return UndefinedBehaviorSubCheck(Ops); 
+        }
         return Builder.CreateNSWSub(Ops.LHS, Ops.RHS, "sub");
       case LangOptions::SOB_Defined:
         return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub");
@@ -2025,14 +2513,95 @@
   if (Ops.LHS->getType() != RHS->getType())
     RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
 
-  if (CGF.CatchUndefined 
+  if (CGF.catchArithUndefined() 
       && isa<llvm::IntegerType>(Ops.LHS->getType())) {
+    std::string tmpRule;
     unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth();
-    llvm::BasicBlock *Cont = CGF.createBasicBlock("cont");
+    bool Continue = Ops.Ty->isSignedIntegerType() 
+                      && (CGF.CatchUndefinedC99 || CGF.CatchUndefinedCXX0X
+                         || CGF.CatchUndefined);
+    llvm::Value *tmpTrapResult = 0;
+    llvm::BasicBlock *tmpTrapBB = 0;
+    llvm::BasicBlock *ShlCont1 = CGF.createBasicBlock("shl.cont");
+    llvm::BasicBlock *ShlNonNormalEnd = 
+                                CGF.createBasicBlock("shl.non.norm.end");
+    llvm::BasicBlock *ShlNormalEnd = CGF.createBasicBlock("shl.norm.end");
+    llvm::BasicBlock *ShlFinalEnd = CGF.createBasicBlock("shl.final.end");
+    CGF.rvOpTy = ConvertType(Ops.Ty);
+
+    CGF.CreateTrapBB();
+    // The type of left shift result is that of the promoted left operand...
+    if (Ops.Ty->isSignedIntegerType()) {
+      tmpRule = "Signed Left Shift: Right operand is negative or is greater";
+      tmpRule += " than or equal to the width of the promoted left operand";
+    }
+    else {
+      tmpRule = "Unsigned Left Shift: Right operand is negative or is greater";
+      tmpRule += " than or equal to the width of the promoted left operand";
+    }
+    if (CGF.HandlerProvidesValue)
+      CGF.ATEI.setAll(Ops.LHS, RHS, Ops.E, 	
+                      Continue? ShlNonNormalEnd : ShlFinalEnd, tmpRule, 0);
+    else
+      CGF.ATEI.setAll(Ops.LHS, RHS, Ops.E, ShlCont1, tmpRule, 0);
     CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS,
                                  llvm::ConstantInt::get(RHS->getType(), Width)),
-                             Cont, CGF.getTrapBB());
-    CGF.EmitBlock(Cont);
+                             ShlCont1, CGF.getSoleTrapBB());
+    CGF.EmitTrapBB();
+    tmpTrapResult = CGF.trapHandlerResult;
+    tmpTrapBB = CGF.getSoleTrapBB();
+    CGF.EmitBlock(ShlCont1);
+    
+    if (Continue) {
+      const llvm::IntegerType *Ty = cast<llvm::IntegerType>(CGF.rvOpTy);
+      llvm::Value *IntMax = llvm::ConstantInt::get(VMContext,
+                            llvm::APInt::getSignedMaxValue(Ty->getBitWidth()));
+      
+      // Here, we can directly execute the instruction "Int_Max >> right"
+      // without checking whether right operand is greater than the 
+      // width of left operand type due to previous checks.
+      llvm::Value *ResValue = Builder.CreateAShr(IntMax, RHS, "shr"); 
+      llvm::BasicBlock *ShlCont2 = CGF.createBasicBlock("shl.cont");
+      CGF.CreateTrapBB();
+      tmpRule = "Signed Left Shift: left operand is negative || ";
+      tmpRule += "left operand is nonnegative, ";
+      tmpRule += "but the result can not be represented in the result ";
+      tmpRule += "signed type";
+      CGF.ATEI.setAll(Ops.LHS, RHS, Ops.E,
+                      CGF.HandlerProvidesValue? ShlNonNormalEnd : ShlCont2, tmpRule, 0);
+      CGF.Builder.CreateCondBr(Builder.CreateICmpUGT(Ops.LHS, ResValue), 
+                               CGF.getSoleTrapBB(), ShlCont2);
+      CGF.EmitTrapBB();
+      CGF.EmitBlock(ShlCont2);
+    }
+
+    if (CGF.HandlerProvidesValue) {
+      CGF.EmitBlock(ShlNormalEnd);
+      llvm::Value *result = Builder.CreateShl(Ops.LHS, RHS, "shl");   
+      llvm::PHINode *tmpphi = 0;
+      llvm::PHINode *finalPHI = 0;
+      CGF.EmitBranch(ShlFinalEnd);
+
+      if (Continue) {
+        CGF.EmitBlock(ShlNonNormalEnd);
+        tmpphi = Builder.CreatePHI(CGF.rvOpTy);
+        tmpphi->reserveOperandSpace(2);
+        tmpphi->addIncoming(tmpTrapResult, tmpTrapBB);
+        tmpphi->addIncoming(CGF.trapHandlerResult, CGF.getSoleTrapBB());
+        CGF.EmitBranch(ShlFinalEnd);
+      }
+
+      CGF.EmitBlock(ShlFinalEnd);
+
+      finalPHI = Builder.CreatePHI(CGF.rvOpTy);
+      finalPHI->reserveOperandSpace(2);
+      if (Continue)
+        finalPHI->addIncoming(tmpphi, ShlNonNormalEnd);
+      else
+        finalPHI->addIncoming(CGF.trapHandlerResult, CGF.getSoleTrapBB());
+      finalPHI->addIncoming(result, ShlNormalEnd);
+      return finalPHI;
+    }
   }
 
   return Builder.CreateShl(Ops.LHS, RHS, "shl");
@@ -2045,14 +2614,50 @@
   if (Ops.LHS->getType() != RHS->getType())
     RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
 
-  if (CGF.CatchUndefined 
+  if (CGF.catchArithUndefined() 
       && isa<llvm::IntegerType>(Ops.LHS->getType())) {
+    std::string tmpRule;
     unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth();
-    llvm::BasicBlock *Cont = CGF.createBasicBlock("cont");
+    CGF.rvOpTy = ConvertType(Ops.Ty);
+    llvm::BasicBlock *ShrNormalEnd = CGF.createBasicBlock("shr.norm.cont");
+    llvm::BasicBlock *ShrFinalEnd = CGF.createBasicBlock("shr.final.cont");
+
+    CGF.CreateTrapBB();
+    // Since the type of the result is that of the promoted left operand...
+    if (Ops.Ty->isSignedIntegerType()) {
+      tmpRule = "Signed Right Shift: Right operand is negative or is greater";
+      tmpRule += " than or equal to the width of the promoted left operand";
+    }
+    else {
+      tmpRule = "Unsigned Right Shift: Right operand is negative or is greater";
+      tmpRule += " than or equal to the width of the promoted left operand";
+    }
+    CGF.ATEI.setAll(Ops.LHS, RHS, Ops.E, ShrFinalEnd, tmpRule, 0);
     CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS,
-                                 llvm::ConstantInt::get(RHS->getType(), Width)),
-                             Cont, CGF.getTrapBB());
-    CGF.EmitBlock(Cont);
+                               llvm::ConstantInt::get(RHS->getType(), Width)),
+                             CGF.HandlerProvidesValue? ShrNormalEnd : ShrFinalEnd, 
+                             CGF.getSoleTrapBB());
+    CGF.EmitTrapBB();
+
+    llvm::Value *result = 0;
+    if (CGF.HandlerProvidesValue) {
+      CGF.EmitBlock(ShrNormalEnd);
+      if (Ops.Ty->hasUnsignedIntegerRepresentation())
+        result = Builder.CreateLShr(Ops.LHS, RHS, "shr");
+      else
+        result = Builder.CreateAShr(Ops.LHS, RHS, "shr");
+      CGF.EmitBranch(ShrFinalEnd);
+    }
+
+    CGF.EmitBlock(ShrFinalEnd);
+
+    if (CGF.HandlerProvidesValue) {
+      llvm::PHINode *phi = Builder.CreatePHI(CGF.rvOpTy);
+      phi->reserveOperandSpace(2);
+      phi->addIncoming(CGF.trapHandlerResult, CGF.getSoleTrapBB());
+      phi->addIncoming(result, ShrNormalEnd);
+      return phi;
+    }
   }
 
   if (Ops.Ty->hasUnsignedIntegerRepresentation())
diff -ura clang-2.9/lib/CodeGen/CodeGenFunction.cpp clang/lib/CodeGen/CodeGenFunction.cpp
--- clang-2.9/lib/CodeGen/CodeGenFunction.cpp	2011-04-08 00:48:25.984444262 -0600
+++ clang/lib/CodeGen/CodeGenFunction.cpp	2011-04-07 12:09:19.876444258 -0600
@@ -38,9 +38,28 @@
     DidCallStackSave(false), UnreachableBlock(0),
     CXXThisDecl(0), CXXThisValue(0), CXXVTTDecl(0), CXXVTTValue(0),
     OutermostConditional(0), TerminateLandingPad(0), TerminateHandler(0),
-    TrapBB(0) {
+    TrapBB(0), ATEI(), NonArithSL() {
+  // Get some frequently used types.
+  LLVMPointerWidth = Target.getPointerWidth(0);
+  llvm::LLVMContext &LLVMContext = CGM.getLLVMContext();
+  rvOpTy = 0;
+  trapHandlerResult = 0;
+  IntPtrTy = llvm::IntegerType::get(LLVMContext, LLVMPointerWidth);
+  Int8Ty  = llvm::Type::getInt8Ty(LLVMContext);
+  Int32Ty  = llvm::Type::getInt32Ty(LLVMContext);
+  Int64Ty  = llvm::Type::getInt64Ty(LLVMContext);
+      
+  Exceptions = getContext().getLangOptions().Exceptions;
 
   CatchUndefined = getContext().getLangOptions().CatchUndefined;
+  CatchUndefinedAnsiC = getContext().getLangOptions().CatchUndefinedAnsiC;
+  CatchUndefinedC99 = getContext().getLangOptions().CatchUndefinedC99;
+  CatchUndefinedCXX0X = getContext().getLangOptions().CatchUndefinedCXX0X;
+  CatchUndefinedCXX98 = getContext().getLangOptions().CatchUndefinedCXX98;
+  CatchNonArithUndefined = getContext().getLangOptions().CatchNonArithUndefined;
+  UseIntrinsic = getContext().getLangOptions().UseIntrinsic;
+  HandlerProvidesValue = getContext().getLangOptions().HandlerProvidesValue; 
+  ChecksNum = getContext().getLangOptions().ChecksNum; 
   CGM.getCXXABI().getMangleContext().startNewFunction();
 }
 
@@ -295,6 +314,7 @@
   EmitStartEHSpec(CurCodeDecl);
   EmitFunctionProlog(*CurFnInfo, CurFn, Args);
 
+  NonArithSL = StartLoc;
   if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance())
     CGM.getCXXABI().EmitInstanceFunctionProlog(*this);
 
diff -ura clang-2.9/lib/CodeGen/CodeGenFunction.h clang/lib/CodeGen/CodeGenFunction.h
--- clang-2.9/lib/CodeGen/CodeGenFunction.h	2011-04-08 00:48:25.988444270 -0600
+++ clang/lib/CodeGen/CodeGenFunction.h	2011-04-07 17:06:59.936444289 -0600
@@ -74,6 +74,80 @@
   class BlockFlags;
   class BlockFieldFlags;
 
+// The information contained in this class will be used by trap handler 
+// in trap block. 
+class ArithmeticTrapErrorInfo {
+private:
+  llvm::Value *LValue; // The left operand 
+  llvm::Value *RValue; // The right operand
+  const Expr *Operator; // The binary or unary operator
+  llvm::BasicBlock *trapNextBB; // The basic block that trap block jumps to
+  std::string rule; // The rule violated 
+  unsigned mark; // The mark type for undefined checking or non-undefined one
+public:
+
+  ArithmeticTrapErrorInfo() {
+    LValue = 0; 
+    RValue  = 0;
+    Operator = 0;
+    trapNextBB = 0;
+    mark = 0;
+  }
+
+  ~ArithmeticTrapErrorInfo() {
+    LValue  = 0;
+    RValue  = 0;
+    Operator = 0;
+    trapNextBB = 0;
+    rule.clear();
+    mark = 0;
+  }
+
+  void setAll(llvm::Value *lvalue, llvm::Value *rvalue, const Expr *Op, 
+	      llvm::BasicBlock *nextBB, std::string tmpRule, unsigned m) {
+    LValue = lvalue;
+    RValue = rvalue;
+    Operator = Op;
+    trapNextBB = nextBB; 
+    rule = tmpRule;
+    mark = m;
+  }
+
+  void clearAll() {
+    LValue = 0; 
+    RValue = 0; 
+    Operator = 0;
+    trapNextBB = 0;
+    rule.clear();
+    mark = 0;
+  }
+  
+  llvm::Value *getLValue() const {
+    return LValue; 
+  }
+
+  llvm::Value *getRValue() const {
+    return RValue; 
+  }
+
+  const Expr *getOp() const {
+    return Operator;
+  }
+  
+  llvm::BasicBlock *getTrapNextBB() const {
+    return trapNextBB;
+  }
+ 
+  std::string getRule() const {
+    return rule;
+  }
+
+  unsigned getMark() const {
+    return mark;
+  }
+
+};
+
 /// A branch fixup.  These are required when emitting a goto to a
 /// label which hasn't been emitted yet.  The goto is optimistically
 /// emitted as a branch to the basic block for the label, and (if it
@@ -582,7 +656,29 @@
   /// we prefer to insert allocas.
   llvm::AssertingVH<llvm::Instruction> AllocaInsertPt;
 
-  bool CatchUndefined;
+  // The type used in trap block 
+  const llvm::Type* rvOpTy; 
+  llvm::Value* trapHandlerResult; 
+
+  // intptr_t, i8, i32, i64
+  const llvm::IntegerType *IntPtrTy, *Int8Ty, *Int32Ty, *Int64Ty;
+  uint32_t LLVMPointerWidth;
+
+  bool Exceptions;
+  bool CatchUndefined; 
+  bool CatchUndefinedAnsiC;
+  bool CatchUndefinedC99;
+  bool CatchUndefinedCXX0X;
+  bool CatchUndefinedCXX98;
+  bool CatchNonArithUndefined; 
+
+  // Whether to apply LLVM intrinsic backends for +, - and *
+  bool UseIntrinsic; 
+  // Whether to use the random result returned by trap handler 
+  // instead of operation's own result. 
+  bool HandlerProvidesValue; 
+  // Whether to output the number of instrumented checks
+  bool ChecksNum; 
 
   const CodeGen::CGBlockInfo *BlockInfo;
   llvm::Value *BlockPointer;
@@ -1027,6 +1123,9 @@
   llvm::BasicBlock *TrapBB;
 
 public:
+  ArithmeticTrapErrorInfo ATEI; // The arithmetic trap info object
+  // The detailed source code location of non-arithmetic operation 
+  clang::SourceLocation NonArithSL; 
   CodeGenFunction(CodeGenModule &cgm);
 
   CodeGenTypes &getTypes() const { return CGM.getTypes(); }
@@ -1131,6 +1230,7 @@
   const llvm::Type *BuildByRefType(const VarDecl *var);
 
   void GenerateCode(GlobalDecl GD, llvm::Function *Fn);
+  void CXXThisIsNull();
   void StartFunction(GlobalDecl GD, QualType RetTy,
                      llvm::Function *Fn,
                      const FunctionArgList &Args,
@@ -2073,10 +2173,28 @@
   void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
                             llvm::BasicBlock *FalseBlock);
 
+  /// Whether to catch arithmetic operations..
+  bool catchArithUndefined() const;
+
+  /// Whether to catch non-arithmetic operations..
+  bool catchNonArithUndefined() const;
+
+  /// Invoke the concrete trap handler...
+  void invokeTrapHandlerFunction();
+
   /// getTrapBB - Create a basic block that will call the trap intrinsic.  We'll
   /// generate a branch around the created basic block as necessary.
   llvm::BasicBlock *getTrapBB();
 
+  /// CreateTrapBB - create the trap BB
+  void CreateTrapBB();
+
+  /// getSoleTrapBB - Just return the trap BB
+  llvm::BasicBlock *getSoleTrapBB();
+
+  /// EmitTrapBB - Just emit the relevant trap BB
+  void EmitTrapBB();
+  
   /// EmitCallArg - Emit a single call argument.
   RValue EmitCallArg(const Expr *E, QualType ArgType);
 
diff -ura clang-2.9/lib/CodeGen/CodeGenModule.cpp clang/lib/CodeGen/CodeGenModule.cpp
--- clang-2.9/lib/CodeGen/CodeGenModule.cpp	2011-04-08 00:48:25.988444270 -0600
+++ clang/lib/CodeGen/CodeGenModule.cpp	2011-04-07 12:09:19.904444228 -0600
@@ -87,6 +87,7 @@
                            ABI.getMangleContext());
 
   // If debug info generation is enabled, create the CGDebugInfo object.
+  checksNum = 0;
   DebugInfo = CodeGenOpts.DebugInfo ? new CGDebugInfo(*this) : 0;
 
   Block.GlobalUniqueCount = 0;
diff -ura clang-2.9/lib/CodeGen/CodeGenModule.h clang/lib/CodeGen/CodeGenModule.h
--- clang-2.9/lib/CodeGen/CodeGenModule.h	2011-04-08 00:48:25.988444270 -0600
+++ clang/lib/CodeGen/CodeGenModule.h	2011-04-07 12:09:19.900444354 -0600
@@ -239,6 +239,8 @@
   llvm::Constant *BlockObjectAssign;
   llvm::Constant *BlockObjectDispose;
 
+  uint32_t checksNum;
+  bool nointegeroverflowcheck;
   const llvm::Type *BlockDescriptorType;
   const llvm::Type *GenericBlockLiteralType;
 
@@ -256,6 +258,13 @@
 
   ~CodeGenModule();
 
+  uint32_t getChecksNum() {
+    return ++checksNum;
+  }
+
+  bool getNonIntegerOverflowCheck() {
+    return nointegeroverflowcheck;
+  }
   /// Release - Finalize LLVM code generation.
   void Release();
 
Only in clang/lib/CodeGen: Release
diff -ura clang-2.9/lib/Driver/Driver.cpp clang/lib/Driver/Driver.cpp
--- clang-2.9/lib/Driver/Driver.cpp	2011-04-08 00:48:25.988444270 -0600
+++ clang/lib/Driver/Driver.cpp	2011-04-07 14:07:43.688444277 -0600
@@ -100,6 +100,36 @@
   delete Host;
 }
 
+static phases::ID checkFinalPhase(bool CCCIsCPP, Arg **FinalPhaseArgPtr, 
+                                  const ArgList &Args) {
+  phases::ID FinalPhase;
+
+  // -{E,M,MM} only run the preprocessor.
+  if (CCCIsCPP ||
+      (*FinalPhaseArgPtr = Args.getLastArg(options::OPT_E)) ||
+      (*FinalPhaseArgPtr = Args.getLastArg(options::OPT_M, options::OPT_MM))) {
+    FinalPhase = phases::Preprocess;
+
+    // -{fsyntax-only,-analyze,emit-ast,S} only run up to the compiler.
+  } else if ((*FinalPhaseArgPtr = Args.getLastArg(options::OPT_fsyntax_only)) ||
+             (*FinalPhaseArgPtr = Args.getLastArg(options::OPT_rewrite_objc)) ||
+             (*FinalPhaseArgPtr = Args.getLastArg(options::OPT__analyze,
+                                              options::OPT__analyze_auto)) ||
+             (*FinalPhaseArgPtr = Args.getLastArg(options::OPT_emit_ast)) ||
+             (*FinalPhaseArgPtr = Args.getLastArg(options::OPT_S))) {
+    FinalPhase = phases::Compile;
+
+    // -c only runs up to the assembler.
+  } else if ((*FinalPhaseArgPtr = Args.getLastArg(options::OPT_c))) {
+    FinalPhase = phases::Assemble;
+
+    // Otherwise do everything.
+  } else
+    FinalPhase = phases::Link;
+
+  return FinalPhase;
+}
+
 InputArgList *Driver::ParseArgStrings(const char **ArgBegin,
                                       const char **ArgEnd) {
   llvm::PrettyStackTraceString CrashInfo("Command line argument parsing");
@@ -107,6 +137,42 @@
   InputArgList *Args = getOpts().ParseArgs(ArgBegin, ArgEnd,
                                            MissingArgIndex, MissingArgCount);
 
+  Arg *FinalPhaseArg = 0;
+  if (checkFinalPhase(CCCIsCPP, &FinalPhaseArg, *Args) == phases::Link 
+      && (Args->hasArg(options::OPT_fcatch_undefined_behavior)
+        || Args->hasArg(options::OPT_fcatch_undefined_ansic_behavior)
+        || Args->hasArg(options::OPT_fcatch_undefined_c99_behavior)
+        || Args->hasArg(options::OPT_fcatch_undefined_cxx0x_behavior)
+        || Args->hasArg(options::OPT_fcatch_undefined_cxx98_behavior) 
+        || Args->hasArg(options::OPT_fcatch_undefined_nonarith_behavior))) {
+     // Manifest that the linkage is the final stage of whole compilation chain.
+     unsigned Index = 0, End = ArgEnd - ArgBegin;
+     bool lmFound = false;
+
+     while (Index < End) {
+       if (strcmp(*(ArgBegin + Index), "-lm") == 0) {
+	 lmFound = true;
+	 break;
+       }
+       Index++; 
+     }
+
+     const char *newTrapLib;
+     Index = Args->size();
+     Arg *trapArg = 0;
+
+     // Default case...
+     newTrapLib = "-ltrapub";
+     trapArg = getOpts().ParseOneArgTrap(*Args, Index, newTrapLib);
+     Args->append(trapArg);
+
+     if (!lmFound) {
+       const char *newLmLib = "-lm";
+       trapArg = getOpts().ParseOneArgTrap(*Args, Index, newLmLib);
+       Args->append(trapArg);
+     }
+  }
+
   // Check for missing argument error.
   if (MissingArgCount)
     Diag(clang::diag::err_drv_missing_argument)
@@ -817,30 +883,7 @@
   // affect the phase, starting with the earliest phases, and record which
   // option we used to determine the final phase.
   Arg *FinalPhaseArg = 0;
-  phases::ID FinalPhase;
-
-  // -{E,M,MM} only run the preprocessor.
-  if (CCCIsCPP ||
-      (FinalPhaseArg = Args.getLastArg(options::OPT_E)) ||
-      (FinalPhaseArg = Args.getLastArg(options::OPT_M, options::OPT_MM))) {
-    FinalPhase = phases::Preprocess;
-
-    // -{fsyntax-only,-analyze,emit-ast,S} only run up to the compiler.
-  } else if ((FinalPhaseArg = Args.getLastArg(options::OPT_fsyntax_only)) ||
-             (FinalPhaseArg = Args.getLastArg(options::OPT_rewrite_objc)) ||
-             (FinalPhaseArg = Args.getLastArg(options::OPT__analyze,
-                                              options::OPT__analyze_auto)) ||
-             (FinalPhaseArg = Args.getLastArg(options::OPT_emit_ast)) ||
-             (FinalPhaseArg = Args.getLastArg(options::OPT_S))) {
-    FinalPhase = phases::Compile;
-
-    // -c only runs up to the assembler.
-  } else if ((FinalPhaseArg = Args.getLastArg(options::OPT_c))) {
-    FinalPhase = phases::Assemble;
-
-    // Otherwise do everything.
-  } else
-    FinalPhase = phases::Link;
+  phases::ID FinalPhase = checkFinalPhase(CCCIsCPP, &FinalPhaseArg, Args);
 
   // Reject -Z* at the top level, these options should never have been exposed
   // by gcc.
diff -ura clang-2.9/lib/Driver/OptTable.cpp clang/lib/Driver/OptTable.cpp
--- clang-2.9/lib/Driver/OptTable.cpp	2011-04-08 00:48:25.988444270 -0600
+++ clang/lib/Driver/OptTable.cpp	2011-04-07 12:16:52.404444310 -0600
@@ -184,6 +184,40 @@
   return Opt;
 }
 
+// Index is just a padding argument, no real meaning...
+Arg *OptTable::ParseOneArgTrap(const ArgList &Args, unsigned &Index,
+                               const char *Str) const {
+  unsigned Prev = Index;
+  // Anything that doesn't start with '-' is an input, as is '-' itself.
+  if (Str[0] != '-' || Str[1] == '\0')
+    return new Arg(TheInputOption, Index++, Str);
+
+  const Info *Start = OptionInfos + FirstSearchableIndex;
+  const Info *End = OptionInfos + getNumOptions();
+
+  // Search for the first next option which could be a prefix.
+  Start = std::lower_bound(Start, End, Str);
+
+  for (; Start != End; ++Start) {
+    // Scan for first option which is a proper prefix.
+    for (; Start != End; ++Start)
+      if (memcmp(Str, Start->Name, strlen(Start->Name)) == 0)
+        break;
+    if (Start == End)
+      break;
+
+    // -lxxx, just tease out 'xxx' part...
+    const char *strPart = Str + 2;
+    return new Arg(getOption(Start - OptionInfos + 1), Index++, strPart);
+
+    // Otherwise, see if this argument was missing values.
+    if (Prev != Index)
+      return 0;
+  }
+
+  return new Arg(TheUnknownOption, Index++, Str);
+}
+
 Arg *OptTable::ParseOneArg(const ArgList &Args, unsigned &Index) const {
   unsigned Prev = Index;
   const char *Str = Args.getArgString(Index);
Only in clang/lib/Driver: Release
diff -ura clang-2.9/lib/Driver/Tools.cpp clang/lib/Driver/Tools.cpp
--- clang-2.9/lib/Driver/Tools.cpp	2011-04-08 00:48:25.992444215 -0600
+++ clang/lib/Driver/Tools.cpp	2011-04-08 00:58:12.456444256 -0600
@@ -1388,6 +1388,14 @@
 
   // Forward -f (flag) options which we can pass directly.
   Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_behavior);
+  Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_ansic_behavior);
+  Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_c99_behavior);
+  Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_cxx0x_behavior);
+  Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_cxx98_behavior);
+  Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_nonarith_behavior);
+  Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_use_intrinsic);
+  Args.AddLastArg(CmdArgs, options::OPT_fhandler_provides_value);
+  Args.AddLastArg(CmdArgs, options::OPT_fchecks_num);
   Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
   Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
   Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
diff -ura clang-2.9/lib/Frontend/CompilerInvocation.cpp clang/lib/Frontend/CompilerInvocation.cpp
--- clang-2.9/lib/Frontend/CompilerInvocation.cpp	2011-04-08 00:48:25.992444215 -0600
+++ clang/lib/Frontend/CompilerInvocation.cpp	2011-04-08 00:56:27.208444236 -0600
@@ -555,6 +555,22 @@
     Res.push_back("-fpascal-strings");
   if (Opts.CatchUndefined)
     Res.push_back("-fcatch-undefined-behavior");
+  if (Opts.CatchUndefinedAnsiC)
+    Res.push_back("-fcatch-undefined-ansic-behavior");
+  if (Opts.CatchUndefinedC99)
+    Res.push_back("-fcatch-undefined-c99-behavior");
+  if (Opts.CatchUndefinedCXX0X)
+    Res.push_back("-fcatch-undefined-cxx0x-behavior");
+  if (Opts.CatchUndefinedCXX98)
+    Res.push_back("-fcatch-undefined-cxx98-behavior");
+  if (Opts.CatchNonArithUndefined)
+    Res.push_back("-fcatch-undefined-nonarith-behavior");
+  if (Opts.UseIntrinsic)
+    Res.push_back("-fcatch-undefined-use-intrinsic");
+  if (Opts.HandlerProvidesValue)
+    Res.push_back("-fuse-random-value");
+  if (Opts.ChecksNum)
+    Res.push_back("-fchecks-num");
   if (Opts.WritableStrings)
     Res.push_back("-fwritable-strings");
   if (Opts.ConstStrings)
@@ -1454,6 +1470,15 @@
   Opts.ObjCDefaultSynthProperties =
     Args.hasArg(OPT_fobjc_default_synthesize_properties);
   Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior);
+  Opts.CatchUndefinedAnsiC = Args.hasArg(OPT_fcatch_undefined_ansic_behavior);
+  Opts.CatchUndefinedC99 = Args.hasArg(OPT_fcatch_undefined_c99_behavior);
+  Opts.CatchUndefinedCXX0X = Args.hasArg(OPT_fcatch_undefined_cxx0x_behavior);
+  Opts.CatchUndefinedCXX98 = Args.hasArg(OPT_fcatch_undefined_cxx98_behavior);
+  Opts.CatchNonArithUndefined = Args.hasArg(
+                                      OPT_fcatch_undefined_nonarith_behavior);
+  Opts.UseIntrinsic = Args.hasArg(OPT_fcatch_undefined_use_intrinsic);
+  Opts.HandlerProvidesValue = Args.hasArg(OPT_fhandler_provides_value);
+  Opts.ChecksNum = Args.hasArg(OPT_fchecks_num);
   Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
   Opts.PICLevel = Args.getLastArgIntValue(OPT_pic_level, 0, Diags);
   Opts.Static = Args.hasArg(OPT_static_define);
Only in clang/lib/Frontend: CompilerInvocation.cpp.orig
Only in clang/lib/Frontend: Release
Only in clang/lib/FrontendTool: Release
Only in clang/lib/Headers: arm_neon.h.inc
Only in clang/lib/Headers: Release
Only in clang/lib/Index: Release
Only in clang/lib/Lex: Release
Only in clang/lib/Parse: Release
Only in clang/lib/Rewrite: Release
diff -ura clang-2.9/lib/Sema/AttributeList.cpp clang/lib/Sema/AttributeList.cpp
--- clang-2.9/lib/Sema/AttributeList.cpp	2011-04-08 00:48:25.992444215 -0600
+++ clang/lib/Sema/AttributeList.cpp	2011-04-07 12:09:19.872444263 -0600
@@ -75,6 +75,7 @@
     .Case("iboutlet", AT_IBOutlet)
     .Case("iboutletcollection", AT_IBOutletCollection)
     .Case("noreturn", AT_noreturn)
+    .Case("nointegercheck", AT_nointegercheck)
     .Case("noinline", AT_noinline)
     .Case("sentinel", AT_sentinel)
     .Case("NSObject", AT_nsobject)
Only in clang/lib/Sema: Release
diff -ura clang-2.9/lib/Sema/SemaDeclAttr.cpp clang/lib/Sema/SemaDeclAttr.cpp
--- clang-2.9/lib/Sema/SemaDeclAttr.cpp	2011-04-08 00:48:25.996444144 -0600
+++ clang/lib/Sema/SemaDeclAttr.cpp	2011-04-07 12:09:19.872444263 -0600
@@ -826,6 +826,13 @@
   d->addAttr(::new (S.Context) NoReturnAttr(attr.getLoc(), S.Context));
 }
 
+static void HandleNoIntegerCheckAttr(Decl *d, const AttributeList &Attr, 
+                                     Sema &S) {
+  /* Diagnostics (if any) was emitted by Sema::ProcessFnAttr(). */
+  assert(Attr.isInvalid() == false);
+  d->addAttr(::new (S.Context) NoIntegerCheckAttr(Attr.getLoc(), S.Context));
+}
+
 bool Sema::CheckNoReturnAttr(const AttributeList &attr) {
   if (attr.getNumArgs() != 0) {
     Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
@@ -2772,6 +2779,8 @@
       HandleOwnershipAttr     (D, Attr, S); break;
   case AttributeList::AT_naked:       HandleNakedAttr       (D, Attr, S); break;
   case AttributeList::AT_noreturn:    HandleNoReturnAttr    (D, Attr, S); break;
+  case AttributeList::AT_nointegercheck:    
+                                HandleNoIntegerCheckAttr    (D, Attr, S); break;
   case AttributeList::AT_nothrow:     HandleNothrowAttr     (D, Attr, S); break;
   case AttributeList::AT_shared:      HandleSharedAttr      (D, Attr, S); break;
   case AttributeList::AT_vecreturn:   HandleVecReturnAttr   (D, Attr, S); break;
Only in clang/lib/Serialization: Release
Only in clang/lib/StaticAnalyzer/Checkers: Checkers.inc
Only in clang/lib/StaticAnalyzer/Checkers: Release
Only in clang/lib/StaticAnalyzer/Core: Release
Only in clang/lib/StaticAnalyzer/Frontend: Release
Only in clang/tools/c-index-test: Release
Only in clang/tools/driver: Release
Only in clang/tools/libclang: Release
Only in clang/unittests/Basic: Release
Only in clang/unittests/Frontend: Release
