//
// The LLVM Compiler Infrastructure
//
-// This file was developed by James M. Laskey and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
#include "llvm/Support/Mangler.h"
#include "llvm/System/Path.h"
#include "llvm/Target/TargetAsmInfo.h"
-#include "llvm/Target/MRegisterInfo.h"
+#include "llvm/Target/TargetRegisterInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetFrameInfo.h"
#include "llvm/Target/TargetInstrInfo.h"
const TargetData *TD;
/// RI - Register Information.
- const MRegisterInfo *RI;
+ const TargetRegisterInfo *RI;
/// M - Current module.
///
AsmPrinter *getAsm() const { return Asm; }
MachineModuleInfo *getMMI() const { return MMI; }
const TargetAsmInfo *getTargetAsmInfo() const { return TAI; }
+ const TargetData *getTargetData() const { return TD; }
void PrintRelDirective(bool Force32Bit = false, bool isInSection = false)
const {
if (isInSection && TAI->getDwarfSectionOffsetDirective())
O << TAI->getDwarfSectionOffsetDirective();
- else if (Force32Bit || TAI->getAddressSize() == sizeof(int32_t))
+ else if (Force32Bit || TD->getPointerSize() == sizeof(int32_t))
O << TAI->getData32bitsDirective();
else
O << TAI->getData64bitsDirective();
/// EmitReference - Emit a reference to a label.
///
- void EmitReference(DWLabel Label, bool IsPCRelative = false) const {
- EmitReference(Label.Tag, Label.Number, IsPCRelative);
+ void EmitReference(DWLabel Label, bool IsPCRelative = false,
+ bool Force32Bit = false) const {
+ EmitReference(Label.Tag, Label.Number, IsPCRelative, Force32Bit);
}
void EmitReference(const char *Tag, unsigned Number,
- bool IsPCRelative = false) const {
- PrintRelDirective();
+ bool IsPCRelative = false, bool Force32Bit = false) const {
+ PrintRelDirective(Force32Bit);
PrintLabelName(Tag, Number);
if (IsPCRelative) O << "-" << TAI->getPCSymbol();
}
- void EmitReference(const std::string &Name, bool IsPCRelative = false) const {
- PrintRelDirective();
+ void EmitReference(const std::string &Name, bool IsPCRelative = false,
+ bool Force32Bit = false) const {
+ PrintRelDirective(Force32Bit);
O << Name;
void EmitSectionOffset(const char* Label, const char* Section,
unsigned LabelNumber, unsigned SectionNumber,
- bool IsSmall = false, bool isEH = false) {
+ bool IsSmall = false, bool isEH = false,
+ bool useSet = true) {
bool printAbsolute = false;
- if (TAI->needsSet()) {
+ if (isEH)
+ printAbsolute = TAI->isAbsoluteEHSectionOffsets();
+ else
+ printAbsolute = TAI->isAbsoluteDebugSectionOffsets();
+
+ if (TAI->needsSet() && useSet) {
O << "\t.set\t";
PrintLabelName("set", SetCounter, Flavor);
O << ",";
PrintLabelName(Label, LabelNumber);
- if (isEH)
- printAbsolute = TAI->isAbsoluteEHSectionOffsets();
- else
- printAbsolute = TAI->isAbsoluteDebugSectionOffsets();
-
if (!printAbsolute) {
O << "-";
PrintLabelName(Section, SectionNumber);
PrintLabelName(Label, LabelNumber);
- if (isEH)
- printAbsolute = TAI->isAbsoluteEHSectionOffsets();
- else
- printAbsolute = TAI->isAbsoluteDebugSectionOffsets();
-
if (!printAbsolute) {
O << "-";
PrintLabelName(Section, SectionNumber);
/// EmitFrameMoves - Emit frame instructions to describe the layout of the
/// frame.
void EmitFrameMoves(const char *BaseLabel, unsigned BaseLabelID,
- const std::vector<MachineMove> &Moves) {
+ const std::vector<MachineMove> &Moves, bool isEH) {
int stackGrowth =
Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
TargetFrameInfo::StackGrowsUp ?
- TAI->getAddressSize() : -TAI->getAddressSize();
+ TD->getPointerSize() : -TD->getPointerSize();
bool IsLocal = BaseLabel && strcmp(BaseLabel, "label") == 0;
for (unsigned i = 0, N = Moves.size(); i < N; ++i) {
} else {
Asm->EmitInt8(DW_CFA_def_cfa);
Asm->EOL("DW_CFA_def_cfa");
- Asm->EmitULEB128Bytes(RI->getDwarfRegNum(Src.getRegister()));
+ Asm->EmitULEB128Bytes(RI->getDwarfRegNum(Src.getRegister(), isEH));
Asm->EOL("Register");
}
if (Dst.isRegister()) {
Asm->EmitInt8(DW_CFA_def_cfa_register);
Asm->EOL("DW_CFA_def_cfa_register");
- Asm->EmitULEB128Bytes(RI->getDwarfRegNum(Dst.getRegister()));
+ Asm->EmitULEB128Bytes(RI->getDwarfRegNum(Dst.getRegister(), isEH));
Asm->EOL("Register");
} else {
assert(0 && "Machine move no supported yet.");
}
} else {
- unsigned Reg = RI->getDwarfRegNum(Src.getRegister());
+ unsigned Reg = RI->getDwarfRegNum(Src.getRegister(), isEH);
int Offset = Dst.getOffset() / stackGrowth;
if (Offset < 0) {
/// provided.
void AddAddress(DIE *Die, unsigned Attribute,
const MachineLocation &Location) {
- unsigned Reg = RI->getDwarfRegNum(Location.getRegister());
+ unsigned Reg = RI->getDwarfRegNum(Location.getRegister(), false);
DIEBlock *Block = new DIEBlock();
if (Location.isRegister()) {
///
DIE *ConstructPointerType(CompileUnit *Unit, const std::string &Name) {
DIE Buffer(DW_TAG_pointer_type);
- AddUInt(&Buffer, DW_AT_byte_size, 0, TAI->getAddressSize());
+ AddUInt(&Buffer, DW_AT_byte_size, 0, TD->getPointerSize());
if (!Name.empty()) AddString(&Buffer, DW_AT_name, DW_FORM_string, Name);
return Unit->AddDie(Buffer);
}
// Add variable address.
MachineLocation Location;
- RI->getLocation(*MF, DV->getFrameIndex(), Location);
+ Location.set(RI->getFrameRegister(*MF),
+ RI->getFrameIndexOffset(*MF, DV->getFrameIndex()));
AddAddress(VariableDie, DW_AT_location, Location);
return VariableDie;
if (didInitial) return;
didInitial = true;
- // Print out .file directives to specify files for .loc directives.
- if (TAI->hasDotLocAndDotFile()) {
- const UniqueVector<SourceFileInfo> &SourceFiles = MMI->getSourceFiles();
- const UniqueVector<std::string> &Directories = MMI->getDirectories();
- for (unsigned i = 1, e = SourceFiles.size(); i <= e; ++i) {
- sys::Path FullPath(Directories[SourceFiles[i].getDirectoryID()]);
- bool AppendOk = FullPath.appendComponent(SourceFiles[i].getName());
- assert(AppendOk && "Could not append filename to directory!");
- Asm->EmitFile(i, FullPath.toString());
- Asm->EOL();
- }
- }
-
// Dwarf sections base addresses.
if (TAI->doesDwarfRequireFrameSection()) {
Asm->SwitchToDataSection(TAI->getDwarfFrameSection());
Asm->EmitInt16(DWARF_VERSION); Asm->EOL("DWARF version number");
EmitSectionOffset("abbrev_begin", "section_abbrev", 0, 0, true, false);
Asm->EOL("Offset Into Abbrev. Section");
- Asm->EmitInt8(TAI->getAddressSize()); Asm->EOL("Address Size (in bytes)");
+ Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
EmitDIE(Die);
// FIXME - extra padding for gdb bug.
// Define the line address.
Asm->EmitInt8(0); Asm->EOL("Extended Op");
- Asm->EmitInt8(TAI->getAddressSize() + 1); Asm->EOL("Op size");
+ Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
Asm->EmitInt8(DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
EmitReference("label", LabelID); Asm->EOL("Location label");
// Define last address of section.
Asm->EmitInt8(0); Asm->EOL("Extended Op");
- Asm->EmitInt8(TAI->getAddressSize() + 1); Asm->EOL("Op size");
+ Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
Asm->EmitInt8(DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
EmitReference("section_end", j + 1); Asm->EOL("Section end label");
int stackGrowth =
Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
TargetFrameInfo::StackGrowsUp ?
- TAI->getAddressSize() : -TAI->getAddressSize();
+ TD->getPointerSize() : -TD->getPointerSize();
// Start the dwarf frame section.
Asm->SwitchToDataSection(TAI->getDwarfFrameSection());
Asm->EOL("CIE Code Alignment Factor");
Asm->EmitSLEB128Bytes(stackGrowth);
Asm->EOL("CIE Data Alignment Factor");
- Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister()));
+ Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
Asm->EOL("CIE RA Column");
std::vector<MachineMove> Moves;
RI->getInitialFrameState(Moves);
- EmitFrameMoves(NULL, 0, Moves);
+ EmitFrameMoves(NULL, 0, Moves, false);
- Asm->EmitAlignment(2);
+ Asm->EmitAlignment(2, 0, 0, false);
EmitLabel("debug_frame_common_end", 0);
Asm->EOL();
"func_begin", DebugFrameInfo.Number);
Asm->EOL("FDE address range");
- EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves);
+ EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves, false);
- Asm->EmitAlignment(2);
+ Asm->EmitAlignment(2, 0, 0, false);
EmitLabel("debug_frame_end", DebugFrameInfo.Number);
Asm->EOL();
EmitReference("info_begin", Unit->getID());
Asm->EOL("Offset of Compilation Unit Info");
- Asm->EmitInt8(TAI->getAddressSize()); Asm->EOL("Size of Address");
+ Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address");
Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor");
MMI = mmi;
shouldEmit = true;
- // Emit initial sections
- EmitInitial();
-
// Create all the compile unit DIEs.
ConstructCompileUnitDIEs();
// Prime section data.
SectionMap.insert(TAI->getTextSection());
+
+ // Print out .file directives to specify files for .loc directives. These
+ // are printed out early so that they precede any .loc directives.
+ if (TAI->hasDotLocAndDotFile()) {
+ const UniqueVector<SourceFileInfo> &SourceFiles = MMI->getSourceFiles();
+ const UniqueVector<std::string> &Directories = MMI->getDirectories();
+ for (unsigned i = 1, e = SourceFiles.size(); i <= e; ++i) {
+ sys::Path FullPath(Directories[SourceFiles[i].getDirectoryID()]);
+ bool AppendOk = FullPath.appendComponent(SourceFiles[i].getName());
+ assert(AppendOk && "Could not append filename to directory!");
+ Asm->EmitFile(i, FullPath.toString());
+ Asm->EOL();
+ }
+ }
+
+ // Emit initial sections
+ EmitInitial();
}
}
// Assumes in correct section after the entry point.
EmitLabel("func_begin", ++SubprogramCount);
+
+ // Emit label for the implicitly defined dbg.stoppoint at the start of
+ // the function.
+ const std::vector<SourceLineInfo> &LineInfos = MMI->getSourceLines();
+ if (!LineInfos.empty()) {
+ const SourceLineInfo &LineInfo = LineInfos[0];
+ Asm->printLabel(LineInfo.getLabelID());
+ }
}
/// EndFunction - Gather and emit post-function debug information.
bool hasCalls;
bool hasLandingPads;
std::vector<MachineMove> Moves;
+ const Function * function;
FunctionEHFrameInfo(const std::string &FN, unsigned Num, unsigned P,
bool hC, bool hL,
- const std::vector<MachineMove> &M):
+ const std::vector<MachineMove> &M,
+ const Function *f):
FnName(FN), Number(Num), PersonalityIndex(P),
- hasCalls(hC), hasLandingPads(hL), Moves(M) { }
+ hasCalls(hC), hasLandingPads(hL), Moves(M), function (f) { }
};
std::vector<FunctionEHFrameInfo> EHFrames;
-
- /// shouldEmit - Flag to indicate if debug information should be emitted.
- ///
- bool shouldEmit;
+
+ /// shouldEmitTable - Per-function flag to indicate if EH tables should
+ /// be emitted.
+ bool shouldEmitTable;
+
+ /// shouldEmitMoves - Per-function flag to indicate if frame moves info
+ /// should be emitted.
+ bool shouldEmitMoves;
+
+ /// shouldEmitTableModule - Per-module flag to indicate if EH tables
+ /// should be emitted.
+ bool shouldEmitTableModule;
+
+ /// shouldEmitFrameModule - Per-module flag to indicate if frame moves
+ /// should be emitted.
+ bool shouldEmitMovesModule;
/// EmitCommonEHFrame - Emit the common eh unwind frame.
///
int stackGrowth =
Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
TargetFrameInfo::StackGrowsUp ?
- TAI->getAddressSize() : -TAI->getAddressSize();
+ TD->getPointerSize() : -TD->getPointerSize();
// Begin eh frame section.
Asm->SwitchToTextSection(TAI->getDwarfEHFrameSection());
Asm->EOL("CIE Code Alignment Factor");
Asm->EmitSLEB128Bytes(stackGrowth);
Asm->EOL("CIE Data Alignment Factor");
- Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister()));
+ Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), true));
Asm->EOL("CIE RA Column");
// If there is a personality, we need to indicate the functions location.
Asm->EOL("Personality (pcrel sdata4 indirect)");
- PrintRelDirective();
+ PrintRelDirective(TAI->getShortenEHDataOn64Bit());
O << TAI->getPersonalityPrefix();
Asm->EmitExternalGlobal((const GlobalVariable *)(Personality));
O << TAI->getPersonalitySuffix();
- O << "-" << TAI->getPCSymbol();
+ if (!TAI->getShortenEHDataOn64Bit()) {
+ O << "-" << TAI->getPCSymbol();
+ }
Asm->EOL("Personality");
Asm->EmitULEB128Bytes(DW_EH_PE_pcrel);
// Indicate locations of general callee saved registers in frame.
std::vector<MachineMove> Moves;
RI->getInitialFrameState(Moves);
- EmitFrameMoves(NULL, 0, Moves);
+ EmitFrameMoves(NULL, 0, Moves, true);
- Asm->EmitAlignment(2);
+ Asm->EmitAlignment(TD->getPointerSize() == sizeof(int32_t) ? 2 : 3,
+ 0, 0, false);
EmitLabel("eh_frame_common_end", Index);
Asm->EOL();
/// EmitEHFrame - Emit function exception frame information.
///
void EmitEHFrame(const FunctionEHFrameInfo &EHFrameInfo) {
+ Function::LinkageTypes linkage = EHFrameInfo.function->getLinkage();
+
Asm->SwitchToTextSection(TAI->getDwarfEHFrameSection());
// Externally visible entry into the functions eh frame info.
- if (const char *GlobalDirective = TAI->getGlobalDirective())
- O << GlobalDirective << EHFrameInfo.FnName << "\n";
-
- // If there are no calls then you can't unwind.
- if (!EHFrameInfo.hasCalls) {
+ // If the corresponding function is static, this should not be
+ // externally visible.
+ if (linkage != Function::InternalLinkage) {
+ if (const char *GlobalEHDirective = TAI->getGlobalEHDirective())
+ O << GlobalEHDirective << EHFrameInfo.FnName << "\n";
+ }
+
+ // If corresponding function is weak definition, this should be too.
+ if ((linkage == Function::WeakLinkage ||
+ linkage == Function::LinkOnceLinkage) &&
+ TAI->getWeakDefDirective())
+ O << TAI->getWeakDefDirective() << EHFrameInfo.FnName << "\n";
+
+ // If there are no calls then you can't unwind. This may mean we can
+ // omit the EH Frame, but some environments do not handle weak absolute
+ // symbols.
+ // If UnwindTablesMandatory is set we cannot do this optimization; the
+ // unwind info is to be available for non-EH uses.
+ if (!EHFrameInfo.hasCalls &&
+ !UnwindTablesMandatory &&
+ ((linkage != Function::WeakLinkage &&
+ linkage != Function::LinkOnceLinkage) ||
+ !TAI->getWeakDefDirective() ||
+ TAI->getSupportsWeakOmittedEHFrame()))
+ {
O << EHFrameInfo.FnName << " = 0\n";
+ // This name has no connection to the function, so it might get
+ // dead-stripped when the function is not, erroneously. Prohibit
+ // dead-stripping unconditionally.
+ if (const char *UsedDirective = TAI->getUsedDirective())
+ O << UsedDirective << EHFrameInfo.FnName << "\n\n";
} else {
O << EHFrameInfo.FnName << ":\n";
-
+
// EH frame header.
EmitDifference("eh_frame_end", EHFrameInfo.Number,
"eh_frame_begin", EHFrameInfo.Number, true);
EmitSectionOffset("eh_frame_begin", "eh_frame_common",
EHFrameInfo.Number, EHFrameInfo.PersonalityIndex,
- true, true);
+ true, true, false);
Asm->EOL("FDE CIE offset");
EmitReference("eh_func_begin", EHFrameInfo.Number, true);
// If there is a personality and landing pads then point to the language
// specific data area in the exception table.
if (EHFrameInfo.PersonalityIndex) {
- Asm->EmitULEB128Bytes(4);
+ Asm->EmitULEB128Bytes(TAI->getShortenEHDataOn64Bit() ? 8 : 4);
Asm->EOL("Augmentation size");
if (EHFrameInfo.hasLandingPads) {
EmitReference("exception", EHFrameInfo.Number, true);
- } else if(TAI->getAddressSize() == 8) {
+ } else if (TD->getPointerSize() == 8) {
Asm->EmitInt64((int)0);
} else {
Asm->EmitInt32((int)0);
// Indicate locations of function specific callee saved registers in
// frame.
- EmitFrameMoves("eh_func_begin", EHFrameInfo.Number, EHFrameInfo.Moves);
+ EmitFrameMoves("eh_func_begin", EHFrameInfo.Number, EHFrameInfo.Moves, true);
- Asm->EmitAlignment(2);
+ Asm->EmitAlignment(TD->getPointerSize() == sizeof(int32_t) ? 2 : 3,
+ 0, 0, false);
EmitLabel("eh_frame_end", EHFrameInfo.Number);
- }
- if (const char *UsedDirective = TAI->getUsedDirective())
- O << UsedDirective << EHFrameInfo.FnName << "\n\n";
+ // If the function is marked used, this table should be also. We cannot
+ // make the mark unconditional in this case, since retaining the table
+ // also retains the function in this case, and there is code around
+ // that depends on unused functions (calling undefined externals) being
+ // dead-stripped to link correctly. Yes, there really is.
+ if (MMI->getUsedFunctions().count(EHFrameInfo.function))
+ if (const char *UsedDirective = TAI->getUsedDirective())
+ O << UsedDirective << EHFrameInfo.FnName << "\n\n";
+ }
}
/// EmitExceptionTable - Emit landing pads and actions.
/// CallSiteEntry - Structure describing an entry in the call-site table.
struct CallSiteEntry {
+ // The 'try-range' is BeginLabel .. EndLabel.
unsigned BeginLabel; // zero indicates the start of the function.
unsigned EndLabel; // zero indicates the end of the function.
+ // The landing pad starts at PadLabel.
unsigned PadLabel; // zero indicates that there is no landing pad.
unsigned Action;
};
void EmitExceptionTable() {
- // Map all labels and get rid of any dead landing pads.
- MMI->TidyLandingPads();
-
const std::vector<GlobalVariable *> &TypeInfos = MMI->getTypeInfos();
const std::vector<unsigned> &FilterIds = MMI->getFilterIds();
const std::vector<LandingPadInfo> &PadInfos = MMI->getLandingPads();
SizeActions += SizeSiteActions;
}
- // Compute the call-site table. Entries must be ordered by address.
+ // 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.
SmallVector<CallSiteEntry, 64> CallSites;
RangeMapType PadMap;
+ // Invokes and nounwind calls have entries in PadMap (due to being bracketed
+ // by try-range labels when lowered). Ordinary calls do not, so appropriate
+ // try-ranges for them need be deduced.
for (unsigned i = 0, N = LandingPads.size(); i != N; ++i) {
const LandingPadInfo *LandingPad = LandingPads[i];
- for (unsigned j=0, E = LandingPad->BeginLabels.size(); j != E; ++j) {
+ for (unsigned j = 0, E = LandingPad->BeginLabels.size(); j != E; ++j) {
unsigned BeginLabel = LandingPad->BeginLabels[j];
assert(!PadMap.count(BeginLabel) && "Duplicate landing pad labels!");
PadRange P = { i, j };
}
}
- bool MayThrow = false;
+ // The end label of the previous invoke or nounwind try-range.
unsigned LastLabel = 0;
- const TargetInstrInfo *TII = MF->getTarget().getInstrInfo();
+
+ // Whether there is a potentially throwing instruction (currently this means
+ // an ordinary call) between the end of the previous try-range and now.
+ bool SawPotentiallyThrowing = false;
+
+ // Whether the last callsite entry was for an invoke.
+ bool PreviousIsInvoke = false;
+
+ // Visit all instructions in order of address.
for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
I != E; ++I) {
for (MachineBasicBlock::const_iterator MI = I->begin(), E = I->end();
MI != E; ++MI) {
if (MI->getOpcode() != TargetInstrInfo::LABEL) {
- MayThrow |= TII->isCall(MI->getOpcode());
+ SawPotentiallyThrowing |= MI->getDesc().isCall();
continue;
}
- unsigned BeginLabel = MI->getOperand(0).getImmedValue();
+ unsigned BeginLabel = MI->getOperand(0).getImm();
assert(BeginLabel && "Invalid label!");
+ // End of the previous try-range?
if (BeginLabel == LastLabel)
- MayThrow = false;
+ SawPotentiallyThrowing = false;
+ // Beginning of a new try-range?
RangeMapType::iterator L = PadMap.find(BeginLabel);
-
if (L == PadMap.end())
+ // Nope, it was just some random label.
continue;
PadRange P = L->second;
// If some 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 (MayThrow) {
+ if (SawPotentiallyThrowing) {
CallSiteEntry Site = {LastLabel, BeginLabel, 0, 0};
CallSites.push_back(Site);
+ PreviousIsInvoke = false;
}
LastLabel = LandingPad->EndLabels[P.RangeIndex];
- CallSiteEntry Site = {BeginLabel, LastLabel,
- LandingPad->LandingPadLabel, FirstActions[P.PadIndex]};
-
- assert(Site.BeginLabel && Site.EndLabel && Site.PadLabel &&
- "Invalid landing pad!");
-
- // Try to merge with the previous call-site.
- if (CallSites.size()) {
- CallSiteEntry &Prev = CallSites[CallSites.size()-1];
- if (Site.PadLabel == Prev.PadLabel && Site.Action == Prev.Action) {
- // Extend the range of the previous entry.
- Prev.EndLabel = Site.EndLabel;
- continue;
+ assert(BeginLabel && LastLabel && "Invalid landing pad!");
+
+ if (LandingPad->LandingPadLabel) {
+ // This try-range is for an invoke.
+ CallSiteEntry Site = {BeginLabel, LastLabel,
+ LandingPad->LandingPadLabel, FirstActions[P.PadIndex]};
+
+ // Try to merge with the previous call-site.
+ if (PreviousIsInvoke) {
+ CallSiteEntry &Prev = CallSites[CallSites.size()-1];
+ if (Site.PadLabel == Prev.PadLabel && Site.Action == Prev.Action) {
+ // Extend the range of the previous entry.
+ Prev.EndLabel = Site.EndLabel;
+ continue;
+ }
}
- }
- // Otherwise, create a new call-site.
- CallSites.push_back(Site);
+ // Otherwise, create a new call-site.
+ CallSites.push_back(Site);
+ PreviousIsInvoke = true;
+ } else {
+ // Create a gap.
+ PreviousIsInvoke = false;
+ }
}
}
// 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 (MayThrow) {
+ if (SawPotentiallyThrowing) {
CallSiteEntry Site = {LastLabel, 0, 0, 0};
CallSites.push_back(Site);
}
for (unsigned i = 0, e = CallSites.size(); i < e; ++i)
SizeSites += Asm->SizeULEB128(CallSites[i].Action);
- unsigned SizeTypes = TypeInfos.size() * TAI->getAddressSize();
+ unsigned SizeTypes = TypeInfos.size() * TD->getPointerSize();
unsigned TypeOffset = sizeof(int8_t) + // Call site format
Asm->SizeULEB128(SizeSites) + // Call-site table length
// Begin the exception table.
Asm->SwitchToDataSection(TAI->getDwarfExceptionSection());
O << "GCC_except_table" << SubprogramCount << ":\n";
- Asm->EmitAlignment(2);
+ Asm->EmitAlignment(2, 0, 0, false);
for (unsigned i = 0; i != SizeAlign; ++i) {
Asm->EmitInt8(0);
Asm->EOL("Padding");
}
EmitSectionOffset(BeginTag, "eh_func_begin", BeginNumber, SubprogramCount,
- false, true);
+ TAI->getShortenEHDataOn64Bit(), true);
Asm->EOL("Region start");
if (!S.EndLabel) {
- EmitDifference("eh_func_end", SubprogramCount, BeginTag, BeginNumber);
+ EmitDifference("eh_func_end", SubprogramCount, BeginTag, BeginNumber,
+ TAI->getShortenEHDataOn64Bit());
} else {
- EmitDifference("label", S.EndLabel, BeginTag, BeginNumber);
+ EmitDifference("label", S.EndLabel, BeginTag, BeginNumber,
+ TAI->getShortenEHDataOn64Bit());
}
Asm->EOL("Region length");
if (!S.PadLabel) {
- if (TAI->getAddressSize() == sizeof(int32_t))
+ if (TD->getPointerSize() == sizeof(int32_t) || TAI->getShortenEHDataOn64Bit())
Asm->EmitInt32(0);
else
Asm->EmitInt64(0);
} else {
EmitSectionOffset("label", "eh_func_begin", S.PadLabel, SubprogramCount,
- false, true);
+ TAI->getShortenEHDataOn64Bit(), true);
}
Asm->EOL("Landing pad");
Asm->EOL("Filter TypeInfo index");
}
- Asm->EmitAlignment(2);
+ Asm->EmitAlignment(2, 0, 0, false);
}
public:
//
DwarfException(std::ostream &OS, AsmPrinter *A, const TargetAsmInfo *T)
: Dwarf(OS, A, T, "eh")
- , shouldEmit(false)
+ , shouldEmitTable(false)
+ , shouldEmitMoves(false)
+ , shouldEmitTableModule(false)
+ , shouldEmitMovesModule(false)
{}
virtual ~DwarfException() {}
/// EndModule - Emit all exception information that should come after the
/// content.
void EndModule() {
- if (!shouldEmit) return;
-
- const std::vector<Function *> Personalities = MMI->getPersonalities();
- for (unsigned i =0; i < Personalities.size(); ++i)
- EmitCommonEHFrame(Personalities[i], i);
-
- for (std::vector<FunctionEHFrameInfo>::iterator I = EHFrames.begin(),
- E = EHFrames.end(); I != E; ++I)
- EmitEHFrame(*I);
+ if (shouldEmitMovesModule || shouldEmitTableModule) {
+ const std::vector<Function *> Personalities = MMI->getPersonalities();
+ for (unsigned i =0; i < Personalities.size(); ++i)
+ EmitCommonEHFrame(Personalities[i], i);
+
+ for (std::vector<FunctionEHFrameInfo>::iterator I = EHFrames.begin(),
+ E = EHFrames.end(); I != E; ++I)
+ EmitEHFrame(*I);
+ }
}
/// BeginFunction - Gather pre-function exception information. Assumes being
/// emitted immediately after the function entry point.
void BeginFunction(MachineFunction *MF) {
this->MF = MF;
-
- if (MMI &&
- ExceptionHandling &&
- TAI->doesSupportExceptionHandling()) {
- shouldEmit = true;
- // Assumes in correct section after the entry point.
- EmitLabel("eh_func_begin", ++SubprogramCount);
+ shouldEmitTable = shouldEmitMoves = false;
+ if (MMI && TAI->doesSupportExceptionHandling()) {
+
+ // Map all labels and get rid of any dead landing pads.
+ MMI->TidyLandingPads();
+ // If any landing pads survive, we need an EH table.
+ if (MMI->getLandingPads().size())
+ shouldEmitTable = true;
+
+ // See if we need frame move info.
+ if (MMI->hasDebugInfo() ||
+ !MF->getFunction()->doesNotThrow() ||
+ UnwindTablesMandatory)
+ shouldEmitMoves = true;
+
+ if (shouldEmitMoves || shouldEmitTable)
+ // Assumes in correct section after the entry point.
+ EmitLabel("eh_func_begin", ++SubprogramCount);
}
+ shouldEmitTableModule |= shouldEmitTable;
+ shouldEmitMovesModule |= shouldEmitMoves;
}
/// EndFunction - Gather and emit post-function exception information.
///
void EndFunction() {
- if (!shouldEmit) return;
+ if (shouldEmitMoves || shouldEmitTable) {
+ EmitLabel("eh_func_end", SubprogramCount);
+ EmitExceptionTable();
- EmitLabel("eh_func_end", SubprogramCount);
- EmitExceptionTable();
-
- // Save EH frame information
- EHFrames.
- push_back(FunctionEHFrameInfo(getAsm()->getCurrentFunctionEHName(MF),
+ // Save EH frame information
+ EHFrames.
+ push_back(FunctionEHFrameInfo(getAsm()->getCurrentFunctionEHName(MF),
SubprogramCount,
MMI->getPersonalityIndex(),
MF->getFrameInfo()->hasCalls(),
!MMI->getLandingPads().empty(),
- MMI->getFrameMoves()));
+ MMI->getFrameMoves(),
+ MF->getFunction()));
+ }
}
};
/// EmitValue - Emit label value.
///
void DIEDwarfLabel::EmitValue(DwarfDebug &DD, unsigned Form) {
- DD.EmitReference(Label);
+ bool IsSmall = Form == DW_FORM_data4;
+ DD.EmitReference(Label, false, IsSmall);
}
/// SizeOf - Determine size of label value in bytes.
///
unsigned DIEDwarfLabel::SizeOf(const DwarfDebug &DD, unsigned Form) const {
- return DD.getTargetAsmInfo()->getAddressSize();
+ if (Form == DW_FORM_data4) return 4;
+ return DD.getTargetData()->getPointerSize();
}
//===----------------------------------------------------------------------===//
/// EmitValue - Emit label value.
///
void DIEObjectLabel::EmitValue(DwarfDebug &DD, unsigned Form) {
- DD.EmitReference(Label);
+ bool IsSmall = Form == DW_FORM_data4;
+ DD.EmitReference(Label, false, IsSmall);
}
/// SizeOf - Determine size of label value in bytes.
///
unsigned DIEObjectLabel::SizeOf(const DwarfDebug &DD, unsigned Form) const {
- return DD.getTargetAsmInfo()->getAddressSize();
+ if (Form == DW_FORM_data4) return 4;
+ return DD.getTargetData()->getPointerSize();
}
//===----------------------------------------------------------------------===//
///
unsigned DIEDelta::SizeOf(const DwarfDebug &DD, unsigned Form) const {
if (Form == DW_FORM_data4) return 4;
- return DD.getTargetAsmInfo()->getAddressSize();
+ return DD.getTargetData()->getPointerSize();
}
//===----------------------------------------------------------------------===//