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

Rename EH related stuff to be more precise

Browse Source 
Summary:
The current "WinEH" exception handling type is more about Itanium-style
LSDA tables layered on top of the Windows native unwind info format
instead of .eh_frame tables or EHABI unwind info. Use the name
"ItaniumWinEH" to better reflect the hybrid nature of the design.

Also rename isExceptionHandlingDWARF to usesItaniumLSDAForExceptions,
since the LSDA is part of the Itanium C++ ABI document, and not the
DWARF standard.

Reviewers: echristo

Subscribers: llvm-commits, compnerd

Differential Revision: http://reviews.llvm.org/D6279

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@222062 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Reid Kleckner 2014-11-14 23:31:07 +00:00
parent e2eb8b632d
commit 0737b4ee14
7 changed files with 29 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
include/llvm/MC/MCAsmInfo.h
View File

@ -42,11 +42,11 @@ enum class EncodingType {
}
enum class ExceptionHandling {
None, /// No exception support
DwarfCFI, /// DWARF-like instruction based exceptions
SjLj, /// setjmp/longjmp based exceptions
ARM, /// ARM EHABI
WinEH, /// Windows Exception Handling
None, /// No exception support
DwarfCFI, /// DWARF-like instruction based exceptions
SjLj, /// setjmp/longjmp based exceptions
ARM, /// ARM EHABI
ItaniumWinEH, /// Itanium EH built on Windows unwind info (.pdata and .xdata)
};
namespace LCOMM {
@ -472,12 +472,16 @@ public:
}
ExceptionHandling getExceptionHandlingType() const { return ExceptionsType; }
WinEH::EncodingType getWinEHEncodingType() const { return WinEHEncodingType; }
bool isExceptionHandlingDwarf() const {
/// Return true if the exception handling type uses the language-specific data
/// area (LSDA) format specified by the Itanium C++ ABI.
bool usesItaniumLSDAForExceptions() const {
return (ExceptionsType == ExceptionHandling::DwarfCFI ||
ExceptionsType == ExceptionHandling::ARM ||
// Windows handler data still uses DWARF LSDA encoding.
ExceptionsType == ExceptionHandling::WinEH);
// This Windows EH type uses the Itanium LSDA encoding.
ExceptionsType == ExceptionHandling::ItaniumWinEH);
}
bool doesDwarfUseRelocationsAcrossSections() const {
return DwarfUsesRelocationsAcrossSections;
}

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

@ -241,7 +241,7 @@ bool AsmPrinter::doInitialization(Module &M) {
case ExceptionHandling::ARM:
ES = new ARMException(this);
break;
case ExceptionHandling::WinEH:
case ExceptionHandling::ItaniumWinEH:
switch (MAI->getWinEHEncodingType()) {
default: llvm_unreachable("unsupported unwinding information encoding");
case WinEH::EncodingType::Itanium:
@ -701,8 +701,8 @@ AsmPrinter::CFIMoveType AsmPrinter::needsCFIMoves() {
}
bool AsmPrinter::needsSEHMoves() {
return MAI->getExceptionHandlingType() == ExceptionHandling::WinEH &&
MF->getFunction()->needsUnwindTableEntry();
return MAI->getExceptionHandlingType() == ExceptionHandling::ItaniumWinEH &&
MF->getFunction()->needsUnwindTableEntry();
}
void AsmPrinter::emitCFIInstruction(const MachineInstr &MI) {

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

@ -51,7 +51,7 @@ void DwarfCFIException::endModule() {
if (moveTypeModule == AsmPrinter::CFI_M_Debug)
Asm->OutStreamer.EmitCFISections(false, true);
if (!Asm->MAI->isExceptionHandlingDwarf())
if (!Asm->MAI->usesItaniumLSDAForExceptions())
return;
const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();

10
lib/CodeGen/AsmPrinter/EHStreamer.cpp
View File

@ -237,7 +237,7 @@ computeCallSiteTable(SmallVectorImpl<CallSiteEntry> &CallSites,
// instruction between the previous try-range and this one may throw,
// create a call-site entry with no landing pad for the region between the
// try-ranges.
if (SawPotentiallyThrowing && Asm->MAI->isExceptionHandlingDwarf()) {
if (SawPotentiallyThrowing && Asm->MAI->usesItaniumLSDAForExceptions()) {
CallSiteEntry Site = { LastLabel, BeginLabel, nullptr, 0 };
CallSites.push_back(Site);
PreviousIsInvoke = false;
@ -259,7 +259,7 @@ computeCallSiteTable(SmallVectorImpl<CallSiteEntry> &CallSites,
};
// Try to merge with the previous call-site. SJLJ doesn't do this
if (PreviousIsInvoke && Asm->MAI->isExceptionHandlingDwarf()) {
if (PreviousIsInvoke && Asm->MAI->usesItaniumLSDAForExceptions()) {
CallSiteEntry &Prev = CallSites.back();
if (Site.PadLabel == Prev.PadLabel && Site.Action == Prev.Action) {
// Extend the range of the previous entry.
@ -269,7 +269,7 @@ computeCallSiteTable(SmallVectorImpl<CallSiteEntry> &CallSites,
}
// Otherwise, create a new call-site.
if (Asm->MAI->isExceptionHandlingDwarf())
if (Asm->MAI->usesItaniumLSDAForExceptions())
CallSites.push_back(Site);
else {
// SjLj EH must maintain the call sites in the order assigned
@ -287,7 +287,7 @@ computeCallSiteTable(SmallVectorImpl<CallSiteEntry> &CallSites,
// If some instruction between the previous try-range and the end of the
// function may throw, create a call-site entry with no landing pad for the
// region following the try-range.
if (SawPotentiallyThrowing && Asm->MAI->isExceptionHandlingDwarf()) {
if (SawPotentiallyThrowing && Asm->MAI->usesItaniumLSDAForExceptions()) {
CallSiteEntry Site = { LastLabel, nullptr, nullptr, 0 };
CallSites.push_back(Site);
}
@ -520,7 +520,7 @@ void EHStreamer::emitExceptionTable() {
}
} else {
// DWARF Exception handling
assert(Asm->MAI->isExceptionHandlingDwarf());
assert(Asm->MAI->usesItaniumLSDAForExceptions());
// The call-site table is a list of all call sites that may throw an
// exception (including C++ 'throw' statements) in the procedure

2
lib/CodeGen/Passes.cpp
View File

@ -429,7 +429,7 @@ void TargetPassConfig::addPassesToHandleExceptions() {
// FALLTHROUGH
case ExceptionHandling::DwarfCFI:
case ExceptionHandling::ARM:
case ExceptionHandling::WinEH:
case ExceptionHandling::ItaniumWinEH:
addPass(createDwarfEHPass(TM));
break;
case ExceptionHandling::None:

4
lib/Target/X86/MCTargetDesc/X86MCAsmInfo.cpp
View File

@ -137,7 +137,7 @@ X86MCAsmInfoMicrosoft::X86MCAsmInfoMicrosoft(const Triple &Triple) {
PrivateGlobalPrefix = ".L";
PointerSize = 8;
WinEHEncodingType = WinEH::EncodingType::Itanium;
ExceptionsType = ExceptionHandling::WinEH;
ExceptionsType = ExceptionHandling::ItaniumWinEH;
}
AssemblerDialect = AsmWriterFlavor;
@ -157,7 +157,7 @@ X86MCAsmInfoGNUCOFF::X86MCAsmInfoGNUCOFF(const Triple &Triple) {
PrivateGlobalPrefix = ".L";
PointerSize = 8;
WinEHEncodingType = WinEH::EncodingType::Itanium;
ExceptionsType = ExceptionHandling::WinEH;
ExceptionsType = ExceptionHandling::ItaniumWinEH;
} else {
ExceptionsType = ExceptionHandling::DwarfCFI;
}

11
lib/Target/X86/X86FrameLowering.cpp
View File

@ -482,9 +482,9 @@ void X86FrameLowering::emitPrologue(MachineFunction &MF) const {
// standard x86_64 and NaCl use 64-bit frame/stack pointers, x32 - 32-bit.
const bool Uses64BitFramePtr = STI.isTarget64BitLP64() || STI.isTargetNaCl64();
bool IsWin64 = STI.isTargetWin64();
bool IsWinEH =
MF.getTarget().getMCAsmInfo()->getExceptionHandlingType() ==
ExceptionHandling::WinEH; // Not necessarily synonymous with IsWin64.
// Not necessarily synonymous with IsWin64.
bool IsWinEH = MF.getTarget().getMCAsmInfo()->getExceptionHandlingType() ==
ExceptionHandling::ItaniumWinEH;
bool NeedsWinEH = IsWinEH && Fn->needsUnwindTableEntry();
bool NeedsDwarfCFI =
!IsWinEH && (MMI.hasDebugInfo() || Fn->needsUnwindTableEntry());
@ -883,9 +883,8 @@ void X86FrameLowering::emitEpilogue(MachineFunction &MF,
getX86SubSuperRegister(FramePtr, MVT::i64, false) : FramePtr;
unsigned StackPtr = RegInfo->getStackRegister();
bool IsWinEH =
MF.getTarget().getMCAsmInfo()->getExceptionHandlingType() ==
ExceptionHandling::WinEH;
bool IsWinEH = MF.getTarget().getMCAsmInfo()->getExceptionHandlingType() ==
ExceptionHandling::ItaniumWinEH;
bool NeedsWinEH = IsWinEH && MF.getFunction()->needsUnwindTableEntry();
switch (RetOpcode) {