6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-27 13:30:05 +00:00
Code Issues Projects Releases Wiki Activity

CodeGen: refactor DwarfException

Browse Source 
DwarfException served as a base class for exception handling directive emission.
However, this is also used by other exception models (e.g. Win64EH).  Rename
this class to EHStreamer and split it out of DwarfException.h.  NFC.

Use the opportunity to fix up some of the documentation comments to match
current LLVM style.  Also rename some functions to conform better with current
LLVM coding style.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@210622 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Saleem Abdulrasool 2014-06-11 01:19:03 +00:00
parent c3c6d5fcb8
commit 095271bcf4
9 changed files with 201 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/llvm/CodeGen/AsmPrinter.h
View File

@ -52,7 +52,6 @@ class MCSubtargetInfo;
class MCSymbol;
class MDNode;
class DwarfDebug;
class DwarfException;
class Mangler;
class TargetLoweringObjectFile;
class DataLayout;

7
lib/CodeGen/AsmPrinter/ARMException.cpp
View File

@ -37,8 +37,7 @@
using namespace llvm;
ARMException::ARMException(AsmPrinter *A)
: DwarfException(A),
shouldEmitCFI(false) {}
: EHStreamer(A), shouldEmitCFI(false) {}
ARMException::~ARMException() {}
@ -100,7 +99,7 @@ void ARMException::endFunction(const MachineFunction *) {
ATS.emitHandlerData();
// Emit actual exception table
EmitExceptionTable();
emitExceptionTable();
}
}
@ -108,7 +107,7 @@ void ARMException::endFunction(const MachineFunction *) {
ATS.emitFnEnd();
}
void ARMException::EmitTypeInfos(unsigned TTypeEncoding) {
void ARMException::emitTypeInfos(unsigned TTypeEncoding) {
const std::vector<const GlobalVariable *> &TypeInfos = MMI->getTypeInfos();
const std::vector<unsigned> &FilterIds = MMI->getFilterIds();

12
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
View File

@ -233,23 +233,23 @@ bool AsmPrinter::doInitialization(Module &M) {
}
}
DwarfException *DE = nullptr;
EHStreamer *ES = nullptr;
switch (MAI->getExceptionHandlingType()) {
case ExceptionHandling::None:
break;
case ExceptionHandling::SjLj:
case ExceptionHandling::DwarfCFI:
DE = new DwarfCFIException(this);
ES = new DwarfCFIException(this);
break;
case ExceptionHandling::ARM:
DE = new ARMException(this);
ES = new ARMException(this);
break;
case ExceptionHandling::Win64:
DE = new Win64Exception(this);
ES = new Win64Exception(this);
break;
}
if (DE)
Handlers.push_back(HandlerInfo(DE, EHTimerName, DWARFGroupName));
if (ES)
Handlers.push_back(HandlerInfo(ES, EHTimerName, DWARFGroupName));
return false;
}

2
lib/CodeGen/AsmPrinter/CMakeLists.txt
View File

@ -10,10 +10,10 @@ add_llvm_library(LLVMAsmPrinter
DwarfAccelTable.cpp
DwarfCFIException.cpp
DwarfDebug.cpp
DwarfException.cpp
DwarfFile.cpp
DwarfStringPool.cpp
DwarfUnit.cpp
EHStreamer.cpp
ErlangGCPrinter.cpp
OcamlGCPrinter.cpp
Win64Exception.cpp

7
lib/CodeGen/AsmPrinter/DwarfCFIException.cpp
View File

@ -40,9 +40,8 @@
using namespace llvm;
DwarfCFIException::DwarfCFIException(AsmPrinter *A)
: DwarfException(A),
shouldEmitPersonality(false), shouldEmitLSDA(false), shouldEmitMoves(false),
moveTypeModule(AsmPrinter::CFI_M_None) {}
: EHStreamer(A), shouldEmitPersonality(false), shouldEmitLSDA(false),
shouldEmitMoves(false), moveTypeModule(AsmPrinter::CFI_M_None) {}
DwarfCFIException::~DwarfCFIException() {}
@ -153,5 +152,5 @@ void DwarfCFIException::endFunction(const MachineFunction *) {
// Map all labels and get rid of any dead landing pads.
MMI->TidyLandingPads();
EmitExceptionTable();
emitExceptionTable();
}

134
lib/CodeGen/AsmPrinter/DwarfException.h
View File

@ -14,138 +14,14 @@
#ifndef LLVM_CODEGEN_ASMPRINTER_DWARFEXCEPTION_H
#define LLVM_CODEGEN_ASMPRINTER_DWARFEXCEPTION_H
#include "AsmPrinterHandler.h"
#include "llvm/ADT/DenseMap.h"
#include "EHStreamer.h"
#include "llvm/CodeGen/AsmPrinter.h"
#include <vector>
namespace llvm {
template <typename T> class SmallVectorImpl;
struct LandingPadInfo;
class MachineModuleInfo;
class MachineInstr;
class MachineFunction;
class MCAsmInfo;
class MCExpr;
class MCSymbol;
class Function;
class ARMTargetStreamer;
class AsmPrinter;
//===----------------------------------------------------------------------===//
/// DwarfException - Emits Dwarf exception handling directives.
///
class DwarfException : public AsmPrinterHandler {
protected:
/// Asm - Target of Dwarf emission.
AsmPrinter *Asm;
/// MMI - Collected machine module information.
MachineModuleInfo *MMI;
/// SharedTypeIds - How many leading type ids two landing pads have in common.
static unsigned SharedTypeIds(const LandingPadInfo *L,
const LandingPadInfo *R);
/// PadRange - Structure holding a try-range and the associated landing pad.
struct PadRange {
// The index of the landing pad.
unsigned PadIndex;
// The index of the begin and end labels in the landing pad's label lists.
unsigned RangeIndex;
};
typedef DenseMap<MCSymbol *, PadRange> RangeMapType;
/// ActionEntry - Structure describing an entry in the actions table.
struct ActionEntry {
int ValueForTypeID; // The value to write - may not be equal to the type id.
int NextAction;
unsigned Previous;
};
/// CallSiteEntry - Structure describing an entry in the call-site table.
struct CallSiteEntry {
// The 'try-range' is BeginLabel .. EndLabel.
MCSymbol *BeginLabel; // zero indicates the start of the function.
MCSymbol *EndLabel; // zero indicates the end of the function.
// The landing pad starts at PadLabel.
MCSymbol *PadLabel; // zero indicates that there is no landing pad.
unsigned Action;
};
/// ComputeActionsTable - Compute the actions table and gather the first
/// action index for each landing pad site.
unsigned ComputeActionsTable(const SmallVectorImpl<const LandingPadInfo*>&LPs,
SmallVectorImpl<ActionEntry> &Actions,
SmallVectorImpl<unsigned> &FirstActions);
/// CallToNoUnwindFunction - Return `true' if this is a call to a function
/// marked `nounwind'. Return `false' otherwise.
bool CallToNoUnwindFunction(const MachineInstr *MI);
/// ComputeCallSiteTable - Compute the call-site table. The entry for an
/// invoke has a try-range containing the call, a non-zero landing pad and an
/// appropriate action. The entry for an ordinary call has a try-range
/// containing the call and zero for the landing pad and the action. Calls
/// marked 'nounwind' have no entry and must not be contained in the try-range
/// of any entry - they form gaps in the table. Entries must be ordered by
/// try-range address.
void ComputeCallSiteTable(SmallVectorImpl<CallSiteEntry> &CallSites,
const RangeMapType &PadMap,
const SmallVectorImpl<const LandingPadInfo *> &LPs,
const SmallVectorImpl<unsigned> &FirstActions);
/// EmitExceptionTable - Emit landing pads and actions.
///
/// The general organization of the table is complex, but the basic concepts
/// are easy. First there is a header which describes the location and
/// organization of the three components that follow.
/// 1. The landing pad site information describes the range of code covered
/// by the try. In our case it's an accumulation of the ranges covered
/// by the invokes in the try. There is also a reference to the landing
/// pad that handles the exception once processed. Finally an index into
/// the actions table.
/// 2. The action table, in our case, is composed of pairs of type ids
/// and next action offset. Starting with the action index from the
/// landing pad site, each type Id is checked for a match to the current
/// exception. If it matches then the exception and type id are passed
/// on to the landing pad. Otherwise the next action is looked up. This
/// chain is terminated with a next action of zero. If no type id is
/// found the frame is unwound and handling continues.
/// 3. Type id table contains references to all the C++ typeinfo for all
/// catches in the function. This tables is reversed indexed base 1.
void EmitExceptionTable();
virtual void EmitTypeInfos(unsigned TTypeEncoding);
public:
//===--------------------------------------------------------------------===//
// Main entry points.
//
DwarfException(AsmPrinter *A);
virtual ~DwarfException();
/// endModule - Emit all exception information that should come after the
/// content.
void endModule() override;
/// beginFunction - Gather pre-function exception information. Assumes being
/// emitted immediately after the function entry point.
void beginFunction(const MachineFunction *MF) override;
/// endFunction - Gather and emit post-function exception information.
void endFunction(const MachineFunction *) override;
// We don't need these.
void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override {}
void beginInstruction(const MachineInstr *MI) override {}
void endInstruction() override {}
};
class DwarfCFIException : public DwarfException {
class DwarfCFIException : public EHStreamer {
/// shouldEmitPersonality - Per-function flag to indicate if .cfi_personality
/// should be emitted.
bool shouldEmitPersonality;
@ -179,8 +55,8 @@ public:
void endFunction(const MachineFunction *) override;
};
class ARMException : public DwarfException {
void EmitTypeInfos(unsigned TTypeEncoding) override;
class ARMException : public EHStreamer {
void emitTypeInfos(unsigned TTypeEncoding) override;
ARMTargetStreamer &getTargetStreamer();
/// shouldEmitCFI - Per-function flag to indicate if frame CFI info
@ -206,7 +82,7 @@ public:
void endFunction(const MachineFunction *) override;
};
class Win64Exception : public DwarfException {
class Win64Exception : public EHStreamer {
/// shouldEmitPersonality - Per-function flag to indicate if personality
/// info should be emitted.
bool shouldEmitPersonality;

99
lib/CodeGen/AsmPrinter/DwarfException.cpp → lib/CodeGen/AsmPrinter/EHStreamer.cpp
View File

@ -1,4 +1,4 @@
//===-- CodeGen/AsmPrinter/DwarfException.cpp - Dwarf Exception Impl ------===//
//===-- CodeGen/AsmPrinter/EHStreamer.cpp - Exception Directive Streamer --===//
//
// The LLVM Compiler Infrastructure
//
@ -7,45 +7,31 @@
//
//===----------------------------------------------------------------------===//
//
// This file contains support for writing DWARF exception info into asm files.
// This file contains support for writing exception info into assembly files.
//
//===----------------------------------------------------------------------===//
#include "DwarfException.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/Twine.h"
#include "EHStreamer.h"
#include "llvm/CodeGen/AsmPrinter.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/Mangler.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Function.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCSection.h"
#include "llvm/MC/MCStreamer.h"
#include "llvm/MC/MCSymbol.h"
#include "llvm/Support/Dwarf.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormattedStream.h"
#include "llvm/Support/LEB128.h"
#include "llvm/Target/TargetFrameLowering.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/Target/TargetRegisterInfo.h"
using namespace llvm;
DwarfException::DwarfException(AsmPrinter *A)
: Asm(A), MMI(Asm->MMI) {}
EHStreamer::EHStreamer(AsmPrinter *A) : Asm(A), MMI(Asm->MMI) {}
DwarfException::~DwarfException() {}
EHStreamer::~EHStreamer() {}
/// SharedTypeIds - How many leading type ids two landing pads have in common.
unsigned DwarfException::SharedTypeIds(const LandingPadInfo *L,
const LandingPadInfo *R) {
/// How many leading type ids two landing pads have in common.
unsigned EHStreamer::sharedTypeIDs(const LandingPadInfo *L,
const LandingPadInfo *R) {
const std::vector<int> &LIds = L->TypeIds, &RIds = R->TypeIds;
unsigned LSize = LIds.size(), RSize = RIds.size();
unsigned MinSize = LSize < RSize ? LSize : RSize;
@ -58,10 +44,10 @@ unsigned DwarfException::SharedTypeIds(const LandingPadInfo *L,
return Count;
}
/// ComputeActionsTable - Compute the actions table and gather the first action
/// index for each landing pad site.
unsigned DwarfException::
ComputeActionsTable(const SmallVectorImpl<const LandingPadInfo*> &LandingPads,
/// Compute the actions table and gather the first action index for each landing
/// pad site.
unsigned EHStreamer::
computeActionsTable(const SmallVectorImpl<const LandingPadInfo*> &LandingPads,
SmallVectorImpl<ActionEntry> &Actions,
SmallVectorImpl<unsigned> &FirstActions) {
@ -109,7 +95,7 @@ ComputeActionsTable(const SmallVectorImpl<const LandingPadInfo*> &LandingPads,
I = LandingPads.begin(), E = LandingPads.end(); I != E; ++I) {
const LandingPadInfo *LPI = *I;
const std::vector<int> &TypeIds = LPI->TypeIds;
unsigned NumShared = PrevLPI ? SharedTypeIds(LPI, PrevLPI) : 0;
unsigned NumShared = PrevLPI ? sharedTypeIDs(LPI, PrevLPI) : 0;
unsigned SizeSiteActions = 0;
if (NumShared < TypeIds.size()) {
@ -167,9 +153,9 @@ ComputeActionsTable(const SmallVectorImpl<const LandingPadInfo*> &LandingPads,
return SizeActions;
}
/// CallToNoUnwindFunction - Return `true' if this is a call to a function
/// marked `nounwind'. Return `false' otherwise.
bool DwarfException::CallToNoUnwindFunction(const MachineInstr *MI) {
/// Return `true' if this is a call to a function marked `nounwind'. Return
/// `false' otherwise.
bool EHStreamer::callToNoUnwindFunction(const MachineInstr *MI) {
assert(MI->isCall() && "This should be a call instruction!");
bool MarkedNoUnwind = false;
@ -201,15 +187,14 @@ bool DwarfException::CallToNoUnwindFunction(const MachineInstr *MI) {
return MarkedNoUnwind;
}
/// ComputeCallSiteTable - Compute the call-site table. The entry for an invoke
/// has a try-range containing the call, a non-zero landing pad, and an
/// appropriate action. The entry for an ordinary call has a try-range
/// containing the call and zero for the landing pad and the action. Calls
/// marked 'nounwind' have no entry and must not be contained in the try-range
/// of any entry - they form gaps in the table. Entries must be ordered by
/// try-range address.
void DwarfException::
ComputeCallSiteTable(SmallVectorImpl<CallSiteEntry> &CallSites,
/// Compute the call-site table. The entry for an invoke has a try-range
/// containing the call, a non-zero landing pad, and an appropriate action. The
/// entry for an ordinary call has a try-range containing the call and zero for
/// the landing pad and the action. Calls marked 'nounwind' have no entry and
/// must not be contained in the try-range of any entry - they form gaps in the
/// table. Entries must be ordered by try-range address.
void EHStreamer::
computeCallSiteTable(SmallVectorImpl<CallSiteEntry> &CallSites,
const RangeMapType &PadMap,
const SmallVectorImpl<const LandingPadInfo *> &LandingPads,
const SmallVectorImpl<unsigned> &FirstActions) {
@ -228,7 +213,7 @@ ComputeCallSiteTable(SmallVectorImpl<CallSiteEntry> &CallSites,
for (const auto &MI : MBB) {
if (!MI.isEHLabel()) {
if (MI.isCall())
SawPotentiallyThrowing |= !CallToNoUnwindFunction(&MI);
SawPotentiallyThrowing |= !callToNoUnwindFunction(&MI);
continue;
}
@ -308,7 +293,7 @@ ComputeCallSiteTable(SmallVectorImpl<CallSiteEntry> &CallSites,
}
}
/// EmitExceptionTable - Emit landing pads and actions.
/// Emit landing pads and actions.
///
/// The general organization of the table is complex, but the basic concepts are
/// easy. First there is a header which describes the location and organization
@ -328,7 +313,7 @@ ComputeCallSiteTable(SmallVectorImpl<CallSiteEntry> &CallSites,
/// unwound and handling continues.
/// 3. Type ID table contains references to all the C++ typeinfo for all
/// catches in the function. This tables is reverse indexed base 1.
void DwarfException::EmitExceptionTable() {
void EHStreamer::emitExceptionTable() {
const std::vector<const GlobalVariable *> &TypeInfos = MMI->getTypeInfos();
const std::vector<unsigned> &FilterIds = MMI->getFilterIds();
const std::vector<LandingPadInfo> &PadInfos = MMI->getLandingPads();
@ -350,7 +335,8 @@ void DwarfException::EmitExceptionTable() {
// landing pad site.
SmallVector<ActionEntry, 32> Actions;
SmallVector<unsigned, 64> FirstActions;
unsigned SizeActions=ComputeActionsTable(LandingPads, Actions, FirstActions);
unsigned SizeActions =
computeActionsTable(LandingPads, Actions, FirstActions);
// Invokes and nounwind calls have entries in PadMap (due to being bracketed
// by try-range labels when lowered). Ordinary calls do not, so appropriate
@ -368,7 +354,7 @@ void DwarfException::EmitExceptionTable() {
// Compute the call-site table.
SmallVector<CallSiteEntry, 64> CallSites;
ComputeCallSiteTable(CallSites, PadMap, LandingPads, FirstActions);
computeCallSiteTable(CallSites, PadMap, LandingPads, FirstActions);
// Final tallies.
@ -657,12 +643,12 @@ void DwarfException::EmitExceptionTable() {
Asm->EmitSLEB128(Action.NextAction);
}
EmitTypeInfos(TTypeEncoding);
emitTypeInfos(TTypeEncoding);
Asm->EmitAlignment(2);
}
void DwarfException::EmitTypeInfos(unsigned TTypeEncoding) {
void EHStreamer::emitTypeInfos(unsigned TTypeEncoding) {
const std::vector<const GlobalVariable *> &TypeInfos = MMI->getTypeInfos();
const std::vector<unsigned> &FilterIds = MMI->getFilterIds();
@ -703,19 +689,18 @@ void DwarfException::EmitTypeInfos(unsigned TTypeEncoding) {
}
}
/// endModule - Emit all exception information that should come after the
/// content.
void DwarfException::endModule() {
/// Emit all exception information that should come after the content.
void EHStreamer::endModule() {
llvm_unreachable("Should be implemented");
}
/// beginFunction - Gather pre-function exception information. Assumes it's
/// being emitted immediately after the function entry point.
void DwarfException::beginFunction(const MachineFunction *MF) {
/// Gather pre-function exception information. Assumes it's being emitted
/// immediately after the function entry point.
void EHStreamer::beginFunction(const MachineFunction *MF) {
llvm_unreachable("Should be implemented");
}
/// endFunction - Gather and emit post-function exception information.
void DwarfException::endFunction(const MachineFunction *) {
/// Gather and emit post-function exception information.
void EHStreamer::endFunction(const MachineFunction *) {
llvm_unreachable("Should be implemented");
}

138
lib/CodeGen/AsmPrinter/EHStreamer.h Normal file
View File

@ -0,0 +1,138 @@
//===-- EHStreamer.h - Exception Handling Directive Streamer ---*- C++ -*--===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains support for writing exception info into assembly files.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_ASMPRINTER_EHSTREAMER_H
#define LLVM_CODEGEN_ASMPRINTER_EHSTREAMER_H
#include "AsmPrinterHandler.h"
#include "llvm/ADT/DenseMap.h"
namespace llvm {
struct LandingPadInfo;
class MachineModuleInfo;
class MachineInstr;
class MachineFunction;
class AsmPrinter;
template <typename T>
class SmallVectorImpl;
/// Emits exception handling directives.
class EHStreamer : public AsmPrinterHandler {
protected:
/// Target of directive emission.
AsmPrinter *Asm;
/// Collected machine module information.
MachineModuleInfo *MMI;
/// How many leading type ids two landing pads have in common.
static unsigned sharedTypeIDs(const LandingPadInfo *L,
const LandingPadInfo *R);
/// Structure holding a try-range and the associated landing pad.
struct PadRange {
// The index of the landing pad.
unsigned PadIndex;
// The index of the begin and end labels in the landing pad's label lists.
unsigned RangeIndex;
};
typedef DenseMap<MCSymbol *, PadRange> RangeMapType;
/// Structure describing an entry in the actions table.
struct ActionEntry {
int ValueForTypeID; // The value to write - may not be equal to the type id.
int NextAction;
unsigned Previous;
};
/// Structure describing an entry in the call-site table.
struct CallSiteEntry {
// The 'try-range' is BeginLabel .. EndLabel.
MCSymbol *BeginLabel; // zero indicates the start of the function.
MCSymbol *EndLabel; // zero indicates the end of the function.
// The landing pad starts at PadLabel.
MCSymbol *PadLabel; // zero indicates that there is no landing pad.
unsigned Action;
};
/// Compute the actions table and gather the first action index for each
/// landing pad site.
unsigned computeActionsTable(const SmallVectorImpl<const LandingPadInfo*>&LPs,
SmallVectorImpl<ActionEntry> &Actions,
SmallVectorImpl<unsigned> &FirstActions);
/// Return `true' if this is a call to a function marked `nounwind'. Return
/// `false' otherwise.
bool callToNoUnwindFunction(const MachineInstr *MI);
/// Compute the call-site table. The entry for an invoke has a try-range
/// containing the call, a non-zero landing pad and an appropriate action.
/// The entry for an ordinary call has a try-range containing the call and
/// zero for the landing pad and the action. Calls marked 'nounwind' have
/// no entry and must not be contained in the try-range of any entry - they
/// form gaps in the table. Entries must be ordered by try-range address.
void computeCallSiteTable(SmallVectorImpl<CallSiteEntry> &CallSites,
const RangeMapType &PadMap,
const SmallVectorImpl<const LandingPadInfo *> &LPs,
const SmallVectorImpl<unsigned> &FirstActions);
/// Emit landing pads and actions.
///
/// The general organization of the table is complex, but the basic concepts
/// are easy. First there is a header which describes the location and
/// organization of the three components that follow.
/// 1. The landing pad site information describes the range of code covered
/// by the try. In our case it's an accumulation of the ranges covered
/// by the invokes in the try. There is also a reference to the landing
/// pad that handles the exception once processed. Finally an index into
/// the actions table.
/// 2. The action table, in our case, is composed of pairs of type ids
/// and next action offset. Starting with the action index from the
/// landing pad site, each type Id is checked for a match to the current
/// exception. If it matches then the exception and type id are passed
/// on to the landing pad. Otherwise the next action is looked up. This
/// chain is terminated with a next action of zero. If no type id is
/// found the frame is unwound and handling continues.
/// 3. Type id table contains references to all the C++ typeinfo for all
/// catches in the function. This tables is reversed indexed base 1.
void emitExceptionTable();
virtual void emitTypeInfos(unsigned TTypeEncoding);
public:
EHStreamer(AsmPrinter *A);
virtual ~EHStreamer();
/// Emit all exception information that should come after the content.
void endModule() override;
/// Gather pre-function exception information. Assumes being emitted
/// immediately after the function entry point.
void beginFunction(const MachineFunction *MF) override;
/// Gather and emit post-function exception information.
void endFunction(const MachineFunction *) override;
// Unused.
void setSymbolSize(const MCSymbol *Sym, uint64_t Size) override {}
void beginInstruction(const MachineInstr *MI) override {}
void endInstruction() override {}
};
}
#endif

7
lib/CodeGen/AsmPrinter/Win64Exception.cpp
View File

@ -38,9 +38,8 @@
using namespace llvm;
Win64Exception::Win64Exception(AsmPrinter *A)
: DwarfException(A),
shouldEmitPersonality(false), shouldEmitLSDA(false), shouldEmitMoves(false)
{}
: EHStreamer(A), shouldEmitPersonality(false), shouldEmitLSDA(false),
shouldEmitMoves(false) {}
Win64Exception::~Win64Exception() {}
@ -108,7 +107,7 @@ void Win64Exception::endFunction(const MachineFunction *) {
Asm->OutStreamer.EmitWin64EHHandlerData();
Asm->OutStreamer.EmitValue(MCSymbolRefExpr::Create(Sym, Asm->OutContext),
4);
EmitExceptionTable();
emitExceptionTable();
Asm->OutStreamer.PopSection();
}
Asm->OutStreamer.EmitWin64EHEndProc();