diff --git a/llvm/include/llvm/Target/TargetOptions.h b/llvm/include/llvm/Target/TargetOptions.h index bd696f399d54..e931ec875c01 100644 --- a/llvm/include/llvm/Target/TargetOptions.h +++ b/llvm/include/llvm/Target/TargetOptions.h @@ -71,7 +71,7 @@ namespace llvm { EnableFastISel(false), PositionIndependentExecutable(false), UseInitArray(false), DisableIntegratedAS(false), CompressDebugSections(false), FunctionSections(false), - DataSections(false), UniqueSectionNames(true), TrapUnreachable(false), + DataSections(false), UniqueSectionNames(true), EmulatedTLS(false), FloatABIType(FloatABI::Default), AllowFPOpFusion(FPOpFusion::Standard), Reciprocals(TargetRecip()), JTType(JumpTable::Single), @@ -169,9 +169,6 @@ namespace llvm { unsigned UniqueSectionNames : 1; - /// Emit target-specific trap instruction for 'unreachable' IR instructions. - unsigned TrapUnreachable : 1; - /// EmulatedTLS - This flag enables emulated TLS model, using emutls /// function in the runtime library.. unsigned EmulatedTLS : 1; @@ -234,7 +231,6 @@ inline bool operator==(const TargetOptions &LHS, ARE_EQUAL(EnableFastISel) && ARE_EQUAL(PositionIndependentExecutable) && ARE_EQUAL(UseInitArray) && - ARE_EQUAL(TrapUnreachable) && ARE_EQUAL(EmulatedTLS) && ARE_EQUAL(FloatABIType) && ARE_EQUAL(AllowFPOpFusion) && diff --git a/llvm/lib/CodeGen/SelectionDAG/FastISel.cpp b/llvm/lib/CodeGen/SelectionDAG/FastISel.cpp index 13b097cfc606..f97edb4ef090 100644 --- a/llvm/lib/CodeGen/SelectionDAG/FastISel.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/FastISel.cpp @@ -1569,10 +1569,8 @@ bool FastISel::selectOperator(const User *I, unsigned Opcode) { } case Instruction::Unreachable: - if (TM.Options.TrapUnreachable) - return fastEmit_(MVT::Other, MVT::Other, ISD::TRAP) != 0; - else - return true; + // Nothing to emit. + return true; case Instruction::Alloca: // FunctionLowering has the static-sized case covered. diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp index 72af2760bb7d..a48de5721137 100644 --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp @@ -2205,10 +2205,7 @@ void SelectionDAGBuilder::visitIndirectBr(const IndirectBrInst &I) { getValue(I.getAddress()))); } -void SelectionDAGBuilder::visitUnreachable(const UnreachableInst &I) { - if (DAG.getTarget().Options.TrapUnreachable) - DAG.setRoot(DAG.getNode(ISD::TRAP, getCurSDLoc(), MVT::Other, DAG.getRoot())); -} +void SelectionDAGBuilder::visitUnreachable(const UnreachableInst &I) {} void SelectionDAGBuilder::visitFSub(const User &I) { // -0.0 - X --> fneg diff --git a/llvm/lib/Target/X86/X86ISelLowering.cpp b/llvm/lib/Target/X86/X86ISelLowering.cpp index 6fd04733e01d..0ed196a4acb5 100644 --- a/llvm/lib/Target/X86/X86ISelLowering.cpp +++ b/llvm/lib/Target/X86/X86ISelLowering.cpp @@ -2945,6 +2945,20 @@ static SDValue getMOVL(SelectionDAG &DAG, SDLoc dl, EVT VT, SDValue V1, return DAG.getVectorShuffle(VT, dl, V1, V2, &Mask[0]); } +/// Check if the fall through instruction after a call site is unreachable. +/// FIXME: This will fail if there are interesting non-code generating IR +/// instructions between the call and the unreachable (lifetime.end). In +/// practice, this should be rare because optimizations like to delete non-call +/// code before unreachable. +static bool isCallFollowedByUnreachable(ImmutableCallSite CS) { + const Instruction *NextInst; + if (auto *II = dyn_cast(CS.getInstruction())) + NextInst = II->getNormalDest()->getFirstNonPHIOrDbg(); + else + NextInst = CS.getInstruction()->getNextNode(); + return isa(NextInst); +} + SDValue X86TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI, SmallVectorImpl &InVals) const { @@ -3450,6 +3464,15 @@ X86TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI, InFlag = Chain.getValue(1); } + if (Subtarget->isTargetWin64() && CLI.CS) { + // Look for a call followed by unreachable. On Win64, we need to ensure that + // the call does not accidentally fall through to something that looks like + // an epilogue. We do this by inserting a DEBUGTRAP, which lowers to int3, + // which is what MSVC emits after noreturn calls. + if (isCallFollowedByUnreachable(*CLI.CS)) + Chain = DAG.getNode(ISD::DEBUGTRAP, dl, MVT::Other, Chain); + } + // Handle result values, copying them out of physregs into vregs that we // return. return LowerCallResult(Chain, InFlag, CallConv, isVarArg, diff --git a/llvm/lib/Target/X86/X86TargetMachine.cpp b/llvm/lib/Target/X86/X86TargetMachine.cpp index 2e869eb7c3cd..d318244e0f70 100644 --- a/llvm/lib/Target/X86/X86TargetMachine.cpp +++ b/llvm/lib/Target/X86/X86TargetMachine.cpp @@ -110,13 +110,6 @@ X86TargetMachine::X86TargetMachine(const Target &T, const Triple &TT, OL), TLOF(createTLOF(getTargetTriple())), Subtarget(TT, CPU, FS, *this, Options.StackAlignmentOverride) { - // Windows stack unwinder gets confused when execution flow "falls through" - // after a call to 'noreturn' function. - // To prevent that, we emit a trap for 'unreachable' IR instructions. - // (which on X86, happens to be the 'ud2' instruction) - if (Subtarget.isTargetWin64()) - this->Options.TrapUnreachable = true; - // By default (and when -ffast-math is on), enable estimate codegen for // everything except scalar division. By default, use 1 refinement step for // all operations. Defaults may be overridden by using command-line options. diff --git a/llvm/test/CodeGen/X86/br-fold.ll b/llvm/test/CodeGen/X86/br-fold.ll index fd1e73bde8cc..9a7552ddad82 100644 --- a/llvm/test/CodeGen/X86/br-fold.ll +++ b/llvm/test/CodeGen/X86/br-fold.ll @@ -10,10 +10,10 @@ ; X64_LINUX-NEXT: %bb8.i329 ; X64_WINDOWS: orq %rax, %rcx -; X64_WINDOWS-NEXT: ud2 +; X64_WINDOWS-NEXT: %bb8.i329 ; X64_WINDOWS_GNU: orq %rax, %rcx -; X64_WINDOWS_GNU-NEXT: ud2 +; X64_WINDOWS_GNU-NEXT: %bb8.i329 @_ZN11xercesc_2_513SchemaSymbols21fgURI_SCHEMAFORSCHEMAE = external constant [33 x i16], align 32 ; <[33 x i16]*> [#uses=1] @_ZN11xercesc_2_56XMLUni16fgNotationStringE = external constant [9 x i16], align 16 ; <[9 x i16]*> [#uses=1] diff --git a/llvm/test/CodeGen/X86/win-catchpad-rethrow.ll b/llvm/test/CodeGen/X86/win-catchpad-rethrow.ll new file mode 100644 index 000000000000..7585b0794690 --- /dev/null +++ b/llvm/test/CodeGen/X86/win-catchpad-rethrow.ll @@ -0,0 +1,103 @@ +; RUN: llc -mtriple=x86_64-pc-windows-msvc < %s | FileCheck %s + +; C++ EH rethrows are interesting, because they are calls to noreturn +; functions. There *must* be some code after the call instruction that doesn't +; look like an epilogue. We use int3 to be consistent with MSVC. + +; Based on this C++ source: +; int main() { +; try { +; throw 42; +; } catch (int) { +; try { +; throw; +; } catch (int) { +; } +; } +; return 0; +; } + +; ModuleID = 't.cpp' +target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-pc-windows-msvc" + +%rtti.TypeDescriptor2 = type { i8**, i8*, [3 x i8] } +%eh.CatchableType = type { i32, i32, i32, i32, i32, i32, i32 } +%eh.CatchableTypeArray.1 = type { i32, [1 x i32] } +%eh.ThrowInfo = type { i32, i32, i32, i32 } + +$"\01??_R0H@8" = comdat any + +$"_CT??_R0H@84" = comdat any + +$_CTA1H = comdat any + +$_TI1H = comdat any + +@"\01??_7type_info@@6B@" = external constant i8* +@"\01??_R0H@8" = linkonce_odr global %rtti.TypeDescriptor2 { i8** @"\01??_7type_info@@6B@", i8* null, [3 x i8] c".H\00" }, comdat +@__ImageBase = external constant i8 +@"_CT??_R0H@84" = linkonce_odr unnamed_addr constant %eh.CatchableType { i32 1, i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32), i32 0, i32 -1, i32 0, i32 4, i32 0 }, section ".xdata", comdat +@_CTA1H = linkonce_odr unnamed_addr constant %eh.CatchableTypeArray.1 { i32 1, [1 x i32] [i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%eh.CatchableType* @"_CT??_R0H@84" to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32)] }, section ".xdata", comdat +@_TI1H = linkonce_odr unnamed_addr constant %eh.ThrowInfo { i32 0, i32 0, i32 0, i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%eh.CatchableTypeArray.1* @_CTA1H to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32) }, section ".xdata", comdat + +define i32 @main() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) { +entry: + %tmp = alloca i32, align 4 + store i32 42, i32* %tmp, align 4 + %0 = bitcast i32* %tmp to i8* + invoke void @_CxxThrowException(i8* %0, %eh.ThrowInfo* nonnull @_TI1H) #1 + to label %unreachable unwind label %catch.dispatch + +catch.dispatch: ; preds = %entry + %1 = catchpad [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null] + to label %catch unwind label %catchendblock + +catch: ; preds = %catch.dispatch + invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null) #1 + to label %unreachable unwind label %catch.dispatch.1 + +catch.dispatch.1: ; preds = %catch + %2 = catchpad [%rtti.TypeDescriptor2* @"\01??_R0H@8", i32 0, i8* null] + to label %catch.3 unwind label %catchendblock.2 + +catch.3: ; preds = %catch.dispatch.1 + catchret %2 to label %try.cont + +try.cont: ; preds = %catch.3 + catchret %1 to label %try.cont.5 + +try.cont.5: ; preds = %try.cont + ret i32 0 + +catchendblock.2: ; preds = %catch.dispatch.1 + catchendpad unwind label %catchendblock + +catchendblock: ; preds = %catchendblock.2, %catch.dispatch + catchendpad unwind to caller + +unreachable: ; preds = %catch, %entry + unreachable +} + +declare void @_CxxThrowException(i8*, %eh.ThrowInfo*) + +declare i32 @__CxxFrameHandler3(...) + +attributes #0 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-features"="+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" } +attributes #1 = { noreturn } + +; CHECK: main: +; CHECK: .seh_proc main +; CHECK: movl $42, +; CHECK-DAG: leaq {{.*}}, %rcx +; CHECK-DAG: leaq _TI1H(%rip), %rdx +; CHECK: callq _CxxThrowException +; CHECK-NEXT: int3 + +; CHECK: "?catch$1@?0?main@4HA": +; CHECK: .seh_proc "?catch$1@?0?main@4HA" +; CHECK-DAG: xorl %ecx, %ecx +; CHECK-DAG: xorl %edx, %edx +; CHECK: callq _CxxThrowException +; CHECK-NEXT: int3 diff --git a/llvm/test/CodeGen/X86/win64_call_epi.ll b/llvm/test/CodeGen/X86/win64_call_epi.ll index 096cbe41c540..d514032dcbf8 100644 --- a/llvm/test/CodeGen/X86/win64_call_epi.ll +++ b/llvm/test/CodeGen/X86/win64_call_epi.ll @@ -24,9 +24,9 @@ catch: ; WIN64: nop ; WIN64: addq ${{[0-9]+}}, %rsp ; WIN64: retq -; Check for 'ud2' after noreturn call +; Check for 'int3' after noreturn call ; WIN64: callq _Unwind_Resume -; WIN64-NEXT: ud2 +; WIN64-NEXT: int3 ; WIN64: .seh_endproc