#include "llvm/CodeGen/DwarfWriter.h"
+#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/UniqueVector.h"
#include "llvm/Target/MRegisterInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetFrameInfo.h"
+#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetOptions.h"
#include <ostream>
unsigned getOffset() const { return Offset; }
unsigned getSize() const { return Size; }
const std::vector<DIE *> &getChildren() const { return Children; }
- const std::vector<DIEValue *> &getValues() const { return Values; }
+ std::vector<DIEValue *> &getValues() { return Values; }
void setTag(unsigned Tag) { Abbrev.setTag(Tag); }
void setOffset(unsigned O) { Offset = O; }
void setSize(unsigned S) { Size = S; }
/// EmitValue - Emit value via the Dwarf writer.
///
- virtual void EmitValue(const DwarfDebug &DD, unsigned Form) const = 0;
+ virtual void EmitValue(DwarfDebug &DD, unsigned Form) = 0;
/// SizeOf - Return the size of a value in bytes.
///
/// EmitValue - Emit integer of appropriate size.
///
- virtual void EmitValue(const DwarfDebug &DD, unsigned Form) const;
+ virtual void EmitValue(DwarfDebug &DD, unsigned Form);
/// SizeOf - Determine size of integer value in bytes.
///
/// EmitValue - Emit string value.
///
- virtual void EmitValue(const DwarfDebug &DD, unsigned Form) const;
+ virtual void EmitValue(DwarfDebug &DD, unsigned Form);
/// SizeOf - Determine size of string value in bytes.
///
/// EmitValue - Emit label value.
///
- virtual void EmitValue(const DwarfDebug &DD, unsigned Form) const;
+ virtual void EmitValue(DwarfDebug &DD, unsigned Form);
/// SizeOf - Determine size of label value in bytes.
///
/// EmitValue - Emit label value.
///
- virtual void EmitValue(const DwarfDebug &DD, unsigned Form) const;
+ virtual void EmitValue(DwarfDebug &DD, unsigned Form);
/// SizeOf - Determine size of label value in bytes.
///
/// EmitValue - Emit delta value.
///
- virtual void EmitValue(const DwarfDebug &DD, unsigned Form) const;
+ virtual void EmitValue(DwarfDebug &DD, unsigned Form);
/// SizeOf - Determine size of delta value in bytes.
///
/// EmitValue - Emit debug information entry offset.
///
- virtual void EmitValue(const DwarfDebug &DD, unsigned Form) const;
+ virtual void EmitValue(DwarfDebug &DD, unsigned Form);
/// SizeOf - Determine size of debug information entry in bytes.
///
/// EmitValue - Emit block data.
///
- virtual void EmitValue(const DwarfDebug &DD, unsigned Form) const;
+ virtual void EmitValue(DwarfDebug &DD, unsigned Form);
/// SizeOf - Determine size of block data in bytes.
///
/// SubprogramCount - The running count of functions being compiled.
///
unsigned SubprogramCount;
-
+
+ unsigned SetCounter;
Dwarf(std::ostream &OS, AsmPrinter *A, const TargetAsmInfo *T)
: O(OS)
, Asm(A)
, MF(NULL)
, MMI(NULL)
, SubprogramCount(0)
+ , SetCounter(1)
{
}
void PrintLabelName(DWLabel Label) const {
PrintLabelName(Label.Tag, Label.Number);
}
- void PrintLabelName(const char *Tag, unsigned Number) const {
- O << TAI->getPrivateGlobalPrefix() << Tag;
+ void PrintLabelName(const char *Tag, unsigned Number,
+ bool isInSection = false) const {
+ if (isInSection && TAI->getDwarfSectionOffsetDirective())
+ O << TAI->getDwarfSectionOffsetDirective() << Tag;
+ else
+ O << TAI->getPrivateGlobalPrefix() << Tag;
if (Number) O << Number;
}
/// assemblers do not behave with absolute expressions with data directives,
/// so there is an option (needsSet) to use an intermediary set expression.
void EmitDifference(DWLabel LabelHi, DWLabel LabelLo,
- bool IsSmall = false) const {
+ bool IsSmall = false) {
EmitDifference(LabelHi.Tag, LabelHi.Number,
LabelLo.Tag, LabelLo.Number,
IsSmall);
}
void EmitDifference(const char *TagHi, unsigned NumberHi,
const char *TagLo, unsigned NumberLo,
- bool IsSmall = false) const {
+ bool IsSmall = false) {
if (TAI->needsSet()) {
- static unsigned SetCounter = 1;
-
O << "\t.set\t";
PrintLabelName("set", SetCounter);
O << ",";
PrintLabelName(TagLo, NumberLo);
}
}
-
+
+ void EmitSectionOffset(const char* Label, const char* Section,
+ unsigned LabelNumber, unsigned SectionNumber,
+ bool IsSmall = false, bool isEH = false) {
+ bool printAbsolute = false;
+ if (TAI->needsSet()) {
+ O << "\t.set\t";
+ PrintLabelName("set", SetCounter);
+ O << ",";
+ PrintLabelName(Label, LabelNumber, true);
+
+ if (isEH)
+ printAbsolute = TAI->isAbsoluteEHSectionOffsets();
+ else
+ printAbsolute = TAI->isAbsoluteDebugSectionOffsets();
+
+ if (!printAbsolute) {
+ O << "-";
+ PrintLabelName(Section, SectionNumber);
+ }
+ O << "\n";
+
+ if (IsSmall || TAI->getAddressSize() == sizeof(int32_t))
+ O << TAI->getData32bitsDirective();
+ else
+ O << TAI->getData64bitsDirective();
+
+ PrintLabelName("set", SetCounter);
+ ++SetCounter;
+ } else {
+ if (IsSmall || TAI->getAddressSize() == sizeof(int32_t))
+ O << TAI->getData32bitsDirective();
+ else
+ O << TAI->getData64bitsDirective();
+
+ PrintLabelName(Label, LabelNumber, true);
+
+ 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,
- std::vector<MachineMove> &Moves) {
+ const std::vector<MachineMove> &Moves) {
int stackGrowth =
Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
TargetFrameInfo::StackGrowsUp ?
bool IsLocal = BaseLabel && strcmp(BaseLabel, "label") == 0;
for (unsigned i = 0, N = Moves.size(); i < N; ++i) {
- MachineMove &Move = Moves[i];
+ const MachineMove &Move = Moves[i];
unsigned LabelID = Move.getLabelID();
if (LabelID) {
///
bool shouldEmit;
+ struct FunctionDebugFrameInfo {
+ unsigned Number;
+ std::vector<MachineMove> Moves;
+
+ FunctionDebugFrameInfo(unsigned Num, const std::vector<MachineMove> &M):
+ Number(Num), Moves(M) { };
+ };
+
+ std::vector<FunctionDebugFrameInfo> DebugFrames;
+
public:
/// ShouldEmitDwarf - Returns true if Dwarf declarations should be made.
CompileUnit *NewCompileUnit(CompileUnitDesc *UnitDesc, unsigned ID) {
// Construct debug information entry.
DIE *Die = new DIE(DW_TAG_compile_unit);
- AddDelta(Die, DW_AT_stmt_list, DW_FORM_data4, DWLabel("section_line", 0),
- DWLabel("section_line", 0));
+ 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));
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());
didInitial = true;
// Dwarf sections base addresses.
- if (TAI->getDwarfRequiresFrameSection()) {
+ if (TAI->doesDwarfRequireFrameSection()) {
Asm->SwitchToDataSection(TAI->getDwarfFrameSection());
- EmitLabel("section_frame", 0);
+ EmitLabel("section_debug_frame", 0);
}
Asm->SwitchToDataSection(TAI->getDwarfInfoSection());
EmitLabel("section_info", 0);
EmitLabel("text_begin", 0);
Asm->SwitchToDataSection(TAI->getDataSection());
EmitLabel("data_begin", 0);
-
- // Emit common frame information.
- EmitInitialDebugFrame();
}
/// EmitDIE - Recusively Emits a debug information entry.
///
- void EmitDIE(DIE *Die) const {
+ void EmitDIE(DIE *Die) {
// Get the abbreviation for this DIE.
unsigned AbbrevNumber = Die->getAbbrevNumber();
const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
":0x" + utohexstr(Die->getSize()) + " " +
TagString(Abbrev->getTag())));
- const std::vector<DIEValue *> &Values = Die->getValues();
+ std::vector<DIEValue *> &Values = Die->getValues();
const std::vector<DIEAbbrevData> &AbbrevData = Abbrev->getData();
// Emit the DIE attribute values.
/// EmitDebugInfo - Emit the debug info section.
///
- void EmitDebugInfo() const {
+ void EmitDebugInfo() {
// Start debug info section.
Asm->SwitchToDataSection(TAI->getDwarfInfoSection());
Asm->EmitInt32(ContentSize); Asm->EOL("Length of Compilation Unit Info");
Asm->EmitInt16(DWARF_VERSION); Asm->EOL("DWARF version number");
- EmitDifference("abbrev_begin", 0, "section_abbrev", 0, true);
+ 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)");
/// EmitDebugLines - Emit source line information.
///
- void EmitDebugLines() const {
+ void EmitDebugLines() {
// Minimum line delta, thus ranging from -10..(255-10).
const int MinLineDelta = -(DW_LNS_fixed_advance_pc + 1);
// Maximum line delta, thus ranging from -10..(255-10).
Asm->EOL();
}
- /// EmitInitialDebugFrame - Emit common frame info into a debug frame section.
+ /// EmitCommonDebugFrame - Emit common frame info into a debug frame section.
///
- void EmitInitialDebugFrame() {
- if (!TAI->getDwarfRequiresFrameSection())
+ void EmitCommonDebugFrame() {
+ if (!TAI->doesDwarfRequireFrameSection())
return;
int stackGrowth =
// Start the dwarf frame section.
Asm->SwitchToDataSection(TAI->getDwarfFrameSection());
- EmitLabel("frame_common", 0);
- EmitDifference("frame_common_end", 0,
- "frame_common_begin", 0, true);
+ EmitLabel("debug_frame_common", 0);
+ EmitDifference("debug_frame_common_end", 0,
+ "debug_frame_common_begin", 0, true);
Asm->EOL("Length of Common Information Entry");
- EmitLabel("frame_common_begin", 0);
+ EmitLabel("debug_frame_common_begin", 0);
Asm->EmitInt32((int)DW_CIE_ID);
Asm->EOL("CIE Identifier Tag");
Asm->EmitInt8(DW_CIE_VERSION);
std::vector<MachineMove> Moves;
RI->getInitialFrameState(Moves);
+
EmitFrameMoves(NULL, 0, Moves);
Asm->EmitAlignment(2);
- EmitLabel("frame_common_end", 0);
+ EmitLabel("debug_frame_common_end", 0);
Asm->EOL();
}
/// EmitFunctionDebugFrame - Emit per function frame info into a debug frame
/// section.
- void EmitFunctionDebugFrame() {
- if (!TAI->getDwarfRequiresFrameSection())
+ void EmitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
+ if (!TAI->doesDwarfRequireFrameSection())
return;
// Start the dwarf frame section.
Asm->SwitchToDataSection(TAI->getDwarfFrameSection());
- EmitDifference("frame_end", SubprogramCount,
- "frame_begin", SubprogramCount, true);
+ EmitDifference("debug_frame_end", DebugFrameInfo.Number,
+ "debug_frame_begin", DebugFrameInfo.Number, true);
Asm->EOL("Length of Frame Information Entry");
- EmitLabel("frame_begin", SubprogramCount);
-
- EmitDifference("frame_common_begin", 0, "section_frame", 0, true);
+ EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
+
+ EmitSectionOffset("debug_frame_common", "section_debug_frame",
+ 0, 0, true, false);
Asm->EOL("FDE CIE offset");
- EmitReference("func_begin", SubprogramCount);
+ EmitReference("func_begin", DebugFrameInfo.Number);
Asm->EOL("FDE initial location");
- EmitDifference("func_end", SubprogramCount,
- "func_begin", SubprogramCount);
+ EmitDifference("func_end", DebugFrameInfo.Number,
+ "func_begin", DebugFrameInfo.Number);
Asm->EOL("FDE address range");
- std::vector<MachineMove> &Moves = MMI->getFrameMoves();
-
- EmitFrameMoves("func_begin", SubprogramCount, Moves);
+ EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves);
Asm->EmitAlignment(2);
- EmitLabel("frame_end", SubprogramCount);
+ EmitLabel("debug_frame_end", DebugFrameInfo.Number);
Asm->EOL();
}
EmitLabel("pubnames_begin", Unit->getID());
Asm->EmitInt16(DWARF_VERSION); Asm->EOL("DWARF Version");
-
- EmitDifference("info_begin", Unit->getID(), "section_info", 0, true);
+
+ EmitSectionOffset("info_begin", "section_info",
+ Unit->getID(), 0, true, false);
Asm->EOL("Offset of Compilation Unit Info");
EmitDifference("info_end", Unit->getID(), "info_begin", Unit->getID(),true);
Asm->SwitchToTextSection(SectionMap[i].c_str());
EmitLabel("section_end", i);
}
-
+
+ // Emit common frame information.
+ EmitCommonDebugFrame();
+
+ // Emit function debug frame information
+ for (std::vector<FunctionDebugFrameInfo>::iterator I = DebugFrames.begin(),
+ E = DebugFrames.end(); I != E; ++I)
+ EmitFunctionDebugFrame(*I);
+
// Compute DIE offsets and sizes.
SizeAndOffsets();
// Construct scopes for subprogram.
ConstructRootScope(MMI->getRootScope());
-
- // Emit function frame information.
- EmitFunctionDebugFrame();
+
+ DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
+ MMI->getFrameMoves()));
}
};
class DwarfException : public Dwarf {
private:
+ struct FunctionEHFrameInfo {
+ std::string FnName;
+ unsigned Number;
+ unsigned PersonalityIndex;
+ bool hasCalls;
+ bool hasLandingPads;
+ std::vector<MachineMove> Moves;
- /// didInitial - Flag to indicate if initial emission has been done.
- ///
- bool didInitial;
-
+ FunctionEHFrameInfo(const std::string &FN, unsigned Num, unsigned P,
+ bool hC, bool hL,
+ const std::vector<MachineMove> &M):
+ FnName(FN), Number(Num), PersonalityIndex(P),
+ hasCalls(hC), hasLandingPads(hL), Moves(M) { };
+ };
+
+ std::vector<FunctionEHFrameInfo> EHFrames;
+
/// shouldEmit - Flag to indicate if debug information should be emitted.
///
bool shouldEmit;
- /// FuncCPPPersonality - C++ persoanlity function.
- ///
- Function *FuncCPPPersonality;
-
/// EmitCommonEHFrame - Emit the common eh unwind frame.
///
- void EmitCommonEHFrame() {
- // Only do it once.
- if (didInitial) return;
- didInitial = true;
-
- // If there is a personality present then we need to indicate that
- // in the common eh frame.
- Function *Personality = FuncCPPPersonality;
-
+ void EmitCommonEHFrame(const Function *Personality, unsigned Index) {
// Size and sign of stack growth.
int stackGrowth =
Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
// Begin eh frame section.
Asm->SwitchToTextSection(TAI->getDwarfEHFrameSection());
- O << "EH_frame:\n";
- EmitLabel("section_eh_frame", 0);
+ O << "EH_frame" << Index << ":\n";
+ EmitLabel("section_eh_frame", Index);
// Define base labels.
- EmitLabel("eh_frame_common", 0);
+ EmitLabel("eh_frame_common", Index);
// Define the eh frame length.
- EmitDifference("eh_frame_common_end", 0,
- "eh_frame_common_begin", 0, true);
+ EmitDifference("eh_frame_common_end", Index,
+ "eh_frame_common_begin", Index, true);
Asm->EOL("Length of Common Information Entry");
// EH frame header.
- EmitLabel("eh_frame_common_begin", 0);
+ EmitLabel("eh_frame_common_begin", Index);
Asm->EmitInt32((int)0);
Asm->EOL("CIE Identifier Tag");
Asm->EmitInt8(DW_CIE_VERSION);
if (Personality) {
Asm->EmitULEB128Bytes(7);
Asm->EOL("Augmentation Size");
- Asm->EmitInt8(DW_EH_PE_indirect |
- DW_EH_PE_pcrel |
- DW_EH_PE_sdata4);
- Asm->EOL("Personality (indirect pcrel sdata4)");
+ Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4);
+ Asm->EOL("Personality (pcrel sdata4)");
O << TAI->getData32bitsDirective();
Asm->EmitExternalGlobal((const GlobalVariable *)(Personality));
EmitFrameMoves(NULL, 0, Moves);
Asm->EmitAlignment(2);
- EmitLabel("eh_frame_common_end", 0);
+ EmitLabel("eh_frame_common_end", Index);
Asm->EOL();
}
- /// EmitEHFrame - Emit initial exception information.
+ /// EmitEHFrame - Emit function exception frame information.
///
- void EmitEHFrame() {
- // If there is a personality present then we need to indicate that
- // in the common eh frame.
- Function *Personality = FuncCPPPersonality;
-// Function *Personality = MMI->getPersonality();
- MachineFrameInfo *MFI = MF->getFrameInfo();
-
+ void EmitEHFrame(const FunctionEHFrameInfo &EHFrameInfo) {
Asm->SwitchToTextSection(TAI->getDwarfEHFrameSection());
// Externally visible entry into the functions eh frame info.
if (const char *GlobalDirective = TAI->getGlobalDirective())
- O << GlobalDirective << getAsm()->CurrentFnName << ".eh\n";
+ O << GlobalDirective << EHFrameInfo.FnName << ".eh\n";
// If there are no calls then you can't unwind.
- if (!MFI->hasCalls()) {
- O << getAsm()->CurrentFnName << ".eh = 0\n";
+ if (!EHFrameInfo.hasCalls) {
+ O << EHFrameInfo.FnName << ".eh = 0\n";
} else {
- O << getAsm()->CurrentFnName << ".eh:\n";
+ O << EHFrameInfo.FnName << ".eh:\n";
// EH frame header.
- EmitDifference("eh_frame_end", SubprogramCount,
- "eh_frame_begin", SubprogramCount, true);
+ EmitDifference("eh_frame_end", EHFrameInfo.Number,
+ "eh_frame_begin", EHFrameInfo.Number, true);
Asm->EOL("Length of Frame Information Entry");
- EmitLabel("eh_frame_begin", SubprogramCount);
-
- EmitDifference("eh_frame_begin", SubprogramCount,
- "section_eh_frame", 0, true);
+ EmitLabel("eh_frame_begin", EHFrameInfo.Number);
+
+ EmitSectionOffset("eh_frame_begin", "eh_frame_common",
+ EHFrameInfo.Number, EHFrameInfo.PersonalityIndex,
+ true, true);
Asm->EOL("FDE CIE offset");
- EmitReference("eh_func_begin", SubprogramCount, true);
+ EmitReference("eh_func_begin", EHFrameInfo.Number, true);
Asm->EOL("FDE initial location");
- EmitDifference("eh_func_end", SubprogramCount,
- "eh_func_begin", SubprogramCount);
+ EmitDifference("eh_func_end", EHFrameInfo.Number,
+ "eh_func_begin", EHFrameInfo.Number);
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 (Personality) {
+ if (EHFrameInfo.PersonalityIndex) {
Asm->EmitULEB128Bytes(4);
Asm->EOL("Augmentation size");
- if (!MMI->getLandingPads().empty()) {
- EmitReference("exception", SubprogramCount, true);
+ if (EHFrameInfo.hasLandingPads) {
+ EmitReference("exception", EHFrameInfo.Number, true);
} else if(TAI->getAddressSize() == 8) {
Asm->EmitInt64((int)0);
} else {
// Indicate locations of function specific callee saved registers in
// frame.
- std::vector<MachineMove> &Moves = MMI->getFrameMoves();
- EmitFrameMoves("eh_func_begin", SubprogramCount, Moves);
+ EmitFrameMoves("eh_func_begin", EHFrameInfo.Number, EHFrameInfo.Moves);
Asm->EmitAlignment(2);
- EmitLabel("eh_frame_end", SubprogramCount);
+ EmitLabel("eh_frame_end", EHFrameInfo.Number);
}
if (const char *UsedDirective = TAI->getUsedDirective())
- O << UsedDirective << getAsm()->CurrentFnName << ".eh\n\n";
+ O << UsedDirective << EHFrameInfo.FnName << ".eh\n\n";
}
-
+
+ /// EquivPads - Whether two landing pads have equivalent actions.
+ static bool EquivPads(const LandingPadInfo *L, const LandingPadInfo *R) {
+ const std::vector<int> &LIds = L->TypeIds;
+ const std::vector<int> &RIds = R->TypeIds;
+ unsigned LSize = LIds.size(), RSize = RIds.size();
+
+ if (LSize != RSize)
+ return false;
+
+ for (unsigned i = 0; i != LSize; ++i)
+ if (LIds[i] != RIds[i])
+ return false;
+
+ return true;
+ }
+
+ /// PadLT - An order on landing pads, with EquivPads as order equivalence.
+ static bool PadLT(const LandingPadInfo *L, const LandingPadInfo *R) {
+ const std::vector<int> &LIds = L->TypeIds;
+ const std::vector<int> &RIds = R->TypeIds;
+ unsigned LSize = LIds.size(), RSize = RIds.size();
+
+ if (LSize != RSize)
+ return LSize < RSize;
+
+ for (unsigned i = 0; i != LSize; ++i)
+ if (LIds[i] != RIds[i])
+ return LIds[i] < RIds[i];
+
+ return false; // Equivalent
+ }
+
/// EmitExceptionTable - Emit landpads and actions.
///
/// The general organization of the table is complex, but the basic concepts
/// found the 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.
+
+ struct KeyInfo {
+ static inline unsigned getEmptyKey() { return -1U; }
+ static inline unsigned getTombstoneKey() { return -2U; }
+ static unsigned getHashValue(const unsigned &Key) { return Key; }
+ static bool isPod() { return true; }
+ };
+
+ struct PadSite {
+ unsigned PadIndex;
+ unsigned SiteIndex;
+ };
+
+ typedef DenseMap<unsigned, PadSite, KeyInfo> PadMapType;
+
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<LandingPadInfo> &LandingPads = MMI->getLandingPads();
- if (LandingPads.empty()) return;
-
- // FIXME - Should fold actions for multiple landing pads.
-
+ const std::vector<unsigned> &FilterIds = MMI->getFilterIds();
+ const std::vector<LandingPadInfo> &PadInfos = MMI->getLandingPads();
+ if (PadInfos.empty()) return;
+
+ // Sort the landing pads in order of their type ids. This is used to fold
+ // duplicate actions.
+ SmallVector<const LandingPadInfo *, 32> LandingPads(PadInfos.size(), NULL);
+ for (unsigned i = 0, N = PadInfos.size(); i != N; ++i)
+ LandingPads[i] = &PadInfos[i];
+ std::sort(LandingPads.begin(), LandingPads.end(), PadLT);
+
// Gather first action index for each landing pad site.
- SmallVector<unsigned, 8> Actions;
-
- // FIXME - Assume there is only one filter typeinfo list per function
- // time being. I.E., Each call to eh_filter will have the same list.
- // This can change if a function is inlined.
- const LandingPadInfo *Filter = 0;
+ SmallVector<unsigned, 32> Actions;
// Compute sizes for exception table.
- unsigned SizeHeader = sizeof(int8_t) + // LPStart format
- sizeof(int8_t) + // TType format
- sizeof(int8_t) + // TType base offset (NEED ULEB128)
- sizeof(int8_t) + // Call site format
- sizeof(int8_t); // Call-site table length
unsigned SizeSites = 0;
unsigned SizeActions = 0;
// Look at each landing pad site to compute size. We need the size of each
// landing pad site info and the size of the landing pad's actions.
+ signed FirstAction = 0;
+
for (unsigned i = 0, N = LandingPads.size(); i != N; ++i) {
- const LandingPadInfo &LandingPad = LandingPads[i];
- bool IsFilter = LandingPad.IsFilter;
+ const LandingPadInfo *LandingPad = LandingPads[i];
unsigned SizeSiteActions = 0;
- const std::vector<unsigned> &TypeIds = LandingPad.TypeIds;
- unsigned SizeAction = 0;
- signed FirstAction;
-
- if (IsFilter) {
- // FIXME - Assume there is only one filter typeinfo list per function
- // time being. I.E., Each call to eh_filter will have the same list.
- // This can change if a function is inlined.
- Filter = &LandingPad;
- SizeAction = Asm->SizeSLEB128(-1) + Asm->SizeSLEB128(0);
- SizeSiteActions += SizeAction;
- // Record the first action of the landing pad site.
- FirstAction = SizeActions + SizeSiteActions - SizeAction + 1;
- } else if (TypeIds.empty()) {
- FirstAction = 0;
- } else {
- // Gather the action sizes
- for (unsigned j = 0, M = TypeIds.size(); j != M; ++j) {
- unsigned TypeID = TypeIds[i];
- unsigned SizeTypeID = Asm->SizeSLEB128(TypeID);
- signed Action = j ? -(SizeAction + SizeTypeID) : 0;
- SizeAction = SizeTypeID + Asm->SizeSLEB128(Action);
- SizeSiteActions += SizeAction;
+
+ if (!i || !EquivPads(LandingPad, LandingPads[i-1])) {
+ const std::vector<int> &TypeIds = LandingPad->TypeIds;
+ unsigned SizeAction = 0;
+
+ if (TypeIds.empty()) {
+ FirstAction = 0;
+ } else {
+ // Gather the action sizes
+ for (unsigned j = 0, M = TypeIds.size(); j != M; ++j) {
+ int TypeID = TypeIds[j];
+ unsigned SizeTypeID = Asm->SizeSLEB128(TypeID);
+ signed Action = j ? -(SizeAction + SizeTypeID) : 0;
+ SizeAction = SizeTypeID + Asm->SizeSLEB128(Action);
+ SizeSiteActions += SizeAction;
+ }
+
+ // Record the first action of the landing pad site.
+ FirstAction = SizeActions + SizeSiteActions - SizeAction + 1;
}
-
- // Record the first action of the landing pad site.
- FirstAction = SizeActions + SizeSiteActions - SizeAction + 1;
- }
-
+ } // else re-use previous FirstAction
+
Actions.push_back(FirstAction);
-
+
// Compute this sites contribution to size.
SizeActions += SizeSiteActions;
- SizeSites += sizeof(int32_t) + // Site start.
- sizeof(int32_t) + // Site length.
- sizeof(int32_t) + // Landing pad.
- Asm->SizeSLEB128(FirstAction); // Action.
+ unsigned M = LandingPad->BeginLabels.size();
+ SizeSites += M*(sizeof(int32_t) + // Site start.
+ sizeof(int32_t) + // Site length.
+ sizeof(int32_t) + // Landing pad.
+ Asm->SizeULEB128(FirstAction)); // Action.
}
// Final tallies.
unsigned SizeTypes = TypeInfos.size() * TAI->getAddressSize();
- unsigned SizePreType = SizeHeader + SizeSites + SizeActions;
- unsigned SizeAlign = (4 - SizePreType) & 3;
- unsigned TypeOffset = SizePreType +
- SizeTypes +
- SizeAlign -
- sizeof(int8_t) - // LPStart format
- sizeof(int8_t) - // TType format
- sizeof(int8_t); // TType base offset (NEED ULEB128)
-
+
+ unsigned TypeOffset = sizeof(int8_t) + // Call site format
+ Asm->SizeULEB128(SizeSites) + // Call-site table length
+ SizeSites + SizeActions + SizeTypes;
+
+ unsigned TotalSize = sizeof(int8_t) + // LPStart format
+ sizeof(int8_t) + // TType format
+ Asm->SizeULEB128(TypeOffset) + // TType base offset
+ TypeOffset;
+
+ unsigned SizeAlign = (4 - TotalSize) & 3;
+
// Begin the exception table.
Asm->SwitchToDataSection(TAI->getDwarfExceptionSection());
O << "GCC_except_table" << SubprogramCount << ":\n";
+ Asm->EmitAlignment(2);
+ for (unsigned i = 0; i != SizeAlign; ++i) {
+ Asm->EmitInt8(0);
+ Asm->EOL("Padding");
+ }
EmitLabel("exception", SubprogramCount);
-
+
// Emit the header.
Asm->EmitInt8(DW_EH_PE_omit);
Asm->EOL("LPStart format (DW_EH_PE_omit)");
Asm->EOL("Call site format (DW_EH_PE_udata4)");
Asm->EmitULEB128Bytes(SizeSites);
Asm->EOL("Call-site table length");
-
- // Emit the landng pad site information.
+
+ // Emit the landing pad site information in order of address.
+ PadMapType PadMap;
+
for (unsigned i = 0, N = LandingPads.size(); i != N; ++i) {
- const LandingPadInfo &LandingPad = LandingPads[i];
- EmitDifference("label", LandingPad.BeginLabel,
- "eh_func_begin", SubprogramCount);
- Asm->EOL("Region start");
-
- EmitDifference("label", LandingPad.EndLabel,
- "label", LandingPad.BeginLabel);
- Asm->EOL("Region length");
-
- if (LandingPad.TypeIds.empty()) {
- if (TAI->getAddressSize() == sizeof(int32_t))
- Asm->EmitInt32(0);
- else
- Asm->EmitInt64(0);
- } else {
- EmitDifference("label", LandingPad.LandingPadLabel,
- "eh_func_begin", SubprogramCount);
+ const LandingPadInfo *LandingPad = LandingPads[i];
+ for (unsigned j=0, E = LandingPad->BeginLabels.size(); j != E; ++j) {
+ unsigned BeginLabel = LandingPad->BeginLabels[j];
+ assert(!PadMap.count(BeginLabel) && "duplicate landing pad labels!");
+ PadSite P = { i, j };
+ PadMap[BeginLabel] = P;
}
- Asm->EOL("Landing pad");
+ }
+
+ 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)
+ continue;
+
+ unsigned BeginLabel = MI->getOperand(0).getImmedValue();
+ PadMapType::iterator L = PadMap.find(BeginLabel);
+
+ if (L == PadMap.end())
+ continue;
+
+ PadSite P = L->second;
+ const LandingPadInfo *LandingPad = LandingPads[P.PadIndex];
- Asm->EmitULEB128Bytes(Actions[i]);
- Asm->EOL("Action");
+ assert(BeginLabel == LandingPad->BeginLabels[P.SiteIndex] &&
+ "Inconsistent landing pad map!");
+
+ EmitSectionOffset("label", "eh_func_begin", BeginLabel, SubprogramCount,
+ false, true);
+ Asm->EOL("Region start");
+
+ EmitDifference("label", LandingPad->EndLabels[P.SiteIndex],
+ "label", BeginLabel);
+ Asm->EOL("Region length");
+
+ if (LandingPad->TypeIds.empty()) {
+ if (TAI->getAddressSize() == sizeof(int32_t))
+ Asm->EmitInt32(0);
+ else
+ Asm->EmitInt64(0);
+ } else {
+ EmitSectionOffset("label", "eh_func_begin",
+ LandingPad->LandingPadLabel, SubprogramCount,
+ false, true);
+ }
+ Asm->EOL("Landing pad");
+
+ Asm->EmitULEB128Bytes(Actions[P.PadIndex]);
+ Asm->EOL("Action");
+ }
}
-
+
// Emit the actions.
for (unsigned i = 0, N = LandingPads.size(); i != N; ++i) {
- const LandingPadInfo &LandingPad = LandingPads[i];
- const std::vector<unsigned> &TypeIds = LandingPad.TypeIds;
- unsigned SizeAction = 0;
-
- if (LandingPad.IsFilter) {
- Asm->EmitSLEB128Bytes(-1);
- Asm->EOL("TypeInfo index");
- Asm->EmitSLEB128Bytes(0);
- Asm->EOL("Next action");
- } else {
+ if (!i || Actions[i] != Actions[i-1]) {
+ const LandingPadInfo *LandingPad = LandingPads[i];
+ const std::vector<int> &TypeIds = LandingPad->TypeIds;
+ unsigned SizeAction = 0;
+
for (unsigned j = 0, M = TypeIds.size(); j < M; ++j) {
- unsigned TypeID = TypeIds[j];
+ int TypeID = TypeIds[j];
unsigned SizeTypeID = Asm->SizeSLEB128(TypeID);
Asm->EmitSLEB128Bytes(TypeID);
Asm->EOL("TypeInfo index");
}
// Emit the type ids.
- Asm->EmitAlignment(2);
for (unsigned M = TypeInfos.size(); M; --M) {
GlobalVariable *GV = TypeInfos[M - 1];
Asm->EOL("TypeInfo");
}
- // Emit the filter typeinfo.
- if (Filter) {
- const std::vector<unsigned> &TypeIds = Filter->TypeIds;
- for (unsigned j = 0, M = TypeIds.size(); j < M; ++j) {
- unsigned TypeID = TypeIds[j];
- Asm->EmitSLEB128Bytes(TypeID);
- Asm->EOL("TypeInfo index");
- }
- Asm->EmitSLEB128Bytes(0);
- Asm->EOL("End of filter typeinfo");
+ // Emit the filter typeids.
+ for (unsigned j = 0, M = FilterIds.size(); j < M; ++j) {
+ unsigned TypeID = FilterIds[j];
+ Asm->EmitSLEB128Bytes(TypeID);
+ Asm->EOL("Filter TypeInfo index");
}
Asm->EmitAlignment(2);
//
DwarfException(std::ostream &OS, AsmPrinter *A, const TargetAsmInfo *T)
: Dwarf(OS, A, T)
- , didInitial(false)
, shouldEmit(false)
- , FuncCPPPersonality(NULL)
{}
virtual ~DwarfException() {}
/// content.
void BeginModule(Module *M) {
this->M = M;
- FuncCPPPersonality = M->getFunction("__gxx_personality_v0");
}
/// 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);
}
/// BeginFunction - Gather pre-function exception information. Assumes being
if (MMI &&
ExceptionHandling &&
- TAI->getSupportsExceptionHandling()) {
+ TAI->doesSupportExceptionHandling()) {
shouldEmit = true;
// Assumes in correct section after the entry point.
EmitLabel("eh_func_begin", ++SubprogramCount);
EmitLabel("eh_func_end", SubprogramCount);
EmitExceptionTable();
- EmitCommonEHFrame();
- EmitEHFrame();
+
+ // Save EH frame information
+ EHFrames.push_back(FunctionEHFrameInfo(getAsm()->CurrentFnName,
+ SubprogramCount,
+ MMI->getPersonalityIndex(),
+ MF->getFrameInfo()->hasCalls(),
+ !MMI->getLandingPads().empty(),
+ MMI->getFrameMoves()));
}
};
/// EmitValue - Emit integer of appropriate size.
///
-void DIEInteger::EmitValue(const DwarfDebug &DD, unsigned Form) const {
+void DIEInteger::EmitValue(DwarfDebug &DD, unsigned Form) {
switch (Form) {
case DW_FORM_flag: // Fall thru
case DW_FORM_ref1: // Fall thru
/// EmitValue - Emit string value.
///
-void DIEString::EmitValue(const DwarfDebug &DD, unsigned Form) const {
+void DIEString::EmitValue(DwarfDebug &DD, unsigned Form) {
DD.getAsm()->EmitString(String);
}
/// EmitValue - Emit label value.
///
-void DIEDwarfLabel::EmitValue(const DwarfDebug &DD, unsigned Form) const {
+void DIEDwarfLabel::EmitValue(DwarfDebug &DD, unsigned Form) {
DD.EmitReference(Label);
}
/// EmitValue - Emit label value.
///
-void DIEObjectLabel::EmitValue(const DwarfDebug &DD, unsigned Form) const {
+void DIEObjectLabel::EmitValue(DwarfDebug &DD, unsigned Form) {
DD.EmitReference(Label);
}
/// EmitValue - Emit delta value.
///
-void DIEDelta::EmitValue(const DwarfDebug &DD, unsigned Form) const {
+void DIEDelta::EmitValue(DwarfDebug &DD, unsigned Form) {
bool IsSmall = Form == DW_FORM_data4;
DD.EmitDifference(LabelHi, LabelLo, IsSmall);
}
/// EmitValue - Emit debug information entry offset.
///
-void DIEntry::EmitValue(const DwarfDebug &DD, unsigned Form) const {
+void DIEntry::EmitValue(DwarfDebug &DD, unsigned Form) {
DD.getAsm()->EmitInt32(Entry->getOffset());
}
/// EmitValue - Emit block data.
///
-void DIEBlock::EmitValue(const DwarfDebug &DD, unsigned Form) const {
+void DIEBlock::EmitValue(DwarfDebug &DD, unsigned Form) {
switch (Form) {
case DW_FORM_block1: DD.getAsm()->EmitInt8(Size); break;
case DW_FORM_block2: DD.getAsm()->EmitInt16(Size); break;
projects / oota-llvm.git / blobdiff