Index: lib/Target/X86/CMakeLists.txt
===================================================================
--- lib/Target/X86/CMakeLists.txt
+++ lib/Target/X86/CMakeLists.txt
@@ -15,6 +15,7 @@
 set(sources
   X86AsmPrinter.cpp
   X86CallFrameOptimization.cpp
+  X86CFIInstrInserter.cpp
   X86ExpandPseudo.cpp
   X86FastISel.cpp
   X86FloatingPoint.cpp
Index: lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp
===================================================================
--- lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp
+++ lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp
@@ -542,9 +542,12 @@
         //  L0:
         //     .cfi_def_cfa_offset 80
         //
-        PrevStackSize = StackSize;
-        StackSize = std::abs(Inst.getOffset()) / StackDivide;
-        ++NumDefCFAOffsets;
+        // Find the maximum def_cfa_offset that is set in a function
+        if ((std::abs(Inst.getOffset()) / StackDivide) > StackSize) {
+          PrevStackSize = StackSize;
+          StackSize = std::abs(Inst.getOffset()) / StackDivide;
+          ++NumDefCFAOffsets;
+        }
         break;
       }
       case MCCFIInstruction::OpOffset: {
@@ -571,6 +574,9 @@
         InstrOffset += PushInstrSize(Reg);
         break;
       }
+      case MCCFIInstruction::OpDefCfa: {
+        break;
+      }
       }
     }
 
Index: lib/Target/X86/X86.h
===================================================================
--- lib/Target/X86/X86.h
+++ lib/Target/X86/X86.h
@@ -78,6 +78,11 @@
 /// in order to eliminate partial register usage, false dependences on
 /// the upper portions of registers, and to save code size.
 FunctionPass *createX86FixupBWInsts();
+
+/// Return a pass that inserts CFI instructions in epilogue in order to
+/// provide precise unwind info for a machine function.
+FunctionPass *createX86CFIInstrInserter();
+
 } // End llvm namespace
 
 #endif
Index: lib/Target/X86/X86CFIInstrInserter.cpp
===================================================================
--- /dev/null
+++ lib/Target/X86/X86CFIInstrInserter.cpp
@@ -0,0 +1,402 @@
+//===------ X86CFIInstrInserter.cpp - Insert needed CFI instructions ------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass inserts CFI instructions in epilogue and additional CFI
+// instructions where needed in order to provide precise unwind info
+// for a machine function.
+//
+//===----------------------------------------------------------------------===//
+
+#include "X86.h"
+#include "X86FrameLowering.h"
+#include "X86MachineFunctionInfo.h"
+#include "X86Subtarget.h"
+#include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/MC/MCAsmInfo.h"
+#include <queue>
+
+using namespace llvm;
+
+namespace {
+class X86CFIInstrInserter : public MachineFunctionPass {
+public:
+  X86CFIInstrInserter() : MachineFunctionPass(ID) {}
+  bool runOnMachineFunction(MachineFunction &MF) override;
+  static char ID;
+
+private:
+  const char *getPassName() const override {
+    return "X86 CFI Instruction Inserter";
+  }
+
+  // Holds information about offset and register values
+  // at the beginning and the end of a MBB
+  struct MBBInfo {
+    MachineBasicBlock *MBB;
+    int BeginOffset;
+    int EndOffset;
+    int BeginRegister;
+    int EndRegister;
+    bool IsChecked = false;
+  };
+
+  // Analyze if this MBB changes or should change offset and register values
+  // for calculating CFA. If this MBB is the epilogue, InsertCFIInEpilogue() is
+  // called.
+  void AnalyzeMBB(MachineFunction &MF);
+
+  // Insert CFI instructions to the beginnings of MBBs, if that insertion is
+  // needed.
+  // CorrectCFA will insert additional CFI instructions if the epilogue sets
+  // offset or register values that do not apply to MBBs below it.
+  void CorrectCFA(MachineFunction &MF);
+
+  // Inserts appropriate CFI instructions to a function epilogue
+  //   MBBInfo - contains the epilogue MBB
+  //   SetOffset - the def_cfa_offset set by the prologue (the offset value
+  // that is valid before the epilogue)
+  void InsertCFIInEpilogue(struct MBBInfo *MBBInfo, int SetOffset);
+
+  const X86Subtarget *ST;
+  const X86RegisterInfo *RI;
+  const X86FrameLowering *TFL;
+  const TargetRegisterInfo *TRI;
+  const MCRegisterInfo *MRI;
+  unsigned StackPtr;
+  unsigned FramePtr;
+  bool Is64Bit;
+
+  // An array of MBBs with additional information needed to insert CFI
+  // instructions
+  struct MBBInfo *MBBInfoList;
+
+  // Keeps track of MBBs that need to be analyzed
+  std::queue<int> *BlocksToAnalyze;
+
+  // Initial frame state register
+  int InitialRegister;
+
+  // Initial frame state offset
+  int InitialOffset;
+
+  // Were any CFI instructions inserted
+  bool InsertedCFIInstr = false;
+};
+
+char X86CFIInstrInserter::ID = 0;
+}
+
+FunctionPass *llvm::createX86CFIInstrInserter() {
+  return new X86CFIInstrInserter();
+}
+
+bool X86CFIInstrInserter::runOnMachineFunction(MachineFunction &MF) {
+
+  if (!MF.getMMI().hasDebugInfo()) {
+    return false;
+  }
+
+  ST = &MF.getSubtarget<X86Subtarget>();
+  RI = ST->getRegisterInfo();
+  StackPtr = ST->is64Bit() ? X86::RSP : X86::ESP;
+  TFL = ST->getFrameLowering();
+  TRI = ST->getRegisterInfo();
+  const bool Is64BitILP32 = ST->isTarget64BitILP32();
+  unsigned FrameReg = TRI->getFrameRegister(MF);
+  FramePtr = Is64BitILP32 ? getX86SubSuperRegister(FrameReg, 64) : FrameReg;
+  MRI = MF.getMMI().getContext().getRegisterInfo();
+  Is64Bit = ST->is64Bit();
+
+  InitialRegister = RI->getDwarfRegNum(StackPtr, true);
+  InitialOffset = -RI->getSlotSize();
+
+  // Update ordinal numbers of MBBs
+  MF.RenumberBlocks();
+
+  MBBInfoList = new struct MBBInfo[MF.size()];
+  BlocksToAnalyze = new std::queue<int>();
+
+  // Create a list of all MBBs in the function, along with info needed for
+  // debug info insertion
+  for (auto I = MF.begin(); I != MF.end(); ++I) {
+    // Number of the MBB is the index in the array
+    unsigned Number = I->getNumber();
+    MBBInfoList[Number].MBB = &(*I);
+    // Set offset and register to initial values for now
+    MBBInfoList[Number].BeginOffset = InitialOffset;
+    MBBInfoList[Number].EndOffset = InitialOffset;
+    MBBInfoList[Number].BeginRegister = InitialRegister;
+    MBBInfoList[Number].EndRegister = InitialRegister;
+  }
+
+  // Go through all MBBs, starting with the first one, and determine whether
+  // they are prologue or epilogue and what register and offset values are
+  // correct for their beginnings and ends
+  AnalyzeMBB(MF);
+
+  // Insert appropriate CFI instructions for each MBB if CFA calculation rule
+  // needs to be corrected for that MBB
+  CorrectCFA(MF);
+
+  delete MBBInfoList;
+  delete BlocksToAnalyze;
+  return InsertedCFIInstr;
+}
+
+void X86CFIInstrInserter::AnalyzeMBB(MachineFunction &MF) {
+
+  BlocksToAnalyze->push(0);
+  MBBInfoList[0].IsChecked = true;
+
+  while (!BlocksToAnalyze->empty()) {
+
+    int Index = BlocksToAnalyze->front();
+    BlocksToAnalyze->pop();
+    struct MBBInfo *NewMBBInfo = &MBBInfoList[Index];
+
+    int AdjustOffset = 0;
+    DebugLoc DL = NewMBBInfo->MBB->findDebugLoc(NewMBBInfo->MBB->begin());
+    auto CFIInstructions = MF.getMMI().getFrameInstructions();
+    unsigned CFIIndex;
+
+    bool SetOffset = false;
+    bool SetRegister = false;
+    bool FoundEpilogue = false;
+
+    for (auto MBBI = NewMBBInfo->MBB->rbegin(); MBBI != NewMBBInfo->MBB->rend();
+         ++MBBI) {
+      // Check if this MBB has CFI instructions that change rule for CFA
+      // calculation
+      if ((TFL->hasFP(MF) && (!SetOffset || !SetRegister)) ||
+          (!TFL->hasFP(MF) && !SetOffset)) {
+        if (MBBI->isCFIInstruction()) {
+          CFIIndex = MBBI->getOperand(0).getCFIIndex();
+          if (CFIInstructions[CFIIndex].getOperation() ==
+              MCCFIInstruction::OpType::OpAdjustCfaOffset) {
+            AdjustOffset += -CFIInstructions[CFIIndex].getOffset();
+          }
+          // Check the offset value
+          if (CFIInstructions[CFIIndex].getOperation() ==
+              MCCFIInstruction::OpType::OpDefCfaOffset) {
+            NewMBBInfo->EndOffset = -CFIInstructions[CFIIndex].getOffset();
+            NewMBBInfo->EndOffset += AdjustOffset;
+            SetOffset = true;
+          }
+          // Check the offset and register value
+          if (CFIInstructions[CFIIndex].getOperation() ==
+              MCCFIInstruction::OpType::OpDefCfa) {
+            NewMBBInfo->EndRegister = CFIInstructions[CFIIndex].getRegister();
+            NewMBBInfo->EndOffset = -CFIInstructions[CFIIndex].getOffset();
+            SetOffset = true;
+            SetRegister = true;
+          }
+          // Check the register value
+          if (CFIInstructions[CFIIndex].getOperation() ==
+              MCCFIInstruction::OpType::OpDefCfaRegister) {
+            NewMBBInfo->EndRegister = CFIInstructions[CFIIndex].getRegister();
+            SetRegister = true;
+          }
+        }
+      }
+      // Check if this MBB is epilogue
+      if (!FoundEpilogue) {
+        if (TFL->hasFP(MF) && (MBBI->getOpcode() == X86::POP32r ||
+                               MBBI->getOpcode() == X86::POP64r)) {
+          if (MBBI->getOperand(0).getReg() == FramePtr) {
+            FoundEpilogue = true;
+          }
+        }
+
+        if (!TFL->hasFP(MF) && (MBBI->getOpcode() == X86::POP32r ||
+                                MBBI->getOpcode() == X86::POP64r)) {
+          FoundEpilogue = true;
+        }
+        if (!TFL->hasFP(MF) && (MBBI->getOpcode() == X86::ADD32ri8 ||
+                                MBBI->getOpcode() == X86::ADD64ri8 ||
+                                MBBI->getOpcode() == X86::ADD32ri)) {
+          if (MBBI->getOperand(0).getReg() == StackPtr) {
+            FoundEpilogue = true;
+          }
+        }
+        if (!TFL->hasFP(MF) && (MBBI->getOpcode() == X86::LEA32r ||
+                                MBBI->getOpcode() == X86::LEA64r)) {
+          if (MBBI->getOperand(0).getReg() == StackPtr &&
+              MBBI->getOperand(1).getReg() == StackPtr) {
+            FoundEpilogue = true;
+          }
+        }
+      }
+    }
+    // If only .cfi_adjust_cfa_offset is found in the MBB (no def_cfa_offset),
+    // then the resulting offset value will be value at the beginning
+    // of the block adjusted by the specified offset
+    if (!SetOffset && AdjustOffset) {
+      NewMBBInfo->EndOffset = NewMBBInfo->BeginOffset + AdjustOffset;
+    }
+
+    if (FoundEpilogue) {
+      // Set offset that is set by prologue
+      InsertCFIInEpilogue(NewMBBInfo, NewMBBInfo->EndOffset);
+    }
+
+    // Set EndOffset and EndRegister values of this MBB to be
+    // the values at the beginnings of all its successors
+    for (auto Succ : NewMBBInfo->MBB->successors()) {
+      int SuccNumber = Succ->getNumber();
+      // Check if this successor MBB needs to be analyzed
+      if ((Succ->getNumber() == Index) || MBBInfoList[SuccNumber].IsChecked) {
+        continue;
+      }
+      // Set offset and register values to the successor MBB
+      MBBInfoList[SuccNumber].BeginOffset = NewMBBInfo->EndOffset;
+      MBBInfoList[SuccNumber].EndOffset = NewMBBInfo->EndOffset;
+      MBBInfoList[SuccNumber].BeginRegister = NewMBBInfo->EndRegister;
+      MBBInfoList[SuccNumber].EndRegister = NewMBBInfo->EndRegister;
+
+      BlocksToAnalyze->push(SuccNumber);
+      // Mark this MBB as checked (inserted in the BlocksToAnalyze queue)
+      MBBInfoList[SuccNumber].IsChecked = true;
+    }
+  }
+}
+
+void X86CFIInstrInserter::CorrectCFA(MachineFunction &MF) {
+
+  // Current register value
+  int CurrentRegister = InitialRegister;
+  // Current offset value
+  int CurrentOffset = InitialOffset;
+
+  // Go through all MBBs and insert appropriate CFI instruction(s) if needed
+  for (unsigned int I = 0; I < MF.size(); I++) {
+    auto MBBI = MBBInfoList[I].MBB->begin();
+    DebugLoc DL = MBBInfoList[I].MBB->findDebugLoc(MBBI);
+    if (MBBInfoList[I].BeginRegister == CurrentRegister) {
+      // Insert a cfi_def_cfa instruction at the beginning of this MBB
+      if (MBBInfoList[I].BeginOffset != CurrentOffset) {
+        TFL->BuildCFI(*(MBBInfoList[I].MBB), MBBI, DL,
+                      MCCFIInstruction::createDefCfaOffset(
+                          nullptr, MBBInfoList[I].BeginOffset));
+        InsertedCFIInstr = true;
+      }
+    } else {
+      // Because offset and register values are different than before, create
+      // a cfi_def_cfa instruction and insert it at the beginning of the MBB
+      if (MBBInfoList[I].BeginOffset != CurrentOffset) {
+        TFL->BuildCFI(*(MBBInfoList[I].MBB), MBBI, DL,
+                      MCCFIInstruction::createDefCfa(
+                          nullptr, MBBInfoList[I].BeginRegister,
+                          MBBInfoList[I].BeginOffset));
+        InsertedCFIInstr = true;
+      } else {
+        // Because register value is different than before, create a
+        // cfi_def_cfa_register instruction and insert it at the beginning of
+        // the MBB
+        TFL->BuildCFI(*(MBBInfoList[I].MBB), MBBI, DL,
+                      MCCFIInstruction::createDefCfaRegister(
+                          nullptr, MBBInfoList[I].BeginRegister));
+        InsertedCFIInstr = true;
+      }
+    }
+    CurrentOffset = MBBInfoList[I].EndOffset;
+    CurrentRegister = MBBInfoList[I].EndRegister;
+  }
+}
+
+void X86CFIInstrInserter::InsertCFIInEpilogue(struct MBBInfo *EpilogueInfo,
+                                              int SetOffset) {
+  int CurrentOffset = SetOffset;
+  MachineBasicBlock::iterator MBBI = EpilogueInfo->MBB->begin();
+
+  if (TFL->hasFP(*EpilogueInfo->MBB->getParent())) {
+    while (MBBI != EpilogueInfo->MBB->end()) {
+      DebugLoc DL = EpilogueInfo->MBB->findDebugLoc(MBBI);
+      // If frame pointer is used and the instruction pops the frame pointer,
+      // then
+      // add new def_cfa instruction with initial offset and register values
+      if (MBBI->getOpcode() == X86::POP32r ||
+          MBBI->getOpcode() == X86::POP64r) {
+        if (MBBI->getOperand(0).getReg() == FramePtr) {
+          MachineBasicBlock::iterator MBBITemp = MBBI;
+          ++MBBI;
+          TFL->BuildCFI(*EpilogueInfo->MBB, MBBI, DL,
+                        MCCFIInstruction::createDefCfa(
+                            nullptr, MRI->getDwarfRegNum(
+                                         Is64Bit ? X86::RSP : X86::ESP, true),
+                            InitialOffset));
+          EpilogueInfo->EndOffset = InitialOffset;
+          EpilogueInfo->EndRegister =
+              MRI->getDwarfRegNum(Is64Bit ? X86::RSP : X86::ESP, true);
+          MBBI = MBBITemp;
+          InsertedCFIInstr = true;
+          break;
+        }
+      }
+      ++MBBI;
+    }
+  } else {
+    while (MBBI != EpilogueInfo->MBB->end()) {
+      DebugLoc DL = EpilogueInfo->MBB->findDebugLoc(MBBI);
+      // If frame pointer is not used and the instruction pops the stack
+      // pointer,
+      // then add new def_cfa_offset instruction with appropriate offset
+      if (MBBI->getOpcode() == X86::POP32r ||
+          MBBI->getOpcode() == X86::POP64r) {
+        MachineBasicBlock::iterator MBBITemp = MBBI;
+        ++MBBI;
+        CurrentOffset -= InitialOffset;
+        TFL->BuildCFI(
+            *EpilogueInfo->MBB, MBBI, DL,
+            MCCFIInstruction::createDefCfaOffset(nullptr, CurrentOffset));
+        EpilogueInfo->EndOffset = CurrentOffset;
+        MBBI = MBBITemp;
+        InsertedCFIInstr = true;
+      }
+      // If frame pointer is not used and the instruction is ADD and it changes
+      // stack pointer value, then add new def_cfa_offset instruction with
+      // appropriate offset
+      if (MBBI->getOpcode() == X86::ADD32ri8 ||
+          MBBI->getOpcode() == X86::ADD64ri8 ||
+          MBBI->getOpcode() == X86::ADD32ri) {
+        if (MBBI->getOperand(0).getReg() == StackPtr) {
+          MachineBasicBlock::iterator MBBITemp = MBBI;
+          ++MBBI;
+
+          CurrentOffset += MBBITemp->getOperand(2).getImm();
+          TFL->BuildCFI(
+              *EpilogueInfo->MBB, MBBI, DL,
+              MCCFIInstruction::createDefCfaOffset(nullptr, CurrentOffset));
+          EpilogueInfo->EndOffset = CurrentOffset;
+          MBBI = MBBITemp;
+          InsertedCFIInstr = true;
+        }
+      }
+      // If frame pointer is not used and the instruction is LEA and it changes
+      // stack pointer value, then add new def_cfa_offset instruction with
+      // appropriate offset
+      if (MBBI->getOpcode() == X86::LEA32r ||
+          MBBI->getOpcode() == X86::LEA64r) {
+        if (MBBI->getOperand(0).getReg() == StackPtr &&
+            MBBI->getOperand(1).getReg() == StackPtr) {
+          MachineBasicBlock::iterator MBBITemp = MBBI;
+          ++MBBI;
+          CurrentOffset += MBBITemp->getOperand(4).getImm();
+          TFL->BuildCFI(
+              *EpilogueInfo->MBB, MBBI, DL,
+              MCCFIInstruction::createDefCfaOffset(nullptr, CurrentOffset));
+          EpilogueInfo->EndOffset = CurrentOffset;
+          MBBI = MBBITemp;
+          InsertedCFIInstr = true;
+        }
+      }
+      ++MBBI;
+    }
+  }
+}
Index: lib/Target/X86/X86FrameLowering.cpp
===================================================================
--- lib/Target/X86/X86FrameLowering.cpp
+++ lib/Target/X86/X86FrameLowering.cpp
@@ -2168,9 +2168,16 @@
       assert((!MF.getRegInfo().isLiveIn(ScratchReg2) || SaveScratch2) &&
              "Scratch register is live-in and not saved");
 
-      if (SaveScratch2)
+      if (SaveScratch2) {
         BuildMI(checkMBB, DL, TII.get(X86::PUSH32r))
           .addReg(ScratchReg2, RegState::Kill);
+        if (MF.getMMI().hasDebugInfo()) {
+          MachineBasicBlock::iterator it = checkMBB->getLastNonDebugInstr();
+          ++it;
+          BuildCFI(*checkMBB, it, DL,
+                  MCCFIInstruction::createAdjustCfaOffset(nullptr, SlotSize));
+        }
+      }
 
       BuildMI(checkMBB, DL, TII.get(X86::MOV32ri), ScratchReg2)
         .addImm(TlsOffset);
Index: lib/Target/X86/X86TargetMachine.cpp
===================================================================
--- lib/Target/X86/X86TargetMachine.cpp
+++ lib/Target/X86/X86TargetMachine.cpp
@@ -283,4 +283,5 @@
     addPass(createX86PadShortFunctions());
     addPass(createX86FixupLEAs());
   }
+  addPass(createX86CFIInstrInserter());
 }
Index: test/CodeGen/X86/epilogue-cfi-fp.ll
===================================================================
--- /dev/null
+++ test/CodeGen/X86/epilogue-cfi-fp.ll
@@ -0,0 +1,87 @@
+; RUN: llc < %s | FileCheck %s
+
+; ModuleID = 'epilogue-cfi-fp.c'
+target datalayout = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"
+target triple = "i686-pc-linux"
+
+; Function Attrs: nounwind
+define i32 @foo(i32 %i, i32 %j, i32 %k, i32 %l, i32 %m) #0 !dbg !4 {
+
+; CHECK-LABEL: foo:
+; CHECK:       popl %ebp
+; CHECK-NEXT:  :
+; CHECK-NEXT:  .cfi_def_cfa %esp, 4
+; CHECK-NEXT:  retl
+
+  %1 = alloca i32, align 4
+  %2 = alloca i32, align 4
+  %3 = alloca i32, align 4
+  %4 = alloca i32, align 4
+  %5 = alloca i32, align 4
+  store i32 %i, i32* %1, align 4
+  call void @llvm.dbg.declare(metadata i32* %1, metadata !15, metadata !16), !dbg !17
+  store i32 %j, i32* %2, align 4
+  call void @llvm.dbg.declare(metadata i32* %2, metadata !18, metadata !16), !dbg !19
+  store i32 %k, i32* %3, align 4
+  call void @llvm.dbg.declare(metadata i32* %3, metadata !20, metadata !16), !dbg !21
+  store i32 %l, i32* %4, align 4
+  call void @llvm.dbg.declare(metadata i32* %4, metadata !22, metadata !16), !dbg !23
+  store i32 %m, i32* %5, align 4
+  call void @llvm.dbg.declare(metadata i32* %5, metadata !24, metadata !16), !dbg !25
+  ret i32 0, !dbg !26
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+; Function Attrs: nounwind
+define i32 @main() #0 !dbg !8 {
+
+; CHECK-LABEL: main:
+; CHECK:       popl %ebp
+; CHECK-NEXT:  :
+; CHECK-NEXT:  .cfi_def_cfa %esp, 4
+; CHECK-NEXT:  retl
+
+  %1 = alloca i32, align 4
+  store i32 0, i32* %1, align 4
+  %2 = call i32 @foo(i32 1, i32 2, i32 3, i32 4, i32 5), !dbg !27
+  ret i32 %2, !dbg !28
+}
+
+attributes #0 = { nounwind "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="i686" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!11, !12, !13}
+!llvm.ident = !{!14}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.9.0 (http://llvm.org/git/clang.git d7ffc218c4adde4846b58b3aa4b56312f9442d61) (http://llvm.org/git/llvm.git 8a96b704a3c73c081bf72f9bed1e5db5b4635d5e)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, subprograms: !3)
+!1 = !DIFile(filename: "epilogue-cfi-fp.c", directory: "epilogue-dwarf/test")
+!2 = !{}
+!3 = !{!4, !8}
+!4 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: false, variables: !2)
+!5 = !DISubroutineType(types: !6)
+!6 = !{!7, !7, !7, !7, !7, !7}
+!7 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!8 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 6, type: !9, isLocal: false, isDefinition: true, scopeLine: 7, isOptimized: false, variables: !2)
+!9 = !DISubroutineType(types: !10)
+!10 = !{!7}
+!11 = !{i32 2, !"Dwarf Version", i32 4}
+!12 = !{i32 2, !"Debug Info Version", i32 3}
+!13 = !{i32 1, !"PIC Level", i32 2}
+!14 = !{!"clang version 3.9.0 (http://llvm.org/git/clang.git d7ffc218c4adde4846b58b3aa4b56312f9442d61) (http://llvm.org/git/llvm.git 8a96b704a3c73c081bf72f9bed1e5db5b4635d5e)"}
+!15 = !DILocalVariable(name: "i", arg: 1, scope: !4, file: !1, line: 1, type: !7)
+!16 = !DIExpression()
+!17 = !DILocation(line: 1, column: 13, scope: !4)
+!18 = !DILocalVariable(name: "j", arg: 2, scope: !4, file: !1, line: 1, type: !7)
+!19 = !DILocation(line: 1, column: 20, scope: !4)
+!20 = !DILocalVariable(name: "k", arg: 3, scope: !4, file: !1, line: 1, type: !7)
+!21 = !DILocation(line: 1, column: 27, scope: !4)
+!22 = !DILocalVariable(name: "l", arg: 4, scope: !4, file: !1, line: 1, type: !7)
+!23 = !DILocation(line: 1, column: 34, scope: !4)
+!24 = !DILocalVariable(name: "m", arg: 5, scope: !4, file: !1, line: 1, type: !7)
+!25 = !DILocation(line: 1, column: 41, scope: !4)
+!26 = !DILocation(line: 3, column: 4, scope: !4)
+!27 = !DILocation(line: 8, column: 11, scope: !8)
+!28 = !DILocation(line: 8, column: 4, scope: !8)
Index: test/CodeGen/X86/epilogue-cfi-no-fp.ll
===================================================================
--- /dev/null
+++ test/CodeGen/X86/epilogue-cfi-no-fp.ll
@@ -0,0 +1,77 @@
+; RUN: llc < %s | FileCheck %s
+
+; ModuleID = 'epilogue-cfi-no-fp.c'
+target datalayout = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"
+target triple = "i686-pc-linux"
+
+; CHECK: addl $20, %esp
+; CHECK-NEXT: :
+; CHECK-NEXT: .cfi_def_cfa_offset 12
+; CHECK-NEXT: popl
+; CHECK-NEXT: :
+; CHECK-NEXT: .cfi_def_cfa_offset 8
+; CHECK-NEXT: popl
+; CHECK-NEXT: :
+; CHECK-NEXT: .cfi_def_cfa_offset 4
+; CHECK-NEXT: ret
+;
+; Function Attrs: nounwind
+define i32 @foo(i32 %i, i32 %j, i32 %k, i32 %l, i32 %m) #0 !dbg !4 {
+entry:
+  %i.addr = alloca i32, align 4
+  %j.addr = alloca i32, align 4
+  %k.addr = alloca i32, align 4
+  %l.addr = alloca i32, align 4
+  %m.addr = alloca i32, align 4
+  store i32 %i, i32* %i.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %i.addr, metadata !15, metadata !16), !dbg !17
+  store i32 %j, i32* %j.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %j.addr, metadata !18, metadata !16), !dbg !19
+  store i32 %k, i32* %k.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %k.addr, metadata !20, metadata !16), !dbg !21
+  store i32 %l, i32* %l.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %l.addr, metadata !22, metadata !16), !dbg !23
+  store i32 %m, i32* %m.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %m.addr, metadata !24, metadata !16), !dbg !25
+  ret i32 0, !dbg !26
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind "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-cpu"="i686" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!11, !12, !13}
+!llvm.ident = !{!14}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.9.0 (http://llvm.org/git/clang.git 97b13649469111ebc7970314c0857d86f8f7b720) (http://llvm.org/git/llvm.git 4ced44d3d77424108ec2cad0f1baada9c4bc837e)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, subprograms: !3)
+!1 = !DIFile(filename: "epilogue-cfi-no-fp.c", directory: "epilogue-dwarf/test")
+!2 = !{}
+!3 = !{!4, !8}
+!4 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: false, variables: !2)
+!5 = !DISubroutineType(types: !6)
+!6 = !{!7, !7, !7, !7, !7, !7}
+!7 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!8 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 6, type: !9, isLocal: false, isDefinition: true, scopeLine: 7, isOptimized: false, variables: !2)
+!9 = !DISubroutineType(types: !10)
+!10 = !{!7}
+!11 = !{i32 2, !"Dwarf Version", i32 4}
+!12 = !{i32 2, !"Debug Info Version", i32 3}
+!13 = !{i32 1, !"PIC Level", i32 2}
+!14 = !{!"clang version 3.9.0 (http://llvm.org/git/clang.git 97b13649469111ebc7970314c0857d86f8f7b720) (http://llvm.org/git/llvm.git 4ced44d3d77424108ec2cad0f1baada9c4bc837e)"}
+!15 = !DILocalVariable(name: "i", arg: 1, scope: !4, file: !1, line: 1, type: !7)
+!16 = !DIExpression()
+!17 = !DILocation(line: 1, column: 13, scope: !4)
+!18 = !DILocalVariable(name: "j", arg: 2, scope: !4, file: !1, line: 1, type: !7)
+!19 = !DILocation(line: 1, column: 20, scope: !4)
+!20 = !DILocalVariable(name: "k", arg: 3, scope: !4, file: !1, line: 1, type: !7)
+!21 = !DILocation(line: 1, column: 27, scope: !4)
+!22 = !DILocalVariable(name: "l", arg: 4, scope: !4, file: !1, line: 1, type: !7)
+!23 = !DILocation(line: 1, column: 34, scope: !4)
+!24 = !DILocalVariable(name: "m", arg: 5, scope: !4, file: !1, line: 1, type: !7)
+!25 = !DILocation(line: 1, column: 41, scope: !4)
+!26 = !DILocation(line: 3, column: 4, scope: !4)
+!27 = !DILocation(line: 8, column: 11, scope: !8)
+!28 = !DILocation(line: 8, column: 4, scope: !8)
Index: test/CodeGen/X86/throws-cfi-fp.ll
===================================================================
--- /dev/null
+++ test/CodeGen/X86/throws-cfi-fp.ll
@@ -0,0 +1,223 @@
+; RUN: llc %s -o - | FileCheck %s
+
+; ModuleID = 'throws-cfi-fp.cpp'
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+$__clang_call_terminate = comdat any
+
+@_ZL11ShouldThrow = internal global i8 0, align 1
+@_ZTIi = external constant i8*
+@.str = private unnamed_addr constant [21 x i8] c"Threw an exception!\0A\00", align 1
+
+; Function Attrs: uwtable
+define void @_Z6throwsv() #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) !dbg !4 {
+
+; CHECK-LABEL: _Z6throwsv:
+; CHECK:       popq %rbp
+; CHECK-NEXT:  :
+; CHECK-NEXT:  .cfi_def_cfa %rsp, 8
+; CHECK-NEXT:  retq
+; CHECK-NEXT:  .LBB0_2:
+; CHECK-NEXT:  :
+; CHECK-NEXT:  .loc  1 7 22 discriminator 1  # throws-cfi-fp.cpp:7:22
+; CHECK-NEXT:  :
+; CHECK-NEXT:  .cfi_def_cfa %rbp, 16
+
+  %1 = alloca i8*
+  %2 = alloca i32
+  %3 = load i8, i8* @_ZL11ShouldThrow, align 1, !dbg !17
+  %4 = trunc i8 %3 to i1, !dbg !17
+  br i1 %4, label %5, label %17, !dbg !20
+
+; <label>:5:                                      ; preds = %0
+  %6 = call i8* @__cxa_allocate_exception(i64 4) #4, !dbg !21
+  %7 = bitcast i8* %6 to i32*, !dbg !21
+  store i32 1, i32* %7, align 16, !dbg !21
+  invoke void @__cxa_throw(i8* %6, i8* bitcast (i8** @_ZTIi to i8*), i8* null) #5
+          to label %32 unwind label %8, !dbg !21
+
+; <label>:8:                                      ; preds = %5
+  %9 = landingpad { i8*, i32 }
+          catch i8* null, !dbg !23
+  %10 = extractvalue { i8*, i32 } %9, 0, !dbg !23
+  store i8* %10, i8** %1, align 8, !dbg !23
+  %11 = extractvalue { i8*, i32 } %9, 1, !dbg !23
+  store i32 %11, i32* %2, align 4, !dbg !23
+  br label %12, !dbg !23
+
+; <label>:12:                                     ; preds = %8
+  %13 = load i8*, i8** %1, align 8, !dbg !24
+  %14 = call i8* @__cxa_begin_catch(i8* %13) #4, !dbg !24
+  %15 = invoke i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i32 0, i32 0))
+          to label %16 unwind label %18, !dbg !25
+
+; <label>:16:                                     ; preds = %12
+  invoke void @__cxa_rethrow() #5
+          to label %32 unwind label %18, !dbg !27
+
+; <label>:17:                                     ; preds = %0
+  br label %23, !dbg !28
+
+; <label>:18:                                     ; preds = %16, %12
+  %19 = landingpad { i8*, i32 }
+          cleanup, !dbg !30
+  %20 = extractvalue { i8*, i32 } %19, 0, !dbg !30
+  store i8* %20, i8** %1, align 8, !dbg !30
+  %21 = extractvalue { i8*, i32 } %19, 1, !dbg !30
+  store i32 %21, i32* %2, align 4, !dbg !30
+  invoke void @__cxa_end_catch()
+          to label %22 unwind label %29, !dbg !32
+
+; <label>:22:                                     ; preds = %18
+  br label %24, !dbg !33
+
+; <label>:23:                                     ; preds = %17
+  ret void, !dbg !34
+
+; <label>:24:                                     ; preds = %22
+  %25 = load i8*, i8** %1, align 8, !dbg !36
+  %26 = load i32, i32* %2, align 4, !dbg !36
+  %27 = insertvalue { i8*, i32 } undef, i8* %25, 0, !dbg !36
+  %28 = insertvalue { i8*, i32 } %27, i32 %26, 1, !dbg !36
+  resume { i8*, i32 } %28, !dbg !36
+
+; <label>:29:                                     ; preds = %18
+  %30 = landingpad { i8*, i32 }
+          catch i8* null, !dbg !38
+  %31 = extractvalue { i8*, i32 } %30, 0, !dbg !38
+  call void @__clang_call_terminate(i8* %31) #6, !dbg !38
+  unreachable, !dbg !38
+
+; <label>:32:                                     ; preds = %16, %5
+  unreachable
+}
+
+declare i8* @__cxa_allocate_exception(i64)
+
+declare void @__cxa_throw(i8*, i8*, i8*)
+
+declare i32 @__gxx_personality_v0(...)
+
+declare i8* @__cxa_begin_catch(i8*)
+
+declare i32 @printf(i8*, ...) #1
+
+declare void @__cxa_rethrow()
+
+declare void @__cxa_end_catch()
+
+; Function Attrs: noinline noreturn nounwind
+define linkonce_odr hidden void @__clang_call_terminate(i8*) #2 comdat {
+  %2 = call i8* @__cxa_begin_catch(i8* %0) #4
+  call void @_ZSt9terminatev() #6
+  unreachable
+}
+
+declare void @_ZSt9terminatev()
+
+; Function Attrs: norecurse uwtable
+define i32 @main() #3 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) !dbg !7 {
+  %1 = alloca i32, align 4
+  %2 = alloca i8*
+  %3 = alloca i32
+  store i32 0, i32* %1, align 4
+  call void @_Z6throwsv(), !dbg !40
+  store i8 1, i8* @_ZL11ShouldThrow, align 1, !dbg !41
+  invoke void @_Z6throwsv()
+          to label %4 unwind label %5, !dbg !43
+
+; <label>:4:                                      ; preds = %0
+  br label %12, !dbg !44
+
+; <label>:5:                                      ; preds = %0
+  %6 = landingpad { i8*, i32 }
+          catch i8* null, !dbg !45
+  %7 = extractvalue { i8*, i32 } %6, 0, !dbg !45
+  store i8* %7, i8** %2, align 8, !dbg !45
+  %8 = extractvalue { i8*, i32 } %6, 1, !dbg !45
+  store i32 %8, i32* %3, align 4, !dbg !45
+  br label %9, !dbg !45
+
+; <label>:9:                                      ; preds = %5
+  %10 = load i8*, i8** %2, align 8, !dbg !46
+  %11 = call i8* @__cxa_begin_catch(i8* %10) #4, !dbg !46
+  store i32 1, i32* %1, align 4, !dbg !48
+  call void @__cxa_end_catch(), !dbg !50
+  br label %13
+
+; <label>:12:                                     ; preds = %4
+  store i32 0, i32* %1, align 4, !dbg !51
+  br label %13, !dbg !51
+
+; <label>:13:                                     ; preds = %12, %9
+  %14 = load i32, i32* %1, align 4, !dbg !52
+  ret i32 %14, !dbg !52
+}
+
+attributes #0 = { uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #2 = { noinline noreturn nounwind }
+attributes #3 = { norecurse uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #4 = { nounwind }
+attributes #5 = { noreturn }
+attributes #6 = { noreturn nounwind }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!14, !15}
+!llvm.ident = !{!16}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.9.0 (http://llvm.org/git/clang.git d7ffc218c4adde4846b58b3aa4b56312f9442d61) (http://llvm.org/git/llvm.git 8a96b704a3c73c081bf72f9bed1e5db5b4635d5e)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, subprograms: !3, globals: !11)
+!1 = !DIFile(filename: "throws-cfi-fp.cpp", directory: "epilogue-dwarf/test")
+!2 = !{}
+!3 = !{!4, !7}
+!4 = distinct !DISubprogram(name: "throws", linkageName: "_Z6throwsv", scope: !1, file: !1, line: 4, type: !5, isLocal: false, isDefinition: true, scopeLine: 4, flags: DIFlagPrototyped, isOptimized: false, variables: !2)
+!5 = !DISubroutineType(types: !6)
+!6 = !{null}
+!7 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 14, type: !8, isLocal: false, isDefinition: true, scopeLine: 14, flags: DIFlagPrototyped, isOptimized: false, variables: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10}
+!10 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!11 = !{!12}
+!12 = !DIGlobalVariable(name: "ShouldThrow", linkageName: "_ZL11ShouldThrow", scope: !0, file: !1, line: 2, type: !13, isLocal: true, isDefinition: true, variable: i8* @_ZL11ShouldThrow)
+!13 = !DIBasicType(name: "bool", size: 8, align: 8, encoding: DW_ATE_boolean)
+!14 = !{i32 2, !"Dwarf Version", i32 4}
+!15 = !{i32 2, !"Debug Info Version", i32 3}
+!16 = !{!"clang version 3.9.0 (http://llvm.org/git/clang.git d7ffc218c4adde4846b58b3aa4b56312f9442d61) (http://llvm.org/git/llvm.git 8a96b704a3c73c081bf72f9bed1e5db5b4635d5e)"}
+!17 = !DILocation(line: 7, column: 9, scope: !18)
+!18 = distinct !DILexicalBlock(scope: !19, file: !1, line: 7, column: 9)
+!19 = distinct !DILexicalBlock(scope: !4, file: !1, line: 6, column: 3)
+!20 = !DILocation(line: 7, column: 9, scope: !19)
+!21 = !DILocation(line: 7, column: 22, scope: !22)
+!22 = !DILexicalBlockFile(scope: !18, file: !1, discriminator: 1)
+!23 = !DILocation(line: 12, column: 1, scope: !18)
+!24 = !DILocation(line: 8, column: 3, scope: !19)
+!25 = !DILocation(line: 9, column: 5, scope: !26)
+!26 = distinct !DILexicalBlock(scope: !4, file: !1, line: 8, column: 17)
+!27 = !DILocation(line: 10, column: 5, scope: !26)
+!28 = !DILocation(line: 7, column: 31, scope: !29)
+!29 = !DILexicalBlockFile(scope: !19, file: !1, discriminator: 2)
+!30 = !DILocation(line: 12, column: 1, scope: !31)
+!31 = !DILexicalBlockFile(scope: !26, file: !1, discriminator: 1)
+!32 = !DILocation(line: 11, column: 3, scope: !26)
+!33 = !DILocation(line: 11, column: 3, scope: !31)
+!34 = !DILocation(line: 12, column: 1, scope: !35)
+!35 = !DILexicalBlockFile(scope: !4, file: !1, discriminator: 2)
+!36 = !DILocation(line: 11, column: 3, scope: !37)
+!37 = !DILexicalBlockFile(scope: !26, file: !1, discriminator: 2)
+!38 = !DILocation(line: 11, column: 3, scope: !39)
+!39 = !DILexicalBlockFile(scope: !26, file: !1, discriminator: 3)
+!40 = !DILocation(line: 15, column: 3, scope: !7)
+!41 = !DILocation(line: 17, column: 17, scope: !42)
+!42 = distinct !DILexicalBlock(scope: !7, file: !1, line: 16, column: 7)
+!43 = !DILocation(line: 18, column: 5, scope: !42)
+!44 = !DILocation(line: 19, column: 3, scope: !42)
+!45 = !DILocation(line: 23, column: 1, scope: !42)
+!46 = !DILocation(line: 19, column: 3, scope: !47)
+!47 = !DILexicalBlockFile(scope: !42, file: !1, discriminator: 1)
+!48 = !DILocation(line: 20, column: 5, scope: !49)
+!49 = distinct !DILexicalBlock(scope: !7, file: !1, line: 19, column: 17)
+!50 = !DILocation(line: 21, column: 3, scope: !49)
+!51 = !DILocation(line: 22, column: 3, scope: !7)
+!52 = !DILocation(line: 23, column: 1, scope: !53)
+!53 = !DILexicalBlockFile(scope: !7, file: !1, discriminator: 1)
Index: test/CodeGen/X86/throws-cfi-no-fp.ll
===================================================================
--- /dev/null
+++ test/CodeGen/X86/throws-cfi-no-fp.ll
@@ -0,0 +1,173 @@
+; RUN: llc %s -o - | FileCheck %s
+
+; ModuleID = 'throws-cfi-no-fp.cpp'
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+$__clang_call_terminate = comdat any
+
+@_ZL11ShouldThrow = internal unnamed_addr global i1 false, align 1
+@_ZTIi = external constant i8*
+@str = private unnamed_addr constant [20 x i8] c"Threw an exception!\00"
+
+; Function Attrs: uwtable
+define void @_Z6throwsv() #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) !dbg !4 {
+
+; CHECK-LABEL: _Z6throwsv:
+; CHECK:       popq
+; CHECK-NEXT:  :
+; CHECK-NEXT:  .cfi_def_cfa_offset 8
+; CHECK-NEXT:  ret
+; CHECK-NEXT:  .LBB0_2:
+; CHECK-NEXT:  :
+; CHECK-NEXT:  .loc  1 7 22 discriminator 1  # throws-cfi-no-fp.cpp:7:22
+; CHECK-NEXT:  :
+; CHECK-NEXT:  .cfi_def_cfa_offset 16
+
+  %.b1 = load i1, i1* @_ZL11ShouldThrow, align 1
+  br i1 %.b1, label %1, label %10, !dbg !17
+
+; <label>:1:                                      ; preds = %0
+  %2 = tail call i8* @__cxa_allocate_exception(i64 4) #3, !dbg !19
+  %3 = bitcast i8* %2 to i32*, !dbg !19
+  store i32 1, i32* %3, align 16, !dbg !19, !tbaa !22
+  invoke void @__cxa_throw(i8* %2, i8* bitcast (i8** @_ZTIi to i8*), i8* null) #4
+          to label %15 unwind label %4, !dbg !19
+
+; <label>:4:                                      ; preds = %1
+  %5 = landingpad { i8*, i32 }
+          catch i8* null, !dbg !26
+  %6 = extractvalue { i8*, i32 } %5, 0, !dbg !26
+  %7 = tail call i8* @__cxa_begin_catch(i8* %6) #3, !dbg !27
+  %puts = tail call i32 @puts(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @str, i64 0, i64 0)), !dbg !28
+  invoke void @__cxa_rethrow() #4
+          to label %15 unwind label %8, !dbg !30
+
+; <label>:8:                                      ; preds = %4
+  %9 = landingpad { i8*, i32 }
+          cleanup, !dbg !31
+  invoke void @__cxa_end_catch()
+          to label %11 unwind label %12, !dbg !33
+
+; <label>:10:                                     ; preds = %0
+  ret void, !dbg !34
+
+; <label>:11:                                     ; preds = %8
+  resume { i8*, i32 } %9, !dbg !36
+
+; <label>:12:                                     ; preds = %8
+  %13 = landingpad { i8*, i32 }
+          catch i8* null, !dbg !38
+  %14 = extractvalue { i8*, i32 } %13, 0, !dbg !38
+  tail call void @__clang_call_terminate(i8* %14) #5, !dbg !38
+  unreachable, !dbg !38
+
+; <label>:15:                                     ; preds = %4, %1
+  unreachable
+}
+
+declare i8* @__cxa_allocate_exception(i64)
+
+declare void @__cxa_throw(i8*, i8*, i8*)
+
+declare i32 @__gxx_personality_v0(...)
+
+declare i8* @__cxa_begin_catch(i8*)
+
+declare void @__cxa_rethrow()
+
+declare void @__cxa_end_catch()
+
+; Function Attrs: noinline noreturn nounwind
+define linkonce_odr hidden void @__clang_call_terminate(i8*) #1 comdat {
+  %2 = tail call i8* @__cxa_begin_catch(i8* %0) #3
+  tail call void @_ZSt9terminatev() #5
+  unreachable
+}
+
+declare void @_ZSt9terminatev()
+
+; Function Attrs: norecurse uwtable
+define i32 @main() #2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) !dbg !7 {
+  tail call void @_Z6throwsv(), !dbg !40
+  store i1 true, i1* @_ZL11ShouldThrow, align 1
+  invoke void @_Z6throwsv()
+          to label %5 unwind label %1, !dbg !41
+
+; <label>:1:                                      ; preds = %0
+  %2 = landingpad { i8*, i32 }
+          catch i8* null, !dbg !43
+  %3 = extractvalue { i8*, i32 } %2, 0, !dbg !43
+  %4 = tail call i8* @__cxa_begin_catch(i8* %3) #3, !dbg !44
+  tail call void @__cxa_end_catch(), !dbg !46
+  br label %5
+
+; <label>:5:                                      ; preds = %0, %1
+  %.0 = phi i32 [ 1, %1 ], [ 0, %0 ]
+  ret i32 %.0, !dbg !48
+}
+
+; Function Attrs: nounwind
+declare i32 @puts(i8* nocapture) #3
+
+attributes #0 = { uwtable "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-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { noinline noreturn nounwind }
+attributes #2 = { norecurse uwtable "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-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #3 = { nounwind }
+attributes #4 = { noreturn }
+attributes #5 = { noreturn nounwind }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!14, !15}
+!llvm.ident = !{!16}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.9.0 (http://llvm.org/git/clang.git d7ffc218c4adde4846b58b3aa4b56312f9442d61) (http://llvm.org/git/llvm.git 8a96b704a3c73c081bf72f9bed1e5db5b4635d5e)", isOptimized: true, runtimeVersion: 0, emissionKind: 1, enums: !2, subprograms: !3, globals: !11)
+!1 = !DIFile(filename: "throws-cfi-no-fp.cpp", directory: "epilogue-dwarf/test")
+!2 = !{}
+!3 = !{!4, !7}
+!4 = distinct !DISubprogram(name: "throws", linkageName: "_Z6throwsv", scope: !1, file: !1, line: 4, type: !5, isLocal: false, isDefinition: true, scopeLine: 4, flags: DIFlagPrototyped, isOptimized: true, variables: !2)
+!5 = !DISubroutineType(types: !6)
+!6 = !{null}
+!7 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 14, type: !8, isLocal: false, isDefinition: true, scopeLine: 14, flags: DIFlagPrototyped, isOptimized: true, variables: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10}
+!10 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!11 = !{!12}
+!12 = !DIGlobalVariable(name: "ShouldThrow", linkageName: "_ZL11ShouldThrow", scope: !0, file: !1, line: 2, type: !13, isLocal: true, isDefinition: true)
+!13 = !DIBasicType(name: "bool", size: 8, align: 8, encoding: DW_ATE_boolean)
+!14 = !{i32 2, !"Dwarf Version", i32 4}
+!15 = !{i32 2, !"Debug Info Version", i32 3}
+!16 = !{!"clang version 3.9.0 (http://llvm.org/git/clang.git d7ffc218c4adde4846b58b3aa4b56312f9442d61) (http://llvm.org/git/llvm.git 8a96b704a3c73c081bf72f9bed1e5db5b4635d5e)"}
+!17 = !DILocation(line: 7, column: 9, scope: !18)
+!18 = distinct !DILexicalBlock(scope: !4, file: !1, line: 6, column: 3)
+!19 = !DILocation(line: 7, column: 22, scope: !20)
+!20 = !DILexicalBlockFile(scope: !21, file: !1, discriminator: 1)
+!21 = distinct !DILexicalBlock(scope: !18, file: !1, line: 7, column: 9)
+!22 = !{!23, !23, i64 0}
+!23 = !{!"int", !24, i64 0}
+!24 = !{!"omnipotent char", !25, i64 0}
+!25 = !{!"Simple C++ TBAA"}
+!26 = !DILocation(line: 12, column: 1, scope: !21)
+!27 = !DILocation(line: 8, column: 3, scope: !18)
+!28 = !DILocation(line: 9, column: 5, scope: !29)
+!29 = distinct !DILexicalBlock(scope: !4, file: !1, line: 8, column: 17)
+!30 = !DILocation(line: 10, column: 5, scope: !29)
+!31 = !DILocation(line: 12, column: 1, scope: !32)
+!32 = !DILexicalBlockFile(scope: !29, file: !1, discriminator: 1)
+!33 = !DILocation(line: 11, column: 3, scope: !29)
+!34 = !DILocation(line: 12, column: 1, scope: !35)
+!35 = !DILexicalBlockFile(scope: !4, file: !1, discriminator: 2)
+!36 = !DILocation(line: 11, column: 3, scope: !37)
+!37 = !DILexicalBlockFile(scope: !29, file: !1, discriminator: 2)
+!38 = !DILocation(line: 11, column: 3, scope: !39)
+!39 = !DILexicalBlockFile(scope: !29, file: !1, discriminator: 3)
+!40 = !DILocation(line: 15, column: 3, scope: !7)
+!41 = !DILocation(line: 18, column: 5, scope: !42)
+!42 = distinct !DILexicalBlock(scope: !7, file: !1, line: 16, column: 7)
+!43 = !DILocation(line: 23, column: 1, scope: !42)
+!44 = !DILocation(line: 19, column: 3, scope: !45)
+!45 = !DILexicalBlockFile(scope: !42, file: !1, discriminator: 1)
+!46 = !DILocation(line: 21, column: 3, scope: !47)
+!47 = distinct !DILexicalBlock(scope: !7, file: !1, line: 19, column: 17)
+!48 = !DILocation(line: 23, column: 1, scope: !49)
+!49 = !DILexicalBlockFile(scope: !7, file: !1, discriminator: 1)