#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"
/// Data - Raw data bytes for abbreviation.
///
- std::vector<DIEAbbrevData> Data;
+ SmallVector<DIEAbbrevData, 8> Data;
public:
unsigned getTag() const { return Tag; }
unsigned getNumber() const { return Number; }
unsigned getChildrenFlag() const { return ChildrenFlag; }
- const std::vector<DIEAbbrevData> &getData() const { return Data; }
+ const SmallVector<DIEAbbrevData, 8> &getData() const { return Data; }
void setTag(unsigned T) { Tag = T; }
void setChildrenFlag(unsigned CF) { ChildrenFlag = CF; }
void setNumber(unsigned N) { Number = N; }
/// Attributes values.
///
- std::vector<DIEValue *> Values;
+ SmallVector<DIEValue*, 32> Values;
public:
explicit DIE(unsigned Tag)
unsigned getOffset() const { return Offset; }
unsigned getSize() const { return Size; }
const std::vector<DIE *> &getChildren() const { return Children; }
- std::vector<DIEValue *> &getValues() { return Values; }
+ SmallVector<DIEValue*, 32> &getValues() { return Values; }
void setTag(unsigned Tag) { Abbrev.setTag(Tag); }
void setOffset(unsigned O) { Offset = O; }
void setSize(unsigned S) { Size = S; }
isString,
isLabel,
isAsIsLabel,
+ isSectionOffset,
isDelta,
isEntry,
isBlock
#endif
};
+//===----------------------------------------------------------------------===//
+/// DIESectionOffset - A section offset DIE.
+//
+class DIESectionOffset : public DIEValue {
+public:
+ const DWLabel Label;
+ const DWLabel Section;
+ bool IsEH : 1;
+ bool UseSet : 1;
+
+ DIESectionOffset(const DWLabel &Lab, const DWLabel &Sec,
+ bool isEH = false, bool useSet = true)
+ : DIEValue(isSectionOffset), Label(Lab), Section(Sec),
+ IsEH(isEH), UseSet(useSet) {}
+
+ // Implement isa/cast/dyncast.
+ static bool classof(const DIESectionOffset *) { return true; }
+ static bool classof(const DIEValue *D) { return D->Type == isSectionOffset; }
+
+ /// EmitValue - Emit section offset.
+ ///
+ virtual void EmitValue(DwarfDebug &DD, unsigned Form);
+
+ /// SizeOf - Determine size of section offset value in bytes.
+ ///
+ virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const;
+
+ /// Profile - Used to gather unique data for the value folding set.
+ ///
+ static void Profile(FoldingSetNodeID &ID, const DWLabel &Label,
+ const DWLabel &Section) {
+ ID.AddInteger(isSectionOffset);
+ Label.Profile(ID);
+ Section.Profile(ID);
+ // IsEH and UseSet are specific to the Label/Section that we will emit
+ // the offset for; so Label/Section are enough for uniqueness.
+ }
+ virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, Label, Section); }
+
+#ifndef NDEBUG
+ virtual void print(std::ostream &O) {
+ O << "Off: ";
+ Label.print(O);
+ O << "-";
+ Section.print(O);
+ O << "-" << IsEH << "-" << UseSet;
+ }
+#endif
+};
+
//===----------------------------------------------------------------------===//
/// DIEDelta - A simple label difference DIE.
///
///
AsmPrinter *Asm;
- /// TAI - Target Asm Printer.
+ /// TAI - Target asm information.
const TargetAsmInfo *TAI;
/// TD - Target data.
const TargetData *TD;
/// RI - Register Information.
- const MRegisterInfo *RI;
+ const TargetRegisterInfo *RI;
/// M - Current module.
///
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);
Die->AddValue(Attribute, Form, Value);
}
+ /// AddSectionOffset - Add a section offset label attribute data and value.
+ ///
+ void AddSectionOffset(DIE *Die, unsigned Attribute, unsigned Form,
+ const DWLabel &Label, const DWLabel &Section,
+ bool isEH = false, bool useSet = true) {
+ FoldingSetNodeID ID;
+ DIESectionOffset::Profile(ID, Label, Section);
+ void *Where;
+ DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where);
+ if (!Value) {
+ Value = new DIESectionOffset(Label, Section, isEH, useSet);
+ ValuesSet.InsertNode(Value, Where);
+ Values.push_back(Value);
+ }
+
+ Die->AddValue(Attribute, Form, Value);
+ }
+
/// AddDelta - Add a label delta attribute data and value.
///
void AddDelta(DIE *Die, unsigned Attribute, unsigned Form,
CompileUnit *NewCompileUnit(CompileUnitDesc *UnitDesc, unsigned ID) {
// Construct debug information entry.
DIE *Die = new DIE(DW_TAG_compile_unit);
- if (TAI->isAbsoluteDebugSectionOffsets())
- AddLabel(Die, DW_AT_stmt_list, DW_FORM_data4, DWLabel("section_line", 0));
- else
- AddDelta(Die, DW_AT_stmt_list, DW_FORM_data4, DWLabel("section_line", 0),
- DWLabel("section_line", 0));
+ AddSectionOffset(Die, DW_AT_stmt_list, DW_FORM_data4,
+ DWLabel("section_line", 0), DWLabel("section_line", 0), false);
AddString(Die, DW_AT_producer, DW_FORM_string, UnitDesc->getProducer());
AddUInt (Die, DW_AT_language, DW_FORM_data1, UnitDesc->getLanguage());
AddString(Die, DW_AT_name, DW_FORM_string, UnitDesc->getFileName());
// Emit the code (index) for the abbreviation.
Asm->EmitULEB128Bytes(AbbrevNumber);
- Asm->EOL(std::string("Abbrev [" +
- utostr(AbbrevNumber) +
- "] 0x" + utohexstr(Die->getOffset()) +
- ":0x" + utohexstr(Die->getSize()) + " " +
- TagString(Abbrev->getTag())));
+
+ if (VerboseAsm)
+ Asm->EOL(std::string("Abbrev [" +
+ utostr(AbbrevNumber) +
+ "] 0x" + utohexstr(Die->getOffset()) +
+ ":0x" + utohexstr(Die->getSize()) + " " +
+ TagString(Abbrev->getTag())));
+ else
+ Asm->EOL();
- std::vector<DIEValue *> &Values = Die->getValues();
- const std::vector<DIEAbbrevData> &AbbrevData = Abbrev->getData();
+ SmallVector<DIEValue*, 32> &Values = Die->getValues();
+ const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
// Emit the DIE attribute values.
for (unsigned i = 0, N = Values.size(); i < N; ++i) {
// Start the size with the size of abbreviation code.
Offset += Asm->SizeULEB128(AbbrevNumber);
- const std::vector<DIEValue *> &Values = Die->getValues();
- const std::vector<DIEAbbrevData> &AbbrevData = Abbrev->getData();
+ const SmallVector<DIEValue*, 32> &Values = Die->getValues();
+ const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
// Size the DIE attribute values.
for (unsigned i = 0, N = Values.size(); i < N; ++i) {
Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count");
const UniqueVector<std::string> &Directories = MMI->getDirectories();
- const UniqueVector<SourceFileInfo>
- &SourceFiles = MMI->getSourceFiles();
+ const UniqueVector<SourceFileInfo> &SourceFiles = MMI->getSourceFiles();
// Emit directories.
for (unsigned DirectoryID = 1, NDID = Directories.size();
for (unsigned j = 0, M = SectionSourceLines.size(); j < M; ++j) {
// Isolate current sections line info.
const std::vector<SourceLineInfo> &LineInfos = SectionSourceLines[j];
-
- Asm->EOL(std::string("Section ") + SectionMap[j + 1]);
+
+ if (VerboseAsm)
+ Asm->EOL(std::string("Section ") + SectionMap[j + 1]);
+ else
+ Asm->EOL();
// Dwarf assumes we start with first line of first source file.
unsigned Source = 1;
unsigned SourceID = LineInfo.getSourceID();
const SourceFileInfo &SourceFile = SourceFiles[SourceID];
unsigned DirectoryID = SourceFile.getDirectoryID();
- Asm->EOL(Directories[DirectoryID]
- + SourceFile.getName()
- + ":"
- + utostr_32(LineInfo.getLine()));
+ if (VerboseAsm)
+ Asm->EOL(Directories[DirectoryID]
+ + SourceFile.getName()
+ + ":"
+ + utostr_32(LineInfo.getLine()));
+ else
+ Asm->EOL();
// Define the line address.
Asm->EmitInt8(0); Asm->EOL("Extended Op");
EmitFrameMoves(NULL, 0, Moves, false);
- Asm->EmitAlignment(2);
+ Asm->EmitAlignment(2, 0, 0, false);
EmitLabel("debug_frame_common_end", 0);
Asm->EOL();
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();
/// ConstructGlobalDIEs - Create DIEs for each of the externally visible
/// global variables.
void ConstructGlobalDIEs() {
- std::vector<GlobalVariableDesc *> GlobalVariables =
- MMI->getAnchoredDescriptors<GlobalVariableDesc>(*M);
+ std::vector<GlobalVariableDesc *> GlobalVariables;
+ MMI->getAnchoredDescriptors<GlobalVariableDesc>(*M, GlobalVariables);
for (unsigned i = 0, N = GlobalVariables.size(); i < N; ++i) {
GlobalVariableDesc *GVD = GlobalVariables[i];
/// ConstructSubprogramDIEs - Create DIEs for each of the externally visible
/// subprograms.
void ConstructSubprogramDIEs() {
- std::vector<SubprogramDesc *> Subprograms =
- MMI->getAnchoredDescriptors<SubprogramDesc>(*M);
+ std::vector<SubprogramDesc *> Subprograms;
+ MMI->getAnchoredDescriptors<SubprogramDesc>(*M, Subprograms);
for (unsigned i = 0, N = Subprograms.size(); i < N; ++i) {
SubprogramDesc *SPD = Subprograms[i];
/// content.
void BeginModule(Module *M) {
this->M = M;
-
- if (!ShouldEmitDwarf()) return;
}
/// EndModule - Emit all Dwarf sections that should come after the content.
// Emit label for the implicitly defined dbg.stoppoint at the start of
// the function.
- const SourceLineInfo &LineInfo = MMI->getSourceLines()[0];
- Asm->printLabel(LineInfo.getLabelID());
+ 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.
};
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.
///
void EmitCommonEHFrame(const Function *Personality, unsigned Index) {
// Define base labels.
EmitLabel("eh_frame_common", Index);
-
+
// Define the eh frame length.
EmitDifference("eh_frame_common_end", Index,
"eh_frame_common_begin", Index, true);
Asm->EOL("CIE Identifier Tag");
Asm->EmitInt8(DW_CIE_VERSION);
Asm->EOL("CIE Version");
-
+
// The personality presence indicates that language specific information
// will show up in the eh frame.
Asm->EmitString(Personality ? "zPLR" : "zR");
Asm->EOL("CIE Augmentation");
-
+
// Round out reader.
Asm->EmitULEB128Bytes(1);
Asm->EOL("CIE Code Alignment Factor");
Asm->EmitSLEB128Bytes(stackGrowth);
- Asm->EOL("CIE Data Alignment Factor");
+ Asm->EOL("CIE Data Alignment Factor");
Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), true));
- Asm->EOL("CIE RA Column");
-
+ Asm->EOL("CIE Return Address Column");
+
// If there is a personality, we need to indicate the functions location.
if (Personality) {
Asm->EmitULEB128Bytes(7);
Asm->EOL("Augmentation Size");
- if (TAI->getNeedsIndirectEncoding())
+ if (TAI->getNeedsIndirectEncoding()) {
Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4 | DW_EH_PE_indirect);
- else
+ Asm->EOL("Personality (pcrel sdata4 indirect)");
+ } else {
Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4);
+ Asm->EOL("Personality (pcrel sdata4)");
+ }
- Asm->EOL("Personality (pcrel sdata4 indirect)");
-
- PrintRelDirective(TAI->getShortenEHDataOn64Bit());
+ PrintRelDirective(true);
O << TAI->getPersonalityPrefix();
Asm->EmitExternalGlobal((const GlobalVariable *)(Personality));
O << TAI->getPersonalitySuffix();
- if (!TAI->getShortenEHDataOn64Bit()) {
+ if (strcmp(TAI->getPersonalitySuffix(), "+4@GOTPCREL"))
O << "-" << TAI->getPCSymbol();
- }
Asm->EOL("Personality");
- Asm->EmitULEB128Bytes(DW_EH_PE_pcrel);
- Asm->EOL("LSDA Encoding (pcrel)");
- Asm->EmitULEB128Bytes(DW_EH_PE_pcrel);
- Asm->EOL("FDE Encoding (pcrel)");
+ Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4);
+ Asm->EOL("LSDA Encoding (pcrel sdata4)");
+ Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4);
+ Asm->EOL("FDE Encoding (pcrel sdata4)");
} else {
Asm->EmitULEB128Bytes(1);
Asm->EOL("Augmentation Size");
- Asm->EmitULEB128Bytes(DW_EH_PE_pcrel);
- Asm->EOL("FDE Encoding (pcrel)");
+ Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4);
+ Asm->EOL("FDE Encoding (pcrel sdata4)");
}
// Indicate locations of general callee saved registers in frame.
RI->getInitialFrameState(Moves);
EmitFrameMoves(NULL, 0, Moves, true);
- Asm->EmitAlignment(2);
+ // On Darwin the linker honors the alignment of eh_frame, which means it
+ // must be 8-byte on 64-bit targets to match what gcc does. Otherwise
+ // you get holes which confuse readers of eh_frame.
+ 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) {
// 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.
+ // 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() ||
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);
+ EmitReference("eh_func_begin", EHFrameInfo.Number, true, true);
Asm->EOL("FDE initial location");
EmitDifference("eh_func_end", EHFrameInfo.Number,
- "eh_func_begin", EHFrameInfo.Number);
+ "eh_func_begin", EHFrameInfo.Number, true);
Asm->EOL("FDE address range");
-
+
// 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(TAI->getShortenEHDataOn64Bit() ? 8 : 4);
+ Asm->EmitULEB128Bytes(4);
Asm->EOL("Augmentation size");
-
- if (EHFrameInfo.hasLandingPads) {
- EmitReference("exception", EHFrameInfo.Number, true);
- } else if (TD->getPointerSize() == 8) {
- Asm->EmitInt64((int)0);
- } else {
+
+ if (EHFrameInfo.hasLandingPads)
+ EmitReference("exception", EHFrameInfo.Number, true, true);
+ else
Asm->EmitInt32((int)0);
- }
Asm->EOL("Language Specific Data Area");
} else {
Asm->EmitULEB128Bytes(0);
Asm->EOL("Augmentation size");
}
-
+
// Indicate locations of function specific callee saved registers in
// frame.
EmitFrameMoves("eh_func_begin", EHFrameInfo.Number, EHFrameInfo.Moves, true);
- Asm->EmitAlignment(2);
+ // On Darwin the linker honors the alignment of eh_frame, which means it
+ // must be 8-byte on 64-bit targets to match what gcc does. Otherwise
+ // you get holes which confuse readers of eh_frame.
+ Asm->EmitAlignment(TD->getPointerSize() == sizeof(int32_t) ? 2 : 3,
+ 0, 0, false);
EmitLabel("eh_frame_end", EHFrameInfo.Number);
// If the function is marked used, this table should be also. We cannot
};
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();
I != E; ++I) {
for (MachineBasicBlock::const_iterator MI = I->begin(), E = I->end();
MI != E; ++MI) {
- if (MI->getOpcode() != TargetInstrInfo::LABEL) {
+ if (!MI->isLabel()) {
SawPotentiallyThrowing |= MI->getDesc().isCall();
continue;
}
// Try to merge with the previous call-site.
if (PreviousIsInvoke) {
- CallSiteEntry &Prev = CallSites[CallSites.size()-1];
+ CallSiteEntry &Prev = CallSites.back();
if (Site.PadLabel == Prev.PadLabel && Site.Action == Prev.Action) {
// Extend the range of the previous entry.
Prev.EndLabel = Site.EndLabel;
}
// Final tallies.
- unsigned SizeSites = CallSites.size() * (sizeof(int32_t) + // Site start.
- sizeof(int32_t) + // Site length.
- sizeof(int32_t)); // Landing pad.
+
+ // Call sites.
+ const unsigned SiteStartSize = sizeof(int32_t); // DW_EH_PE_udata4
+ const unsigned SiteLengthSize = sizeof(int32_t); // DW_EH_PE_udata4
+ const unsigned LandingPadSize = sizeof(int32_t); // DW_EH_PE_udata4
+ unsigned SizeSites = CallSites.size() * (SiteStartSize +
+ SiteLengthSize +
+ LandingPadSize);
for (unsigned i = 0, e = CallSites.size(); i < e; ++i)
SizeSites += Asm->SizeULEB128(CallSites[i].Action);
- unsigned SizeTypes = TypeInfos.size() * TD->getPointerSize();
+ // Type infos.
+ const unsigned TypeInfoSize = TD->getPointerSize(); // DW_EH_PE_absptr
+ unsigned SizeTypes = TypeInfos.size() * TypeInfoSize;
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,
- TAI->getShortenEHDataOn64Bit(), true);
+ true, true);
Asm->EOL("Region start");
if (!S.EndLabel) {
EmitDifference("eh_func_end", SubprogramCount, BeginTag, BeginNumber,
- TAI->getShortenEHDataOn64Bit());
+ true);
} else {
- EmitDifference("label", S.EndLabel, BeginTag, BeginNumber,
- TAI->getShortenEHDataOn64Bit());
+ EmitDifference("label", S.EndLabel, BeginTag, BeginNumber, true);
}
Asm->EOL("Region length");
- if (!S.PadLabel) {
- if (TD->getPointerSize() == sizeof(int32_t) || TAI->getShortenEHDataOn64Bit())
- Asm->EmitInt32(0);
- else
- Asm->EmitInt64(0);
- } else {
+ if (!S.PadLabel)
+ Asm->EmitInt32(0);
+ else
EmitSectionOffset("label", "eh_func_begin", S.PadLabel, SubprogramCount,
- TAI->getShortenEHDataOn64Bit(), true);
- }
+ true, true);
Asm->EOL("Landing pad");
Asm->EmitULEB128Bytes(S.Action);
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 (!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;
-
- EmitLabel("eh_func_end", SubprogramCount);
- EmitExceptionTable();
+ if (shouldEmitMoves || shouldEmitTable) {
+ 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(),
MF->getFunction()));
+ }
}
};
//===----------------------------------------------------------------------===//
+/// EmitValue - Emit delta value.
+///
+void DIESectionOffset::EmitValue(DwarfDebug &DD, unsigned Form) {
+ bool IsSmall = Form == DW_FORM_data4;
+ DD.EmitSectionOffset(Label.Tag, Section.Tag,
+ Label.Number, Section.Number, IsSmall, IsEH, UseSet);
+}
+
+/// SizeOf - Determine size of delta value in bytes.
+///
+unsigned DIESectionOffset::SizeOf(const DwarfDebug &DD, unsigned Form) const {
+ if (Form == DW_FORM_data4) return 4;
+ return DD.getTargetData()->getPointerSize();
+}
+
+//===----------------------------------------------------------------------===//
+
/// EmitValue - Emit delta value.
///
void DIEDelta::EmitValue(DwarfDebug &DD, unsigned Form) {
///
unsigned DIEBlock::ComputeSize(DwarfDebug &DD) {
if (!Size) {
- const std::vector<DIEAbbrevData> &AbbrevData = Abbrev.getData();
+ const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev.getData();
for (unsigned i = 0, N = Values.size(); i < N; ++i) {
Size += Values[i]->SizeOf(DD, AbbrevData[i].getForm());
default: assert(0 && "Improper form for block"); break;
}
- const std::vector<DIEAbbrevData> &AbbrevData = Abbrev.getData();
+ const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev.getData();
for (unsigned i = 0, N = Values.size(); i < N; ++i) {
DD.getAsm()->EOL();
}
O << "\n";
- const std::vector<DIEAbbrevData> &Data = Abbrev.getData();
+ const SmallVector<DIEAbbrevData, 8> &Data = Abbrev.getData();
IndentCount += 2;
for (unsigned i = 0, N = Data.size(); i < N; ++i) {