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; def fcaret_diagnostics : Flag<"-fcaret-diagnostics">, Group; def fcatch_undefined_behavior : Flag<"-fcatch-undefined-behavior">, - Group, HelpText<"Generate runtime checks for undefined behavior.">; + Group, HelpText<"Generate runtime checks for undefined behaviors.">; +def fcatch_undefined_ansic_behavior : Flag<"-fcatch-undefined-ansic-behavior">, + Group, + HelpText<"Generate runtime checks for undefined behaviors upon ansic standard.">; +def fcatch_undefined_c99_behavior : Flag<"-fcatch-undefined-c99-behavior">, + Group, + HelpText<"Generate runtime checks for undefined behaviors upon c99 standard.">; +def fcatch_undefined_cxx0x_behavior : Flag<"-fcatch-undefined-cxx0x-behavior">, + Group, + HelpText<"Generate runtime checks for undefined behaviors upon c++0x standard.">; +def fcatch_undefined_cxx98_behavior : Flag<"-fcatch-undefined-cxx98-behavior">, + Group, + HelpText<"Generate runtime checks for undefined behaviors upon c++98 standard.">; +def fcatch_undefined_nonarith_behavior : Flag<"-fcatch-undefined-nonarith-behavior">, + Group, + HelpText<"Generate runtime checks for undefined behaviors for non-arithmetic operations.">; +def fcatch_undefined_use_intrinsic : Flag<"-fcatch-undefined-use-intrinsic">, + Group, + HelpText<"Use LLVM's intrinsic checks to detect overflow.">; +def fhandler_provides_value : Flag<"-fhandler-provides-value">, + Group, + HelpText<"Use random values returned by trap handler as arithmetic operations' results.">; +def fchecks_num : Flag<"-fchecks-num">, + Group, HelpText<"Output the number of instrumented number.">; def fclasspath_EQ : Joined<"-fclasspath=">, Group; def fcolor_diagnostics : Flag<"-fcolor-diagnostics">, Group; def fcommon : Flag<"-fcommon">, 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()) FuncAttrs |= llvm::Attribute::NoReturn; + if (TargetDecl->hasAttr()) + FuncAttrs |= llvm::Attribute::NoIntegerCheck; if (TargetDecl->hasAttr()) FuncAttrs |= llvm::Attribute::ReadNone; else if (TargetDecl->hasAttr()) 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(E) && !LV.isBitField() && LV.isSimple()) + if (!isa(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())) + && ((CatchUndefined == true) || + (CatchUndefinedAnsiC == true) || + (CatchUndefinedC99 == true) || + (CatchUndefinedCXX0X == true) || + (CatchUndefinedCXX98 == true)); +} + +bool CodeGenFunction::catchNonArithUndefined() const { + return (!CurFuncDecl || !(CurFuncDecl->hasAttr())) + && ((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(ATEI.getOp())) { + BOP = cast(ATEI.getOp()); + opcodeStr = clang::BinaryOperator::getOpcodeStr(BOP->getOpcode()); + SL = BOP->getOperatorLoc(); + } + else { + UOP = cast(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 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 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(E->getBase())){ if (const DeclRefExpr *DRE = dyn_cast(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(CE->getCallee()->IgnoreParens())) return EmitCXXMemberPointerCallExpr(CE, ReturnValue); + NonArithSL = CE->getExprLoc(); const MemberExpr *ME = cast(CE->getCallee()->IgnoreParens()); const CXXMethodDecl *MD = cast(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 +#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(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(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(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(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(Ops.LHS->getType())) { + std::string tmpRule; unsigned Width = cast(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(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(Ops.LHS->getType())) { + std::string tmpRule; unsigned Width = cast(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(D) && cast(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 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