2009-05-10 23:14:38 +00:00
|
|
|
//===-- llvm/CodeGen/DwarfWriter.cpp - Dwarf Framework --------------------===//
|
2005-12-21 19:48:16 +00:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-12-21 19:48:16 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2007-01-29 18:51:14 +00:00
|
|
|
// This file contains support for writing dwarf info into asm files.
|
2005-12-21 19:48:16 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
2006-01-27 18:32:41 +00:00
|
|
|
|
2006-01-04 22:28:25 +00:00
|
|
|
#include "llvm/CodeGen/DwarfWriter.h"
|
2006-01-24 00:49:18 +00:00
|
|
|
#include "llvm/Module.h"
|
2009-01-05 23:03:32 +00:00
|
|
|
#include "llvm/DerivedTypes.h"
|
2009-01-15 23:41:32 +00:00
|
|
|
#include "llvm/Constants.h"
|
2006-01-04 13:52:30 +00:00
|
|
|
#include "llvm/CodeGen/AsmPrinter.h"
|
2007-01-26 21:22:28 +00:00
|
|
|
#include "llvm/CodeGen/MachineModuleInfo.h"
|
2006-04-07 16:34:46 +00:00
|
|
|
#include "llvm/CodeGen/MachineFrameInfo.h"
|
2006-03-23 18:07:55 +00:00
|
|
|
#include "llvm/CodeGen/MachineLocation.h"
|
2009-01-05 17:57:47 +00:00
|
|
|
#include "llvm/Analysis/DebugInfo.h"
|
2007-02-28 18:38:31 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2006-01-26 20:21:46 +00:00
|
|
|
#include "llvm/Support/Dwarf.h"
|
2006-01-04 13:52:30 +00:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2006-10-30 13:35:07 +00:00
|
|
|
#include "llvm/Support/DataTypes.h"
|
2006-01-24 00:49:18 +00:00
|
|
|
#include "llvm/Support/Mangler.h"
|
2009-03-10 20:41:52 +00:00
|
|
|
#include "llvm/Support/Timer.h"
|
2008-08-21 00:14:44 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2007-09-24 21:32:18 +00:00
|
|
|
#include "llvm/System/Path.h"
|
2006-09-06 18:34:40 +00:00
|
|
|
#include "llvm/Target/TargetAsmInfo.h"
|
2008-02-10 18:45:23 +00:00
|
|
|
#include "llvm/Target/TargetRegisterInfo.h"
|
2006-05-12 06:33:49 +00:00
|
|
|
#include "llvm/Target/TargetData.h"
|
2006-04-10 23:09:19 +00:00
|
|
|
#include "llvm/Target/TargetFrameInfo.h"
|
2007-05-16 12:12:23 +00:00
|
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
2007-01-29 20:48:32 +00:00
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2007-01-29 23:40:33 +00:00
|
|
|
#include "llvm/Target/TargetOptions.h"
|
2009-02-25 07:04:34 +00:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
|
|
|
#include "llvm/ADT/FoldingSet.h"
|
|
|
|
#include "llvm/ADT/StringExtras.h"
|
|
|
|
#include "llvm/ADT/StringMap.h"
|
2006-11-29 00:39:47 +00:00
|
|
|
#include <ostream>
|
2006-10-30 13:35:07 +00:00
|
|
|
#include <string>
|
2006-01-04 22:28:25 +00:00
|
|
|
using namespace llvm;
|
2006-02-27 22:37:23 +00:00
|
|
|
using namespace llvm::dwarf;
|
2006-01-04 13:52:30 +00:00
|
|
|
|
2009-01-08 23:40:34 +00:00
|
|
|
static RegisterPass<DwarfWriter>
|
|
|
|
X("dwarfwriter", "DWARF Information Writer");
|
|
|
|
char DwarfWriter::ID = 0;
|
|
|
|
|
2009-03-10 22:58:53 +00:00
|
|
|
static TimerGroup &getDwarfTimerGroup() {
|
|
|
|
static TimerGroup DwarfTimerGroup("Dwarf Exception and Debugging");
|
|
|
|
return DwarfTimerGroup;
|
2009-03-10 20:41:52 +00:00
|
|
|
}
|
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
namespace llvm {
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-10-30 13:35:07 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Configuration values for initial hash set sizes (log2).
|
|
|
|
///
|
2009-02-03 21:17:20 +00:00
|
|
|
static const unsigned InitDiesSetSize = 9; // log2(512)
|
|
|
|
static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
|
|
|
|
static const unsigned InitValuesSetSize = 9; // log2(512)
|
2006-02-27 12:43:29 +00:00
|
|
|
|
2006-01-17 17:31:53 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-10-30 15:59:54 +00:00
|
|
|
/// Forward declarations.
|
2006-11-02 20:12:39 +00:00
|
|
|
///
|
2006-02-27 12:43:29 +00:00
|
|
|
class DIE;
|
2006-11-02 20:12:39 +00:00
|
|
|
class DIEValue;
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// DWLabel - Labels are used to track locations in the assembler file.
|
2008-08-16 12:57:46 +00:00
|
|
|
/// Labels appear in the form @verbatim <prefix><Tag><Number> @endverbatim,
|
|
|
|
/// where the tag is a category of label (Ex. location) and number is a value
|
2007-08-05 20:06:04 +00:00
|
|
|
/// unique in that category.
|
2006-11-02 20:12:39 +00:00
|
|
|
class DWLabel {
|
|
|
|
public:
|
|
|
|
/// Tag - Label category tag. Should always be a staticly declared C string.
|
2006-02-27 17:27:12 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
const char *Tag;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Number - Value to make label unique.
|
2006-02-27 17:27:12 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
unsigned Number;
|
|
|
|
|
|
|
|
DWLabel(const char *T, unsigned N) : Tag(T), Number(N) {}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
void Profile(FoldingSetNodeID &ID) const {
|
2009-02-25 07:04:34 +00:00
|
|
|
ID.AddString(Tag);
|
2006-11-02 20:12:39 +00:00
|
|
|
ID.AddInteger(Number);
|
2006-03-23 23:02:34 +00:00
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
#ifndef NDEBUG
|
2006-12-17 05:15:13 +00:00
|
|
|
void print(std::ostream *O) const {
|
|
|
|
if (O) print(*O);
|
2006-11-29 00:39:47 +00:00
|
|
|
}
|
2006-11-02 20:12:39 +00:00
|
|
|
void print(std::ostream &O) const {
|
2007-02-21 22:48:45 +00:00
|
|
|
O << "." << Tag;
|
2006-11-02 20:12:39 +00:00
|
|
|
if (Number) O << Number;
|
|
|
|
}
|
|
|
|
#endif
|
2006-02-27 17:27:12 +00:00
|
|
|
};
|
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-10-30 15:59:54 +00:00
|
|
|
/// DIEAbbrevData - Dwarf abbreviation data, describes the one attribute of a
|
|
|
|
/// Dwarf abbreviation.
|
2006-02-27 12:43:29 +00:00
|
|
|
class DIEAbbrevData {
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Attribute - Dwarf attribute code.
|
|
|
|
///
|
|
|
|
unsigned Attribute;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Form - Dwarf form code.
|
2008-08-16 12:57:46 +00:00
|
|
|
///
|
|
|
|
unsigned Form;
|
2006-02-27 12:43:29 +00:00
|
|
|
public:
|
2009-03-10 23:57:09 +00:00
|
|
|
DIEAbbrevData(unsigned A, unsigned F) : Attribute(A), Form(F) {}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 17:27:12 +00:00
|
|
|
// Accessors.
|
2006-02-27 12:43:29 +00:00
|
|
|
unsigned getAttribute() const { return Attribute; }
|
|
|
|
unsigned getForm() const { return Form; }
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2006-10-30 15:59:54 +00:00
|
|
|
/// Profile - Used to gather unique data for the abbreviation folding set.
|
2006-02-27 12:43:29 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
void Profile(FoldingSetNodeID &ID)const {
|
2006-10-30 15:59:54 +00:00
|
|
|
ID.AddInteger(Attribute);
|
|
|
|
ID.AddInteger(Form);
|
2006-01-17 17:31:53 +00:00
|
|
|
}
|
2006-02-27 12:43:29 +00:00
|
|
|
};
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-10-30 15:59:54 +00:00
|
|
|
/// DIEAbbrev - Dwarf abbreviation, describes the organization of a debug
|
|
|
|
/// information object.
|
|
|
|
class DIEAbbrev : public FoldingSetNode {
|
2006-02-27 12:43:29 +00:00
|
|
|
private:
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Tag - Dwarf tag code.
|
|
|
|
///
|
|
|
|
unsigned Tag;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Unique number for node.
|
|
|
|
///
|
|
|
|
unsigned Number;
|
|
|
|
|
|
|
|
/// ChildrenFlag - Dwarf children flag.
|
|
|
|
///
|
|
|
|
unsigned ChildrenFlag;
|
|
|
|
|
|
|
|
/// Data - Raw data bytes for abbreviation.
|
|
|
|
///
|
2008-06-24 21:44:59 +00:00
|
|
|
SmallVector<DIEAbbrevData, 8> Data;
|
2006-02-27 12:43:29 +00:00
|
|
|
public:
|
2009-03-10 23:57:09 +00:00
|
|
|
DIEAbbrev(unsigned T, unsigned C) : Tag(T), ChildrenFlag(C), Data() {}
|
|
|
|
virtual ~DIEAbbrev() {}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 17:27:12 +00:00
|
|
|
// Accessors.
|
2006-02-27 12:43:29 +00:00
|
|
|
unsigned getTag() const { return Tag; }
|
2006-11-02 20:12:39 +00:00
|
|
|
unsigned getNumber() const { return Number; }
|
2006-02-27 12:43:29 +00:00
|
|
|
unsigned getChildrenFlag() const { return ChildrenFlag; }
|
2008-06-24 21:44:59 +00:00
|
|
|
const SmallVector<DIEAbbrevData, 8> &getData() const { return Data; }
|
2006-11-02 20:12:39 +00:00
|
|
|
void setTag(unsigned T) { Tag = T; }
|
2006-02-27 12:43:29 +00:00
|
|
|
void setChildrenFlag(unsigned CF) { ChildrenFlag = CF; }
|
2006-11-02 20:12:39 +00:00
|
|
|
void setNumber(unsigned N) { Number = N; }
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
/// AddAttribute - Adds another set of attribute information to the
|
|
|
|
/// abbreviation.
|
|
|
|
void AddAttribute(unsigned Attribute, unsigned Form) {
|
|
|
|
Data.push_back(DIEAbbrevData(Attribute, Form));
|
2006-01-17 17:31:53 +00:00
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-03-23 18:07:55 +00:00
|
|
|
/// AddFirstAttribute - Adds a set of attribute information to the front
|
|
|
|
/// of the abbreviation.
|
|
|
|
void AddFirstAttribute(unsigned Attribute, unsigned Form) {
|
|
|
|
Data.insert(Data.begin(), DIEAbbrevData(Attribute, Form));
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-10-30 15:59:54 +00:00
|
|
|
/// Profile - Used to gather unique data for the abbreviation folding set.
|
|
|
|
///
|
|
|
|
void Profile(FoldingSetNodeID &ID) {
|
|
|
|
ID.AddInteger(Tag);
|
|
|
|
ID.AddInteger(ChildrenFlag);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-10-30 15:59:54 +00:00
|
|
|
// For each attribute description.
|
|
|
|
for (unsigned i = 0, N = Data.size(); i < N; ++i)
|
|
|
|
Data[i].Profile(ID);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
/// Emit - Print the abbreviation using the specified Dwarf writer.
|
|
|
|
///
|
2008-08-16 12:57:46 +00:00
|
|
|
void Emit(const DwarfDebug &DD) const;
|
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
#ifndef NDEBUG
|
2006-12-17 05:15:13 +00:00
|
|
|
void print(std::ostream *O) {
|
|
|
|
if (O) print(*O);
|
2006-11-29 00:39:47 +00:00
|
|
|
}
|
2006-02-27 12:43:29 +00:00
|
|
|
void print(std::ostream &O);
|
|
|
|
void dump();
|
|
|
|
#endif
|
|
|
|
};
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// DIE - A structured debug information entry. Has an abbreviation which
|
|
|
|
/// describes it's organization.
|
2009-05-10 23:14:38 +00:00
|
|
|
class CompileUnit;
|
2006-11-02 20:12:39 +00:00
|
|
|
class DIE : public FoldingSetNode {
|
|
|
|
protected:
|
|
|
|
/// Abbrev - Buffer for constructing abbreviation.
|
|
|
|
///
|
|
|
|
DIEAbbrev Abbrev;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Offset - Offset in debug info section.
|
|
|
|
///
|
|
|
|
unsigned Offset;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Size - Size of instance + children.
|
|
|
|
///
|
|
|
|
unsigned Size;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Children DIEs.
|
|
|
|
///
|
|
|
|
std::vector<DIE *> Children;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Attributes values.
|
|
|
|
///
|
2008-06-24 21:44:59 +00:00
|
|
|
SmallVector<DIEValue*, 32> Values;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
/// Abstract compile unit.
|
|
|
|
CompileUnit *AbstractCU;
|
2006-11-02 20:12:39 +00:00
|
|
|
public:
|
2007-08-27 14:50:10 +00:00
|
|
|
explicit DIE(unsigned Tag)
|
2009-05-08 20:38:02 +00:00
|
|
|
: Abbrev(Tag, DW_CHILDREN_no), Offset(0), Size(0) {}
|
2006-11-02 20:12:39 +00:00
|
|
|
virtual ~DIE();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Accessors.
|
|
|
|
DIEAbbrev &getAbbrev() { return Abbrev; }
|
|
|
|
unsigned getAbbrevNumber() const {
|
|
|
|
return Abbrev.getNumber();
|
|
|
|
}
|
2006-11-09 16:32:26 +00:00
|
|
|
unsigned getTag() const { return Abbrev.getTag(); }
|
2006-11-02 20:12:39 +00:00
|
|
|
unsigned getOffset() const { return Offset; }
|
|
|
|
unsigned getSize() const { return Size; }
|
|
|
|
const std::vector<DIE *> &getChildren() const { return Children; }
|
2008-06-24 21:44:59 +00:00
|
|
|
SmallVector<DIEValue*, 32> &getValues() { return Values; }
|
2009-05-10 23:14:38 +00:00
|
|
|
CompileUnit *getAbstractCompileUnit() const { return AbstractCU; }
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
void setTag(unsigned Tag) { Abbrev.setTag(Tag); }
|
|
|
|
void setOffset(unsigned O) { Offset = O; }
|
|
|
|
void setSize(unsigned S) { Size = S; }
|
2009-05-10 23:14:38 +00:00
|
|
|
void setAbstractCompileUnit(CompileUnit *CU) { AbstractCU = CU; }
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// AddValue - Add a value and attributes to a DIE.
|
|
|
|
///
|
|
|
|
void AddValue(unsigned Attribute, unsigned Form, DIEValue *Value) {
|
|
|
|
Abbrev.AddAttribute(Attribute, Form);
|
|
|
|
Values.push_back(Value);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// SiblingOffset - Return the offset of the debug information entry's
|
|
|
|
/// sibling.
|
|
|
|
unsigned SiblingOffset() const { return Offset + Size; }
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// AddSiblingOffset - Add a sibling offset field to the front of the DIE.
|
|
|
|
///
|
|
|
|
void AddSiblingOffset();
|
|
|
|
|
|
|
|
/// AddChild - Add a child to the DIE.
|
|
|
|
///
|
|
|
|
void AddChild(DIE *Child) {
|
|
|
|
Abbrev.setChildrenFlag(DW_CHILDREN_yes);
|
|
|
|
Children.push_back(Child);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Detach - Detaches objects connected to it after copying.
|
|
|
|
///
|
|
|
|
void Detach() {
|
|
|
|
Children.clear();
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Profile - Used to gather unique data for the value folding set.
|
|
|
|
///
|
|
|
|
void Profile(FoldingSetNodeID &ID) ;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
#ifndef NDEBUG
|
2006-12-17 05:15:13 +00:00
|
|
|
void print(std::ostream *O, unsigned IncIndent = 0) {
|
|
|
|
if (O) print(*O, IncIndent);
|
2006-11-29 00:39:47 +00:00
|
|
|
}
|
2006-11-02 20:12:39 +00:00
|
|
|
void print(std::ostream &O, unsigned IncIndent = 0);
|
|
|
|
void dump();
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-10-30 15:59:54 +00:00
|
|
|
/// DIEValue - A debug information entry value.
|
2006-11-02 20:12:39 +00:00
|
|
|
///
|
|
|
|
class DIEValue : public FoldingSetNode {
|
2006-02-27 12:43:29 +00:00
|
|
|
public:
|
|
|
|
enum {
|
|
|
|
isInteger,
|
|
|
|
isString,
|
|
|
|
isLabel,
|
|
|
|
isAsIsLabel,
|
2008-06-18 19:27:37 +00:00
|
|
|
isSectionOffset,
|
2006-02-27 12:43:29 +00:00
|
|
|
isDelta,
|
2006-03-03 21:00:14 +00:00
|
|
|
isEntry,
|
|
|
|
isBlock
|
2006-02-27 12:43:29 +00:00
|
|
|
};
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Type - Type of data stored in the value.
|
|
|
|
///
|
|
|
|
unsigned Type;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-03-10 23:57:09 +00:00
|
|
|
explicit DIEValue(unsigned T) : Type(T) {}
|
2006-02-27 12:43:29 +00:00
|
|
|
virtual ~DIEValue() {}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 21:48:18 +00:00
|
|
|
// Accessors
|
2006-11-02 20:12:39 +00:00
|
|
|
unsigned getType() const { return Type; }
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
// Implement isa/cast/dyncast.
|
|
|
|
static bool classof(const DIEValue *) { return true; }
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
/// EmitValue - Emit value via the Dwarf writer.
|
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
virtual void EmitValue(DwarfDebug &DD, unsigned Form) = 0;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
/// SizeOf - Return the size of a value in bytes.
|
|
|
|
///
|
2007-01-29 18:51:14 +00:00
|
|
|
virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const = 0;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Profile - Used to gather unique data for the value folding set.
|
|
|
|
///
|
|
|
|
virtual void Profile(FoldingSetNodeID &ID) = 0;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
#ifndef NDEBUG
|
2006-12-17 05:15:13 +00:00
|
|
|
void print(std::ostream *O) {
|
|
|
|
if (O) print(*O);
|
2006-11-29 00:39:47 +00:00
|
|
|
}
|
2006-11-02 20:12:39 +00:00
|
|
|
virtual void print(std::ostream &O) = 0;
|
|
|
|
void dump();
|
|
|
|
#endif
|
2006-02-27 12:43:29 +00:00
|
|
|
};
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-10-30 15:59:54 +00:00
|
|
|
/// DWInteger - An integer value DIE.
|
2008-08-16 12:57:46 +00:00
|
|
|
///
|
2006-02-27 12:43:29 +00:00
|
|
|
class DIEInteger : public DIEValue {
|
|
|
|
private:
|
|
|
|
uint64_t Integer;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
public:
|
2007-08-27 14:50:10 +00:00
|
|
|
explicit DIEInteger(uint64_t I) : DIEValue(isInteger), Integer(I) {}
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
// Implement isa/cast/dyncast.
|
|
|
|
static bool classof(const DIEInteger *) { return true; }
|
|
|
|
static bool classof(const DIEValue *I) { return I->Type == isInteger; }
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-03-03 21:00:14 +00:00
|
|
|
/// BestForm - Choose the best form for integer.
|
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
static unsigned BestForm(bool IsSigned, uint64_t Integer) {
|
|
|
|
if (IsSigned) {
|
|
|
|
if ((char)Integer == (signed)Integer) return DW_FORM_data1;
|
|
|
|
if ((short)Integer == (signed)Integer) return DW_FORM_data2;
|
|
|
|
if ((int)Integer == (signed)Integer) return DW_FORM_data4;
|
|
|
|
} else {
|
|
|
|
if ((unsigned char)Integer == Integer) return DW_FORM_data1;
|
|
|
|
if ((unsigned short)Integer == Integer) return DW_FORM_data2;
|
|
|
|
if ((unsigned int)Integer == Integer) return DW_FORM_data4;
|
|
|
|
}
|
|
|
|
return DW_FORM_data8;
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
/// EmitValue - Emit integer of appropriate size.
|
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
virtual void EmitValue(DwarfDebug &DD, unsigned Form);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
/// SizeOf - Determine size of integer value in bytes.
|
|
|
|
///
|
2007-01-29 18:51:14 +00:00
|
|
|
virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Profile - Used to gather unique data for the value folding set.
|
|
|
|
///
|
2006-11-09 14:52:14 +00:00
|
|
|
static void Profile(FoldingSetNodeID &ID, unsigned Integer) {
|
2006-11-02 21:48:18 +00:00
|
|
|
ID.AddInteger(isInteger);
|
2006-11-02 20:12:39 +00:00
|
|
|
ID.AddInteger(Integer);
|
|
|
|
}
|
2006-11-09 14:52:14 +00:00
|
|
|
virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, Integer); }
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
virtual void print(std::ostream &O) {
|
|
|
|
O << "Int: " << (int64_t)Integer
|
|
|
|
<< " 0x" << std::hex << Integer << std::dec;
|
|
|
|
}
|
|
|
|
#endif
|
2006-02-27 12:43:29 +00:00
|
|
|
};
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-10-30 15:59:54 +00:00
|
|
|
/// DIEString - A string value DIE.
|
2008-08-16 12:57:46 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
class DIEString : public DIEValue {
|
2009-03-10 23:57:09 +00:00
|
|
|
const std::string Str;
|
2006-11-02 20:12:39 +00:00
|
|
|
public:
|
2009-03-10 23:57:09 +00:00
|
|
|
explicit DIEString(const std::string &S) : DIEValue(isString), Str(S) {}
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
// Implement isa/cast/dyncast.
|
|
|
|
static bool classof(const DIEString *) { return true; }
|
|
|
|
static bool classof(const DIEValue *S) { return S->Type == isString; }
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
/// EmitValue - Emit string value.
|
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
virtual void EmitValue(DwarfDebug &DD, unsigned Form);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
/// SizeOf - Determine size of string value in bytes.
|
|
|
|
///
|
2007-01-29 18:51:14 +00:00
|
|
|
virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const {
|
2009-03-10 23:57:09 +00:00
|
|
|
return Str.size() + sizeof(char); // sizeof('\0');
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Profile - Used to gather unique data for the value folding set.
|
|
|
|
///
|
2009-03-10 23:57:09 +00:00
|
|
|
static void Profile(FoldingSetNodeID &ID, const std::string &Str) {
|
2006-11-02 21:48:18 +00:00
|
|
|
ID.AddInteger(isString);
|
2009-03-10 23:57:09 +00:00
|
|
|
ID.AddString(Str);
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2009-03-10 23:57:09 +00:00
|
|
|
virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, Str); }
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
virtual void print(std::ostream &O) {
|
2009-03-10 23:57:09 +00:00
|
|
|
O << "Str: \"" << Str << "\"";
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
|
|
|
#endif
|
2006-02-27 12:43:29 +00:00
|
|
|
};
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-10-30 15:59:54 +00:00
|
|
|
/// DIEDwarfLabel - A Dwarf internal label expression DIE.
|
2006-02-27 12:43:29 +00:00
|
|
|
//
|
2006-11-02 20:12:39 +00:00
|
|
|
class DIEDwarfLabel : public DIEValue {
|
2006-02-27 12:43:29 +00:00
|
|
|
const DWLabel Label;
|
2009-03-10 23:57:09 +00:00
|
|
|
public:
|
2007-08-27 14:50:10 +00:00
|
|
|
explicit DIEDwarfLabel(const DWLabel &L) : DIEValue(isLabel), Label(L) {}
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
// Implement isa/cast/dyncast.
|
|
|
|
static bool classof(const DIEDwarfLabel *) { return true; }
|
|
|
|
static bool classof(const DIEValue *L) { return L->Type == isLabel; }
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
/// EmitValue - Emit label value.
|
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
virtual void EmitValue(DwarfDebug &DD, unsigned Form);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
/// SizeOf - Determine size of label value in bytes.
|
|
|
|
///
|
2007-01-29 18:51:14 +00:00
|
|
|
virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Profile - Used to gather unique data for the value folding set.
|
|
|
|
///
|
2006-11-09 14:52:14 +00:00
|
|
|
static void Profile(FoldingSetNodeID &ID, const DWLabel &Label) {
|
2006-11-02 21:48:18 +00:00
|
|
|
ID.AddInteger(isLabel);
|
2006-11-02 20:12:39 +00:00
|
|
|
Label.Profile(ID);
|
|
|
|
}
|
2006-11-09 14:52:14 +00:00
|
|
|
virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, Label); }
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
virtual void print(std::ostream &O) {
|
|
|
|
O << "Lbl: ";
|
|
|
|
Label.print(O);
|
|
|
|
}
|
|
|
|
#endif
|
2006-02-27 12:43:29 +00:00
|
|
|
};
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-10-30 15:59:54 +00:00
|
|
|
/// DIEObjectLabel - A label to an object in code or data.
|
2006-02-27 12:43:29 +00:00
|
|
|
//
|
2006-11-02 20:12:39 +00:00
|
|
|
class DIEObjectLabel : public DIEValue {
|
2006-02-27 12:43:29 +00:00
|
|
|
const std::string Label;
|
2009-03-10 23:57:09 +00:00
|
|
|
public:
|
2007-08-27 14:50:10 +00:00
|
|
|
explicit DIEObjectLabel(const std::string &L)
|
|
|
|
: DIEValue(isAsIsLabel), Label(L) {}
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
// Implement isa/cast/dyncast.
|
|
|
|
static bool classof(const DIEObjectLabel *) { return true; }
|
|
|
|
static bool classof(const DIEValue *L) { return L->Type == isAsIsLabel; }
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
/// EmitValue - Emit label value.
|
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
virtual void EmitValue(DwarfDebug &DD, unsigned Form);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
/// SizeOf - Determine size of label value in bytes.
|
|
|
|
///
|
2007-01-29 18:51:14 +00:00
|
|
|
virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Profile - Used to gather unique data for the value folding set.
|
|
|
|
///
|
2006-11-09 14:52:14 +00:00
|
|
|
static void Profile(FoldingSetNodeID &ID, const std::string &Label) {
|
2006-11-02 21:48:18 +00:00
|
|
|
ID.AddInteger(isAsIsLabel);
|
2006-11-02 20:12:39 +00:00
|
|
|
ID.AddString(Label);
|
|
|
|
}
|
2009-02-25 07:04:34 +00:00
|
|
|
virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, Label.c_str()); }
|
2006-11-02 20:12:39 +00:00
|
|
|
|
|
|
|
#ifndef NDEBUG
|
|
|
|
virtual void print(std::ostream &O) {
|
|
|
|
O << "Obj: " << Label;
|
|
|
|
}
|
|
|
|
#endif
|
2006-02-27 12:43:29 +00:00
|
|
|
};
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2008-06-18 19:27:37 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// DIESectionOffset - A section offset DIE.
|
|
|
|
//
|
|
|
|
class DIESectionOffset : public DIEValue {
|
|
|
|
const DWLabel Label;
|
|
|
|
const DWLabel Section;
|
|
|
|
bool IsEH : 1;
|
|
|
|
bool UseSet : 1;
|
2009-03-10 23:57:09 +00:00
|
|
|
public:
|
2008-06-18 19:27:37 +00:00
|
|
|
DIESectionOffset(const DWLabel &Lab, const DWLabel &Sec,
|
|
|
|
bool isEH = false, bool useSet = true)
|
2009-03-10 23:57:09 +00:00
|
|
|
: DIEValue(isSectionOffset), Label(Lab), Section(Sec),
|
|
|
|
IsEH(isEH), UseSet(useSet) {}
|
2008-06-18 19:27:37 +00:00
|
|
|
|
|
|
|
// Implement isa/cast/dyncast.
|
|
|
|
static bool classof(const DIESectionOffset *) { return true; }
|
|
|
|
static bool classof(const DIEValue *D) { return D->Type == isSectionOffset; }
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2008-06-18 19:27:37 +00:00
|
|
|
/// EmitValue - Emit section offset.
|
|
|
|
///
|
|
|
|
virtual void EmitValue(DwarfDebug &DD, unsigned Form);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2008-06-18 19:27:37 +00:00
|
|
|
/// SizeOf - Determine size of section offset value in bytes.
|
|
|
|
///
|
|
|
|
virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2008-06-18 19:27:37 +00:00
|
|
|
/// 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
|
|
|
|
};
|
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-10-30 15:59:54 +00:00
|
|
|
/// DIEDelta - A simple label difference DIE.
|
2008-08-16 12:57:46 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
class DIEDelta : public DIEValue {
|
2006-02-27 12:43:29 +00:00
|
|
|
const DWLabel LabelHi;
|
|
|
|
const DWLabel LabelLo;
|
2009-03-10 23:57:09 +00:00
|
|
|
public:
|
2006-02-27 12:43:29 +00:00
|
|
|
DIEDelta(const DWLabel &Hi, const DWLabel &Lo)
|
2009-03-10 23:57:09 +00:00
|
|
|
: DIEValue(isDelta), LabelHi(Hi), LabelLo(Lo) {}
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
// Implement isa/cast/dyncast.
|
|
|
|
static bool classof(const DIEDelta *) { return true; }
|
|
|
|
static bool classof(const DIEValue *D) { return D->Type == isDelta; }
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
/// EmitValue - Emit delta value.
|
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
virtual void EmitValue(DwarfDebug &DD, unsigned Form);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
/// SizeOf - Determine size of delta value in bytes.
|
|
|
|
///
|
2007-01-29 18:51:14 +00:00
|
|
|
virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Profile - Used to gather unique data for the value folding set.
|
|
|
|
///
|
2006-11-09 14:52:14 +00:00
|
|
|
static void Profile(FoldingSetNodeID &ID, const DWLabel &LabelHi,
|
|
|
|
const DWLabel &LabelLo) {
|
2006-11-02 21:48:18 +00:00
|
|
|
ID.AddInteger(isDelta);
|
2006-11-02 20:12:39 +00:00
|
|
|
LabelHi.Profile(ID);
|
|
|
|
LabelLo.Profile(ID);
|
|
|
|
}
|
2006-11-09 14:52:14 +00:00
|
|
|
virtual void Profile(FoldingSetNodeID &ID) { Profile(ID, LabelHi, LabelLo); }
|
2006-11-02 20:12:39 +00:00
|
|
|
|
|
|
|
#ifndef NDEBUG
|
|
|
|
virtual void print(std::ostream &O) {
|
|
|
|
O << "Del: ";
|
|
|
|
LabelHi.print(O);
|
|
|
|
O << "-";
|
|
|
|
LabelLo.print(O);
|
|
|
|
}
|
|
|
|
#endif
|
2006-02-27 12:43:29 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
2006-11-02 20:12:39 +00:00
|
|
|
/// DIEntry - A pointer to another debug information entry. An instance of this
|
|
|
|
/// class can also be used as a proxy for a debug information entry not yet
|
|
|
|
/// defined (ie. types.)
|
|
|
|
class DIEntry : public DIEValue {
|
2006-02-27 12:43:29 +00:00
|
|
|
DIE *Entry;
|
2009-03-10 23:57:09 +00:00
|
|
|
public:
|
2007-08-27 14:50:10 +00:00
|
|
|
explicit DIEntry(DIE *E) : DIEValue(isEntry), Entry(E) {}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-05-08 20:38:02 +00:00
|
|
|
DIE *getEntry() const { return Entry; }
|
2009-03-10 23:57:09 +00:00
|
|
|
void setEntry(DIE *E) { Entry = E; }
|
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
// Implement isa/cast/dyncast.
|
|
|
|
static bool classof(const DIEntry *) { return true; }
|
|
|
|
static bool classof(const DIEValue *E) { return E->Type == isEntry; }
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-03-23 18:07:55 +00:00
|
|
|
/// EmitValue - Emit debug information entry offset.
|
2006-02-27 12:43:29 +00:00
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
virtual void EmitValue(DwarfDebug &DD, unsigned Form);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-03-23 18:07:55 +00:00
|
|
|
/// SizeOf - Determine size of debug information entry in bytes.
|
2006-02-27 12:43:29 +00:00
|
|
|
///
|
2007-01-29 18:51:14 +00:00
|
|
|
virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const {
|
2006-11-02 20:12:39 +00:00
|
|
|
return sizeof(int32_t);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Profile - Used to gather unique data for the value folding set.
|
|
|
|
///
|
2006-11-09 14:52:14 +00:00
|
|
|
static void Profile(FoldingSetNodeID &ID, DIE *Entry) {
|
|
|
|
ID.AddInteger(isEntry);
|
|
|
|
ID.AddPointer(Entry);
|
|
|
|
}
|
2006-11-02 20:12:39 +00:00
|
|
|
virtual void Profile(FoldingSetNodeID &ID) {
|
2006-11-02 21:48:18 +00:00
|
|
|
ID.AddInteger(isEntry);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
if (Entry) {
|
|
|
|
ID.AddPointer(Entry);
|
|
|
|
} else {
|
|
|
|
ID.AddPointer(this);
|
|
|
|
}
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
virtual void print(std::ostream &O) {
|
|
|
|
O << "Die: 0x" << std::hex << (intptr_t)Entry << std::dec;
|
|
|
|
}
|
|
|
|
#endif
|
2006-02-27 12:43:29 +00:00
|
|
|
};
|
|
|
|
|
2006-03-03 21:00:14 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-10-30 15:59:54 +00:00
|
|
|
/// DIEBlock - A block of values. Primarily used for location expressions.
|
2006-03-03 21:00:14 +00:00
|
|
|
//
|
2006-11-02 20:12:39 +00:00
|
|
|
class DIEBlock : public DIEValue, public DIE {
|
2009-03-10 23:57:09 +00:00
|
|
|
unsigned Size; // Size in bytes excluding size header.
|
2006-11-02 20:12:39 +00:00
|
|
|
public:
|
2006-03-03 21:00:14 +00:00
|
|
|
DIEBlock()
|
2009-03-10 23:57:09 +00:00
|
|
|
: DIEValue(isBlock), DIE(0), Size(0) {}
|
|
|
|
virtual ~DIEBlock() {}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-03-03 21:00:14 +00:00
|
|
|
// Implement isa/cast/dyncast.
|
|
|
|
static bool classof(const DIEBlock *) { return true; }
|
|
|
|
static bool classof(const DIEValue *E) { return E->Type == isBlock; }
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-03-03 21:00:14 +00:00
|
|
|
/// ComputeSize - calculate the size of the block.
|
|
|
|
///
|
2007-01-29 18:51:14 +00:00
|
|
|
unsigned ComputeSize(DwarfDebug &DD);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-03-03 21:00:14 +00:00
|
|
|
/// BestForm - Choose the best form for data.
|
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
unsigned BestForm() const {
|
|
|
|
if ((unsigned char)Size == Size) return DW_FORM_block1;
|
|
|
|
if ((unsigned short)Size == Size) return DW_FORM_block2;
|
|
|
|
if ((unsigned int)Size == Size) return DW_FORM_block4;
|
|
|
|
return DW_FORM_block;
|
|
|
|
}
|
2006-03-03 21:00:14 +00:00
|
|
|
|
|
|
|
/// EmitValue - Emit block data.
|
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
virtual void EmitValue(DwarfDebug &DD, unsigned Form);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-03-03 21:00:14 +00:00
|
|
|
/// SizeOf - Determine size of block data in bytes.
|
|
|
|
///
|
2007-01-29 18:51:14 +00:00
|
|
|
virtual unsigned SizeOf(const DwarfDebug &DD, unsigned Form) const;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Profile - Used to gather unique data for the value folding set.
|
2006-03-03 21:00:14 +00:00
|
|
|
///
|
2006-11-02 23:56:21 +00:00
|
|
|
virtual void Profile(FoldingSetNodeID &ID) {
|
2006-11-02 21:48:18 +00:00
|
|
|
ID.AddInteger(isBlock);
|
2006-11-02 20:12:39 +00:00
|
|
|
DIE::Profile(ID);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
virtual void print(std::ostream &O) {
|
|
|
|
O << "Blk: ";
|
|
|
|
DIE::print(O, 5);
|
|
|
|
}
|
|
|
|
#endif
|
2006-03-03 21:00:14 +00:00
|
|
|
};
|
|
|
|
|
2006-02-27 12:43:29 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-11-02 20:12:39 +00:00
|
|
|
/// CompileUnit - This dwarf writer support class manages information associate
|
|
|
|
/// with a source file.
|
|
|
|
class CompileUnit {
|
|
|
|
/// ID - File identifier for source.
|
|
|
|
///
|
|
|
|
unsigned ID;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Die - Compile unit debug information entry.
|
2006-03-23 18:07:55 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
DIE *Die;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-01-13 23:54:55 +00:00
|
|
|
/// GVToDieMap - Tracks the mapping of unit level debug informaton
|
|
|
|
/// variables to debug information entries.
|
2009-01-20 00:58:55 +00:00
|
|
|
std::map<GlobalVariable *, DIE *> GVToDieMap;
|
2006-02-27 12:43:29 +00:00
|
|
|
|
2009-01-13 23:54:55 +00:00
|
|
|
/// GVToDIEntryMap - Tracks the mapping of unit level debug informaton
|
2006-11-02 20:12:39 +00:00
|
|
|
/// descriptors to debug information entries using a DIEntry proxy.
|
2009-01-20 00:58:55 +00:00
|
|
|
std::map<GlobalVariable *, DIEntry *> GVToDIEntryMap;
|
2006-02-27 12:43:29 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Globals - A map of globally visible named entities for this unit.
|
2006-02-27 12:43:29 +00:00
|
|
|
///
|
2009-04-09 21:49:15 +00:00
|
|
|
StringMap<DIE*> Globals;
|
2006-11-02 20:12:39 +00:00
|
|
|
|
|
|
|
/// DiesSet - Used to uniquely define dies within the compile unit.
|
2006-02-27 12:43:29 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
FoldingSet<DIE> DiesSet;
|
|
|
|
public:
|
2009-01-05 23:03:32 +00:00
|
|
|
CompileUnit(unsigned I, DIE *D)
|
2009-01-13 23:54:55 +00:00
|
|
|
: ID(I), Die(D), GVToDieMap(),
|
2009-01-17 06:51:37 +00:00
|
|
|
GVToDIEntryMap(), Globals(), DiesSet(InitDiesSetSize)
|
2009-01-05 23:03:32 +00:00
|
|
|
{}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
~CompileUnit() {
|
|
|
|
delete Die;
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Accessors.
|
|
|
|
unsigned getID() const { return ID; }
|
|
|
|
DIE* getDie() const { return Die; }
|
2009-04-09 21:49:15 +00:00
|
|
|
StringMap<DIE*> &getGlobals() { return Globals; }
|
2006-02-27 12:43:29 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// hasContent - Return true if this compile unit has something to write out.
|
2006-03-03 21:00:14 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
bool hasContent() const {
|
|
|
|
return !Die->getChildren().empty();
|
|
|
|
}
|
2006-03-03 21:00:14 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// AddGlobal - Add a new global entity to the compile unit.
|
2006-02-27 12:43:29 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
void AddGlobal(const std::string &Name, DIE *Die) {
|
|
|
|
Globals[Name] = Die;
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// getDieMapSlotFor - Returns the debug information entry map slot for the
|
2009-01-13 23:54:55 +00:00
|
|
|
/// specified debug variable.
|
2009-01-05 21:47:57 +00:00
|
|
|
DIE *&getDieMapSlotFor(GlobalVariable *GV) {
|
|
|
|
return GVToDieMap[GV];
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// getDIEntrySlotFor - Returns the debug information entry proxy slot for the
|
2009-01-13 23:54:55 +00:00
|
|
|
/// specified debug variable.
|
2009-01-05 21:47:57 +00:00
|
|
|
DIEntry *&getDIEntrySlotFor(GlobalVariable *GV) {
|
|
|
|
return GVToDIEntryMap[GV];
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// AddDie - Adds or interns the DIE to the compile unit.
|
|
|
|
///
|
|
|
|
DIE *AddDie(DIE &Buffer) {
|
|
|
|
FoldingSetNodeID ID;
|
|
|
|
Buffer.Profile(ID);
|
|
|
|
void *Where;
|
|
|
|
DIE *Die = DiesSet.FindNodeOrInsertPos(ID, Where);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
if (!Die) {
|
|
|
|
Die = new DIE(Buffer);
|
|
|
|
DiesSet.InsertNode(Die, Where);
|
|
|
|
this->Die->AddChild(Die);
|
|
|
|
Buffer.Detach();
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
return Die;
|
|
|
|
}
|
2006-02-27 12:43:29 +00:00
|
|
|
};
|
|
|
|
|
2006-10-30 13:35:07 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2008-08-16 12:57:46 +00:00
|
|
|
/// Dwarf - Emits general Dwarf directives.
|
2006-11-02 20:12:39 +00:00
|
|
|
///
|
2006-10-30 13:35:07 +00:00
|
|
|
class Dwarf {
|
2007-01-29 18:51:14 +00:00
|
|
|
protected:
|
2006-10-30 13:35:07 +00:00
|
|
|
//===--------------------------------------------------------------------===//
|
2007-01-29 18:51:14 +00:00
|
|
|
// Core attributes used by the Dwarf writer.
|
2006-10-30 13:35:07 +00:00
|
|
|
//
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-10-30 13:35:07 +00:00
|
|
|
//
|
|
|
|
/// O - Stream to .s file.
|
|
|
|
///
|
2008-08-21 00:14:44 +00:00
|
|
|
raw_ostream &O;
|
2006-10-30 13:35:07 +00:00
|
|
|
|
|
|
|
/// Asm - Target of Dwarf emission.
|
|
|
|
///
|
|
|
|
AsmPrinter *Asm;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2008-07-01 23:34:48 +00:00
|
|
|
/// TAI - Target asm information.
|
2006-10-30 13:35:07 +00:00
|
|
|
const TargetAsmInfo *TAI;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-10-30 13:35:07 +00:00
|
|
|
/// TD - Target data.
|
|
|
|
const TargetData *TD;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-10-30 13:35:07 +00:00
|
|
|
/// RI - Register Information.
|
2008-02-10 18:45:23 +00:00
|
|
|
const TargetRegisterInfo *RI;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-10-30 13:35:07 +00:00
|
|
|
/// M - Current module.
|
|
|
|
///
|
|
|
|
Module *M;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-10-30 13:35:07 +00:00
|
|
|
/// MF - Current machine function.
|
|
|
|
///
|
|
|
|
MachineFunction *MF;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-01-26 21:22:28 +00:00
|
|
|
/// MMI - Collected machine module information.
|
2006-10-30 13:35:07 +00:00
|
|
|
///
|
2007-01-26 21:22:28 +00:00
|
|
|
MachineModuleInfo *MMI;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-10-30 13:35:07 +00:00
|
|
|
/// SubprogramCount - The running count of functions being compiled.
|
|
|
|
///
|
|
|
|
unsigned SubprogramCount;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-09-24 03:35:37 +00:00
|
|
|
/// Flavor - A unique string indicating what dwarf producer this is, used to
|
|
|
|
/// unique labels.
|
|
|
|
const char * const Flavor;
|
2007-03-07 08:25:02 +00:00
|
|
|
|
|
|
|
unsigned SetCounter;
|
2008-08-21 00:14:44 +00:00
|
|
|
Dwarf(raw_ostream &OS, AsmPrinter *A, const TargetAsmInfo *T,
|
2007-09-24 03:35:37 +00:00
|
|
|
const char *flavor)
|
2007-01-29 18:51:14 +00:00
|
|
|
: O(OS)
|
|
|
|
, Asm(A)
|
|
|
|
, TAI(T)
|
|
|
|
, TD(Asm->TM.getTargetData())
|
|
|
|
, RI(Asm->TM.getRegisterInfo())
|
|
|
|
, M(NULL)
|
|
|
|
, MF(NULL)
|
|
|
|
, MMI(NULL)
|
|
|
|
, SubprogramCount(0)
|
2007-09-24 03:35:37 +00:00
|
|
|
, Flavor(flavor)
|
2007-03-07 08:25:02 +00:00
|
|
|
, SetCounter(1)
|
2007-01-29 18:51:14 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
// Accessors.
|
|
|
|
//
|
2009-04-10 00:00:25 +00:00
|
|
|
const AsmPrinter *getAsm() const { return Asm; }
|
2007-02-01 16:31:34 +00:00
|
|
|
MachineModuleInfo *getMMI() const { return MMI; }
|
2007-01-29 18:51:14 +00:00
|
|
|
const TargetAsmInfo *getTargetAsmInfo() const { return TAI; }
|
2007-09-27 23:12:31 +00:00
|
|
|
const TargetData *getTargetData() const { return TD; }
|
2007-01-29 18:51:14 +00:00
|
|
|
|
2007-09-02 22:07:21 +00:00
|
|
|
void PrintRelDirective(bool Force32Bit = false, bool isInSection = false)
|
|
|
|
const {
|
|
|
|
if (isInSection && TAI->getDwarfSectionOffsetDirective())
|
|
|
|
O << TAI->getDwarfSectionOffsetDirective();
|
2007-09-27 23:12:31 +00:00
|
|
|
else if (Force32Bit || TD->getPointerSize() == sizeof(int32_t))
|
2007-09-02 22:07:21 +00:00
|
|
|
O << TAI->getData32bitsDirective();
|
|
|
|
else
|
|
|
|
O << TAI->getData64bitsDirective();
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-10-30 13:35:07 +00:00
|
|
|
/// PrintLabelName - Print label name in form used by Dwarf writer.
|
|
|
|
///
|
|
|
|
void PrintLabelName(DWLabel Label) const {
|
|
|
|
PrintLabelName(Label.Tag, Label.Number);
|
|
|
|
}
|
2007-09-02 22:07:21 +00:00
|
|
|
void PrintLabelName(const char *Tag, unsigned Number) const {
|
|
|
|
O << TAI->getPrivateGlobalPrefix() << Tag;
|
2006-11-02 20:12:39 +00:00
|
|
|
if (Number) O << Number;
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-09-24 03:35:37 +00:00
|
|
|
void PrintLabelName(const char *Tag, unsigned Number,
|
|
|
|
const char *Suffix) const {
|
|
|
|
O << TAI->getPrivateGlobalPrefix() << Tag;
|
|
|
|
if (Number) O << Number;
|
|
|
|
O << Suffix;
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-10-30 13:35:07 +00:00
|
|
|
/// EmitLabel - Emit location label for internal use by Dwarf.
|
|
|
|
///
|
|
|
|
void EmitLabel(DWLabel Label) const {
|
|
|
|
EmitLabel(Label.Tag, Label.Number);
|
|
|
|
}
|
2006-11-02 20:12:39 +00:00
|
|
|
void EmitLabel(const char *Tag, unsigned Number) const {
|
|
|
|
PrintLabelName(Tag, Number);
|
|
|
|
O << ":\n";
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-10-30 13:35:07 +00:00
|
|
|
/// EmitReference - Emit a reference to a label.
|
|
|
|
///
|
2007-09-28 15:43:33 +00:00
|
|
|
void EmitReference(DWLabel Label, bool IsPCRelative = false,
|
|
|
|
bool Force32Bit = false) const {
|
|
|
|
EmitReference(Label.Tag, Label.Number, IsPCRelative, Force32Bit);
|
2006-10-30 13:35:07 +00:00
|
|
|
}
|
2007-02-01 16:31:34 +00:00
|
|
|
void EmitReference(const char *Tag, unsigned Number,
|
2007-09-28 15:43:33 +00:00
|
|
|
bool IsPCRelative = false, bool Force32Bit = false) const {
|
|
|
|
PrintRelDirective(Force32Bit);
|
2006-11-02 20:12:39 +00:00
|
|
|
PrintLabelName(Tag, Number);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
if (IsPCRelative) O << "-" << TAI->getPCSymbol();
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2007-09-28 15:43:33 +00:00
|
|
|
void EmitReference(const std::string &Name, bool IsPCRelative = false,
|
|
|
|
bool Force32Bit = false) const {
|
|
|
|
PrintRelDirective(Force32Bit);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
O << Name;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
if (IsPCRelative) O << "-" << TAI->getPCSymbol();
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2006-10-30 13:35:07 +00:00
|
|
|
|
|
|
|
/// EmitDifference - Emit the difference between two labels. Some
|
|
|
|
/// assemblers do not behave with absolute expressions with data directives,
|
|
|
|
/// so there is an option (needsSet) to use an intermediary set expression.
|
2006-12-06 17:43:18 +00:00
|
|
|
void EmitDifference(DWLabel LabelHi, DWLabel LabelLo,
|
2007-03-07 08:25:02 +00:00
|
|
|
bool IsSmall = false) {
|
2006-12-06 17:43:18 +00:00
|
|
|
EmitDifference(LabelHi.Tag, LabelHi.Number,
|
|
|
|
LabelLo.Tag, LabelLo.Number,
|
|
|
|
IsSmall);
|
2006-10-30 13:35:07 +00:00
|
|
|
}
|
|
|
|
void EmitDifference(const char *TagHi, unsigned NumberHi,
|
2006-12-06 17:43:18 +00:00
|
|
|
const char *TagLo, unsigned NumberLo,
|
2007-03-07 08:25:02 +00:00
|
|
|
bool IsSmall = false) {
|
2006-11-02 20:12:39 +00:00
|
|
|
if (TAI->needsSet()) {
|
|
|
|
O << "\t.set\t";
|
2007-09-24 03:35:37 +00:00
|
|
|
PrintLabelName("set", SetCounter, Flavor);
|
2006-11-02 20:12:39 +00:00
|
|
|
O << ",";
|
|
|
|
PrintLabelName(TagHi, NumberHi);
|
|
|
|
O << "-";
|
|
|
|
PrintLabelName(TagLo, NumberLo);
|
|
|
|
O << "\n";
|
2007-09-02 22:07:21 +00:00
|
|
|
|
|
|
|
PrintRelDirective(IsSmall);
|
2007-09-24 03:35:37 +00:00
|
|
|
PrintLabelName("set", SetCounter, Flavor);
|
2006-11-02 20:12:39 +00:00
|
|
|
++SetCounter;
|
|
|
|
} else {
|
2007-09-02 22:07:21 +00:00
|
|
|
PrintRelDirective(IsSmall);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
PrintLabelName(TagHi, NumberHi);
|
|
|
|
O << "-";
|
|
|
|
PrintLabelName(TagLo, NumberLo);
|
|
|
|
}
|
|
|
|
}
|
2007-03-07 02:47:57 +00:00
|
|
|
|
|
|
|
void EmitSectionOffset(const char* Label, const char* Section,
|
|
|
|
unsigned LabelNumber, unsigned SectionNumber,
|
2008-03-26 23:31:39 +00:00
|
|
|
bool IsSmall = false, bool isEH = false,
|
|
|
|
bool useSet = true) {
|
2007-05-01 22:23:12 +00:00
|
|
|
bool printAbsolute = false;
|
2008-03-26 23:31:39 +00:00
|
|
|
if (isEH)
|
|
|
|
printAbsolute = TAI->isAbsoluteEHSectionOffsets();
|
|
|
|
else
|
|
|
|
printAbsolute = TAI->isAbsoluteDebugSectionOffsets();
|
|
|
|
|
|
|
|
if (TAI->needsSet() && useSet) {
|
2007-03-07 02:47:57 +00:00
|
|
|
O << "\t.set\t";
|
2007-09-24 03:35:37 +00:00
|
|
|
PrintLabelName("set", SetCounter, Flavor);
|
2007-03-07 02:47:57 +00:00
|
|
|
O << ",";
|
2007-09-02 22:07:21 +00:00
|
|
|
PrintLabelName(Label, LabelNumber);
|
2007-05-01 22:23:12 +00:00
|
|
|
|
|
|
|
if (!printAbsolute) {
|
2007-03-07 02:47:57 +00:00
|
|
|
O << "-";
|
|
|
|
PrintLabelName(Section, SectionNumber);
|
2008-08-16 12:57:46 +00:00
|
|
|
}
|
2007-03-07 02:47:57 +00:00
|
|
|
O << "\n";
|
2007-09-02 22:07:21 +00:00
|
|
|
|
|
|
|
PrintRelDirective(IsSmall);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-09-24 03:35:37 +00:00
|
|
|
PrintLabelName("set", SetCounter, Flavor);
|
2007-03-07 02:47:57 +00:00
|
|
|
++SetCounter;
|
|
|
|
} else {
|
2007-09-02 22:07:21 +00:00
|
|
|
PrintRelDirective(IsSmall, true);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-09-02 22:07:21 +00:00
|
|
|
PrintLabelName(Label, LabelNumber);
|
2007-05-01 22:23:12 +00:00
|
|
|
|
|
|
|
if (!printAbsolute) {
|
2007-03-07 02:47:57 +00:00
|
|
|
O << "-";
|
|
|
|
PrintLabelName(Section, SectionNumber);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
}
|
2007-03-07 02:47:57 +00:00
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
/// EmitFrameMoves - Emit frame instructions to describe the layout of the
|
|
|
|
/// frame.
|
|
|
|
void EmitFrameMoves(const char *BaseLabel, unsigned BaseLabelID,
|
2007-11-13 19:13:01 +00:00
|
|
|
const std::vector<MachineMove> &Moves, bool isEH) {
|
2007-02-01 16:31:34 +00:00
|
|
|
int stackGrowth =
|
|
|
|
Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
|
|
|
|
TargetFrameInfo::StackGrowsUp ?
|
2007-09-27 23:12:31 +00:00
|
|
|
TD->getPointerSize() : -TD->getPointerSize();
|
2007-02-21 22:48:45 +00:00
|
|
|
bool IsLocal = BaseLabel && strcmp(BaseLabel, "label") == 0;
|
2007-02-01 16:31:34 +00:00
|
|
|
|
|
|
|
for (unsigned i = 0, N = Moves.size(); i < N; ++i) {
|
2007-05-12 22:36:25 +00:00
|
|
|
const MachineMove &Move = Moves[i];
|
2007-02-01 16:31:34 +00:00
|
|
|
unsigned LabelID = Move.getLabelID();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
if (LabelID) {
|
|
|
|
LabelID = MMI->MappedLabel(LabelID);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
// Throw out move if the label is invalid.
|
|
|
|
if (!LabelID) continue;
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
const MachineLocation &Dst = Move.getDestination();
|
|
|
|
const MachineLocation &Src = Move.getSource();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
// Advance row if new location.
|
|
|
|
if (BaseLabel && LabelID && (BaseLabelID != LabelID || !IsLocal)) {
|
|
|
|
Asm->EmitInt8(DW_CFA_advance_loc4);
|
|
|
|
Asm->EOL("DW_CFA_advance_loc4");
|
2007-02-21 22:48:45 +00:00
|
|
|
EmitDifference("label", LabelID, BaseLabel, BaseLabelID, true);
|
|
|
|
Asm->EOL();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
BaseLabelID = LabelID;
|
2007-02-21 22:48:45 +00:00
|
|
|
BaseLabel = "label";
|
2007-02-01 16:31:34 +00:00
|
|
|
IsLocal = true;
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
// If advancing cfa.
|
2008-10-03 15:45:36 +00:00
|
|
|
if (Dst.isReg() && Dst.getReg() == MachineLocation::VirtualFP) {
|
|
|
|
if (!Src.isReg()) {
|
|
|
|
if (Src.getReg() == MachineLocation::VirtualFP) {
|
2007-02-01 16:31:34 +00:00
|
|
|
Asm->EmitInt8(DW_CFA_def_cfa_offset);
|
|
|
|
Asm->EOL("DW_CFA_def_cfa_offset");
|
|
|
|
} else {
|
|
|
|
Asm->EmitInt8(DW_CFA_def_cfa);
|
|
|
|
Asm->EOL("DW_CFA_def_cfa");
|
2008-10-03 15:45:36 +00:00
|
|
|
Asm->EmitULEB128Bytes(RI->getDwarfRegNum(Src.getReg(), isEH));
|
2007-02-01 16:31:34 +00:00
|
|
|
Asm->EOL("Register");
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
int Offset = -Src.getOffset();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
Asm->EmitULEB128Bytes(Offset);
|
|
|
|
Asm->EOL("Offset");
|
|
|
|
} else {
|
|
|
|
assert(0 && "Machine move no supported yet.");
|
|
|
|
}
|
2008-10-03 15:45:36 +00:00
|
|
|
} else if (Src.isReg() &&
|
|
|
|
Src.getReg() == MachineLocation::VirtualFP) {
|
|
|
|
if (Dst.isReg()) {
|
2007-02-01 16:31:34 +00:00
|
|
|
Asm->EmitInt8(DW_CFA_def_cfa_register);
|
|
|
|
Asm->EOL("DW_CFA_def_cfa_register");
|
2008-10-03 15:45:36 +00:00
|
|
|
Asm->EmitULEB128Bytes(RI->getDwarfRegNum(Dst.getReg(), isEH));
|
2007-02-01 16:31:34 +00:00
|
|
|
Asm->EOL("Register");
|
|
|
|
} else {
|
|
|
|
assert(0 && "Machine move no supported yet.");
|
|
|
|
}
|
|
|
|
} else {
|
2008-10-03 15:45:36 +00:00
|
|
|
unsigned Reg = RI->getDwarfRegNum(Src.getReg(), isEH);
|
2007-02-01 16:31:34 +00:00
|
|
|
int Offset = Dst.getOffset() / stackGrowth;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
if (Offset < 0) {
|
|
|
|
Asm->EmitInt8(DW_CFA_offset_extended_sf);
|
|
|
|
Asm->EOL("DW_CFA_offset_extended_sf");
|
|
|
|
Asm->EmitULEB128Bytes(Reg);
|
|
|
|
Asm->EOL("Reg");
|
|
|
|
Asm->EmitSLEB128Bytes(Offset);
|
|
|
|
Asm->EOL("Offset");
|
|
|
|
} else if (Reg < 64) {
|
|
|
|
Asm->EmitInt8(DW_CFA_offset + Reg);
|
2009-03-25 01:47:28 +00:00
|
|
|
if (Asm->isVerbose())
|
2008-07-09 21:53:02 +00:00
|
|
|
Asm->EOL("DW_CFA_offset + Reg (" + utostr(Reg) + ")");
|
|
|
|
else
|
|
|
|
Asm->EOL();
|
2007-02-01 16:31:34 +00:00
|
|
|
Asm->EmitULEB128Bytes(Offset);
|
|
|
|
Asm->EOL("Offset");
|
|
|
|
} else {
|
|
|
|
Asm->EmitInt8(DW_CFA_offset_extended);
|
|
|
|
Asm->EOL("DW_CFA_offset_extended");
|
|
|
|
Asm->EmitULEB128Bytes(Reg);
|
|
|
|
Asm->EOL("Reg");
|
|
|
|
Asm->EmitULEB128Bytes(Offset);
|
|
|
|
Asm->EOL("Offset");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2009-01-08 17:19:22 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2009-01-12 22:54:42 +00:00
|
|
|
/// SrcLineInfo - This class is used to record source line correspondence.
|
2009-01-08 17:19:22 +00:00
|
|
|
///
|
|
|
|
class SrcLineInfo {
|
|
|
|
unsigned Line; // Source line number.
|
|
|
|
unsigned Column; // Source column.
|
|
|
|
unsigned SourceID; // Source ID number.
|
|
|
|
unsigned LabelID; // Label in code ID number.
|
|
|
|
public:
|
|
|
|
SrcLineInfo(unsigned L, unsigned C, unsigned S, unsigned I)
|
2009-02-03 21:17:20 +00:00
|
|
|
: Line(L), Column(C), SourceID(S), LabelID(I) {}
|
2009-04-30 23:22:31 +00:00
|
|
|
|
2009-01-08 17:19:22 +00:00
|
|
|
// Accessors
|
|
|
|
unsigned getLine() const { return Line; }
|
|
|
|
unsigned getColumn() const { return Column; }
|
|
|
|
unsigned getSourceID() const { return SourceID; }
|
|
|
|
unsigned getLabelID() const { return LabelID; }
|
|
|
|
};
|
|
|
|
|
2009-01-08 02:33:41 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// DbgVariable - This class is used to track local variable information.
|
|
|
|
///
|
|
|
|
class DbgVariable {
|
2009-01-16 19:28:14 +00:00
|
|
|
DIVariable Var; // Variable Descriptor.
|
2009-05-07 19:46:24 +00:00
|
|
|
unsigned FrameIndex; // Variable frame index.
|
2009-01-08 02:33:41 +00:00
|
|
|
public:
|
2009-01-16 19:28:14 +00:00
|
|
|
DbgVariable(DIVariable V, unsigned I) : Var(V), FrameIndex(I) {}
|
2009-01-08 02:33:41 +00:00
|
|
|
|
|
|
|
// Accessors.
|
2009-01-16 19:28:14 +00:00
|
|
|
DIVariable getVariable() const { return Var; }
|
2009-01-08 02:33:41 +00:00
|
|
|
unsigned getFrameIndex() const { return FrameIndex; }
|
|
|
|
};
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// DbgScope - This class is used to track scope information.
|
|
|
|
///
|
2009-05-10 23:14:38 +00:00
|
|
|
class DbgConcreteScope;
|
2009-01-08 02:33:41 +00:00
|
|
|
class DbgScope {
|
|
|
|
DbgScope *Parent; // Parent to this scope.
|
2009-01-16 18:01:58 +00:00
|
|
|
DIDescriptor Desc; // Debug info descriptor for scope.
|
2009-01-08 02:33:41 +00:00
|
|
|
// Either subprogram or block.
|
|
|
|
unsigned StartLabelID; // Label ID of the beginning of scope.
|
|
|
|
unsigned EndLabelID; // Label ID of the end of scope.
|
2009-01-16 18:01:58 +00:00
|
|
|
SmallVector<DbgScope *, 4> Scopes; // Scopes defined in scope.
|
2009-01-10 02:42:49 +00:00
|
|
|
SmallVector<DbgVariable *, 8> Variables;// Variables declared in scope.
|
2009-05-10 23:14:38 +00:00
|
|
|
SmallVector<DbgConcreteScope *, 8> ConcreteInsts;// Concrete insts of funcs.
|
2009-01-08 02:33:41 +00:00
|
|
|
public:
|
2009-01-15 18:25:17 +00:00
|
|
|
DbgScope(DbgScope *P, DIDescriptor D)
|
2009-05-10 23:14:38 +00:00
|
|
|
: Parent(P), Desc(D), StartLabelID(0), EndLabelID(0) {}
|
|
|
|
virtual ~DbgScope();
|
2009-01-08 02:33:41 +00:00
|
|
|
|
|
|
|
// Accessors.
|
2009-01-16 18:01:58 +00:00
|
|
|
DbgScope *getParent() const { return Parent; }
|
|
|
|
DIDescriptor getDesc() const { return Desc; }
|
2009-01-08 02:33:41 +00:00
|
|
|
unsigned getStartLabelID() const { return StartLabelID; }
|
|
|
|
unsigned getEndLabelID() const { return EndLabelID; }
|
2009-01-10 02:42:49 +00:00
|
|
|
SmallVector<DbgScope *, 4> &getScopes() { return Scopes; }
|
|
|
|
SmallVector<DbgVariable *, 8> &getVariables() { return Variables; }
|
2009-05-10 23:14:38 +00:00
|
|
|
SmallVector<DbgConcreteScope*,8> &getConcreteInsts() { return ConcreteInsts; }
|
2009-01-08 02:33:41 +00:00
|
|
|
void setStartLabelID(unsigned S) { StartLabelID = S; }
|
|
|
|
void setEndLabelID(unsigned E) { EndLabelID = E; }
|
|
|
|
|
|
|
|
/// AddScope - Add a scope to the scope.
|
|
|
|
///
|
|
|
|
void AddScope(DbgScope *S) { Scopes.push_back(S); }
|
|
|
|
|
|
|
|
/// AddVariable - Add a variable to the scope.
|
|
|
|
///
|
|
|
|
void AddVariable(DbgVariable *V) { Variables.push_back(V); }
|
2009-04-15 00:10:26 +00:00
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
/// AddConcreteInst - Add a concrete instance to the scope.
|
|
|
|
///
|
|
|
|
void AddConcreteInst(DbgConcreteScope *C) { ConcreteInsts.push_back(C); }
|
2009-05-06 21:21:34 +00:00
|
|
|
|
|
|
|
#ifndef NDEBUG
|
|
|
|
void dump() const;
|
|
|
|
#endif
|
2009-04-15 00:10:26 +00:00
|
|
|
};
|
|
|
|
|
2009-05-06 21:21:34 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
void DbgScope::dump() const {
|
|
|
|
static unsigned IndentLevel = 0;
|
|
|
|
std::string Indent(IndentLevel, ' ');
|
|
|
|
|
|
|
|
cerr << Indent; Desc.dump();
|
|
|
|
cerr << " [" << StartLabelID << ", " << EndLabelID << "]\n";
|
|
|
|
|
|
|
|
IndentLevel += 2;
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = Scopes.size(); i != e; ++i)
|
|
|
|
if (Scopes[i] != this)
|
|
|
|
Scopes[i]->dump();
|
|
|
|
|
|
|
|
IndentLevel -= 2;
|
|
|
|
}
|
|
|
|
#endif
|
2009-04-15 00:10:26 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
2009-05-10 23:14:38 +00:00
|
|
|
/// DbgConcreteScope - This class is used to track a scope that holds concrete
|
|
|
|
/// instance information.
|
|
|
|
///
|
|
|
|
class DbgConcreteScope : public DbgScope {
|
|
|
|
CompileUnit *Unit;
|
|
|
|
DIE *Die; // Debug info for this concrete scope.
|
2009-04-15 00:10:26 +00:00
|
|
|
public:
|
2009-05-10 23:14:38 +00:00
|
|
|
DbgConcreteScope(DIDescriptor D) : DbgScope(NULL, D) {}
|
2009-04-15 00:10:26 +00:00
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
// Accessors.
|
|
|
|
DIE *getDie() const { return Die; }
|
|
|
|
void setDie(DIE *D) { Die = D; }
|
2009-01-08 02:33:41 +00:00
|
|
|
};
|
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
DbgScope::~DbgScope() {
|
|
|
|
for (unsigned i = 0, N = Scopes.size(); i < N; ++i)
|
|
|
|
delete Scopes[i];
|
|
|
|
for (unsigned j = 0, M = Variables.size(); j < M; ++j)
|
|
|
|
delete Variables[j];
|
|
|
|
for (unsigned k = 0, O = ConcreteInsts.size(); k < O; ++k)
|
|
|
|
delete ConcreteInsts[k];
|
|
|
|
}
|
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2008-08-16 12:57:46 +00:00
|
|
|
/// DwarfDebug - Emits Dwarf debug directives.
|
2007-02-01 16:31:34 +00:00
|
|
|
///
|
|
|
|
class DwarfDebug : public Dwarf {
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
// Attributes used to construct specific Dwarf sections.
|
|
|
|
//
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
/// CompileUnitMap - A map of global variables representing compile units to
|
|
|
|
/// compile units.
|
|
|
|
DenseMap<Value *, CompileUnit *> CompileUnitMap;
|
|
|
|
|
|
|
|
/// CompileUnits - All the compile units in this module.
|
|
|
|
///
|
|
|
|
SmallVector<CompileUnit *, 8> CompileUnits;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-01-30 18:20:31 +00:00
|
|
|
/// MainCU - Some platform prefers one compile unit per .o file. In such
|
|
|
|
/// cases, all dies are inserted in MainCU.
|
|
|
|
CompileUnit *MainCU;
|
2009-02-20 20:40:28 +00:00
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
/// AbbreviationsSet - Used to uniquely define abbreviations.
|
|
|
|
///
|
|
|
|
FoldingSet<DIEAbbrev> AbbreviationsSet;
|
|
|
|
|
|
|
|
/// Abbreviations - A list of all the unique abbreviations in use.
|
|
|
|
///
|
|
|
|
std::vector<DIEAbbrev *> Abbreviations;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
/// DirectoryIdMap - Directory name to directory id map.
|
|
|
|
///
|
|
|
|
StringMap<unsigned> DirectoryIdMap;
|
|
|
|
|
|
|
|
/// DirectoryNames - A list of directory names.
|
|
|
|
SmallVector<std::string, 8> DirectoryNames;
|
|
|
|
|
|
|
|
/// SourceFileIdMap - Source file name to source file id map.
|
|
|
|
///
|
|
|
|
StringMap<unsigned> SourceFileIdMap;
|
2009-01-05 22:35:52 +00:00
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
/// SourceFileNames - A list of source file names.
|
|
|
|
SmallVector<std::string, 8> SourceFileNames;
|
|
|
|
|
|
|
|
/// SourceIdMap - Source id map, i.e. pair of directory id and source file
|
|
|
|
/// id mapped to a unique id.
|
|
|
|
DenseMap<std::pair<unsigned, unsigned>, unsigned> SourceIdMap;
|
|
|
|
|
|
|
|
/// SourceIds - Reverse map from source id to directory id + file id pair.
|
|
|
|
///
|
|
|
|
SmallVector<std::pair<unsigned, unsigned>, 8> SourceIds;
|
2009-01-05 22:35:52 +00:00
|
|
|
|
2009-01-16 21:07:53 +00:00
|
|
|
/// Lines - List of of source line correspondence.
|
2009-01-08 17:19:22 +00:00
|
|
|
std::vector<SrcLineInfo> Lines;
|
|
|
|
|
2009-01-16 21:07:53 +00:00
|
|
|
/// ValuesSet - Used to uniquely define values.
|
|
|
|
///
|
2007-02-01 16:31:34 +00:00
|
|
|
FoldingSet<DIEValue> ValuesSet;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
/// Values - A list of all the unique values in use.
|
|
|
|
///
|
|
|
|
std::vector<DIEValue *> Values;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
/// StringPool - A UniqueVector of strings used by indirect references.
|
|
|
|
///
|
|
|
|
UniqueVector<std::string> StringPool;
|
|
|
|
|
|
|
|
/// SectionMap - Provides a unique id per text section.
|
|
|
|
///
|
2008-09-24 22:15:21 +00:00
|
|
|
UniqueVector<const Section*> SectionMap;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
/// SectionSourceLines - Tracks line numbers per text section.
|
|
|
|
///
|
2009-01-12 22:54:42 +00:00
|
|
|
std::vector<std::vector<SrcLineInfo> > SectionSourceLines;
|
2007-02-01 16:31:34 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
/// didInitial - Flag to indicate if initial emission has been done.
|
|
|
|
///
|
|
|
|
bool didInitial;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
/// shouldEmit - Flag to indicate if debug information should be emitted.
|
|
|
|
///
|
|
|
|
bool shouldEmit;
|
2007-02-01 16:31:34 +00:00
|
|
|
|
2009-04-15 20:41:31 +00:00
|
|
|
// FunctionDbgScope - Top level scope for the current function.
|
2009-01-08 02:33:41 +00:00
|
|
|
//
|
2009-04-15 20:41:31 +00:00
|
|
|
DbgScope *FunctionDbgScope;
|
2009-01-08 02:33:41 +00:00
|
|
|
|
2009-03-10 21:23:25 +00:00
|
|
|
/// DbgScopeMap - Tracks the scopes in the current function.
|
2009-01-08 02:33:41 +00:00
|
|
|
DenseMap<GlobalVariable *, DbgScope *> DbgScopeMap;
|
2009-03-10 21:23:25 +00:00
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
/// DbgConcreteScopeMap - Tracks inlined scopes in the current function.
|
|
|
|
DenseMap<GlobalVariable *,
|
|
|
|
SmallVector<DbgConcreteScope *, 8> > DbgConcreteScopeMap;
|
2009-04-15 00:10:26 +00:00
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
/// InlineInfo - Keep track of inlined functions and their location. This
|
|
|
|
/// information is used to populate debug_inlined section.
|
2009-04-13 17:02:03 +00:00
|
|
|
DenseMap<GlobalVariable *, SmallVector<unsigned, 4> > InlineInfo;
|
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
/// InlinedVariableScopes - Scopes information for the inlined subroutine
|
|
|
|
/// variables.
|
|
|
|
DenseMap<const MachineInstr *, DbgScope *> InlinedVariableScopes;
|
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
/// AbstractInstanceRootMap - Map of abstract instance roots of inlined
|
|
|
|
/// functions. These are subroutine entries that contain a DW_AT_inline
|
|
|
|
/// attribute.
|
|
|
|
DenseMap<const GlobalVariable *, DbgScope *> AbstractInstanceRootMap;
|
|
|
|
|
|
|
|
/// AbstractInstanceRootList - List of abstract instance roots of inlined
|
|
|
|
/// functions. These are subroutine entries that contain a DW_AT_inline
|
|
|
|
/// attribute.
|
|
|
|
SmallVector<DbgScope *, 32> AbstractInstanceRootList;
|
|
|
|
|
|
|
|
/// LexicalScopeStack - A stack of lexical scopes. The top one is the current
|
|
|
|
/// scope.
|
|
|
|
SmallVector<DbgScope *, 16> LexicalScopeStack;
|
|
|
|
|
2009-05-08 21:03:15 +00:00
|
|
|
/// CompileUnitOffsets - A vector of the offsets of the compile units. This is
|
|
|
|
/// used when calculating the "origin" of a concrete instance of an inlined
|
|
|
|
/// function.
|
|
|
|
DenseMap<CompileUnit *, unsigned> CompileUnitOffsets;
|
|
|
|
|
2009-03-10 21:23:25 +00:00
|
|
|
/// DebugTimer - Timer for the Dwarf debug writer.
|
|
|
|
Timer *DebugTimer;
|
2009-01-08 02:33:41 +00:00
|
|
|
|
2007-05-13 17:30:11 +00:00
|
|
|
struct FunctionDebugFrameInfo {
|
|
|
|
unsigned Number;
|
|
|
|
std::vector<MachineMove> Moves;
|
|
|
|
|
|
|
|
FunctionDebugFrameInfo(unsigned Num, const std::vector<MachineMove> &M):
|
2007-08-27 14:50:10 +00:00
|
|
|
Number(Num), Moves(M) { }
|
2007-05-13 17:30:11 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
std::vector<FunctionDebugFrameInfo> DebugFrames;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-03-10 21:47:45 +00:00
|
|
|
private:
|
2009-03-10 21:59:25 +00:00
|
|
|
/// getSourceDirectoryAndFileIds - Return the directory and file ids that
|
2009-03-10 21:47:45 +00:00
|
|
|
/// maps to the source id. Source id starts at 1.
|
|
|
|
std::pair<unsigned, unsigned>
|
2009-03-10 21:59:25 +00:00
|
|
|
getSourceDirectoryAndFileIds(unsigned SId) const {
|
2009-03-10 21:47:45 +00:00
|
|
|
return SourceIds[SId-1];
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getNumSourceDirectories - Return the number of source directories in the
|
|
|
|
/// debug info.
|
|
|
|
unsigned getNumSourceDirectories() const {
|
|
|
|
return DirectoryNames.size();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getSourceDirectoryName - Return the name of the directory corresponding
|
|
|
|
/// to the id.
|
|
|
|
const std::string &getSourceDirectoryName(unsigned Id) const {
|
|
|
|
return DirectoryNames[Id - 1];
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getSourceFileName - Return the name of the source file corresponding
|
|
|
|
/// to the id.
|
|
|
|
const std::string &getSourceFileName(unsigned Id) const {
|
|
|
|
return SourceFileNames[Id - 1];
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getNumSourceIds - Return the number of unique source ids.
|
|
|
|
unsigned getNumSourceIds() const {
|
|
|
|
return SourceIds.size();
|
|
|
|
}
|
2007-02-01 16:31:34 +00:00
|
|
|
|
2006-10-30 15:59:54 +00:00
|
|
|
/// AssignAbbrevNumber - Define a unique number for the abbreviation.
|
2008-08-16 12:57:46 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
void AssignAbbrevNumber(DIEAbbrev &Abbrev) {
|
|
|
|
// Profile the node so that we can make it unique.
|
|
|
|
FoldingSetNodeID ID;
|
|
|
|
Abbrev.Profile(ID);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Check the set for priors.
|
|
|
|
DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// If it's newly added.
|
|
|
|
if (InSet == &Abbrev) {
|
2008-08-16 12:57:46 +00:00
|
|
|
// Add to abbreviation list.
|
2006-11-02 20:12:39 +00:00
|
|
|
Abbreviations.push_back(&Abbrev);
|
|
|
|
// Assign the vector position + 1 as its number.
|
|
|
|
Abbrev.setNumber(Abbreviations.size());
|
|
|
|
} else {
|
|
|
|
// Assign existing abbreviation number.
|
|
|
|
Abbrev.setNumber(InSet->getNumber());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-10-30 13:35:07 +00:00
|
|
|
/// NewString - Add a string to the constant pool and returns a label.
|
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
DWLabel NewString(const std::string &String) {
|
|
|
|
unsigned StringID = StringPool.insert(String);
|
|
|
|
return DWLabel("string", StringID);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// NewDIEntry - Creates a new DIEntry to be a proxy for a debug information
|
|
|
|
/// entry.
|
|
|
|
DIEntry *NewDIEntry(DIE *Entry = NULL) {
|
|
|
|
DIEntry *Value;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
if (Entry) {
|
|
|
|
FoldingSetNodeID ID;
|
2006-11-09 14:52:14 +00:00
|
|
|
DIEntry::Profile(ID, Entry);
|
2006-11-02 20:12:39 +00:00
|
|
|
void *Where;
|
|
|
|
Value = static_cast<DIEntry *>(ValuesSet.FindNodeOrInsertPos(ID, Where));
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 21:48:18 +00:00
|
|
|
if (Value) return Value;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
Value = new DIEntry(Entry);
|
|
|
|
ValuesSet.InsertNode(Value, Where);
|
|
|
|
} else {
|
|
|
|
Value = new DIEntry(Entry);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
Values.push_back(Value);
|
|
|
|
return Value;
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// SetDIEntry - Set a DIEntry once the debug information entry is defined.
|
|
|
|
///
|
|
|
|
void SetDIEntry(DIEntry *Value, DIE *Entry) {
|
2009-03-10 23:57:09 +00:00
|
|
|
Value->setEntry(Entry);
|
2006-11-02 20:12:39 +00:00
|
|
|
// Add to values set if not already there. If it is, we merely have a
|
|
|
|
// duplicate in the values list (no harm.)
|
|
|
|
ValuesSet.GetOrInsertNode(Value);
|
|
|
|
}
|
2006-10-30 13:35:07 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// AddUInt - Add an unsigned integer attribute data and value.
|
2006-10-30 13:35:07 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
void AddUInt(DIE *Die, unsigned Attribute, unsigned Form, uint64_t Integer) {
|
|
|
|
if (!Form) Form = DIEInteger::BestForm(false, Integer);
|
|
|
|
|
|
|
|
FoldingSetNodeID ID;
|
2006-11-09 14:52:14 +00:00
|
|
|
DIEInteger::Profile(ID, Integer);
|
2006-11-02 20:12:39 +00:00
|
|
|
void *Where;
|
|
|
|
DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where);
|
|
|
|
if (!Value) {
|
|
|
|
Value = new DIEInteger(Integer);
|
|
|
|
ValuesSet.InsertNode(Value, Where);
|
|
|
|
Values.push_back(Value);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
Die->AddValue(Attribute, Form, Value);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// AddSInt - Add an signed integer attribute data and value.
|
2006-10-30 13:35:07 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
void AddSInt(DIE *Die, unsigned Attribute, unsigned Form, int64_t Integer) {
|
|
|
|
if (!Form) Form = DIEInteger::BestForm(true, Integer);
|
|
|
|
|
|
|
|
FoldingSetNodeID ID;
|
2006-11-09 14:52:14 +00:00
|
|
|
DIEInteger::Profile(ID, (uint64_t)Integer);
|
2006-11-02 20:12:39 +00:00
|
|
|
void *Where;
|
|
|
|
DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where);
|
|
|
|
if (!Value) {
|
|
|
|
Value = new DIEInteger(Integer);
|
|
|
|
ValuesSet.InsertNode(Value, Where);
|
|
|
|
Values.push_back(Value);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
Die->AddValue(Attribute, Form, Value);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
/// AddString - Add a string attribute data and value.
|
2006-10-30 13:35:07 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
void AddString(DIE *Die, unsigned Attribute, unsigned Form,
|
|
|
|
const std::string &String) {
|
|
|
|
FoldingSetNodeID ID;
|
2006-11-09 14:52:14 +00:00
|
|
|
DIEString::Profile(ID, String);
|
2006-11-02 20:12:39 +00:00
|
|
|
void *Where;
|
|
|
|
DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where);
|
|
|
|
if (!Value) {
|
|
|
|
Value = new DIEString(String);
|
|
|
|
ValuesSet.InsertNode(Value, Where);
|
|
|
|
Values.push_back(Value);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
Die->AddValue(Attribute, Form, Value);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// AddLabel - Add a Dwarf label attribute data and value.
|
2006-10-30 13:35:07 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
void AddLabel(DIE *Die, unsigned Attribute, unsigned Form,
|
|
|
|
const DWLabel &Label) {
|
|
|
|
FoldingSetNodeID ID;
|
2006-11-09 14:52:14 +00:00
|
|
|
DIEDwarfLabel::Profile(ID, Label);
|
2006-11-02 20:12:39 +00:00
|
|
|
void *Where;
|
|
|
|
DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where);
|
|
|
|
if (!Value) {
|
|
|
|
Value = new DIEDwarfLabel(Label);
|
|
|
|
ValuesSet.InsertNode(Value, Where);
|
|
|
|
Values.push_back(Value);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
Die->AddValue(Attribute, Form, Value);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// AddObjectLabel - Add an non-Dwarf label attribute data and value.
|
|
|
|
///
|
|
|
|
void AddObjectLabel(DIE *Die, unsigned Attribute, unsigned Form,
|
|
|
|
const std::string &Label) {
|
|
|
|
FoldingSetNodeID ID;
|
2006-11-09 14:52:14 +00:00
|
|
|
DIEObjectLabel::Profile(ID, Label);
|
2006-11-02 20:12:39 +00:00
|
|
|
void *Where;
|
|
|
|
DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where);
|
|
|
|
if (!Value) {
|
|
|
|
Value = new DIEObjectLabel(Label);
|
|
|
|
ValuesSet.InsertNode(Value, Where);
|
|
|
|
Values.push_back(Value);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
Die->AddValue(Attribute, Form, Value);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2008-06-18 19:27:37 +00:00
|
|
|
/// 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);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2008-06-18 19:27:37 +00:00
|
|
|
Die->AddValue(Attribute, Form, Value);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// AddDelta - Add a label delta attribute data and value.
|
2006-10-30 13:35:07 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
void AddDelta(DIE *Die, unsigned Attribute, unsigned Form,
|
2009-04-15 00:10:26 +00:00
|
|
|
const DWLabel &Hi, const DWLabel &Lo) {
|
2006-11-02 20:12:39 +00:00
|
|
|
FoldingSetNodeID ID;
|
2006-11-09 14:52:14 +00:00
|
|
|
DIEDelta::Profile(ID, Hi, Lo);
|
2006-11-02 20:12:39 +00:00
|
|
|
void *Where;
|
|
|
|
DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where);
|
|
|
|
if (!Value) {
|
|
|
|
Value = new DIEDelta(Hi, Lo);
|
|
|
|
ValuesSet.InsertNode(Value, Where);
|
|
|
|
Values.push_back(Value);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
Die->AddValue(Attribute, Form, Value);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// AddDIEntry - Add a DIE attribute data and value.
|
2006-10-30 13:35:07 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
void AddDIEntry(DIE *Die, unsigned Attribute, unsigned Form, DIE *Entry) {
|
|
|
|
Die->AddValue(Attribute, Form, NewDIEntry(Entry));
|
|
|
|
}
|
2006-10-30 13:35:07 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// AddBlock - Add block data.
|
2006-10-30 13:35:07 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
void AddBlock(DIE *Die, unsigned Attribute, unsigned Form, DIEBlock *Block) {
|
|
|
|
Block->ComputeSize(*this);
|
|
|
|
FoldingSetNodeID ID;
|
|
|
|
Block->Profile(ID);
|
|
|
|
void *Where;
|
|
|
|
DIEValue *Value = ValuesSet.FindNodeOrInsertPos(ID, Where);
|
|
|
|
if (!Value) {
|
|
|
|
Value = Block;
|
|
|
|
ValuesSet.InsertNode(Value, Where);
|
|
|
|
Values.push_back(Value);
|
|
|
|
} else {
|
2007-09-21 18:25:53 +00:00
|
|
|
// Already exists, reuse the previous one.
|
2006-11-02 20:12:39 +00:00
|
|
|
delete Block;
|
2007-09-21 18:25:53 +00:00
|
|
|
Block = cast<DIEBlock>(Value);
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
Die->AddValue(Attribute, Block->BestForm(), Value);
|
|
|
|
}
|
2006-10-30 13:35:07 +00:00
|
|
|
|
2009-01-08 02:33:41 +00:00
|
|
|
/// AddSourceLine - Add location information to specified debug information
|
|
|
|
/// entry.
|
2009-01-16 19:28:14 +00:00
|
|
|
void AddSourceLine(DIE *Die, const DIVariable *V) {
|
2009-05-05 04:55:56 +00:00
|
|
|
// If there is no compile unit specified, don't add a line #.
|
|
|
|
if (V->getCompileUnit().isNull())
|
|
|
|
return;
|
|
|
|
|
2009-01-08 02:33:41 +00:00
|
|
|
unsigned Line = V->getLineNumber();
|
2009-05-05 04:55:56 +00:00
|
|
|
unsigned FileID = FindCompileUnit(V->getCompileUnit()).getID();
|
|
|
|
assert(FileID && "Invalid file id");
|
2009-01-08 02:33:41 +00:00
|
|
|
AddUInt(Die, DW_AT_decl_file, 0, FileID);
|
|
|
|
AddUInt(Die, DW_AT_decl_line, 0, Line);
|
|
|
|
}
|
|
|
|
|
2009-01-05 22:35:52 +00:00
|
|
|
/// AddSourceLine - Add location information to specified debug information
|
|
|
|
/// entry.
|
2009-01-16 19:28:14 +00:00
|
|
|
void AddSourceLine(DIE *Die, const DIGlobal *G) {
|
2009-05-05 04:55:56 +00:00
|
|
|
// If there is no compile unit specified, don't add a line #.
|
|
|
|
if (G->getCompileUnit().isNull())
|
|
|
|
return;
|
2009-01-05 22:35:52 +00:00
|
|
|
unsigned Line = G->getLineNumber();
|
2009-05-05 04:55:56 +00:00
|
|
|
unsigned FileID = FindCompileUnit(G->getCompileUnit()).getID();
|
|
|
|
assert(FileID && "Invalid file id");
|
2009-01-05 22:35:52 +00:00
|
|
|
AddUInt(Die, DW_AT_decl_file, 0, FileID);
|
|
|
|
AddUInt(Die, DW_AT_decl_line, 0, Line);
|
|
|
|
}
|
|
|
|
|
2009-01-16 19:28:14 +00:00
|
|
|
void AddSourceLine(DIE *Die, const DIType *Ty) {
|
2009-05-05 04:55:56 +00:00
|
|
|
// If there is no compile unit specified, don't add a line #.
|
2009-01-30 18:20:31 +00:00
|
|
|
DICompileUnit CU = Ty->getCompileUnit();
|
|
|
|
if (CU.isNull())
|
|
|
|
return;
|
2009-05-05 04:55:56 +00:00
|
|
|
|
|
|
|
unsigned Line = Ty->getLineNumber();
|
|
|
|
unsigned FileID = FindCompileUnit(CU).getID();
|
|
|
|
assert(FileID && "Invalid file id");
|
2009-01-05 22:35:52 +00:00
|
|
|
AddUInt(Die, DW_AT_decl_file, 0, FileID);
|
|
|
|
AddUInt(Die, DW_AT_decl_line, 0, Line);
|
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// AddAddress - Add an address attribute to a die based on the location
|
|
|
|
/// provided.
|
|
|
|
void AddAddress(DIE *Die, unsigned Attribute,
|
2009-04-15 00:10:26 +00:00
|
|
|
const MachineLocation &Location) {
|
2008-10-03 15:45:36 +00:00
|
|
|
unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
|
2006-11-02 20:12:39 +00:00
|
|
|
DIEBlock *Block = new DIEBlock();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2008-10-03 15:45:36 +00:00
|
|
|
if (Location.isReg()) {
|
2006-11-02 20:12:39 +00:00
|
|
|
if (Reg < 32) {
|
|
|
|
AddUInt(Block, 0, DW_FORM_data1, DW_OP_reg0 + Reg);
|
|
|
|
} else {
|
|
|
|
AddUInt(Block, 0, DW_FORM_data1, DW_OP_regx);
|
|
|
|
AddUInt(Block, 0, DW_FORM_udata, Reg);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (Reg < 32) {
|
|
|
|
AddUInt(Block, 0, DW_FORM_data1, DW_OP_breg0 + Reg);
|
|
|
|
} else {
|
|
|
|
AddUInt(Block, 0, DW_FORM_data1, DW_OP_bregx);
|
|
|
|
AddUInt(Block, 0, DW_FORM_udata, Reg);
|
|
|
|
}
|
|
|
|
AddUInt(Block, 0, DW_FORM_sdata, Location.getOffset());
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
AddBlock(Die, Attribute, 0, Block);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-01-05 21:47:57 +00:00
|
|
|
/// AddType - Add a new type attribute to the specified entity.
|
|
|
|
void AddType(CompileUnit *DW_Unit, DIE *Entity, DIType Ty) {
|
2009-01-23 19:13:31 +00:00
|
|
|
if (Ty.isNull())
|
2009-01-05 21:47:57 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
// Check for pre-existence.
|
|
|
|
DIEntry *&Slot = DW_Unit->getDIEntrySlotFor(Ty.getGV());
|
|
|
|
// If it exists then use the existing value.
|
|
|
|
if (Slot) {
|
|
|
|
Entity->AddValue(DW_AT_type, DW_FORM_ref4, Slot);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set up proxy.
|
|
|
|
Slot = NewDIEntry();
|
|
|
|
|
|
|
|
// Construct type.
|
|
|
|
DIE Buffer(DW_TAG_base_type);
|
2009-01-15 19:26:23 +00:00
|
|
|
if (Ty.isBasicType(Ty.getTag()))
|
|
|
|
ConstructTypeDIE(DW_Unit, Buffer, DIBasicType(Ty.getGV()));
|
|
|
|
else if (Ty.isDerivedType(Ty.getTag()))
|
|
|
|
ConstructTypeDIE(DW_Unit, Buffer, DIDerivedType(Ty.getGV()));
|
|
|
|
else {
|
2009-02-03 21:17:20 +00:00
|
|
|
assert(Ty.isCompositeType(Ty.getTag()) && "Unknown kind of DIType");
|
2009-01-15 19:26:23 +00:00
|
|
|
ConstructTypeDIE(DW_Unit, Buffer, DICompositeType(Ty.getGV()));
|
|
|
|
}
|
|
|
|
|
2009-01-27 23:22:55 +00:00
|
|
|
// Add debug information entry to entity and appropriate context.
|
|
|
|
DIE *Die = NULL;
|
|
|
|
DIDescriptor Context = Ty.getContext();
|
|
|
|
if (!Context.isNull())
|
|
|
|
Die = DW_Unit->getDieMapSlotFor(Context.getGV());
|
|
|
|
|
|
|
|
if (Die) {
|
|
|
|
DIE *Child = new DIE(Buffer);
|
|
|
|
Die->AddChild(Child);
|
|
|
|
Buffer.Detach();
|
|
|
|
SetDIEntry(Slot, Child);
|
2009-02-03 21:17:20 +00:00
|
|
|
} else {
|
2009-01-27 23:22:55 +00:00
|
|
|
Die = DW_Unit->AddDie(Buffer);
|
|
|
|
SetDIEntry(Slot, Die);
|
|
|
|
}
|
|
|
|
|
2009-01-05 21:47:57 +00:00
|
|
|
Entity->AddValue(DW_AT_type, DW_FORM_ref4, Slot);
|
|
|
|
}
|
|
|
|
|
2009-01-05 19:07:53 +00:00
|
|
|
/// ConstructTypeDIE - Construct basic type die from DIBasicType.
|
|
|
|
void ConstructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
|
2009-01-15 19:26:23 +00:00
|
|
|
DIBasicType BTy) {
|
2009-03-13 04:39:26 +00:00
|
|
|
|
2009-01-05 17:57:47 +00:00
|
|
|
// Get core information.
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string Name;
|
|
|
|
BTy.getName(Name);
|
2009-01-05 17:57:47 +00:00
|
|
|
Buffer.setTag(DW_TAG_base_type);
|
2009-01-15 19:26:23 +00:00
|
|
|
AddUInt(&Buffer, DW_AT_encoding, DW_FORM_data1, BTy.getEncoding());
|
2009-01-05 17:57:47 +00:00
|
|
|
// Add name if not anonymous or intermediate type.
|
2009-03-13 04:39:26 +00:00
|
|
|
if (!Name.empty())
|
2009-01-05 17:57:47 +00:00
|
|
|
AddString(&Buffer, DW_AT_name, DW_FORM_string, Name);
|
2009-01-15 19:26:23 +00:00
|
|
|
uint64_t Size = BTy.getSizeInBits() >> 3;
|
2009-01-05 17:57:47 +00:00
|
|
|
AddUInt(&Buffer, DW_AT_byte_size, 0, Size);
|
|
|
|
}
|
|
|
|
|
2009-01-05 19:07:53 +00:00
|
|
|
/// ConstructTypeDIE - Construct derived type die from DIDerivedType.
|
|
|
|
void ConstructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
|
2009-01-15 19:26:23 +00:00
|
|
|
DIDerivedType DTy) {
|
2009-03-13 04:39:26 +00:00
|
|
|
|
2009-01-05 17:57:47 +00:00
|
|
|
// Get core information.
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string Name;
|
|
|
|
DTy.getName(Name);
|
2009-01-15 19:26:23 +00:00
|
|
|
uint64_t Size = DTy.getSizeInBits() >> 3;
|
|
|
|
unsigned Tag = DTy.getTag();
|
2009-03-09 05:04:40 +00:00
|
|
|
|
2009-01-05 17:57:47 +00:00
|
|
|
// FIXME - Workaround for templates.
|
|
|
|
if (Tag == DW_TAG_inheritance) Tag = DW_TAG_reference_type;
|
|
|
|
|
|
|
|
Buffer.setTag(Tag);
|
2009-03-09 05:04:40 +00:00
|
|
|
|
2009-01-05 17:57:47 +00:00
|
|
|
// Map to main type, void will not have a type.
|
2009-01-15 19:26:23 +00:00
|
|
|
DIType FromTy = DTy.getTypeDerivedFrom();
|
2009-01-05 21:47:57 +00:00
|
|
|
AddType(DW_Unit, &Buffer, FromTy);
|
2009-01-05 17:57:47 +00:00
|
|
|
|
|
|
|
// Add name if not anonymous or intermediate type.
|
2009-03-13 04:39:26 +00:00
|
|
|
if (!Name.empty())
|
2009-02-25 07:04:34 +00:00
|
|
|
AddString(&Buffer, DW_AT_name, DW_FORM_string, Name);
|
2009-01-05 17:57:47 +00:00
|
|
|
|
|
|
|
// Add size if non-zero (derived types might be zero-sized.)
|
|
|
|
if (Size)
|
|
|
|
AddUInt(&Buffer, DW_AT_byte_size, 0, Size);
|
|
|
|
|
|
|
|
// Add source line info if available and TyDesc is not a forward
|
|
|
|
// declaration.
|
2009-01-27 00:45:04 +00:00
|
|
|
if (!DTy.isForwardDecl())
|
|
|
|
AddSourceLine(&Buffer, &DTy);
|
2009-01-05 17:57:47 +00:00
|
|
|
}
|
|
|
|
|
2009-01-05 19:55:51 +00:00
|
|
|
/// ConstructTypeDIE - Construct type DIE from DICompositeType.
|
|
|
|
void ConstructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
|
2009-01-15 19:26:23 +00:00
|
|
|
DICompositeType CTy) {
|
2009-01-17 08:01:33 +00:00
|
|
|
// Get core information.
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string Name;
|
|
|
|
CTy.getName(Name);
|
2009-03-09 05:04:40 +00:00
|
|
|
|
2009-01-15 19:26:23 +00:00
|
|
|
uint64_t Size = CTy.getSizeInBits() >> 3;
|
|
|
|
unsigned Tag = CTy.getTag();
|
2009-01-23 01:19:09 +00:00
|
|
|
Buffer.setTag(Tag);
|
2009-03-09 05:04:40 +00:00
|
|
|
|
2009-01-05 19:55:51 +00:00
|
|
|
switch (Tag) {
|
|
|
|
case DW_TAG_vector_type:
|
|
|
|
case DW_TAG_array_type:
|
2009-01-15 19:26:23 +00:00
|
|
|
ConstructArrayTypeDIE(DW_Unit, Buffer, &CTy);
|
2009-01-05 19:55:51 +00:00
|
|
|
break;
|
2009-01-20 18:35:14 +00:00
|
|
|
case DW_TAG_enumeration_type:
|
|
|
|
{
|
|
|
|
DIArray Elements = CTy.getTypeArray();
|
|
|
|
// Add enumerators to enumeration type.
|
|
|
|
for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
|
|
|
|
DIE *ElemDie = NULL;
|
|
|
|
DIEnumerator Enum(Elements.getElement(i).getGV());
|
|
|
|
ElemDie = ConstructEnumTypeDIE(DW_Unit, &Enum);
|
|
|
|
Buffer.AddChild(ElemDie);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2009-01-05 19:55:51 +00:00
|
|
|
case DW_TAG_subroutine_type:
|
|
|
|
{
|
|
|
|
// Add return type.
|
2009-05-06 21:21:34 +00:00
|
|
|
DIArray Elements = CTy.getTypeArray();
|
2009-01-05 21:47:57 +00:00
|
|
|
DIDescriptor RTy = Elements.getElement(0);
|
2009-01-15 19:26:23 +00:00
|
|
|
AddType(DW_Unit, &Buffer, DIType(RTy.getGV()));
|
2009-01-05 21:47:57 +00:00
|
|
|
|
2009-05-06 21:21:34 +00:00
|
|
|
// Add prototype flag.
|
|
|
|
AddUInt(&Buffer, DW_AT_prototyped, DW_FORM_flag, 1);
|
|
|
|
|
2009-01-05 19:55:51 +00:00
|
|
|
// Add arguments.
|
|
|
|
for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
|
|
|
|
DIE *Arg = new DIE(DW_TAG_formal_parameter);
|
2009-01-05 21:47:57 +00:00
|
|
|
DIDescriptor Ty = Elements.getElement(i);
|
2009-01-17 06:57:25 +00:00
|
|
|
AddType(DW_Unit, Arg, DIType(Ty.getGV()));
|
2009-01-05 19:55:51 +00:00
|
|
|
Buffer.AddChild(Arg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case DW_TAG_structure_type:
|
|
|
|
case DW_TAG_union_type:
|
2009-03-25 00:28:40 +00:00
|
|
|
case DW_TAG_class_type:
|
2009-01-05 19:55:51 +00:00
|
|
|
{
|
|
|
|
// Add elements to structure type.
|
2009-01-15 19:26:23 +00:00
|
|
|
DIArray Elements = CTy.getTypeArray();
|
2009-01-16 00:50:53 +00:00
|
|
|
|
|
|
|
// A forward struct declared type may not have elements available.
|
|
|
|
if (Elements.isNull())
|
|
|
|
break;
|
|
|
|
|
2009-01-05 19:55:51 +00:00
|
|
|
// Add elements to structure type.
|
|
|
|
for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
|
|
|
|
DIDescriptor Element = Elements.getElement(i);
|
2009-01-17 08:01:33 +00:00
|
|
|
DIE *ElemDie = NULL;
|
2009-01-15 19:26:23 +00:00
|
|
|
if (Element.getTag() == dwarf::DW_TAG_subprogram)
|
2009-01-17 08:05:14 +00:00
|
|
|
ElemDie = CreateSubprogramDIE(DW_Unit,
|
|
|
|
DISubprogram(Element.getGV()));
|
2009-05-10 23:14:38 +00:00
|
|
|
else if (Element.getTag() == dwarf::DW_TAG_variable) // ??
|
2009-01-17 08:01:33 +00:00
|
|
|
ElemDie = CreateGlobalVariableDIE(DW_Unit,
|
|
|
|
DIGlobalVariable(Element.getGV()));
|
2009-01-20 21:02:02 +00:00
|
|
|
else
|
|
|
|
ElemDie = CreateMemberDIE(DW_Unit,
|
|
|
|
DIDerivedType(Element.getGV()));
|
2009-01-17 08:05:14 +00:00
|
|
|
Buffer.AddChild(ElemDie);
|
2009-01-05 19:55:51 +00:00
|
|
|
}
|
2009-02-17 22:43:44 +00:00
|
|
|
unsigned RLang = CTy.getRunTimeLang();
|
|
|
|
if (RLang)
|
|
|
|
AddUInt(&Buffer, DW_AT_APPLE_runtime_class, DW_FORM_data1, RLang);
|
2009-01-05 19:55:51 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add name if not anonymous or intermediate type.
|
2009-03-13 04:39:26 +00:00
|
|
|
if (!Name.empty())
|
2009-02-25 07:04:34 +00:00
|
|
|
AddString(&Buffer, DW_AT_name, DW_FORM_string, Name);
|
2009-01-05 19:55:51 +00:00
|
|
|
|
2009-01-27 00:45:04 +00:00
|
|
|
if (Tag == DW_TAG_enumeration_type || Tag == DW_TAG_structure_type
|
|
|
|
|| Tag == DW_TAG_union_type) {
|
|
|
|
// Add size if non-zero (derived types might be zero-sized.)
|
|
|
|
if (Size)
|
|
|
|
AddUInt(&Buffer, DW_AT_byte_size, 0, Size);
|
|
|
|
else {
|
|
|
|
// Add zero size if it is not a forward declaration.
|
|
|
|
if (CTy.isForwardDecl())
|
|
|
|
AddUInt(&Buffer, DW_AT_declaration, DW_FORM_flag, 1);
|
|
|
|
else
|
|
|
|
AddUInt(&Buffer, DW_AT_byte_size, 0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add source line info if available.
|
|
|
|
if (!CTy.isForwardDecl())
|
|
|
|
AddSourceLine(&Buffer, &CTy);
|
2009-01-05 19:55:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-03 21:17:20 +00:00
|
|
|
/// ConstructSubrangeDIE - Construct subrange DIE from DISubrange.
|
|
|
|
void ConstructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) {
|
2009-01-15 19:26:23 +00:00
|
|
|
int64_t L = SR.getLo();
|
|
|
|
int64_t H = SR.getHi();
|
2009-01-05 18:33:01 +00:00
|
|
|
DIE *DW_Subrange = new DIE(DW_TAG_subrange_type);
|
|
|
|
if (L != H) {
|
|
|
|
AddDIEntry(DW_Subrange, DW_AT_type, DW_FORM_ref4, IndexTy);
|
|
|
|
if (L)
|
2009-01-17 08:05:14 +00:00
|
|
|
AddSInt(DW_Subrange, DW_AT_lower_bound, 0, L);
|
|
|
|
AddSInt(DW_Subrange, DW_AT_upper_bound, 0, H);
|
2009-01-05 18:33:01 +00:00
|
|
|
}
|
|
|
|
Buffer.AddChild(DW_Subrange);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// ConstructArrayTypeDIE - Construct array type DIE from DICompositeType.
|
|
|
|
void ConstructArrayTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
|
|
|
|
DICompositeType *CTy) {
|
|
|
|
Buffer.setTag(DW_TAG_array_type);
|
|
|
|
if (CTy->getTag() == DW_TAG_vector_type)
|
|
|
|
AddUInt(&Buffer, DW_AT_GNU_vector, DW_FORM_flag, 1);
|
|
|
|
|
2009-01-28 21:08:20 +00:00
|
|
|
// Emit derived type.
|
|
|
|
AddType(DW_Unit, &Buffer, CTy->getTypeDerivedFrom());
|
2009-01-05 18:33:01 +00:00
|
|
|
DIArray Elements = CTy->getTypeArray();
|
|
|
|
|
|
|
|
// Construct an anonymous type for index type.
|
|
|
|
DIE IdxBuffer(DW_TAG_base_type);
|
|
|
|
AddUInt(&IdxBuffer, DW_AT_byte_size, 0, sizeof(int32_t));
|
|
|
|
AddUInt(&IdxBuffer, DW_AT_encoding, DW_FORM_data1, DW_ATE_signed);
|
|
|
|
DIE *IndexTy = DW_Unit->AddDie(IdxBuffer);
|
|
|
|
|
|
|
|
// Add subranges to array type.
|
|
|
|
for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
|
2009-01-05 19:55:51 +00:00
|
|
|
DIDescriptor Element = Elements.getElement(i);
|
2009-01-15 19:26:23 +00:00
|
|
|
if (Element.getTag() == dwarf::DW_TAG_subrange_type)
|
|
|
|
ConstructSubrangeDIE(Buffer, DISubrange(Element.getGV()), IndexTy);
|
2009-01-05 18:33:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-03 21:17:20 +00:00
|
|
|
/// ConstructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
|
2009-01-20 18:35:14 +00:00
|
|
|
DIE *ConstructEnumTypeDIE(CompileUnit *DW_Unit, DIEnumerator *ETy) {
|
2009-01-05 18:38:38 +00:00
|
|
|
|
|
|
|
DIE *Enumerator = new DIE(DW_TAG_enumerator);
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string Name;
|
|
|
|
ETy->getName(Name);
|
2009-02-25 07:04:34 +00:00
|
|
|
AddString(Enumerator, DW_AT_name, DW_FORM_string, Name);
|
2009-01-05 18:38:38 +00:00
|
|
|
int64_t Value = ETy->getEnumValue();
|
|
|
|
AddSInt(Enumerator, DW_AT_const_value, DW_FORM_sdata, Value);
|
2009-01-20 18:35:14 +00:00
|
|
|
return Enumerator;
|
2009-01-05 18:38:38 +00:00
|
|
|
}
|
2009-01-05 18:33:01 +00:00
|
|
|
|
2009-01-17 08:01:33 +00:00
|
|
|
/// CreateGlobalVariableDIE - Create new DIE using GV.
|
2009-02-03 21:17:20 +00:00
|
|
|
DIE *CreateGlobalVariableDIE(CompileUnit *DW_Unit, const DIGlobalVariable &GV)
|
2009-01-17 08:01:33 +00:00
|
|
|
{
|
|
|
|
DIE *GVDie = new DIE(DW_TAG_variable);
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string Name;
|
|
|
|
GV.getDisplayName(Name);
|
2009-02-25 07:04:34 +00:00
|
|
|
AddString(GVDie, DW_AT_name, DW_FORM_string, Name);
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string LinkageName;
|
|
|
|
GV.getLinkageName(LinkageName);
|
|
|
|
if (!LinkageName.empty())
|
2009-01-17 08:01:33 +00:00
|
|
|
AddString(GVDie, DW_AT_MIPS_linkage_name, DW_FORM_string, LinkageName);
|
|
|
|
AddType(DW_Unit, GVDie, GV.getType());
|
|
|
|
if (!GV.isLocalToUnit())
|
|
|
|
AddUInt(GVDie, DW_AT_external, DW_FORM_flag, 1);
|
|
|
|
AddSourceLine(GVDie, &GV);
|
|
|
|
return GVDie;
|
|
|
|
}
|
|
|
|
|
2009-01-20 21:02:02 +00:00
|
|
|
/// CreateMemberDIE - Create new member DIE.
|
|
|
|
DIE *CreateMemberDIE(CompileUnit *DW_Unit, const DIDerivedType &DT) {
|
|
|
|
DIE *MemberDie = new DIE(DT.getTag());
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string Name;
|
|
|
|
DT.getName(Name);
|
|
|
|
if (!Name.empty())
|
2009-01-20 21:02:02 +00:00
|
|
|
AddString(MemberDie, DW_AT_name, DW_FORM_string, Name);
|
|
|
|
|
|
|
|
AddType(DW_Unit, MemberDie, DT.getTypeDerivedFrom());
|
|
|
|
|
|
|
|
AddSourceLine(MemberDie, &DT);
|
|
|
|
|
2009-02-17 21:23:59 +00:00
|
|
|
uint64_t Size = DT.getSizeInBits();
|
|
|
|
uint64_t FieldSize = DT.getOriginalTypeSize();
|
|
|
|
|
|
|
|
if (Size != FieldSize) {
|
|
|
|
// Handle bitfield.
|
|
|
|
AddUInt(MemberDie, DW_AT_byte_size, 0, DT.getOriginalTypeSize() >> 3);
|
|
|
|
AddUInt(MemberDie, DW_AT_bit_size, 0, DT.getSizeInBits());
|
|
|
|
|
|
|
|
uint64_t Offset = DT.getOffsetInBits();
|
|
|
|
uint64_t FieldOffset = Offset;
|
|
|
|
uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
|
|
|
|
uint64_t HiMark = (Offset + FieldSize) & AlignMask;
|
|
|
|
FieldOffset = (HiMark - FieldSize);
|
|
|
|
Offset -= FieldOffset;
|
|
|
|
// Maybe we need to work from the other end.
|
|
|
|
if (TD->isLittleEndian()) Offset = FieldSize - (Offset + Size);
|
|
|
|
AddUInt(MemberDie, DW_AT_bit_offset, 0, Offset);
|
|
|
|
}
|
2009-01-20 21:02:02 +00:00
|
|
|
DIEBlock *Block = new DIEBlock();
|
|
|
|
AddUInt(Block, 0, DW_FORM_data1, DW_OP_plus_uconst);
|
|
|
|
AddUInt(Block, 0, DW_FORM_udata, DT.getOffsetInBits() >> 3);
|
|
|
|
AddBlock(MemberDie, DW_AT_data_member_location, 0, Block);
|
|
|
|
|
2009-01-21 00:08:04 +00:00
|
|
|
if (DT.isProtected())
|
|
|
|
AddUInt(MemberDie, DW_AT_accessibility, 0, DW_ACCESS_protected);
|
|
|
|
else if (DT.isPrivate())
|
|
|
|
AddUInt(MemberDie, DW_AT_accessibility, 0, DW_ACCESS_private);
|
|
|
|
|
2009-01-20 21:02:02 +00:00
|
|
|
return MemberDie;
|
|
|
|
}
|
|
|
|
|
2009-01-17 08:01:33 +00:00
|
|
|
/// CreateSubprogramDIE - Create new DIE using SP.
|
|
|
|
DIE *CreateSubprogramDIE(CompileUnit *DW_Unit,
|
2009-05-06 21:21:34 +00:00
|
|
|
const DISubprogram &SP,
|
2009-01-17 08:05:14 +00:00
|
|
|
bool IsConstructor = false) {
|
2009-01-17 08:01:33 +00:00
|
|
|
DIE *SPDie = new DIE(DW_TAG_subprogram);
|
2009-05-06 21:21:34 +00:00
|
|
|
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string Name;
|
|
|
|
SP.getName(Name);
|
2009-02-25 07:04:34 +00:00
|
|
|
AddString(SPDie, DW_AT_name, DW_FORM_string, Name);
|
2009-05-06 21:21:34 +00:00
|
|
|
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string LinkageName;
|
|
|
|
SP.getLinkageName(LinkageName);
|
2009-05-06 21:21:34 +00:00
|
|
|
|
2009-03-13 04:39:26 +00:00
|
|
|
if (!LinkageName.empty())
|
2009-05-06 21:21:34 +00:00
|
|
|
AddString(SPDie, DW_AT_MIPS_linkage_name, DW_FORM_string, LinkageName);
|
|
|
|
|
2009-01-17 08:01:33 +00:00
|
|
|
AddSourceLine(SPDie, &SP);
|
2009-01-05 18:59:44 +00:00
|
|
|
|
2009-01-17 08:01:33 +00:00
|
|
|
DICompositeType SPTy = SP.getType();
|
|
|
|
DIArray Args = SPTy.getTypeArray();
|
2009-05-06 21:21:34 +00:00
|
|
|
|
|
|
|
// Add prototyped tag, if C or ObjC.
|
|
|
|
unsigned Lang = SP.getCompileUnit().getLanguage();
|
|
|
|
if (Lang == DW_LANG_C99 || Lang == DW_LANG_C89 || Lang == DW_LANG_ObjC)
|
|
|
|
AddUInt(SPDie, DW_AT_prototyped, DW_FORM_flag, 1);
|
2009-01-17 08:01:33 +00:00
|
|
|
|
2009-01-05 18:59:44 +00:00
|
|
|
// Add Return Type.
|
2009-04-08 22:18:45 +00:00
|
|
|
unsigned SPTag = SPTy.getTag();
|
2009-02-27 18:05:21 +00:00
|
|
|
if (!IsConstructor) {
|
2009-04-08 22:18:45 +00:00
|
|
|
if (Args.isNull() || SPTag != DW_TAG_subroutine_type)
|
2009-02-27 18:05:21 +00:00
|
|
|
AddType(DW_Unit, SPDie, SPTy);
|
|
|
|
else
|
|
|
|
AddType(DW_Unit, SPDie, DIType(Args.getElement(0).getGV()));
|
|
|
|
}
|
2009-01-30 01:21:46 +00:00
|
|
|
|
2009-02-02 17:51:41 +00:00
|
|
|
if (!SP.isDefinition()) {
|
|
|
|
AddUInt(SPDie, DW_AT_declaration, DW_FORM_flag, 1);
|
2009-05-06 21:21:34 +00:00
|
|
|
// Add arguments. Do not add arguments for subprogram definition. They
|
|
|
|
// will be handled through RecordVariable.
|
2009-04-08 22:18:45 +00:00
|
|
|
if (SPTag == DW_TAG_subroutine_type)
|
2009-02-02 17:51:41 +00:00
|
|
|
for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
|
|
|
|
DIE *Arg = new DIE(DW_TAG_formal_parameter);
|
|
|
|
AddType(DW_Unit, Arg, DIType(Args.getElement(i).getGV()));
|
2009-05-06 21:21:34 +00:00
|
|
|
AddUInt(Arg, DW_AT_artificial, DW_FORM_flag, 1); // ??
|
2009-02-02 17:51:41 +00:00
|
|
|
SPDie->AddChild(Arg);
|
|
|
|
}
|
|
|
|
}
|
2009-01-30 01:21:46 +00:00
|
|
|
|
2009-01-15 19:26:23 +00:00
|
|
|
if (!SP.isLocalToUnit())
|
2009-01-30 01:21:46 +00:00
|
|
|
AddUInt(SPDie, DW_AT_external, DW_FORM_flag, 1);
|
2009-05-06 21:21:34 +00:00
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
// DW_TAG_inlined_subroutine may refer to this DIE.
|
|
|
|
DIE *&Slot = DW_Unit->getDieMapSlotFor(SP.getGV());
|
|
|
|
Slot = SPDie;
|
2009-01-17 08:01:33 +00:00
|
|
|
return SPDie;
|
2009-01-05 18:59:44 +00:00
|
|
|
}
|
|
|
|
|
2009-01-17 08:01:33 +00:00
|
|
|
/// FindCompileUnit - Get the compile unit for the given descriptor.
|
|
|
|
///
|
2009-05-05 04:55:56 +00:00
|
|
|
CompileUnit &FindCompileUnit(DICompileUnit Unit) const {
|
|
|
|
DenseMap<Value *, CompileUnit *>::const_iterator I =
|
|
|
|
CompileUnitMap.find(Unit.getGV());
|
|
|
|
assert(I != CompileUnitMap.end() && "Missing compile unit.");
|
|
|
|
return *I->second;
|
2009-01-05 22:35:52 +00:00
|
|
|
}
|
|
|
|
|
2009-01-13 23:54:55 +00:00
|
|
|
/// NewDbgScopeVariable - Create a new scope variable.
|
2009-01-08 02:33:41 +00:00
|
|
|
///
|
|
|
|
DIE *NewDbgScopeVariable(DbgVariable *DV, CompileUnit *Unit) {
|
|
|
|
// Get the descriptor.
|
2009-01-16 19:28:14 +00:00
|
|
|
const DIVariable &VD = DV->getVariable();
|
2009-01-08 02:33:41 +00:00
|
|
|
|
|
|
|
// Translate tag to proper Dwarf tag. The result variable is dropped for
|
|
|
|
// now.
|
|
|
|
unsigned Tag;
|
2009-01-16 19:28:14 +00:00
|
|
|
switch (VD.getTag()) {
|
2009-01-08 02:33:41 +00:00
|
|
|
case DW_TAG_return_variable: return NULL;
|
|
|
|
case DW_TAG_arg_variable: Tag = DW_TAG_formal_parameter; break;
|
|
|
|
case DW_TAG_auto_variable: // fall thru
|
|
|
|
default: Tag = DW_TAG_variable; break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Define variable debug information entry.
|
|
|
|
DIE *VariableDie = new DIE(Tag);
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string Name;
|
|
|
|
VD.getName(Name);
|
2009-02-25 07:04:34 +00:00
|
|
|
AddString(VariableDie, DW_AT_name, DW_FORM_string, Name);
|
2009-01-08 02:33:41 +00:00
|
|
|
|
|
|
|
// Add source line info if available.
|
2009-01-16 19:28:14 +00:00
|
|
|
AddSourceLine(VariableDie, &VD);
|
2009-01-08 02:33:41 +00:00
|
|
|
|
|
|
|
// Add variable type.
|
2009-01-16 19:28:14 +00:00
|
|
|
AddType(Unit, VariableDie, VD.getType());
|
2009-01-08 02:33:41 +00:00
|
|
|
|
|
|
|
// Add variable address.
|
|
|
|
MachineLocation Location;
|
|
|
|
Location.set(RI->getFrameRegister(*MF),
|
|
|
|
RI->getFrameIndexOffset(*MF, DV->getFrameIndex()));
|
|
|
|
AddAddress(VariableDie, DW_AT_location, Location);
|
|
|
|
|
|
|
|
return VariableDie;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getOrCreateScope - Returns the scope associated with the given descriptor.
|
|
|
|
///
|
|
|
|
DbgScope *getOrCreateScope(GlobalVariable *V) {
|
|
|
|
DbgScope *&Slot = DbgScopeMap[V];
|
2009-02-20 20:40:28 +00:00
|
|
|
if (Slot) return Slot;
|
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
DbgScope *Parent = NULL;
|
|
|
|
DIBlock Block(V);
|
2009-05-06 21:21:34 +00:00
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
// Don't create a new scope if we already created one for an inlined
|
|
|
|
// function.
|
|
|
|
DenseMap<const GlobalVariable *, DbgScope *>::iterator
|
|
|
|
II = AbstractInstanceRootMap.find(V);
|
|
|
|
if (II != AbstractInstanceRootMap.end())
|
|
|
|
return LexicalScopeStack.back();
|
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
if (!Block.isNull()) {
|
|
|
|
DIDescriptor ParentDesc = Block.getContext();
|
|
|
|
Parent =
|
|
|
|
ParentDesc.isNull() ? NULL : getOrCreateScope(ParentDesc.getGV());
|
2009-01-08 02:33:41 +00:00
|
|
|
}
|
2009-05-06 21:21:34 +00:00
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
Slot = new DbgScope(Parent, DIDescriptor(V));
|
2009-02-20 20:40:28 +00:00
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
if (Parent)
|
2009-02-20 20:40:28 +00:00
|
|
|
Parent->AddScope(Slot);
|
2009-04-15 00:10:26 +00:00
|
|
|
else
|
2009-02-20 20:40:28 +00:00
|
|
|
// First function is top level function.
|
2009-04-15 20:41:31 +00:00
|
|
|
FunctionDbgScope = Slot;
|
2009-02-20 20:40:28 +00:00
|
|
|
|
2009-01-08 02:33:41 +00:00
|
|
|
return Slot;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// ConstructDbgScope - Construct the components of a scope.
|
|
|
|
///
|
|
|
|
void ConstructDbgScope(DbgScope *ParentScope,
|
|
|
|
unsigned ParentStartID, unsigned ParentEndID,
|
|
|
|
DIE *ParentDie, CompileUnit *Unit) {
|
2009-05-07 19:46:24 +00:00
|
|
|
// Add variables to scope.
|
|
|
|
SmallVector<DbgVariable *, 8> &Variables = ParentScope->getVariables();
|
|
|
|
for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
|
|
|
|
DIE *VariableDie = NewDbgScopeVariable(Variables[i], Unit);
|
|
|
|
if (VariableDie) ParentDie->AddChild(VariableDie);
|
2009-01-08 02:33:41 +00:00
|
|
|
}
|
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
// Add concrete instances to scope.
|
|
|
|
SmallVector<DbgConcreteScope *, 8> &ConcreteInsts = ParentScope->getConcreteInsts();
|
|
|
|
for (unsigned i = 0, N = ConcreteInsts.size(); i < N; ++i) {
|
|
|
|
DbgConcreteScope *ConcreteInst = ConcreteInsts[i];
|
|
|
|
DIE *Die = ConcreteInst->getDie();
|
|
|
|
|
|
|
|
unsigned StartID = ConcreteInst->getStartLabelID();
|
|
|
|
unsigned EndID = ConcreteInst->getEndLabelID();
|
|
|
|
|
|
|
|
// Add the scope bounds.
|
|
|
|
if (StartID)
|
|
|
|
AddLabel(Die, DW_AT_low_pc, DW_FORM_addr,
|
|
|
|
DWLabel("label", StartID));
|
|
|
|
else
|
|
|
|
AddLabel(Die, DW_AT_low_pc, DW_FORM_addr,
|
|
|
|
DWLabel("func_begin", SubprogramCount));
|
|
|
|
|
|
|
|
if (EndID)
|
|
|
|
AddLabel(Die, DW_AT_high_pc, DW_FORM_addr,
|
|
|
|
DWLabel("label", EndID));
|
|
|
|
else
|
|
|
|
AddLabel(Die, DW_AT_high_pc, DW_FORM_addr,
|
|
|
|
DWLabel("func_end", SubprogramCount));
|
|
|
|
|
|
|
|
ParentDie->AddChild(Die);
|
|
|
|
}
|
|
|
|
|
2009-01-08 02:33:41 +00:00
|
|
|
// Add nested scopes.
|
2009-01-10 02:42:49 +00:00
|
|
|
SmallVector<DbgScope *, 4> &Scopes = ParentScope->getScopes();
|
2009-01-08 02:33:41 +00:00
|
|
|
for (unsigned j = 0, M = Scopes.size(); j < M; ++j) {
|
|
|
|
// Define the Scope debug information entry.
|
|
|
|
DbgScope *Scope = Scopes[j];
|
|
|
|
|
2009-01-12 18:41:00 +00:00
|
|
|
unsigned StartID = MMI->MappedLabel(Scope->getStartLabelID());
|
|
|
|
unsigned EndID = MMI->MappedLabel(Scope->getEndLabelID());
|
2009-01-08 02:33:41 +00:00
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
// Ignore empty scopes.
|
2009-01-08 02:33:41 +00:00
|
|
|
if (StartID == EndID && StartID != 0) continue;
|
2009-05-10 23:14:38 +00:00
|
|
|
|
|
|
|
// Do not ignore inlined scopes even if they don't have any variables or
|
|
|
|
// scopes.
|
|
|
|
if (Scope->getScopes().empty() && Scope->getVariables().empty() &&
|
|
|
|
Scope->getConcreteInsts().empty())
|
2009-04-13 17:02:03 +00:00
|
|
|
continue;
|
2009-01-08 02:33:41 +00:00
|
|
|
|
|
|
|
if (StartID == ParentStartID && EndID == ParentEndID) {
|
|
|
|
// Just add stuff to the parent scope.
|
|
|
|
ConstructDbgScope(Scope, ParentStartID, ParentEndID, ParentDie, Unit);
|
|
|
|
} else {
|
2009-05-10 23:14:38 +00:00
|
|
|
DIE *ScopeDie = new DIE(DW_TAG_lexical_block);
|
2009-05-01 08:25:13 +00:00
|
|
|
|
|
|
|
// Add the scope bounds.
|
|
|
|
if (StartID)
|
|
|
|
AddLabel(ScopeDie, DW_AT_low_pc, DW_FORM_addr,
|
|
|
|
DWLabel("label", StartID));
|
2009-04-15 00:10:26 +00:00
|
|
|
else
|
2009-05-01 08:25:13 +00:00
|
|
|
AddLabel(ScopeDie, DW_AT_low_pc, DW_FORM_addr,
|
|
|
|
DWLabel("func_begin", SubprogramCount));
|
|
|
|
|
|
|
|
if (EndID)
|
|
|
|
AddLabel(ScopeDie, DW_AT_high_pc, DW_FORM_addr,
|
|
|
|
DWLabel("label", EndID));
|
|
|
|
else
|
|
|
|
AddLabel(ScopeDie, DW_AT_high_pc, DW_FORM_addr,
|
|
|
|
DWLabel("func_end", SubprogramCount));
|
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
// Add the scope's contents.
|
2009-05-01 08:25:13 +00:00
|
|
|
ConstructDbgScope(Scope, StartID, EndID, ScopeDie, Unit);
|
|
|
|
ParentDie->AddChild(ScopeDie);
|
2009-01-08 02:33:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-15 20:41:31 +00:00
|
|
|
/// ConstructFunctionDbgScope - Construct the scope for the subprogram.
|
2009-01-08 02:33:41 +00:00
|
|
|
///
|
2009-04-15 20:41:31 +00:00
|
|
|
void ConstructFunctionDbgScope(DbgScope *RootScope) {
|
2009-01-08 02:33:41 +00:00
|
|
|
// Exit if there is no root scope.
|
|
|
|
if (!RootScope) return;
|
2009-01-15 18:25:17 +00:00
|
|
|
DIDescriptor Desc = RootScope->getDesc();
|
|
|
|
if (Desc.isNull())
|
|
|
|
return;
|
2009-01-08 02:33:41 +00:00
|
|
|
|
|
|
|
// Get the subprogram debug information entry.
|
2009-01-15 18:25:17 +00:00
|
|
|
DISubprogram SPD(Desc.getGV());
|
2009-01-08 02:33:41 +00:00
|
|
|
|
|
|
|
// Get the compile unit context.
|
2009-01-30 18:20:31 +00:00
|
|
|
CompileUnit *Unit = MainCU;
|
|
|
|
if (!Unit)
|
2009-05-05 04:55:56 +00:00
|
|
|
Unit = &FindCompileUnit(SPD.getCompileUnit());
|
2009-01-08 02:33:41 +00:00
|
|
|
|
|
|
|
// Get the subprogram die.
|
2009-01-12 22:58:14 +00:00
|
|
|
DIE *SPDie = Unit->getDieMapSlotFor(SPD.getGV());
|
2009-01-08 02:33:41 +00:00
|
|
|
assert(SPDie && "Missing subprogram descriptor");
|
|
|
|
|
|
|
|
// Add the function bounds.
|
|
|
|
AddLabel(SPDie, DW_AT_low_pc, DW_FORM_addr,
|
|
|
|
DWLabel("func_begin", SubprogramCount));
|
|
|
|
AddLabel(SPDie, DW_AT_high_pc, DW_FORM_addr,
|
|
|
|
DWLabel("func_end", SubprogramCount));
|
|
|
|
MachineLocation Location(RI->getFrameRegister(*MF));
|
|
|
|
AddAddress(SPDie, DW_AT_frame_base, Location);
|
|
|
|
|
|
|
|
ConstructDbgScope(RootScope, 0, 0, SPDie, Unit);
|
|
|
|
}
|
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
/// ConstructFunctionDbgScope - Construct the scope for the abstract debug
|
|
|
|
/// scope.
|
|
|
|
///
|
|
|
|
void ConstructAbstractDbgScope(DbgScope *AbsScope) {
|
|
|
|
// Exit if there is no root scope.
|
|
|
|
if (!AbsScope) return;
|
|
|
|
|
|
|
|
DIDescriptor Desc = AbsScope->getDesc();
|
|
|
|
if (Desc.isNull())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Get the subprogram debug information entry.
|
|
|
|
DISubprogram SPD(Desc.getGV());
|
|
|
|
|
|
|
|
// Get the compile unit context.
|
|
|
|
CompileUnit *Unit = MainCU;
|
|
|
|
if (!Unit)
|
|
|
|
Unit = &FindCompileUnit(SPD.getCompileUnit());
|
|
|
|
|
|
|
|
// Get the subprogram die.
|
|
|
|
DIE *SPDie = Unit->getDieMapSlotFor(SPD.getGV());
|
|
|
|
assert(SPDie && "Missing subprogram descriptor");
|
|
|
|
|
|
|
|
ConstructDbgScope(AbsScope, 0, 0, SPDie, Unit);
|
|
|
|
}
|
|
|
|
|
2009-01-08 02:33:41 +00:00
|
|
|
/// ConstructDefaultDbgScope - Construct a default scope for the subprogram.
|
|
|
|
///
|
|
|
|
void ConstructDefaultDbgScope(MachineFunction *MF) {
|
2009-02-25 07:04:34 +00:00
|
|
|
const char *FnName = MF->getFunction()->getNameStart();
|
|
|
|
if (MainCU) {
|
2009-04-09 21:49:15 +00:00
|
|
|
StringMap<DIE*> &Globals = MainCU->getGlobals();
|
|
|
|
StringMap<DIE*>::iterator GI = Globals.find(FnName);
|
2009-02-25 07:04:34 +00:00
|
|
|
if (GI != Globals.end()) {
|
|
|
|
DIE *SPDie = GI->second;
|
2009-01-08 02:33:41 +00:00
|
|
|
|
|
|
|
// Add the function bounds.
|
|
|
|
AddLabel(SPDie, DW_AT_low_pc, DW_FORM_addr,
|
|
|
|
DWLabel("func_begin", SubprogramCount));
|
|
|
|
AddLabel(SPDie, DW_AT_high_pc, DW_FORM_addr,
|
|
|
|
DWLabel("func_end", SubprogramCount));
|
|
|
|
|
|
|
|
MachineLocation Location(RI->getFrameRegister(*MF));
|
|
|
|
AddAddress(SPDie, DW_AT_frame_base, Location);
|
|
|
|
return;
|
|
|
|
}
|
2009-02-25 07:04:34 +00:00
|
|
|
} else {
|
|
|
|
for (unsigned i = 0, e = CompileUnits.size(); i != e; ++i) {
|
|
|
|
CompileUnit *Unit = CompileUnits[i];
|
2009-04-09 21:49:15 +00:00
|
|
|
StringMap<DIE*> &Globals = Unit->getGlobals();
|
|
|
|
StringMap<DIE*>::iterator GI = Globals.find(FnName);
|
2009-02-25 07:04:34 +00:00
|
|
|
if (GI != Globals.end()) {
|
|
|
|
DIE *SPDie = GI->second;
|
|
|
|
|
|
|
|
// Add the function bounds.
|
|
|
|
AddLabel(SPDie, DW_AT_low_pc, DW_FORM_addr,
|
|
|
|
DWLabel("func_begin", SubprogramCount));
|
|
|
|
AddLabel(SPDie, DW_AT_high_pc, DW_FORM_addr,
|
|
|
|
DWLabel("func_end", SubprogramCount));
|
|
|
|
|
|
|
|
MachineLocation Location(RI->getFrameRegister(*MF));
|
|
|
|
AddAddress(SPDie, DW_AT_frame_base, Location);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2009-01-08 02:33:41 +00:00
|
|
|
}
|
2009-02-25 07:04:34 +00:00
|
|
|
|
2009-01-08 02:33:41 +00:00
|
|
|
#if 0
|
|
|
|
// FIXME: This is causing an abort because C++ mangled names are compared
|
|
|
|
// with their unmangled counterparts. See PR2885. Don't do this assert.
|
|
|
|
assert(0 && "Couldn't find DIE for machine function!");
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// EmitInitial - Emit initial Dwarf declarations. This is necessary for cc
|
|
|
|
/// tools to recognize the object file contains Dwarf information.
|
|
|
|
void EmitInitial() {
|
|
|
|
// Check to see if we already emitted intial headers.
|
|
|
|
if (didInitial) return;
|
|
|
|
didInitial = true;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Dwarf sections base addresses.
|
2007-05-05 09:04:50 +00:00
|
|
|
if (TAI->doesDwarfRequireFrameSection()) {
|
2006-11-02 20:12:39 +00:00
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfFrameSection());
|
2007-05-13 17:30:11 +00:00
|
|
|
EmitLabel("section_debug_frame", 0);
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfInfoSection());
|
|
|
|
EmitLabel("section_info", 0);
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfAbbrevSection());
|
|
|
|
EmitLabel("section_abbrev", 0);
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfARangesSection());
|
|
|
|
EmitLabel("section_aranges", 0);
|
2009-01-26 22:32:51 +00:00
|
|
|
if (TAI->doesSupportMacInfoSection()) {
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfMacInfoSection());
|
|
|
|
EmitLabel("section_macinfo", 0);
|
|
|
|
}
|
2006-11-02 20:12:39 +00:00
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfLineSection());
|
|
|
|
EmitLabel("section_line", 0);
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfLocSection());
|
|
|
|
EmitLabel("section_loc", 0);
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfPubNamesSection());
|
|
|
|
EmitLabel("section_pubnames", 0);
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfStrSection());
|
|
|
|
EmitLabel("section_str", 0);
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfRangesSection());
|
|
|
|
EmitLabel("section_ranges", 0);
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2008-09-24 22:15:21 +00:00
|
|
|
Asm->SwitchToSection(TAI->getTextSection());
|
2006-11-02 20:12:39 +00:00
|
|
|
EmitLabel("text_begin", 0);
|
2008-09-24 22:16:16 +00:00
|
|
|
Asm->SwitchToSection(TAI->getDataSection());
|
2006-11-02 20:12:39 +00:00
|
|
|
EmitLabel("data_begin", 0);
|
2006-01-27 15:20:54 +00:00
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// EmitDIE - Recusively Emits a debug information entry.
|
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
void EmitDIE(DIE *Die) {
|
2006-11-02 20:12:39 +00:00
|
|
|
// Get the abbreviation for this DIE.
|
|
|
|
unsigned AbbrevNumber = Die->getAbbrevNumber();
|
|
|
|
const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL();
|
2006-11-02 20:12:39 +00:00
|
|
|
|
|
|
|
// Emit the code (index) for the abbreviation.
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitULEB128Bytes(AbbrevNumber);
|
2008-07-01 23:18:29 +00:00
|
|
|
|
2009-03-25 01:47:28 +00:00
|
|
|
if (Asm->isVerbose())
|
2008-07-01 23:18:29 +00:00
|
|
|
Asm->EOL(std::string("Abbrev [" +
|
|
|
|
utostr(AbbrevNumber) +
|
|
|
|
"] 0x" + utohexstr(Die->getOffset()) +
|
|
|
|
":0x" + utohexstr(Die->getSize()) + " " +
|
|
|
|
TagString(Abbrev->getTag())));
|
|
|
|
else
|
|
|
|
Asm->EOL();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2008-06-24 21:44:59 +00:00
|
|
|
SmallVector<DIEValue*, 32> &Values = Die->getValues();
|
|
|
|
const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit the DIE attribute values.
|
|
|
|
for (unsigned i = 0, N = Values.size(); i < N; ++i) {
|
|
|
|
unsigned Attr = AbbrevData[i].getAttribute();
|
|
|
|
unsigned Form = AbbrevData[i].getForm();
|
|
|
|
assert(Form && "Too many attributes for DIE (check abbreviation)");
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
switch (Attr) {
|
2009-05-10 23:14:38 +00:00
|
|
|
case DW_AT_sibling:
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt32(Die->SiblingOffset());
|
2006-01-17 17:31:53 +00:00
|
|
|
break;
|
2009-05-10 23:14:38 +00:00
|
|
|
case DW_AT_abstract_origin: {
|
|
|
|
DIEntry *E = cast<DIEntry>(Values[i]);
|
|
|
|
DIE *Origin = E->getEntry();
|
|
|
|
unsigned Addr =
|
|
|
|
CompileUnitOffsets[Die->getAbstractCompileUnit()] +
|
|
|
|
Origin->getOffset();
|
|
|
|
|
|
|
|
Asm->EmitInt32(Addr);
|
|
|
|
break;
|
2006-01-17 17:31:53 +00:00
|
|
|
}
|
2009-05-10 23:14:38 +00:00
|
|
|
default:
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit an attribute using the defined form.
|
|
|
|
Values[i]->EmitValue(*this, Form);
|
|
|
|
break;
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EOL(AttributeString(Attr));
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit the DIE children if any.
|
|
|
|
if (Abbrev->getChildrenFlag() == DW_CHILDREN_yes) {
|
|
|
|
const std::vector<DIE *> &Children = Die->getChildren();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-05-08 20:38:02 +00:00
|
|
|
for (unsigned j = 0, M = Children.size(); j < M; ++j)
|
2006-11-02 20:12:39 +00:00
|
|
|
EmitDIE(Children[j]);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt8(0); Asm->EOL("End Of Children Mark");
|
2006-01-17 17:31:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// SizeAndOffsetDie - Compute the size and offset of a DIE.
|
|
|
|
///
|
|
|
|
unsigned SizeAndOffsetDie(DIE *Die, unsigned Offset, bool Last) {
|
|
|
|
// Get the children.
|
|
|
|
const std::vector<DIE *> &Children = Die->getChildren();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// If not last sibling and has children then add sibling offset attribute.
|
|
|
|
if (!Last && !Children.empty()) Die->AddSiblingOffset();
|
2006-01-04 22:28:25 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Record the abbreviation.
|
|
|
|
AssignAbbrevNumber(Die->getAbbrev());
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Get the abbreviation for this DIE.
|
|
|
|
unsigned AbbrevNumber = Die->getAbbrevNumber();
|
|
|
|
const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
|
2006-01-04 22:28:25 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Set DIE offset
|
|
|
|
Die->setOffset(Offset);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Start the size with the size of abbreviation code.
|
2008-08-16 12:57:46 +00:00
|
|
|
Offset += TargetAsmInfo::getULEB128Size(AbbrevNumber);
|
|
|
|
|
2008-06-24 21:44:59 +00:00
|
|
|
const SmallVector<DIEValue*, 32> &Values = Die->getValues();
|
|
|
|
const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Size the DIE attribute values.
|
|
|
|
for (unsigned i = 0, N = Values.size(); i < N; ++i) {
|
|
|
|
// Size attribute value.
|
|
|
|
Offset += Values[i]->SizeOf(*this, AbbrevData[i].getForm());
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Size the DIE children if any.
|
|
|
|
if (!Children.empty()) {
|
|
|
|
assert(Abbrev->getChildrenFlag() == DW_CHILDREN_yes &&
|
|
|
|
"Children flag not set");
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
for (unsigned j = 0, M = Children.size(); j < M; ++j) {
|
|
|
|
Offset = SizeAndOffsetDie(Children[j], Offset, (j + 1) == M);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// End of children marker.
|
|
|
|
Offset += sizeof(int8_t);
|
|
|
|
}
|
2006-01-20 20:34:06 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
Die->setSize(Offset - Die->getOffset());
|
|
|
|
return Offset;
|
2006-03-23 18:07:55 +00:00
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// SizeAndOffsets - Compute the size and offset of all the DIEs.
|
|
|
|
///
|
|
|
|
void SizeAndOffsets() {
|
2009-05-08 21:03:15 +00:00
|
|
|
// Compute size of compile unit header.
|
|
|
|
static unsigned Offset =
|
|
|
|
sizeof(int32_t) + // Length of Compilation Unit Info
|
|
|
|
sizeof(int16_t) + // DWARF version number
|
|
|
|
sizeof(int32_t) + // Offset Into Abbrev. Section
|
|
|
|
sizeof(int8_t); // Pointer Size (in bytes)
|
|
|
|
|
2006-11-09 14:52:14 +00:00
|
|
|
// Process base compile unit.
|
2009-01-30 18:20:31 +00:00
|
|
|
if (MainCU) {
|
|
|
|
SizeAndOffsetDie(MainCU->getDie(), Offset, true);
|
2009-05-08 21:03:15 +00:00
|
|
|
CompileUnitOffsets[MainCU] = 0;
|
2009-01-30 18:20:31 +00:00
|
|
|
return;
|
|
|
|
}
|
2009-05-08 21:03:15 +00:00
|
|
|
|
|
|
|
// Process all compile units.
|
|
|
|
unsigned PrevOffset = 0;
|
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
for (unsigned i = 0, e = CompileUnits.size(); i != e; ++i) {
|
|
|
|
CompileUnit *Unit = CompileUnits[i];
|
2009-05-08 21:03:15 +00:00
|
|
|
CompileUnitOffsets[Unit] = PrevOffset;
|
|
|
|
PrevOffset += SizeAndOffsetDie(Unit->getDie(), Offset, true)
|
|
|
|
+ sizeof(int32_t); // FIXME - extra pad for gdb bug.
|
2009-01-12 23:05:55 +00:00
|
|
|
}
|
2006-03-28 14:58:32 +00:00
|
|
|
}
|
2006-08-21 21:20:18 +00:00
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
/// EmitDebugInfo / EmitDebugInfoPerCU - Emit the debug info section.
|
2006-11-02 20:12:39 +00:00
|
|
|
///
|
2009-02-25 07:04:34 +00:00
|
|
|
void EmitDebugInfoPerCU(CompileUnit *Unit) {
|
|
|
|
DIE *Die = Unit->getDie();
|
|
|
|
// Emit the compile units header.
|
|
|
|
EmitLabel("info_begin", Unit->getID());
|
|
|
|
// Emit size of content not including length itself
|
|
|
|
unsigned ContentSize = Die->getSize() +
|
|
|
|
sizeof(int16_t) + // DWARF version number
|
|
|
|
sizeof(int32_t) + // Offset Into Abbrev. Section
|
|
|
|
sizeof(int8_t) + // Pointer Size (in bytes)
|
|
|
|
sizeof(int32_t); // FIXME - extra pad for gdb bug.
|
|
|
|
|
|
|
|
Asm->EmitInt32(ContentSize); Asm->EOL("Length of Compilation Unit Info");
|
|
|
|
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(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
|
|
|
|
|
|
|
|
EmitDIE(Die);
|
|
|
|
// FIXME - extra padding for gdb bug.
|
|
|
|
Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
|
|
|
|
Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
|
|
|
|
Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
|
|
|
|
Asm->EmitInt8(0); Asm->EOL("Extra Pad For GDB");
|
|
|
|
EmitLabel("info_end", Unit->getID());
|
|
|
|
|
|
|
|
Asm->EOL();
|
|
|
|
}
|
|
|
|
|
2007-03-07 08:25:02 +00:00
|
|
|
void EmitDebugInfo() {
|
2006-11-02 20:12:39 +00:00
|
|
|
// Start debug info section.
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfInfoSection());
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
if (MainCU) {
|
|
|
|
EmitDebugInfoPerCU(MainCU);
|
|
|
|
return;
|
2009-01-12 23:05:55 +00:00
|
|
|
}
|
2009-02-25 07:04:34 +00:00
|
|
|
|
|
|
|
for (unsigned i = 0, e = CompileUnits.size(); i != e; ++i)
|
|
|
|
EmitDebugInfoPerCU(CompileUnits[i]);
|
2006-02-23 16:58:18 +00:00
|
|
|
}
|
2006-11-02 20:12:39 +00:00
|
|
|
|
|
|
|
/// EmitAbbreviations - Emit the abbreviation section.
|
|
|
|
///
|
|
|
|
void EmitAbbreviations() const {
|
|
|
|
// Check to see if it is worth the effort.
|
|
|
|
if (!Abbreviations.empty()) {
|
|
|
|
// Start the debug abbrev section.
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfAbbrevSection());
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
EmitLabel("abbrev_begin", 0);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// For each abbrevation.
|
|
|
|
for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
|
|
|
|
// Get abbreviation data
|
|
|
|
const DIEAbbrev *Abbrev = Abbreviations[i];
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit the abbrevations code (base 1 index.)
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitULEB128Bytes(Abbrev->getNumber());
|
|
|
|
Asm->EOL("Abbreviation Code");
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit the abbreviations data.
|
|
|
|
Abbrev->Emit(*this);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL();
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-22 18:22:42 +00:00
|
|
|
// Mark end of abbreviations.
|
2007-02-22 18:48:52 +00:00
|
|
|
Asm->EmitULEB128Bytes(0); Asm->EOL("EOM(3)");
|
2007-02-22 18:22:42 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
EmitLabel("abbrev_end", 0);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL();
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2006-04-07 16:34:46 +00:00
|
|
|
}
|
2006-03-23 18:07:55 +00:00
|
|
|
|
2008-07-20 00:11:19 +00:00
|
|
|
/// EmitEndOfLineMatrix - Emit the last address of the section and the end of
|
|
|
|
/// the line matrix.
|
2008-08-16 12:57:46 +00:00
|
|
|
///
|
2008-07-20 00:11:19 +00:00
|
|
|
void EmitEndOfLineMatrix(unsigned SectionEnd) {
|
|
|
|
// Define last address of section.
|
|
|
|
Asm->EmitInt8(0); Asm->EOL("Extended Op");
|
|
|
|
Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
|
|
|
|
Asm->EmitInt8(DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
|
|
|
|
EmitReference("section_end", SectionEnd); Asm->EOL("Section end label");
|
|
|
|
|
|
|
|
// Mark end of matrix.
|
|
|
|
Asm->EmitInt8(0); Asm->EOL("DW_LNE_end_sequence");
|
|
|
|
Asm->EmitULEB128Bytes(1); Asm->EOL();
|
|
|
|
Asm->EmitInt8(1); Asm->EOL();
|
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// EmitDebugLines - Emit source line information.
|
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
void EmitDebugLines() {
|
2008-07-20 00:11:19 +00:00
|
|
|
// If the target is using .loc/.file, the assembler will be emitting the
|
|
|
|
// .debug_line table automatically.
|
|
|
|
if (TAI->hasDotLocAndDotFile())
|
2007-09-24 21:43:52 +00:00
|
|
|
return;
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// 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).
|
|
|
|
const int MaxLineDelta = 255 + MinLineDelta;
|
2006-02-22 19:02:11 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Start the dwarf line section.
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfLineSection());
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Construct the section header.
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-12-06 17:43:18 +00:00
|
|
|
EmitDifference("line_end", 0, "line_begin", 0, true);
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EOL("Length of Source Line Info");
|
2006-11-02 20:12:39 +00:00
|
|
|
EmitLabel("line_begin", 0);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt16(DWARF_VERSION); Asm->EOL("DWARF version number");
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-12-06 17:43:18 +00:00
|
|
|
EmitDifference("line_prolog_end", 0, "line_prolog_begin", 0, true);
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EOL("Prolog Length");
|
2006-11-02 20:12:39 +00:00
|
|
|
EmitLabel("line_prolog_begin", 0);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt8(1); Asm->EOL("Minimum Instruction Length");
|
2006-03-23 18:07:55 +00:00
|
|
|
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt8(1); Asm->EOL("Default is_stmt_start flag");
|
2006-03-23 18:07:55 +00:00
|
|
|
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt8(MinLineDelta); Asm->EOL("Line Base Value (Special Opcodes)");
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt8(MaxLineDelta); Asm->EOL("Line Range Value (Special Opcodes)");
|
2006-03-23 18:07:55 +00:00
|
|
|
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt8(-MinLineDelta); Asm->EOL("Special Opcode Base");
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Line number standard opcode encodings argument count
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt8(0); Asm->EOL("DW_LNS_copy arg count");
|
|
|
|
Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_pc arg count");
|
|
|
|
Asm->EmitInt8(1); Asm->EOL("DW_LNS_advance_line arg count");
|
|
|
|
Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_file arg count");
|
|
|
|
Asm->EmitInt8(1); Asm->EOL("DW_LNS_set_column arg count");
|
|
|
|
Asm->EmitInt8(0); Asm->EOL("DW_LNS_negate_stmt arg count");
|
|
|
|
Asm->EmitInt8(0); Asm->EOL("DW_LNS_set_basic_block arg count");
|
|
|
|
Asm->EmitInt8(0); Asm->EOL("DW_LNS_const_add_pc arg count");
|
|
|
|
Asm->EmitInt8(1); Asm->EOL("DW_LNS_fixed_advance_pc arg count");
|
2006-03-23 18:07:55 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit directories.
|
2009-02-25 07:04:34 +00:00
|
|
|
for (unsigned DI = 1, DE = getNumSourceDirectories()+1; DI != DE; ++DI) {
|
|
|
|
Asm->EmitString(getSourceDirectoryName(DI));
|
|
|
|
Asm->EOL("Directory");
|
2006-03-23 18:07:55 +00:00
|
|
|
}
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt8(0); Asm->EOL("End of directories");
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit files.
|
2009-02-25 07:04:34 +00:00
|
|
|
for (unsigned SI = 1, SE = getNumSourceIds()+1; SI != SE; ++SI) {
|
|
|
|
// Remember source id starts at 1.
|
2009-03-10 21:59:25 +00:00
|
|
|
std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(SI);
|
2009-02-25 07:04:34 +00:00
|
|
|
Asm->EmitString(getSourceFileName(Id.second));
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EOL("Source");
|
2009-02-25 07:04:34 +00:00
|
|
|
Asm->EmitULEB128Bytes(Id.first);
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EOL("Directory #");
|
|
|
|
Asm->EmitULEB128Bytes(0);
|
|
|
|
Asm->EOL("Mod date");
|
|
|
|
Asm->EmitULEB128Bytes(0);
|
|
|
|
Asm->EOL("File size");
|
2006-03-23 18:07:55 +00:00
|
|
|
}
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt8(0); Asm->EOL("End of files");
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
EmitLabel("line_prolog_end", 0);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// A sequence for each text section.
|
2008-07-20 00:11:19 +00:00
|
|
|
unsigned SecSrcLinesSize = SectionSourceLines.size();
|
|
|
|
|
|
|
|
for (unsigned j = 0; j < SecSrcLinesSize; ++j) {
|
2006-11-02 20:12:39 +00:00
|
|
|
// Isolate current sections line info.
|
2009-01-12 22:54:42 +00:00
|
|
|
const std::vector<SrcLineInfo> &LineInfos = SectionSourceLines[j];
|
2008-07-01 23:18:29 +00:00
|
|
|
|
2009-03-25 01:47:28 +00:00
|
|
|
if (Asm->isVerbose()) {
|
2008-09-24 22:15:21 +00:00
|
|
|
const Section* S = SectionMap[j + 1];
|
2009-02-25 07:04:34 +00:00
|
|
|
O << '\t' << TAI->getCommentString() << " Section"
|
|
|
|
<< S->getName() << '\n';
|
2008-09-24 22:15:21 +00:00
|
|
|
} else
|
2008-07-01 23:18:29 +00:00
|
|
|
Asm->EOL();
|
2006-03-23 18:07:55 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Dwarf assumes we start with first line of first source file.
|
|
|
|
unsigned Source = 1;
|
|
|
|
unsigned Line = 1;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Construct rows of the address, source, line, column matrix.
|
|
|
|
for (unsigned i = 0, N = LineInfos.size(); i < N; ++i) {
|
2009-01-12 22:54:42 +00:00
|
|
|
const SrcLineInfo &LineInfo = LineInfos[i];
|
2007-01-26 21:22:28 +00:00
|
|
|
unsigned LabelID = MMI->MappedLabel(LineInfo.getLabelID());
|
2006-11-07 19:33:46 +00:00
|
|
|
if (!LabelID) continue;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-03-25 01:47:28 +00:00
|
|
|
if (!Asm->isVerbose())
|
2008-07-01 23:18:29 +00:00
|
|
|
Asm->EOL();
|
2009-02-25 07:04:34 +00:00
|
|
|
else {
|
|
|
|
std::pair<unsigned, unsigned> SourceID =
|
2009-03-10 21:59:25 +00:00
|
|
|
getSourceDirectoryAndFileIds(LineInfo.getSourceID());
|
2009-02-25 07:04:34 +00:00
|
|
|
O << '\t' << TAI->getCommentString() << ' '
|
|
|
|
<< getSourceDirectoryName(SourceID.first) << ' '
|
|
|
|
<< getSourceFileName(SourceID.second)
|
|
|
|
<<" :" << utostr_32(LineInfo.getLine()) << '\n';
|
|
|
|
}
|
2006-03-23 18:07:55 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Define the line address.
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt8(0); Asm->EOL("Extended Op");
|
2007-09-27 23:12:31 +00:00
|
|
|
Asm->EmitInt8(TD->getPointerSize() + 1); Asm->EOL("Op size");
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt8(DW_LNE_set_address); Asm->EOL("DW_LNE_set_address");
|
2007-02-21 22:48:45 +00:00
|
|
|
EmitReference("label", LabelID); Asm->EOL("Location label");
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// If change of source, then switch to the new source.
|
|
|
|
if (Source != LineInfo.getSourceID()) {
|
|
|
|
Source = LineInfo.getSourceID();
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt8(DW_LNS_set_file); Asm->EOL("DW_LNS_set_file");
|
|
|
|
Asm->EmitULEB128Bytes(Source); Asm->EOL("New Source");
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// If change of line.
|
|
|
|
if (Line != LineInfo.getLine()) {
|
|
|
|
// Determine offset.
|
|
|
|
int Offset = LineInfo.getLine() - Line;
|
|
|
|
int Delta = Offset - MinLineDelta;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Update line.
|
|
|
|
Line = LineInfo.getLine();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// If delta is small enough and in range...
|
|
|
|
if (Delta >= 0 && Delta < (MaxLineDelta - 1)) {
|
|
|
|
// ... then use fast opcode.
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt8(Delta - MinLineDelta); Asm->EOL("Line Delta");
|
2006-11-02 20:12:39 +00:00
|
|
|
} else {
|
|
|
|
// ... otherwise use long hand.
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt8(DW_LNS_advance_line); Asm->EOL("DW_LNS_advance_line");
|
|
|
|
Asm->EmitSLEB128Bytes(Offset); Asm->EOL("Line Offset");
|
|
|
|
Asm->EmitInt8(DW_LNS_copy); Asm->EOL("DW_LNS_copy");
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Copy the previous row (different address or source)
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt8(DW_LNS_copy); Asm->EOL("DW_LNS_copy");
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
|
|
|
}
|
2006-01-04 13:52:30 +00:00
|
|
|
|
2008-07-20 00:11:19 +00:00
|
|
|
EmitEndOfLineMatrix(j + 1);
|
2006-01-17 17:31:53 +00:00
|
|
|
}
|
2008-07-20 00:11:19 +00:00
|
|
|
|
|
|
|
if (SecSrcLinesSize == 0)
|
|
|
|
// Because we're emitting a debug_line section, we still need a line
|
|
|
|
// table. The linker and friends expect it to exist. If there's nothing to
|
|
|
|
// put into it, emit an empty table.
|
|
|
|
EmitEndOfLineMatrix(1);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
EmitLabel("line_end", 0);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL();
|
2006-01-17 17:31:53 +00:00
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-05-13 17:30:11 +00:00
|
|
|
/// EmitCommonDebugFrame - Emit common frame info into a debug frame section.
|
2006-11-02 20:12:39 +00:00
|
|
|
///
|
2007-05-13 17:30:11 +00:00
|
|
|
void EmitCommonDebugFrame() {
|
2007-05-05 09:04:50 +00:00
|
|
|
if (!TAI->doesDwarfRequireFrameSection())
|
2006-11-02 20:12:39 +00:00
|
|
|
return;
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
int stackGrowth =
|
|
|
|
Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
|
|
|
|
TargetFrameInfo::StackGrowsUp ?
|
2007-09-27 23:12:31 +00:00
|
|
|
TD->getPointerSize() : -TD->getPointerSize();
|
2006-03-23 18:07:55 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Start the dwarf frame section.
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfFrameSection());
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2007-05-13 17:30:11 +00:00
|
|
|
EmitLabel("debug_frame_common", 0);
|
|
|
|
EmitDifference("debug_frame_common_end", 0,
|
|
|
|
"debug_frame_common_begin", 0, true);
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EOL("Length of Common Information Entry");
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2007-05-13 17:30:11 +00:00
|
|
|
EmitLabel("debug_frame_common_begin", 0);
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt32((int)DW_CIE_ID);
|
|
|
|
Asm->EOL("CIE Identifier Tag");
|
|
|
|
Asm->EmitInt8(DW_CIE_VERSION);
|
|
|
|
Asm->EOL("CIE Version");
|
|
|
|
Asm->EmitString("");
|
|
|
|
Asm->EOL("CIE Augmentation");
|
|
|
|
Asm->EmitULEB128Bytes(1);
|
|
|
|
Asm->EOL("CIE Code Alignment Factor");
|
|
|
|
Asm->EmitSLEB128Bytes(stackGrowth);
|
2008-08-16 12:57:46 +00:00
|
|
|
Asm->EOL("CIE Data Alignment Factor");
|
2007-11-13 19:13:01 +00:00
|
|
|
Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), false));
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EOL("CIE RA Column");
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-01-24 18:45:13 +00:00
|
|
|
std::vector<MachineMove> Moves;
|
2006-11-02 20:12:39 +00:00
|
|
|
RI->getInitialFrameState(Moves);
|
2007-05-12 22:36:25 +00:00
|
|
|
|
2007-11-13 19:13:01 +00:00
|
|
|
EmitFrameMoves(NULL, 0, Moves, false);
|
2006-11-02 20:12:39 +00:00
|
|
|
|
2008-02-29 19:36:59 +00:00
|
|
|
Asm->EmitAlignment(2, 0, 0, false);
|
2007-05-13 17:30:11 +00:00
|
|
|
EmitLabel("debug_frame_common_end", 0);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL();
|
2006-01-17 17:31:53 +00:00
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// EmitFunctionDebugFrame - Emit per function frame info into a debug frame
|
|
|
|
/// section.
|
2007-05-13 17:30:11 +00:00
|
|
|
void EmitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo) {
|
2007-05-05 09:04:50 +00:00
|
|
|
if (!TAI->doesDwarfRequireFrameSection())
|
2006-11-07 06:36:36 +00:00
|
|
|
return;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Start the dwarf frame section.
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfFrameSection());
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-05-13 17:30:11 +00:00
|
|
|
EmitDifference("debug_frame_end", DebugFrameInfo.Number,
|
|
|
|
"debug_frame_begin", DebugFrameInfo.Number, true);
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EOL("Length of Frame Information Entry");
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-05-13 17:30:11 +00:00
|
|
|
EmitLabel("debug_frame_begin", DebugFrameInfo.Number);
|
2007-03-07 02:47:57 +00:00
|
|
|
|
2007-05-13 17:30:11 +00:00
|
|
|
EmitSectionOffset("debug_frame_common", "section_debug_frame",
|
|
|
|
0, 0, true, false);
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EOL("FDE CIE offset");
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2007-05-13 17:30:11 +00:00
|
|
|
EmitReference("func_begin", DebugFrameInfo.Number);
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EOL("FDE initial location");
|
2007-05-13 17:30:11 +00:00
|
|
|
EmitDifference("func_end", DebugFrameInfo.Number,
|
|
|
|
"func_begin", DebugFrameInfo.Number);
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EOL("FDE address range");
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-01-17 08:01:33 +00:00
|
|
|
EmitFrameMoves("func_begin", DebugFrameInfo.Number, DebugFrameInfo.Moves,
|
2009-01-17 08:05:14 +00:00
|
|
|
false);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2008-02-29 19:36:59 +00:00
|
|
|
Asm->EmitAlignment(2, 0, 0, false);
|
2007-05-13 17:30:11 +00:00
|
|
|
EmitLabel("debug_frame_end", DebugFrameInfo.Number);
|
2006-11-02 20:12:39 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL();
|
2006-01-17 17:31:53 +00:00
|
|
|
}
|
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
void EmitDebugPubNamesPerCU(CompileUnit *Unit) {
|
|
|
|
EmitDifference("pubnames_end", Unit->getID(),
|
|
|
|
"pubnames_begin", Unit->getID(), true);
|
|
|
|
Asm->EOL("Length of Public Names Info");
|
2009-01-12 23:05:55 +00:00
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
EmitLabel("pubnames_begin", Unit->getID());
|
2009-01-12 23:05:55 +00:00
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
Asm->EmitInt16(DWARF_VERSION); Asm->EOL("DWARF Version");
|
2009-01-12 23:05:55 +00:00
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
EmitSectionOffset("info_begin", "section_info",
|
|
|
|
Unit->getID(), 0, true, false);
|
|
|
|
Asm->EOL("Offset of Compilation Unit Info");
|
2009-01-12 23:05:55 +00:00
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
EmitDifference("info_end", Unit->getID(), "info_begin", Unit->getID(),
|
|
|
|
true);
|
|
|
|
Asm->EOL("Compilation Unit Length");
|
2009-01-12 23:05:55 +00:00
|
|
|
|
2009-04-09 21:49:15 +00:00
|
|
|
StringMap<DIE*> &Globals = Unit->getGlobals();
|
2009-04-09 23:51:31 +00:00
|
|
|
for (StringMap<DIE*>::const_iterator
|
2009-04-09 21:49:15 +00:00
|
|
|
GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
|
2009-04-09 23:51:31 +00:00
|
|
|
const char *Name = GI->getKeyData();
|
2009-02-25 07:04:34 +00:00
|
|
|
DIE * Entity = GI->second;
|
2009-01-12 23:05:55 +00:00
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
Asm->EmitInt32(Entity->getOffset()); Asm->EOL("DIE offset");
|
2009-04-09 23:51:31 +00:00
|
|
|
Asm->EmitString(Name, strlen(Name)); Asm->EOL("External Name");
|
2009-02-25 07:04:34 +00:00
|
|
|
}
|
2009-01-12 23:05:55 +00:00
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
Asm->EmitInt32(0); Asm->EOL("End Mark");
|
|
|
|
EmitLabel("pubnames_end", Unit->getID());
|
2009-01-12 23:05:55 +00:00
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
Asm->EOL();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// EmitDebugPubNames - Emit visible names into a debug pubnames section.
|
|
|
|
///
|
|
|
|
void EmitDebugPubNames() {
|
|
|
|
// Start the dwarf pubnames section.
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfPubNamesSection());
|
|
|
|
|
|
|
|
if (MainCU) {
|
|
|
|
EmitDebugPubNamesPerCU(MainCU);
|
|
|
|
return;
|
2006-04-07 16:34:46 +00:00
|
|
|
}
|
2009-02-25 07:04:34 +00:00
|
|
|
|
|
|
|
for (unsigned i = 0, e = CompileUnits.size(); i != e; ++i)
|
|
|
|
EmitDebugPubNamesPerCU(CompileUnits[i]);
|
2006-04-07 16:34:46 +00:00
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// EmitDebugStr - Emit visible names into a debug str section.
|
|
|
|
///
|
|
|
|
void EmitDebugStr() {
|
|
|
|
// Check to see if it is worth the effort.
|
|
|
|
if (!StringPool.empty()) {
|
|
|
|
// Start the dwarf str section.
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfStrSection());
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// For each of strings in the string pool.
|
|
|
|
for (unsigned StringID = 1, N = StringPool.size();
|
|
|
|
StringID <= N; ++StringID) {
|
|
|
|
// Emit a label for reference from debug information entries.
|
|
|
|
EmitLabel("string", StringID);
|
|
|
|
// Emit the string itself.
|
|
|
|
const std::string &String = StringPool[StringID];
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EmitString(String); Asm->EOL();
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL();
|
2006-01-17 17:31:53 +00:00
|
|
|
}
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// EmitDebugLoc - Emit visible names into a debug loc section.
|
|
|
|
///
|
|
|
|
void EmitDebugLoc() {
|
|
|
|
// Start the dwarf loc section.
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfLocSection());
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL();
|
2006-01-17 17:31:53 +00:00
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// EmitDebugARanges - Emit visible names into a debug aranges section.
|
|
|
|
///
|
|
|
|
void EmitDebugARanges() {
|
|
|
|
// Start the dwarf aranges section.
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfARangesSection());
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// FIXME - Mock up
|
2008-09-26 00:28:12 +00:00
|
|
|
#if 0
|
2008-08-16 12:57:46 +00:00
|
|
|
CompileUnit *Unit = GetBaseCompileUnit();
|
|
|
|
|
2006-11-09 14:52:14 +00:00
|
|
|
// Don't include size of length
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt32(0x1c); Asm->EOL("Length of Address Ranges Info");
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt16(DWARF_VERSION); Asm->EOL("Dwarf Version");
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-09 14:52:14 +00:00
|
|
|
EmitReference("info_begin", Unit->getID());
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EOL("Offset of Compilation Unit Info");
|
2006-11-02 20:12:39 +00:00
|
|
|
|
2007-09-27 23:12:31 +00:00
|
|
|
Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Size of Address");
|
2006-11-02 20:12:39 +00:00
|
|
|
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt8(0); Asm->EOL("Size of Segment Descriptor");
|
2006-11-02 20:12:39 +00:00
|
|
|
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt16(0); Asm->EOL("Pad (1)");
|
|
|
|
Asm->EmitInt16(0); Asm->EOL("Pad (2)");
|
2006-11-02 20:12:39 +00:00
|
|
|
|
2006-11-09 14:52:14 +00:00
|
|
|
// Range 1
|
2007-01-25 15:12:02 +00:00
|
|
|
EmitReference("text_begin", 0); Asm->EOL("Address");
|
|
|
|
EmitDifference("text_end", 0, "text_begin", 0, true); Asm->EOL("Length");
|
2006-11-02 20:12:39 +00:00
|
|
|
|
2007-01-25 15:12:02 +00:00
|
|
|
Asm->EmitInt32(0); Asm->EOL("EOM (1)");
|
|
|
|
Asm->EmitInt32(0); Asm->EOL("EOM (2)");
|
2008-09-26 00:28:12 +00:00
|
|
|
#endif
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL();
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// EmitDebugRanges - Emit visible names into a debug ranges section.
|
|
|
|
///
|
|
|
|
void EmitDebugRanges() {
|
|
|
|
// Start the dwarf ranges section.
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfRangesSection());
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL();
|
2006-01-17 17:31:53 +00:00
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// EmitDebugMacInfo - Emit visible names into a debug macinfo section.
|
|
|
|
///
|
|
|
|
void EmitDebugMacInfo() {
|
2009-01-26 22:32:51 +00:00
|
|
|
if (TAI->doesSupportMacInfoSection()) {
|
|
|
|
// Start the dwarf macinfo section.
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfMacInfoSection());
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-01-26 22:32:51 +00:00
|
|
|
Asm->EOL();
|
|
|
|
}
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2009-04-13 17:02:03 +00:00
|
|
|
/// EmitDebugInlineInfo - Emit inline info using following format.
|
|
|
|
/// Section Header:
|
|
|
|
/// 1. length of section
|
|
|
|
/// 2. Dwarf version number
|
|
|
|
/// 3. address size.
|
|
|
|
///
|
|
|
|
/// Entries (one "entry" for each function that was inlined):
|
|
|
|
///
|
|
|
|
/// 1. offset into __debug_str section for MIPS linkage name, if exists;
|
|
|
|
/// otherwise offset into __debug_str for regular function name.
|
|
|
|
/// 2. offset into __debug_str section for regular function name.
|
|
|
|
/// 3. an unsigned LEB128 number indicating the number of distinct inlining
|
|
|
|
/// instances for the function.
|
|
|
|
///
|
|
|
|
/// The rest of the entry consists of a {die_offset, low_pc} pair for each
|
|
|
|
/// inlined instance; the die_offset points to the inlined_subroutine die in
|
|
|
|
/// the __debug_info section, and the low_pc is the starting address for the
|
|
|
|
/// inlining instance.
|
|
|
|
void EmitDebugInlineInfo() {
|
|
|
|
if (!TAI->doesDwarfUsesInlineInfoSection())
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!MainCU)
|
|
|
|
return;
|
|
|
|
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfDebugInlineSection());
|
|
|
|
Asm->EOL();
|
|
|
|
EmitDifference("debug_inlined_end", 1,
|
|
|
|
"debug_inlined_begin", 1, true);
|
|
|
|
Asm->EOL("Length of Debug Inlined Information Entry");
|
|
|
|
|
|
|
|
EmitLabel("debug_inlined_begin", 1);
|
|
|
|
|
|
|
|
Asm->EmitInt16(DWARF_VERSION); Asm->EOL("Dwarf Version");
|
|
|
|
Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
|
|
|
|
|
|
|
|
for (DenseMap<GlobalVariable *, SmallVector<unsigned, 4> >::iterator
|
|
|
|
I = InlineInfo.begin(), E = InlineInfo.end(); I != E; ++I) {
|
|
|
|
GlobalVariable *GV = I->first;
|
|
|
|
SmallVector<unsigned, 4> &Labels = I->second;
|
|
|
|
DISubprogram SP(GV);
|
|
|
|
std::string Name;
|
|
|
|
std::string LName;
|
2009-05-07 19:46:24 +00:00
|
|
|
|
2009-04-13 17:02:03 +00:00
|
|
|
SP.getLinkageName(LName);
|
|
|
|
SP.getName(Name);
|
|
|
|
|
|
|
|
Asm->EmitString(LName.empty() ? Name : LName);
|
|
|
|
Asm->EOL("MIPS linkage name");
|
|
|
|
|
|
|
|
Asm->EmitString(Name); Asm->EOL("Function name");
|
|
|
|
|
|
|
|
Asm->EmitULEB128Bytes(Labels.size()); Asm->EOL("Inline count");
|
|
|
|
|
|
|
|
for (SmallVector<unsigned, 4>::iterator LI = Labels.begin(),
|
|
|
|
LE = Labels.end(); LI != LE; ++LI) {
|
|
|
|
DIE *SP = MainCU->getDieMapSlotFor(GV);
|
|
|
|
Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset");
|
|
|
|
|
|
|
|
if (TD->getPointerSize() == sizeof(int32_t))
|
|
|
|
O << TAI->getData32bitsDirective();
|
|
|
|
else
|
|
|
|
O << TAI->getData64bitsDirective();
|
|
|
|
PrintLabelName("label", *LI); Asm->EOL("low_pc");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EmitLabel("debug_inlined_end", 1);
|
|
|
|
Asm->EOL();
|
|
|
|
}
|
|
|
|
|
2009-03-10 21:47:45 +00:00
|
|
|
/// GetOrCreateSourceID - Look up the source id with the given directory and
|
|
|
|
/// source file names. If none currently exists, create a new id and insert it
|
|
|
|
/// in the SourceIds map. This can update DirectoryNames and SourceFileNames maps
|
|
|
|
/// as well.
|
|
|
|
unsigned GetOrCreateSourceID(const std::string &DirName,
|
|
|
|
const std::string &FileName) {
|
|
|
|
unsigned DId;
|
|
|
|
StringMap<unsigned>::iterator DI = DirectoryIdMap.find(DirName);
|
|
|
|
if (DI != DirectoryIdMap.end()) {
|
|
|
|
DId = DI->getValue();
|
|
|
|
} else {
|
|
|
|
DId = DirectoryNames.size() + 1;
|
|
|
|
DirectoryIdMap[DirName] = DId;
|
|
|
|
DirectoryNames.push_back(DirName);
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned FId;
|
|
|
|
StringMap<unsigned>::iterator FI = SourceFileIdMap.find(FileName);
|
|
|
|
if (FI != SourceFileIdMap.end()) {
|
|
|
|
FId = FI->getValue();
|
|
|
|
} else {
|
|
|
|
FId = SourceFileNames.size() + 1;
|
|
|
|
SourceFileIdMap[FileName] = FId;
|
|
|
|
SourceFileNames.push_back(FileName);
|
|
|
|
}
|
|
|
|
|
|
|
|
DenseMap<std::pair<unsigned, unsigned>, unsigned>::iterator SI =
|
|
|
|
SourceIdMap.find(std::make_pair(DId, FId));
|
|
|
|
if (SI != SourceIdMap.end())
|
|
|
|
return SI->second;
|
|
|
|
|
|
|
|
unsigned SrcId = SourceIds.size() + 1; // DW_AT_decl_file cannot be 0.
|
|
|
|
SourceIdMap[std::make_pair(DId, FId)] = SrcId;
|
|
|
|
SourceIds.push_back(std::make_pair(DId, FId));
|
|
|
|
|
|
|
|
return SrcId;
|
|
|
|
}
|
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
void ConstructCompileUnit(GlobalVariable *GV) {
|
|
|
|
DICompileUnit DIUnit(GV);
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string Dir, FN, Prod;
|
|
|
|
unsigned ID = GetOrCreateSourceID(DIUnit.getDirectory(Dir),
|
|
|
|
DIUnit.getFilename(FN));
|
2009-02-25 07:04:34 +00:00
|
|
|
|
|
|
|
DIE *Die = new DIE(DW_TAG_compile_unit);
|
|
|
|
AddSectionOffset(Die, DW_AT_stmt_list, DW_FORM_data4,
|
|
|
|
DWLabel("section_line", 0), DWLabel("section_line", 0),
|
|
|
|
false);
|
2009-03-13 04:39:26 +00:00
|
|
|
AddString(Die, DW_AT_producer, DW_FORM_string, DIUnit.getProducer(Prod));
|
2009-02-25 07:04:34 +00:00
|
|
|
AddUInt(Die, DW_AT_language, DW_FORM_data1, DIUnit.getLanguage());
|
2009-03-09 05:04:40 +00:00
|
|
|
AddString(Die, DW_AT_name, DW_FORM_string, FN);
|
2009-03-13 04:39:26 +00:00
|
|
|
if (!Dir.empty())
|
2009-03-09 05:04:40 +00:00
|
|
|
AddString(Die, DW_AT_comp_dir, DW_FORM_string, Dir);
|
2009-02-25 07:04:34 +00:00
|
|
|
if (DIUnit.isOptimized())
|
|
|
|
AddUInt(Die, DW_AT_APPLE_optimized, DW_FORM_flag, 1);
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string Flags;
|
|
|
|
DIUnit.getFlags(Flags);
|
|
|
|
if (!Flags.empty())
|
2009-02-25 07:04:34 +00:00
|
|
|
AddString(Die, DW_AT_APPLE_flags, DW_FORM_string, Flags);
|
|
|
|
unsigned RVer = DIUnit.getRunTimeVersion();
|
|
|
|
if (RVer)
|
|
|
|
AddUInt(Die, DW_AT_APPLE_major_runtime_vers, DW_FORM_data1, RVer);
|
|
|
|
|
|
|
|
CompileUnit *Unit = new CompileUnit(ID, Die);
|
|
|
|
if (DIUnit.isMain()) {
|
|
|
|
assert(!MainCU && "Multiple main compile units are found!");
|
|
|
|
MainCU = Unit;
|
|
|
|
}
|
|
|
|
CompileUnitMap[DIUnit.getGV()] = Unit;
|
|
|
|
CompileUnits.push_back(Unit);
|
|
|
|
}
|
|
|
|
|
2009-01-05 23:11:11 +00:00
|
|
|
/// ConstructCompileUnits - Create a compile unit DIEs.
|
2009-01-05 23:03:32 +00:00
|
|
|
void ConstructCompileUnits() {
|
2009-02-25 07:04:34 +00:00
|
|
|
GlobalVariable *Root = M->getGlobalVariable("llvm.dbg.compile_units");
|
|
|
|
if (!Root)
|
|
|
|
return;
|
|
|
|
assert(Root->hasLinkOnceLinkage() && Root->hasOneUse() &&
|
|
|
|
"Malformed compile unit descriptor anchor type");
|
|
|
|
Constant *RootC = cast<Constant>(*Root->use_begin());
|
|
|
|
assert(RootC->hasNUsesOrMore(1) &&
|
|
|
|
"Malformed compile unit descriptor anchor type");
|
|
|
|
for (Value::use_iterator UI = RootC->use_begin(), UE = Root->use_end();
|
|
|
|
UI != UE; ++UI)
|
|
|
|
for (Value::use_iterator UUI = UI->use_begin(), UUE = UI->use_end();
|
|
|
|
UUI != UUE; ++UUI) {
|
|
|
|
GlobalVariable *GV = cast<GlobalVariable>(*UUI);
|
|
|
|
ConstructCompileUnit(GV);
|
2009-01-30 18:20:31 +00:00
|
|
|
}
|
2009-02-25 07:04:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool ConstructGlobalVariableDIE(GlobalVariable *GV) {
|
|
|
|
DIGlobalVariable DI_GV(GV);
|
|
|
|
CompileUnit *DW_Unit = MainCU;
|
|
|
|
if (!DW_Unit)
|
2009-05-05 04:55:56 +00:00
|
|
|
DW_Unit = &FindCompileUnit(DI_GV.getCompileUnit());
|
2009-02-25 07:04:34 +00:00
|
|
|
|
|
|
|
// Check for pre-existence.
|
|
|
|
DIE *&Slot = DW_Unit->getDieMapSlotFor(DI_GV.getGV());
|
|
|
|
if (Slot)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
DIE *VariableDie = CreateGlobalVariableDIE(DW_Unit, DI_GV);
|
|
|
|
|
|
|
|
// Add address.
|
|
|
|
DIEBlock *Block = new DIEBlock();
|
|
|
|
AddUInt(Block, 0, DW_FORM_data1, DW_OP_addr);
|
2009-04-10 00:12:49 +00:00
|
|
|
std::string GLN;
|
2009-02-25 07:04:34 +00:00
|
|
|
AddObjectLabel(Block, 0, DW_FORM_udata,
|
2009-04-10 00:12:49 +00:00
|
|
|
Asm->getGlobalLinkName(DI_GV.getGlobal(), GLN));
|
2009-02-25 07:04:34 +00:00
|
|
|
AddBlock(VariableDie, DW_AT_location, 0, Block);
|
|
|
|
|
|
|
|
// Add to map.
|
|
|
|
Slot = VariableDie;
|
2009-05-06 21:21:34 +00:00
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
// Add to context owner.
|
|
|
|
DW_Unit->getDie()->AddChild(VariableDie);
|
2009-05-06 21:21:34 +00:00
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
// Expose as global. FIXME - need to check external flag.
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string Name;
|
|
|
|
DW_Unit->AddGlobal(DI_GV.getName(Name), VariableDie);
|
2009-02-25 07:04:34 +00:00
|
|
|
return true;
|
2009-01-05 23:03:32 +00:00
|
|
|
}
|
|
|
|
|
2009-01-05 23:11:11 +00:00
|
|
|
/// ConstructGlobalVariableDIEs - Create DIEs for each of the externally
|
2009-02-24 00:02:15 +00:00
|
|
|
/// visible global variables. Return true if at least one global DIE is
|
|
|
|
/// created.
|
|
|
|
bool ConstructGlobalVariableDIEs() {
|
2009-02-25 07:04:34 +00:00
|
|
|
GlobalVariable *Root = M->getGlobalVariable("llvm.dbg.global_variables");
|
|
|
|
if (!Root)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
assert(Root->hasLinkOnceLinkage() && Root->hasOneUse() &&
|
|
|
|
"Malformed global variable descriptor anchor type");
|
|
|
|
Constant *RootC = cast<Constant>(*Root->use_begin());
|
|
|
|
assert(RootC->hasNUsesOrMore(1) &&
|
|
|
|
"Malformed global variable descriptor anchor type");
|
|
|
|
|
|
|
|
bool Result = false;
|
|
|
|
for (Value::use_iterator UI = RootC->use_begin(), UE = Root->use_end();
|
|
|
|
UI != UE; ++UI)
|
|
|
|
for (Value::use_iterator UUI = UI->use_begin(), UUE = UI->use_end();
|
2009-05-06 21:21:34 +00:00
|
|
|
UUI != UUE; ++UUI)
|
|
|
|
Result |= ConstructGlobalVariableDIE(cast<GlobalVariable>(*UUI));
|
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ConstructSubprogram(GlobalVariable *GV) {
|
|
|
|
DISubprogram SP(GV);
|
|
|
|
CompileUnit *Unit = MainCU;
|
|
|
|
if (!Unit)
|
2009-05-05 04:55:56 +00:00
|
|
|
Unit = &FindCompileUnit(SP.getCompileUnit());
|
2009-02-25 07:04:34 +00:00
|
|
|
|
|
|
|
// Check for pre-existence.
|
|
|
|
DIE *&Slot = Unit->getDieMapSlotFor(GV);
|
|
|
|
if (Slot)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!SP.isDefinition())
|
|
|
|
// This is a method declaration which will be handled while
|
|
|
|
// constructing class type.
|
|
|
|
return false;
|
|
|
|
|
|
|
|
DIE *SubprogramDie = CreateSubprogramDIE(Unit, SP);
|
|
|
|
|
|
|
|
// Add to map.
|
|
|
|
Slot = SubprogramDie;
|
|
|
|
// Add to context owner.
|
|
|
|
Unit->getDie()->AddChild(SubprogramDie);
|
|
|
|
// Expose as global.
|
2009-03-13 04:39:26 +00:00
|
|
|
std::string Name;
|
|
|
|
Unit->AddGlobal(SP.getName(Name), SubprogramDie);
|
2009-02-25 07:04:34 +00:00
|
|
|
return true;
|
2009-01-05 23:11:11 +00:00
|
|
|
}
|
|
|
|
|
2009-01-05 23:21:35 +00:00
|
|
|
/// ConstructSubprograms - Create DIEs for each of the externally visible
|
2009-02-24 00:02:15 +00:00
|
|
|
/// subprograms. Return true if at least one subprogram DIE is created.
|
|
|
|
bool ConstructSubprograms() {
|
2009-02-25 07:04:34 +00:00
|
|
|
GlobalVariable *Root = M->getGlobalVariable("llvm.dbg.subprograms");
|
|
|
|
if (!Root)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
assert(Root->hasLinkOnceLinkage() && Root->hasOneUse() &&
|
|
|
|
"Malformed subprogram descriptor anchor type");
|
|
|
|
Constant *RootC = cast<Constant>(*Root->use_begin());
|
|
|
|
assert(RootC->hasNUsesOrMore(1) &&
|
|
|
|
"Malformed subprogram descriptor anchor type");
|
|
|
|
|
|
|
|
bool Result = false;
|
|
|
|
for (Value::use_iterator UI = RootC->use_begin(), UE = Root->use_end();
|
|
|
|
UI != UE; ++UI)
|
|
|
|
for (Value::use_iterator UUI = UI->use_begin(), UUE = UI->use_end();
|
2009-05-06 21:21:34 +00:00
|
|
|
UUI != UUE; ++UUI)
|
|
|
|
Result |= ConstructSubprogram(cast<GlobalVariable>(*UUI));
|
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
return Result;
|
2009-01-05 23:21:35 +00:00
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
public:
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
// Main entry points.
|
|
|
|
//
|
2008-08-21 00:14:44 +00:00
|
|
|
DwarfDebug(raw_ostream &OS, AsmPrinter *A, const TargetAsmInfo *T)
|
2009-03-10 21:23:25 +00:00
|
|
|
: Dwarf(OS, A, T, "dbg"), MainCU(0),
|
|
|
|
AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
|
|
|
|
ValuesSet(InitValuesSetSize), Values(), StringPool(), SectionMap(),
|
|
|
|
SectionSourceLines(), didInitial(false), shouldEmit(false),
|
2009-04-15 20:41:31 +00:00
|
|
|
FunctionDbgScope(0), DebugTimer(0) {
|
2009-03-10 21:23:25 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer = new Timer("Dwarf Debug Writer",
|
2009-03-10 22:58:53 +00:00
|
|
|
getDwarfTimerGroup());
|
2006-01-17 17:31:53 +00:00
|
|
|
}
|
2007-01-29 18:51:14 +00:00
|
|
|
virtual ~DwarfDebug() {
|
2006-11-02 20:12:39 +00:00
|
|
|
for (unsigned j = 0, M = Values.size(); j < M; ++j)
|
|
|
|
delete Values[j];
|
2009-03-10 21:23:25 +00:00
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
for (DenseMap<const GlobalVariable *, DbgScope *>::iterator
|
|
|
|
I = AbstractInstanceRootMap.begin(),
|
|
|
|
E = AbstractInstanceRootMap.end(); I != E;++I)
|
|
|
|
delete I->second;
|
|
|
|
|
2009-03-10 21:23:25 +00:00
|
|
|
delete DebugTimer;
|
2006-01-17 17:31:53 +00:00
|
|
|
}
|
2006-11-02 20:12:39 +00:00
|
|
|
|
2009-03-10 21:47:45 +00:00
|
|
|
/// ShouldEmitDwarfDebug - Returns true if Dwarf debugging declarations should
|
|
|
|
/// be emitted.
|
|
|
|
bool ShouldEmitDwarfDebug() const { return shouldEmit; }
|
|
|
|
|
2009-01-06 21:07:30 +00:00
|
|
|
/// SetDebugInfo - Create global DIEs and emit initial debug info sections.
|
|
|
|
/// This is inovked by the target AsmPrinter.
|
2009-01-12 23:09:42 +00:00
|
|
|
void SetDebugInfo(MachineModuleInfo *mmi) {
|
2009-03-10 21:23:25 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->startTimer();
|
|
|
|
|
2009-02-03 21:38:21 +00:00
|
|
|
// Create all the compile unit DIEs.
|
|
|
|
ConstructCompileUnits();
|
2009-01-12 23:09:42 +00:00
|
|
|
|
2009-03-10 21:23:25 +00:00
|
|
|
if (CompileUnits.empty()) {
|
|
|
|
if (TimePassesIsEnabled)
|
2009-03-10 22:02:13 +00:00
|
|
|
DebugTimer->stopTimer();
|
2009-03-10 21:23:25 +00:00
|
|
|
|
2009-02-03 21:38:21 +00:00
|
|
|
return;
|
2009-03-10 21:23:25 +00:00
|
|
|
}
|
2009-01-12 23:09:42 +00:00
|
|
|
|
2009-02-03 21:38:21 +00:00
|
|
|
// Create DIEs for each of the externally visible global variables.
|
2009-02-24 00:02:15 +00:00
|
|
|
bool globalDIEs = ConstructGlobalVariableDIEs();
|
2009-01-06 21:07:30 +00:00
|
|
|
|
2009-02-03 21:38:21 +00:00
|
|
|
// Create DIEs for each of the externally visible subprograms.
|
2009-02-24 00:02:15 +00:00
|
|
|
bool subprogramDIEs = ConstructSubprograms();
|
|
|
|
|
|
|
|
// If there is not any debug info available for any global variables
|
|
|
|
// and any subprograms then there is not any debug info to emit.
|
2009-03-10 21:23:25 +00:00
|
|
|
if (!globalDIEs && !subprogramDIEs) {
|
|
|
|
if (TimePassesIsEnabled)
|
2009-03-10 22:02:13 +00:00
|
|
|
DebugTimer->stopTimer();
|
2009-03-10 21:23:25 +00:00
|
|
|
|
2009-02-24 00:02:15 +00:00
|
|
|
return;
|
2009-03-10 21:23:25 +00:00
|
|
|
}
|
2009-02-24 00:02:15 +00:00
|
|
|
|
|
|
|
MMI = mmi;
|
|
|
|
shouldEmit = true;
|
|
|
|
MMI->setDebugInfoAvailability(true);
|
2009-01-06 21:07:30 +00:00
|
|
|
|
2009-02-03 21:38:21 +00:00
|
|
|
// Prime section data.
|
|
|
|
SectionMap.insert(TAI->getTextSection());
|
2009-01-06 21:07:30 +00:00
|
|
|
|
2009-02-03 21:38:21 +00:00
|
|
|
// 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()) {
|
2009-02-25 07:04:34 +00:00
|
|
|
for (unsigned i = 1, e = getNumSourceIds()+1; i != e; ++i) {
|
|
|
|
// Remember source id starts at 1.
|
2009-03-10 21:59:25 +00:00
|
|
|
std::pair<unsigned, unsigned> Id = getSourceDirectoryAndFileIds(i);
|
2009-02-25 07:04:34 +00:00
|
|
|
sys::Path FullPath(getSourceDirectoryName(Id.first));
|
|
|
|
bool AppendOk =
|
|
|
|
FullPath.appendComponent(getSourceFileName(Id.second));
|
2009-02-03 21:38:21 +00:00
|
|
|
assert(AppendOk && "Could not append filename to directory!");
|
|
|
|
AppendOk = false;
|
|
|
|
Asm->EmitFile(i, FullPath.toString());
|
|
|
|
Asm->EOL();
|
2009-01-06 21:07:30 +00:00
|
|
|
}
|
2009-02-03 21:38:21 +00:00
|
|
|
}
|
2009-01-06 21:07:30 +00:00
|
|
|
|
2009-02-03 21:38:21 +00:00
|
|
|
// Emit initial sections
|
|
|
|
EmitInitial();
|
2009-03-10 21:23:25 +00:00
|
|
|
|
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->stopTimer();
|
2009-01-06 21:07:30 +00:00
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// BeginModule - Emit all Dwarf sections that should come prior to the
|
|
|
|
/// content.
|
|
|
|
void BeginModule(Module *M) {
|
|
|
|
this->M = M;
|
|
|
|
}
|
2006-06-23 12:51:53 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// EndModule - Emit all Dwarf sections that should come after the content.
|
|
|
|
///
|
|
|
|
void EndModule() {
|
2009-03-10 21:23:25 +00:00
|
|
|
if (!ShouldEmitDwarfDebug())
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->startTimer();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Standard sections final addresses.
|
2008-09-24 22:15:21 +00:00
|
|
|
Asm->SwitchToSection(TAI->getTextSection());
|
2006-11-02 20:12:39 +00:00
|
|
|
EmitLabel("text_end", 0);
|
2008-09-24 22:16:16 +00:00
|
|
|
Asm->SwitchToSection(TAI->getDataSection());
|
2006-11-02 20:12:39 +00:00
|
|
|
EmitLabel("data_end", 0);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// End text sections.
|
|
|
|
for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
|
2008-09-24 22:15:21 +00:00
|
|
|
Asm->SwitchToSection(SectionMap[i]);
|
2006-11-02 20:12:39 +00:00
|
|
|
EmitLabel("section_end", i);
|
2006-01-17 17:31:53 +00:00
|
|
|
}
|
2007-05-13 17:30:11 +00:00
|
|
|
|
|
|
|
// 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);
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Compute DIE offsets and sizes.
|
|
|
|
SizeAndOffsets();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit all the DIEs into a debug info section
|
|
|
|
EmitDebugInfo();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Corresponding abbreviations into a abbrev section.
|
|
|
|
EmitAbbreviations();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit source line correspondence into a debug line section.
|
|
|
|
EmitDebugLines();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit info into a debug pubnames section.
|
|
|
|
EmitDebugPubNames();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit info into a debug str section.
|
|
|
|
EmitDebugStr();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit info into a debug loc section.
|
|
|
|
EmitDebugLoc();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit info into a debug aranges section.
|
|
|
|
EmitDebugARanges();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit info into a debug ranges section.
|
|
|
|
EmitDebugRanges();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit info into a debug macinfo section.
|
|
|
|
EmitDebugMacInfo();
|
2009-03-10 21:23:25 +00:00
|
|
|
|
2009-04-13 17:02:03 +00:00
|
|
|
// Emit inline info.
|
|
|
|
EmitDebugInlineInfo();
|
|
|
|
|
2009-03-10 21:23:25 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->stopTimer();
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2008-08-16 12:57:46 +00:00
|
|
|
/// BeginFunction - Gather pre-function debug information. Assumes being
|
2006-11-02 20:12:39 +00:00
|
|
|
/// emitted immediately after the function entry point.
|
|
|
|
void BeginFunction(MachineFunction *MF) {
|
2009-03-11 00:03:50 +00:00
|
|
|
this->MF = MF;
|
|
|
|
|
2009-02-20 00:44:43 +00:00
|
|
|
if (!ShouldEmitDwarfDebug()) return;
|
2006-02-22 19:02:11 +00:00
|
|
|
|
2009-03-10 21:23:25 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->startTimer();
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Begin accumulating function debug information.
|
2007-01-26 21:22:28 +00:00
|
|
|
MMI->BeginFunction(MF);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Assumes in correct section after the entry point.
|
|
|
|
EmitLabel("func_begin", ++SubprogramCount);
|
2008-02-01 09:10:45 +00:00
|
|
|
|
2009-05-04 19:23:45 +00:00
|
|
|
// Emit label for the implicitly defined dbg.stoppoint at the start of
|
|
|
|
// the function.
|
2009-05-04 18:40:41 +00:00
|
|
|
DebugLoc FDL = MF->getDefaultDebugLoc();
|
|
|
|
if (!FDL.isUnknown()) {
|
|
|
|
DebugLocTuple DLT = MF->getDebugLocTuple(FDL);
|
|
|
|
unsigned LabelID = RecordSourceLine(DLT.Line, DLT.Col,
|
|
|
|
DICompileUnit(DLT.CompileUnit));
|
|
|
|
Asm->printLabel(LabelID);
|
2008-04-03 17:37:43 +00:00
|
|
|
}
|
2009-03-10 21:23:25 +00:00
|
|
|
|
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->stopTimer();
|
2006-06-23 12:51:53 +00:00
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// EndFunction - Gather and emit post-function debug information.
|
|
|
|
///
|
2008-09-26 00:28:12 +00:00
|
|
|
void EndFunction(MachineFunction *MF) {
|
2009-02-20 00:44:43 +00:00
|
|
|
if (!ShouldEmitDwarfDebug()) return;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-03-10 21:23:25 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->startTimer();
|
|
|
|
|
2007-02-01 16:31:34 +00:00
|
|
|
// Define end label for subprogram.
|
|
|
|
EmitLabel("func_end", SubprogramCount);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Get function line info.
|
2009-01-12 22:54:42 +00:00
|
|
|
if (!Lines.empty()) {
|
2006-11-02 20:12:39 +00:00
|
|
|
// Get section line info.
|
2008-09-24 22:15:21 +00:00
|
|
|
unsigned ID = SectionMap.insert(Asm->CurrentSection_);
|
2006-11-02 20:12:39 +00:00
|
|
|
if (SectionSourceLines.size() < ID) SectionSourceLines.resize(ID);
|
2009-01-12 22:54:42 +00:00
|
|
|
std::vector<SrcLineInfo> &SectionLineInfos = SectionSourceLines[ID-1];
|
2006-11-02 20:12:39 +00:00
|
|
|
// Append the function info to section info.
|
|
|
|
SectionLineInfos.insert(SectionLineInfos.end(),
|
2009-01-12 22:54:42 +00:00
|
|
|
Lines.begin(), Lines.end());
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
// Construct the DbgScope for abstract instances.
|
|
|
|
for (SmallVector<DbgScope *, 32>::iterator
|
|
|
|
I = AbstractInstanceRootList.begin(),
|
|
|
|
E = AbstractInstanceRootList.end(); I != E; ++I)
|
|
|
|
ConstructAbstractDbgScope(*I);
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Construct scopes for subprogram.
|
2009-04-15 20:41:31 +00:00
|
|
|
if (FunctionDbgScope)
|
|
|
|
ConstructFunctionDbgScope(FunctionDbgScope);
|
2008-09-26 00:28:12 +00:00
|
|
|
else
|
|
|
|
// FIXME: This is wrong. We are essentially getting past a problem with
|
|
|
|
// debug information not being able to handle unreachable blocks that have
|
|
|
|
// debug information in them. In particular, those unreachable blocks that
|
|
|
|
// have "region end" info in them. That situation results in the "root
|
|
|
|
// scope" not being created. If that's the case, then emit a "default"
|
|
|
|
// scope, i.e., one that encompasses the whole function. This isn't
|
|
|
|
// desirable. And a better way of handling this (and all of the debugging
|
|
|
|
// information) needs to be explored.
|
2009-01-13 00:20:51 +00:00
|
|
|
ConstructDefaultDbgScope(MF);
|
2007-05-13 17:30:11 +00:00
|
|
|
|
|
|
|
DebugFrames.push_back(FunctionDebugFrameInfo(SubprogramCount,
|
|
|
|
MMI->getFrameMoves()));
|
2009-01-12 18:48:36 +00:00
|
|
|
|
|
|
|
// Clear debug info
|
2009-04-15 20:41:31 +00:00
|
|
|
if (FunctionDbgScope) {
|
|
|
|
delete FunctionDbgScope;
|
2009-01-12 18:48:36 +00:00
|
|
|
DbgScopeMap.clear();
|
2009-05-10 23:14:38 +00:00
|
|
|
DbgConcreteScopeMap.clear();
|
2009-04-15 00:10:26 +00:00
|
|
|
InlinedVariableScopes.clear();
|
2009-04-15 20:41:31 +00:00
|
|
|
FunctionDbgScope = NULL;
|
2009-05-10 23:14:38 +00:00
|
|
|
LexicalScopeStack.clear();
|
|
|
|
AbstractInstanceRootList.clear();
|
2009-01-12 18:48:36 +00:00
|
|
|
}
|
2009-03-10 21:23:25 +00:00
|
|
|
|
2009-01-12 18:48:36 +00:00
|
|
|
Lines.clear();
|
2009-01-12 19:17:34 +00:00
|
|
|
|
2009-03-10 21:23:25 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->stopTimer();
|
|
|
|
}
|
2009-01-12 19:17:34 +00:00
|
|
|
|
|
|
|
/// RecordSourceLine - Records location information and associates it with a
|
|
|
|
/// label. Returns a unique label ID used to generate a label and provide
|
|
|
|
/// correspondence to the source line list.
|
|
|
|
unsigned RecordSourceLine(Value *V, unsigned Line, unsigned Col) {
|
2009-03-10 21:23:25 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->startTimer();
|
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
CompileUnit *Unit = CompileUnitMap[V];
|
2009-02-03 21:38:21 +00:00
|
|
|
assert(Unit && "Unable to find CompileUnit");
|
2009-01-12 19:17:34 +00:00
|
|
|
unsigned ID = MMI->NextLabelID();
|
|
|
|
Lines.push_back(SrcLineInfo(Line, Col, Unit->getID(), ID));
|
2009-03-10 21:23:25 +00:00
|
|
|
|
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->stopTimer();
|
|
|
|
|
2009-01-12 19:17:34 +00:00
|
|
|
return ID;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// RecordSourceLine - Records location information and associates it with a
|
|
|
|
/// label. Returns a unique label ID used to generate a label and provide
|
|
|
|
/// correspondence to the source line list.
|
2009-04-30 23:22:31 +00:00
|
|
|
unsigned RecordSourceLine(unsigned Line, unsigned Col, DICompileUnit CU) {
|
2009-03-10 21:23:25 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->startTimer();
|
|
|
|
|
2009-04-30 23:22:31 +00:00
|
|
|
std::string Dir, Fn;
|
|
|
|
unsigned Src = GetOrCreateSourceID(CU.getDirectory(Dir),
|
|
|
|
CU.getFilename(Fn));
|
2009-01-12 19:17:34 +00:00
|
|
|
unsigned ID = MMI->NextLabelID();
|
|
|
|
Lines.push_back(SrcLineInfo(Line, Col, Src, ID));
|
2009-03-10 21:23:25 +00:00
|
|
|
|
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->stopTimer();
|
|
|
|
|
2009-01-12 19:17:34 +00:00
|
|
|
return ID;
|
|
|
|
}
|
|
|
|
|
2009-03-10 21:47:45 +00:00
|
|
|
/// getRecordSourceLineCount - Return the number of source lines in the debug
|
|
|
|
/// info.
|
|
|
|
unsigned getRecordSourceLineCount() const {
|
2009-01-12 19:17:34 +00:00
|
|
|
return Lines.size();
|
|
|
|
}
|
|
|
|
|
2009-03-10 21:47:45 +00:00
|
|
|
/// getOrCreateSourceID - Public version of GetOrCreateSourceID. This can be
|
|
|
|
/// timed. Look up the source id with the given directory and source file
|
|
|
|
/// names. If none currently exists, create a new id and insert it in the
|
|
|
|
/// SourceIds map. This can update DirectoryNames and SourceFileNames maps as
|
|
|
|
/// well.
|
2009-02-25 07:04:34 +00:00
|
|
|
unsigned getOrCreateSourceID(const std::string &DirName,
|
|
|
|
const std::string &FileName) {
|
2009-03-10 21:23:25 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->startTimer();
|
|
|
|
|
2009-03-10 21:47:45 +00:00
|
|
|
unsigned SrcId = GetOrCreateSourceID(DirName, FileName);
|
2009-03-10 21:23:25 +00:00
|
|
|
|
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->stopTimer();
|
|
|
|
|
2009-02-25 07:04:34 +00:00
|
|
|
return SrcId;
|
2009-01-12 19:17:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// RecordRegionStart - Indicate the start of a region.
|
|
|
|
unsigned RecordRegionStart(GlobalVariable *V) {
|
2009-03-10 21:23:25 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->startTimer();
|
|
|
|
|
2009-01-12 19:17:34 +00:00
|
|
|
DbgScope *Scope = getOrCreateScope(V);
|
|
|
|
unsigned ID = MMI->NextLabelID();
|
|
|
|
if (!Scope->getStartLabelID()) Scope->setStartLabelID(ID);
|
2009-05-10 23:14:38 +00:00
|
|
|
LexicalScopeStack.push_back(Scope);
|
2009-03-10 21:23:25 +00:00
|
|
|
|
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->stopTimer();
|
|
|
|
|
2009-01-12 19:17:34 +00:00
|
|
|
return ID;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// RecordRegionEnd - Indicate the end of a region.
|
2009-05-07 19:46:24 +00:00
|
|
|
unsigned RecordRegionEnd(GlobalVariable *V) {
|
2009-03-10 21:23:25 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->startTimer();
|
|
|
|
|
2009-05-07 17:26:14 +00:00
|
|
|
DbgScope *Scope = getOrCreateScope(V);
|
2009-05-07 19:46:24 +00:00
|
|
|
unsigned ID = MMI->NextLabelID();
|
2009-01-12 19:17:34 +00:00
|
|
|
Scope->setEndLabelID(ID);
|
2009-05-10 23:14:38 +00:00
|
|
|
if (LexicalScopeStack.size() != 0)
|
|
|
|
LexicalScopeStack.pop_back();
|
2009-03-10 21:23:25 +00:00
|
|
|
|
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->stopTimer();
|
|
|
|
|
2009-01-12 19:17:34 +00:00
|
|
|
return ID;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// RecordVariable - Indicate the declaration of a local variable.
|
2009-04-15 00:10:26 +00:00
|
|
|
void RecordVariable(GlobalVariable *GV, unsigned FrameIndex,
|
|
|
|
const MachineInstr *MI) {
|
2009-03-10 21:23:25 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->startTimer();
|
|
|
|
|
2009-01-15 18:25:17 +00:00
|
|
|
DIDescriptor Desc(GV);
|
|
|
|
DbgScope *Scope = NULL;
|
2009-03-10 21:23:25 +00:00
|
|
|
|
2009-01-15 18:25:17 +00:00
|
|
|
if (Desc.getTag() == DW_TAG_variable) {
|
|
|
|
// GV is a global variable.
|
|
|
|
DIGlobalVariable DG(GV);
|
|
|
|
Scope = getOrCreateScope(DG.getContext().getGV());
|
|
|
|
} else {
|
2009-04-15 00:10:26 +00:00
|
|
|
DenseMap<const MachineInstr *, DbgScope *>::iterator
|
|
|
|
SI = InlinedVariableScopes.find(MI);
|
2009-05-06 21:21:34 +00:00
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
if (SI != InlinedVariableScopes.end()) {
|
2009-04-15 00:10:26 +00:00
|
|
|
// or GV is an inlined local variable.
|
|
|
|
Scope = SI->second;
|
|
|
|
} else {
|
|
|
|
DIVariable DV(GV);
|
2009-05-10 23:14:38 +00:00
|
|
|
GlobalVariable *V = DV.getContext().getGV();
|
|
|
|
|
|
|
|
// FIXME: The code that checks for the inlined local variable is a hack!
|
|
|
|
DenseMap<const GlobalVariable *, DbgScope *>::iterator
|
|
|
|
AI = AbstractInstanceRootMap.find(V);
|
|
|
|
|
|
|
|
if (AI != AbstractInstanceRootMap.end())
|
|
|
|
// or GV is an inlined local variable.
|
|
|
|
Scope = AI->second;
|
|
|
|
else
|
|
|
|
// or GV is a local variable.
|
|
|
|
Scope = getOrCreateScope(V);
|
2009-04-15 00:10:26 +00:00
|
|
|
}
|
2009-01-15 18:25:17 +00:00
|
|
|
}
|
2009-03-10 21:23:25 +00:00
|
|
|
|
2009-02-03 21:38:21 +00:00
|
|
|
assert(Scope && "Unable to find variable' scope");
|
2009-01-16 19:28:14 +00:00
|
|
|
DbgVariable *DV = new DbgVariable(DIVariable(GV), FrameIndex);
|
2009-01-12 19:17:34 +00:00
|
|
|
Scope->AddVariable(DV);
|
2009-03-10 21:23:25 +00:00
|
|
|
|
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->stopTimer();
|
2009-01-12 19:17:34 +00:00
|
|
|
}
|
2009-04-13 17:02:03 +00:00
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
//// RecordInlinedFnStart - Indicate the start of inlined subroutine.
|
2009-05-07 00:16:31 +00:00
|
|
|
unsigned RecordInlinedFnStart(DISubprogram &SP, DICompileUnit CU,
|
|
|
|
unsigned Line, unsigned Col) {
|
|
|
|
unsigned LabelID = MMI->NextLabelID();
|
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
if (!TAI->doesDwarfUsesInlineInfoSection())
|
2009-05-07 00:16:31 +00:00
|
|
|
return LabelID;
|
2009-04-15 00:10:26 +00:00
|
|
|
|
2009-05-01 08:40:06 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->startTimer();
|
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
GlobalVariable *GV = SP.getGV();
|
2009-05-10 23:14:38 +00:00
|
|
|
DenseMap<const GlobalVariable *, DbgScope *>::iterator
|
|
|
|
II = AbstractInstanceRootMap.find(GV);
|
|
|
|
|
|
|
|
if (II == AbstractInstanceRootMap.end()) {
|
|
|
|
// Create an abstract instance entry for this inlined function if it
|
|
|
|
// doesn't already exist.
|
|
|
|
DbgScope *Scope = new DbgScope(NULL, DIDescriptor(GV));
|
|
|
|
|
|
|
|
// Get the compile unit context.
|
|
|
|
CompileUnit *Unit = &FindCompileUnit(SP.getCompileUnit());
|
|
|
|
DIE *SPDie = Unit->getDieMapSlotFor(GV);
|
|
|
|
if (!SPDie)
|
|
|
|
SPDie = CreateSubprogramDIE(Unit, SP);
|
|
|
|
|
|
|
|
// Mark as being inlined. This makes this subprogram entry an abstract
|
|
|
|
// instance root.
|
|
|
|
// FIXME: Our debugger doesn't care about the value of DW_AT_inline, only
|
|
|
|
// that it's defined. It probably won't change in the future, but this
|
|
|
|
// could be more elegant.
|
|
|
|
AddUInt(SPDie, DW_AT_inline, 0, DW_INL_declared_not_inlined);
|
|
|
|
|
|
|
|
AbstractInstanceRootMap[GV] = Scope;
|
|
|
|
AbstractInstanceRootList.push_back(Scope);
|
|
|
|
}
|
2009-04-15 00:10:26 +00:00
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
// Create a concrete inlined instance for this inlined function.
|
|
|
|
DbgConcreteScope *ConcreteScope = new DbgConcreteScope(DIDescriptor(GV));
|
|
|
|
DIE *ScopeDie = new DIE(DW_TAG_inlined_subroutine);
|
|
|
|
CompileUnit *Unit = &FindCompileUnit(SP.getCompileUnit());
|
|
|
|
ScopeDie->setAbstractCompileUnit(Unit);
|
|
|
|
|
|
|
|
DIE *Origin = Unit->getDieMapSlotFor(GV);
|
|
|
|
AddDIEntry(ScopeDie, DW_AT_abstract_origin, DW_FORM_ref4, Origin);
|
|
|
|
AddUInt(ScopeDie, DW_AT_call_file, 0, Unit->getID());
|
|
|
|
AddUInt(ScopeDie, DW_AT_call_line, 0, Line);
|
|
|
|
AddUInt(ScopeDie, DW_AT_call_column, 0, Col);
|
|
|
|
|
|
|
|
ConcreteScope->setDie(ScopeDie);
|
|
|
|
ConcreteScope->setStartLabelID(LabelID);
|
2009-05-12 00:06:59 +00:00
|
|
|
MMI->RecordUsedDbgLabel(LabelID);
|
2009-05-10 23:14:38 +00:00
|
|
|
|
|
|
|
LexicalScopeStack.back()->AddConcreteInst(ConcreteScope);
|
|
|
|
|
|
|
|
// Keep track of the scope that's inlined into this function.
|
|
|
|
DenseMap<GlobalVariable *, SmallVector<DbgConcreteScope *, 8> >::iterator
|
|
|
|
SI = DbgConcreteScopeMap.find(GV);
|
2009-05-07 17:26:14 +00:00
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
if (SI == DbgConcreteScopeMap.end())
|
|
|
|
DbgConcreteScopeMap[GV].push_back(ConcreteScope);
|
2009-05-07 19:46:24 +00:00
|
|
|
else
|
2009-05-10 23:14:38 +00:00
|
|
|
SI->second.push_back(ConcreteScope);
|
2009-05-01 08:40:06 +00:00
|
|
|
|
2009-05-12 00:06:59 +00:00
|
|
|
// Track the start label for this inlined function.
|
|
|
|
DenseMap<GlobalVariable *, SmallVector<unsigned, 4> >::iterator
|
|
|
|
I = InlineInfo.find(GV);
|
|
|
|
|
|
|
|
if (I == InlineInfo.end())
|
|
|
|
InlineInfo[GV].push_back(LabelID);
|
|
|
|
else
|
|
|
|
I->second.push_back(LabelID);
|
|
|
|
|
2009-05-01 08:40:06 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->stopTimer();
|
2009-05-07 00:16:31 +00:00
|
|
|
|
|
|
|
return LabelID;
|
2009-04-13 17:02:03 +00:00
|
|
|
}
|
2009-04-15 00:10:26 +00:00
|
|
|
|
|
|
|
/// RecordInlinedFnEnd - Indicate the end of inlined subroutine.
|
|
|
|
unsigned RecordInlinedFnEnd(DISubprogram &SP) {
|
|
|
|
if (!TAI->doesDwarfUsesInlineInfoSection())
|
|
|
|
return 0;
|
|
|
|
|
2009-05-01 08:40:06 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->startTimer();
|
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
GlobalVariable *GV = SP.getGV();
|
2009-05-10 23:14:38 +00:00
|
|
|
DenseMap<GlobalVariable *, SmallVector<DbgConcreteScope *, 8> >::iterator
|
|
|
|
I = DbgConcreteScopeMap.find(GV);
|
2009-05-06 21:21:34 +00:00
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
if (I == DbgConcreteScopeMap.end()) {
|
2009-05-01 08:40:06 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->stopTimer();
|
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
return 0;
|
2009-05-01 08:40:06 +00:00
|
|
|
}
|
2009-04-15 00:10:26 +00:00
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
SmallVector<DbgConcreteScope *, 8> &Scopes = I->second;
|
2009-04-29 00:15:41 +00:00
|
|
|
assert(!Scopes.empty() && "We should have at least one debug scope!");
|
2009-05-10 23:14:38 +00:00
|
|
|
DbgConcreteScope *Scope = Scopes.back(); Scopes.pop_back();
|
2009-04-15 00:10:26 +00:00
|
|
|
unsigned ID = MMI->NextLabelID();
|
|
|
|
MMI->RecordUsedDbgLabel(ID);
|
|
|
|
Scope->setEndLabelID(ID);
|
2009-05-01 08:40:06 +00:00
|
|
|
|
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->stopTimer();
|
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
return ID;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// RecordVariableScope - Record scope for the variable declared by
|
|
|
|
/// DeclareMI. DeclareMI must describe TargetInstrInfo::DECLARE.
|
|
|
|
/// Record scopes for only inlined subroutine variables. Other
|
|
|
|
/// variables' scopes are determined during RecordVariable().
|
|
|
|
void RecordVariableScope(DIVariable &DV, const MachineInstr *DeclareMI) {
|
2009-05-01 08:40:06 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->startTimer();
|
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
DISubprogram SP(DV.getContext().getGV());
|
2009-05-01 08:40:06 +00:00
|
|
|
|
|
|
|
if (SP.isNull()) {
|
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->stopTimer();
|
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
return;
|
2009-05-01 08:40:06 +00:00
|
|
|
}
|
|
|
|
|
2009-05-10 23:14:38 +00:00
|
|
|
DenseMap<GlobalVariable *, SmallVector<DbgConcreteScope *, 8> >::iterator
|
|
|
|
I = DbgConcreteScopeMap.find(SP.getGV());
|
|
|
|
if (I != DbgConcreteScopeMap.end())
|
2009-05-01 08:40:06 +00:00
|
|
|
InlinedVariableScopes[DeclareMI] = I->second.back();
|
2009-04-15 00:10:26 +00:00
|
|
|
|
2009-05-01 08:40:06 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
DebugTimer->stopTimer();
|
2009-04-15 00:10:26 +00:00
|
|
|
}
|
2006-11-02 20:12:39 +00:00
|
|
|
};
|
2006-04-07 16:34:46 +00:00
|
|
|
|
2007-01-29 18:51:14 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2008-08-16 12:57:46 +00:00
|
|
|
/// DwarfException - Emits Dwarf exception handling directives.
|
2007-01-29 18:51:14 +00:00
|
|
|
///
|
|
|
|
class DwarfException : public Dwarf {
|
2007-05-12 22:36:25 +00:00
|
|
|
struct FunctionEHFrameInfo {
|
|
|
|
std::string FnName;
|
|
|
|
unsigned Number;
|
2007-05-13 15:42:26 +00:00
|
|
|
unsigned PersonalityIndex;
|
2007-05-12 22:36:25 +00:00
|
|
|
bool hasCalls;
|
|
|
|
bool hasLandingPads;
|
|
|
|
std::vector<MachineMove> Moves;
|
2008-01-16 19:59:28 +00:00
|
|
|
const Function * function;
|
2007-02-01 16:31:34 +00:00
|
|
|
|
2007-05-13 15:42:26 +00:00
|
|
|
FunctionEHFrameInfo(const std::string &FN, unsigned Num, unsigned P,
|
|
|
|
bool hC, bool hL,
|
2007-11-20 23:24:42 +00:00
|
|
|
const std::vector<MachineMove> &M,
|
2008-01-16 19:59:28 +00:00
|
|
|
const Function *f):
|
2007-05-13 15:42:26 +00:00
|
|
|
FnName(FN), Number(Num), PersonalityIndex(P),
|
2008-01-16 19:59:28 +00:00
|
|
|
hasCalls(hC), hasLandingPads(hL), Moves(M), function (f) { }
|
2007-05-12 22:36:25 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
std::vector<FunctionEHFrameInfo> EHFrames;
|
2008-04-02 00:25:04 +00:00
|
|
|
|
|
|
|
/// 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;
|
|
|
|
|
2008-08-16 12:57:46 +00:00
|
|
|
/// shouldEmitFrameModule - Per-module flag to indicate if frame moves
|
2008-04-02 00:25:04 +00:00
|
|
|
/// should be emitted.
|
|
|
|
bool shouldEmitMovesModule;
|
2008-05-07 19:11:09 +00:00
|
|
|
|
2009-03-10 21:23:25 +00:00
|
|
|
/// ExceptionTimer - Timer for the Dwarf exception writer.
|
|
|
|
Timer *ExceptionTimer;
|
|
|
|
|
2007-02-28 18:38:31 +00:00
|
|
|
/// EmitCommonEHFrame - Emit the common eh unwind frame.
|
2007-02-01 16:31:34 +00:00
|
|
|
///
|
2007-05-13 15:42:26 +00:00
|
|
|
void EmitCommonEHFrame(const Function *Personality, unsigned Index) {
|
2007-02-21 22:48:45 +00:00
|
|
|
// Size and sign of stack growth.
|
2007-02-01 16:31:34 +00:00
|
|
|
int stackGrowth =
|
|
|
|
Asm->TM.getFrameInfo()->getStackGrowthDirection() ==
|
|
|
|
TargetFrameInfo::StackGrowsUp ?
|
2007-09-27 23:12:31 +00:00
|
|
|
TD->getPointerSize() : -TD->getPointerSize();
|
2007-02-01 16:31:34 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
// Begin eh frame section.
|
2007-02-01 16:31:34 +00:00
|
|
|
Asm->SwitchToTextSection(TAI->getDwarfEHFrameSection());
|
2008-12-24 08:05:17 +00:00
|
|
|
|
|
|
|
if (!TAI->doesRequireNonLocalEHFrameLabel())
|
|
|
|
O << TAI->getEHGlobalPrefix();
|
|
|
|
O << "EH_frame" << Index << ":\n";
|
2007-05-13 15:42:26 +00:00
|
|
|
EmitLabel("section_eh_frame", Index);
|
2007-02-01 16:31:34 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
// Define base labels.
|
2007-05-13 15:42:26 +00:00
|
|
|
EmitLabel("eh_frame_common", Index);
|
2008-05-07 19:11:09 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
// Define the eh frame length.
|
2007-05-13 15:42:26 +00:00
|
|
|
EmitDifference("eh_frame_common_end", Index,
|
|
|
|
"eh_frame_common_begin", Index, true);
|
2007-02-01 16:31:34 +00:00
|
|
|
Asm->EOL("Length of Common Information Entry");
|
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
// EH frame header.
|
2007-05-13 15:42:26 +00:00
|
|
|
EmitLabel("eh_frame_common_begin", Index);
|
2007-02-01 16:31:34 +00:00
|
|
|
Asm->EmitInt32((int)0);
|
|
|
|
Asm->EOL("CIE Identifier Tag");
|
|
|
|
Asm->EmitInt8(DW_CIE_VERSION);
|
|
|
|
Asm->EOL("CIE Version");
|
2008-05-07 19:11:09 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
// The personality presence indicates that language specific information
|
|
|
|
// will show up in the eh frame.
|
|
|
|
Asm->EmitString(Personality ? "zPLR" : "zR");
|
2007-02-01 16:31:34 +00:00
|
|
|
Asm->EOL("CIE Augmentation");
|
2008-05-07 19:11:09 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
// Round out reader.
|
2007-02-01 16:31:34 +00:00
|
|
|
Asm->EmitULEB128Bytes(1);
|
|
|
|
Asm->EOL("CIE Code Alignment Factor");
|
|
|
|
Asm->EmitSLEB128Bytes(stackGrowth);
|
2008-05-07 19:11:09 +00:00
|
|
|
Asm->EOL("CIE Data Alignment Factor");
|
2007-11-13 19:13:01 +00:00
|
|
|
Asm->EmitInt8(RI->getDwarfRegNum(RI->getRARegister(), true));
|
2008-05-07 19:11:09 +00:00
|
|
|
Asm->EOL("CIE Return Address Column");
|
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
// If there is a personality, we need to indicate the functions location.
|
|
|
|
if (Personality) {
|
|
|
|
Asm->EmitULEB128Bytes(7);
|
|
|
|
Asm->EOL("Augmentation Size");
|
2007-09-11 17:20:55 +00:00
|
|
|
|
2008-05-07 19:11:09 +00:00
|
|
|
if (TAI->getNeedsIndirectEncoding()) {
|
2007-09-11 17:20:55 +00:00
|
|
|
Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4 | DW_EH_PE_indirect);
|
2008-05-07 19:11:09 +00:00
|
|
|
Asm->EOL("Personality (pcrel sdata4 indirect)");
|
|
|
|
} else {
|
2007-09-11 17:20:55 +00:00
|
|
|
Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4);
|
2008-05-07 19:11:09 +00:00
|
|
|
Asm->EOL("Personality (pcrel sdata4)");
|
|
|
|
}
|
2007-09-11 17:20:55 +00:00
|
|
|
|
2008-05-07 19:11:09 +00:00
|
|
|
PrintRelDirective(true);
|
2007-09-11 08:27:17 +00:00
|
|
|
O << TAI->getPersonalityPrefix();
|
|
|
|
Asm->EmitExternalGlobal((const GlobalVariable *)(Personality));
|
|
|
|
O << TAI->getPersonalitySuffix();
|
2008-05-08 12:33:11 +00:00
|
|
|
if (strcmp(TAI->getPersonalitySuffix(), "+4@GOTPCREL"))
|
|
|
|
O << "-" << TAI->getPCSymbol();
|
2007-09-11 08:27:17 +00:00
|
|
|
Asm->EOL("Personality");
|
2007-08-25 00:51:55 +00:00
|
|
|
|
2008-05-07 19:11:09 +00:00
|
|
|
Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4);
|
|
|
|
Asm->EOL("LSDA Encoding (pcrel sdata4)");
|
2008-12-24 05:25:49 +00:00
|
|
|
|
2009-01-05 22:53:45 +00:00
|
|
|
Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4);
|
|
|
|
Asm->EOL("FDE Encoding (pcrel sdata4)");
|
2007-02-21 22:48:45 +00:00
|
|
|
} else {
|
|
|
|
Asm->EmitULEB128Bytes(1);
|
|
|
|
Asm->EOL("Augmentation Size");
|
2008-12-24 05:25:49 +00:00
|
|
|
|
2009-01-05 22:53:45 +00:00
|
|
|
Asm->EmitInt8(DW_EH_PE_pcrel | DW_EH_PE_sdata4);
|
|
|
|
Asm->EOL("FDE Encoding (pcrel sdata4)");
|
2007-02-21 22:48:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Indicate locations of general callee saved registers in frame.
|
2007-02-01 16:31:34 +00:00
|
|
|
std::vector<MachineMove> Moves;
|
|
|
|
RI->getInitialFrameState(Moves);
|
2007-11-13 19:13:01 +00:00
|
|
|
EmitFrameMoves(NULL, 0, Moves, true);
|
2007-02-01 16:31:34 +00:00
|
|
|
|
2008-04-30 00:43:29 +00:00
|
|
|
// 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.
|
2008-08-16 12:57:46 +00:00
|
|
|
Asm->EmitAlignment(TD->getPointerSize() == sizeof(int32_t) ? 2 : 3,
|
2008-04-29 22:58:20 +00:00
|
|
|
0, 0, false);
|
2007-05-13 15:42:26 +00:00
|
|
|
EmitLabel("eh_frame_common_end", Index);
|
2008-05-07 19:11:09 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL();
|
2007-02-01 16:31:34 +00:00
|
|
|
}
|
2008-05-07 19:11:09 +00:00
|
|
|
|
2007-05-12 22:36:25 +00:00
|
|
|
/// EmitEHFrame - Emit function exception frame information.
|
2007-02-01 16:31:34 +00:00
|
|
|
///
|
2007-05-12 22:36:25 +00:00
|
|
|
void EmitEHFrame(const FunctionEHFrameInfo &EHFrameInfo) {
|
2008-01-16 19:59:28 +00:00
|
|
|
Function::LinkageTypes linkage = EHFrameInfo.function->getLinkage();
|
2009-04-13 05:44:34 +00:00
|
|
|
|
|
|
|
assert(!EHFrameInfo.function->hasAvailableExternallyLinkage() &&
|
|
|
|
"Should not emit 'available externally' functions at all");
|
2008-01-16 19:59:28 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->SwitchToTextSection(TAI->getDwarfEHFrameSection());
|
|
|
|
|
|
|
|
// Externally visible entry into the functions eh frame info.
|
2007-11-20 23:24:42 +00:00
|
|
|
// If the corresponding function is static, this should not be
|
|
|
|
// externally visible.
|
2009-01-15 20:18:42 +00:00
|
|
|
if (linkage != Function::InternalLinkage &&
|
2009-01-17 08:05:14 +00:00
|
|
|
linkage != Function::PrivateLinkage) {
|
2007-11-20 23:24:42 +00:00
|
|
|
if (const char *GlobalEHDirective = TAI->getGlobalEHDirective())
|
|
|
|
O << GlobalEHDirective << EHFrameInfo.FnName << "\n";
|
|
|
|
}
|
|
|
|
|
2008-01-10 02:03:30 +00:00
|
|
|
// If corresponding function is weak definition, this should be too.
|
Introduce new linkage types linkonce_odr, weak_odr, common_odr
and extern_weak_odr. These are the same as the non-odr versions,
except that they indicate that the global will only be overridden
by an *equivalent* global. In C, a function with weak linkage can
be overridden by a function which behaves completely differently.
This means that IP passes have to skip weak functions, since any
deductions made from the function definition might be wrong, since
the definition could be replaced by something completely different
at link time. This is not allowed in C++, thanks to the ODR
(One-Definition-Rule): if a function is replaced by another at
link-time, then the new function must be the same as the original
function. If a language knows that a function or other global can
only be overridden by an equivalent global, it can give it the
weak_odr linkage type, and the optimizers will understand that it
is alright to make deductions based on the function body. The
code generators on the other hand map weak and weak_odr linkage
to the same thing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@66339 91177308-0d34-0410-b5e6-96231b3b80d8
2009-03-07 15:45:40 +00:00
|
|
|
if ((linkage == Function::WeakAnyLinkage ||
|
|
|
|
linkage == Function::WeakODRLinkage ||
|
|
|
|
linkage == Function::LinkOnceAnyLinkage ||
|
|
|
|
linkage == Function::LinkOnceODRLinkage) &&
|
2008-01-10 02:03:30 +00:00
|
|
|
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
|
2008-08-16 12:57:46 +00:00
|
|
|
// symbols.
|
2008-04-14 17:54:17 +00:00
|
|
|
// If UnwindTablesMandatory is set we cannot do this optimization; the
|
2008-04-08 00:10:24 +00:00
|
|
|
// unwind info is to be available for non-EH uses.
|
2008-01-10 02:03:30 +00:00
|
|
|
if (!EHFrameInfo.hasCalls &&
|
2008-04-14 17:54:17 +00:00
|
|
|
!UnwindTablesMandatory &&
|
Introduce new linkage types linkonce_odr, weak_odr, common_odr
and extern_weak_odr. These are the same as the non-odr versions,
except that they indicate that the global will only be overridden
by an *equivalent* global. In C, a function with weak linkage can
be overridden by a function which behaves completely differently.
This means that IP passes have to skip weak functions, since any
deductions made from the function definition might be wrong, since
the definition could be replaced by something completely different
at link time. This is not allowed in C++, thanks to the ODR
(One-Definition-Rule): if a function is replaced by another at
link-time, then the new function must be the same as the original
function. If a language knows that a function or other global can
only be overridden by an equivalent global, it can give it the
weak_odr linkage type, and the optimizers will understand that it
is alright to make deductions based on the function body. The
code generators on the other hand map weak and weak_odr linkage
to the same thing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@66339 91177308-0d34-0410-b5e6-96231b3b80d8
2009-03-07 15:45:40 +00:00
|
|
|
((linkage != Function::WeakAnyLinkage &&
|
|
|
|
linkage != Function::WeakODRLinkage &&
|
|
|
|
linkage != Function::LinkOnceAnyLinkage &&
|
|
|
|
linkage != Function::LinkOnceODRLinkage) ||
|
2008-01-10 02:03:30 +00:00
|
|
|
!TAI->getWeakDefDirective() ||
|
|
|
|
TAI->getSupportsWeakOmittedEHFrame()))
|
2008-08-16 12:57:46 +00:00
|
|
|
{
|
2007-09-18 01:47:22 +00:00
|
|
|
O << EHFrameInfo.FnName << " = 0\n";
|
2008-08-16 12:57:46 +00:00
|
|
|
// This name has no connection to the function, so it might get
|
|
|
|
// dead-stripped when the function is not, erroneously. Prohibit
|
2008-01-16 19:59:28 +00:00
|
|
|
// dead-stripping unconditionally.
|
|
|
|
if (const char *UsedDirective = TAI->getUsedDirective())
|
|
|
|
O << UsedDirective << EHFrameInfo.FnName << "\n\n";
|
2007-02-21 22:48:45 +00:00
|
|
|
} else {
|
2007-09-18 01:47:22 +00:00
|
|
|
O << EHFrameInfo.FnName << ":\n";
|
2007-11-20 23:24:42 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
// EH frame header.
|
2007-05-12 22:36:25 +00:00
|
|
|
EmitDifference("eh_frame_end", EHFrameInfo.Number,
|
|
|
|
"eh_frame_begin", EHFrameInfo.Number, true);
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL("Length of Frame Information Entry");
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2007-05-12 22:36:25 +00:00
|
|
|
EmitLabel("eh_frame_begin", EHFrameInfo.Number);
|
2007-03-07 02:47:57 +00:00
|
|
|
|
2008-12-24 08:05:17 +00:00
|
|
|
if (TAI->doesRequireNonLocalEHFrameLabel()) {
|
|
|
|
PrintRelDirective(true, true);
|
|
|
|
PrintLabelName("eh_frame_begin", EHFrameInfo.Number);
|
|
|
|
|
|
|
|
if (!TAI->isAbsoluteEHSectionOffsets())
|
|
|
|
O << "-EH_frame" << EHFrameInfo.PersonalityIndex;
|
|
|
|
} else {
|
|
|
|
EmitSectionOffset("eh_frame_begin", "eh_frame_common",
|
|
|
|
EHFrameInfo.Number, EHFrameInfo.PersonalityIndex,
|
|
|
|
true, true, false);
|
|
|
|
}
|
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL("FDE CIE offset");
|
|
|
|
|
2009-01-06 19:13:55 +00:00
|
|
|
EmitReference("eh_func_begin", EHFrameInfo.Number, true, true);
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL("FDE initial location");
|
2007-05-12 22:36:25 +00:00
|
|
|
EmitDifference("eh_func_end", EHFrameInfo.Number,
|
2009-01-06 19:13:55 +00:00
|
|
|
"eh_func_begin", EHFrameInfo.Number, true);
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL("FDE address range");
|
2008-05-07 19:11:09 +00:00
|
|
|
|
2007-02-28 18:38:31 +00:00
|
|
|
// If there is a personality and landing pads then point to the language
|
|
|
|
// specific data area in the exception table.
|
2007-05-13 15:42:26 +00:00
|
|
|
if (EHFrameInfo.PersonalityIndex) {
|
2008-05-07 19:11:09 +00:00
|
|
|
Asm->EmitULEB128Bytes(4);
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL("Augmentation size");
|
2008-05-07 19:11:09 +00:00
|
|
|
|
|
|
|
if (EHFrameInfo.hasLandingPads)
|
|
|
|
EmitReference("exception", EHFrameInfo.Number, true, true);
|
|
|
|
else
|
2007-02-28 18:38:31 +00:00
|
|
|
Asm->EmitInt32((int)0);
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL("Language Specific Data Area");
|
|
|
|
} else {
|
|
|
|
Asm->EmitULEB128Bytes(0);
|
|
|
|
Asm->EOL("Augmentation size");
|
|
|
|
}
|
2008-05-07 19:11:09 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
// Indicate locations of function specific callee saved registers in
|
|
|
|
// frame.
|
2009-01-17 08:01:33 +00:00
|
|
|
EmitFrameMoves("eh_func_begin", EHFrameInfo.Number, EHFrameInfo.Moves,
|
2009-01-17 08:05:14 +00:00
|
|
|
true);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2008-04-30 00:43:29 +00:00
|
|
|
// 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.
|
2008-08-16 12:57:46 +00:00
|
|
|
Asm->EmitAlignment(TD->getPointerSize() == sizeof(int32_t) ? 2 : 3,
|
2008-04-29 22:58:20 +00:00
|
|
|
0, 0, false);
|
2007-05-12 22:36:25 +00:00
|
|
|
EmitLabel("eh_frame_end", EHFrameInfo.Number);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
|
|
|
// If the function is marked used, this table should be also. We cannot
|
2008-01-16 19:59:28 +00:00
|
|
|
// make the mark unconditional in this case, since retaining the table
|
2008-08-16 12:57:46 +00:00
|
|
|
// also retains the function in this case, and there is code around
|
2008-01-16 19:59:28 +00:00
|
|
|
// 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";
|
|
|
|
}
|
2007-02-21 22:48:45 +00:00
|
|
|
}
|
2007-05-21 18:50:28 +00:00
|
|
|
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
/// EmitExceptionTable - Emit landing pads and actions.
|
2007-07-06 12:46:24 +00:00
|
|
|
///
|
|
|
|
/// 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 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.
|
|
|
|
|
2007-06-06 15:37:31 +00:00
|
|
|
/// SharedTypeIds - How many leading type ids two landing pads have in common.
|
|
|
|
static unsigned SharedTypeIds(const LandingPadInfo *L,
|
|
|
|
const LandingPadInfo *R) {
|
|
|
|
const std::vector<int> &LIds = L->TypeIds, &RIds = R->TypeIds;
|
2007-05-21 18:50:28 +00:00
|
|
|
unsigned LSize = LIds.size(), RSize = RIds.size();
|
2007-06-06 15:37:31 +00:00
|
|
|
unsigned MinSize = LSize < RSize ? LSize : RSize;
|
|
|
|
unsigned Count = 0;
|
2007-05-21 18:50:28 +00:00
|
|
|
|
2007-06-06 15:37:31 +00:00
|
|
|
for (; Count != MinSize; ++Count)
|
|
|
|
if (LIds[Count] != RIds[Count])
|
|
|
|
return Count;
|
2007-05-21 18:50:28 +00:00
|
|
|
|
2007-06-06 15:37:31 +00:00
|
|
|
return Count;
|
2007-05-21 18:50:28 +00:00
|
|
|
}
|
|
|
|
|
2007-06-06 15:37:31 +00:00
|
|
|
/// PadLT - Order landing pads lexicographically by type id.
|
2007-05-21 18:50:28 +00:00
|
|
|
static bool PadLT(const LandingPadInfo *L, const LandingPadInfo *R) {
|
2007-06-06 15:37:31 +00:00
|
|
|
const std::vector<int> &LIds = L->TypeIds, &RIds = R->TypeIds;
|
2007-05-21 18:50:28 +00:00
|
|
|
unsigned LSize = LIds.size(), RSize = RIds.size();
|
2007-06-06 15:37:31 +00:00
|
|
|
unsigned MinSize = LSize < RSize ? LSize : RSize;
|
2007-05-21 18:50:28 +00:00
|
|
|
|
2007-06-06 15:37:31 +00:00
|
|
|
for (unsigned i = 0; i != MinSize; ++i)
|
2007-05-21 18:50:28 +00:00
|
|
|
if (LIds[i] != RIds[i])
|
|
|
|
return LIds[i] < RIds[i];
|
|
|
|
|
2007-06-06 15:37:31 +00:00
|
|
|
return LSize < RSize;
|
2007-05-21 18:50:28 +00:00
|
|
|
}
|
|
|
|
|
2007-05-16 12:12:23 +00:00
|
|
|
struct KeyInfo {
|
|
|
|
static inline unsigned getEmptyKey() { return -1U; }
|
|
|
|
static inline unsigned getTombstoneKey() { return -2U; }
|
|
|
|
static unsigned getHashValue(const unsigned &Key) { return Key; }
|
2007-09-17 18:34:04 +00:00
|
|
|
static bool isEqual(unsigned LHS, unsigned RHS) { return LHS == RHS; }
|
2007-05-16 12:12:23 +00:00
|
|
|
static bool isPod() { return true; }
|
|
|
|
};
|
|
|
|
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
/// ActionEntry - Structure describing an entry in the actions table.
|
2007-06-06 15:37:31 +00:00
|
|
|
struct ActionEntry {
|
2007-07-06 12:46:24 +00:00
|
|
|
int ValueForTypeID; // The value to write - may not be equal to the type id.
|
2007-06-06 15:37:31 +00:00
|
|
|
int NextAction;
|
|
|
|
struct ActionEntry *Previous;
|
|
|
|
};
|
|
|
|
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
/// 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<unsigned, PadRange, KeyInfo> RangeMapType;
|
|
|
|
|
|
|
|
/// CallSiteEntry - Structure describing an entry in the call-site table.
|
|
|
|
struct CallSiteEntry {
|
2007-12-19 07:36:31 +00:00
|
|
|
// The 'try-range' is BeginLabel .. EndLabel.
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
unsigned BeginLabel; // zero indicates the start of the function.
|
|
|
|
unsigned EndLabel; // zero indicates the end of the function.
|
2007-12-19 07:36:31 +00:00
|
|
|
// The landing pad starts at PadLabel.
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
unsigned PadLabel; // zero indicates that there is no landing pad.
|
|
|
|
unsigned Action;
|
|
|
|
};
|
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
void EmitExceptionTable() {
|
|
|
|
const std::vector<GlobalVariable *> &TypeInfos = MMI->getTypeInfos();
|
2007-06-02 16:53:42 +00:00
|
|
|
const std::vector<unsigned> &FilterIds = MMI->getFilterIds();
|
2007-05-21 18:50:28 +00:00
|
|
|
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.
|
2007-06-08 08:59:11 +00:00
|
|
|
SmallVector<const LandingPadInfo *, 64> LandingPads;
|
|
|
|
LandingPads.reserve(PadInfos.size());
|
2007-05-21 18:50:28 +00:00
|
|
|
for (unsigned i = 0, N = PadInfos.size(); i != N; ++i)
|
2007-06-08 08:59:11 +00:00
|
|
|
LandingPads.push_back(&PadInfos[i]);
|
2007-05-21 18:50:28 +00:00
|
|
|
std::sort(LandingPads.begin(), LandingPads.end(), PadLT);
|
|
|
|
|
2007-07-06 12:46:24 +00:00
|
|
|
// Negative type ids index into FilterIds, positive type ids index into
|
|
|
|
// TypeInfos. The value written for a positive type id is just the type
|
|
|
|
// id itself. For a negative type id, however, the value written is the
|
|
|
|
// (negative) byte offset of the corresponding FilterIds entry. The byte
|
|
|
|
// offset is usually equal to the type id, because the FilterIds entries
|
|
|
|
// are written using a variable width encoding which outputs one byte per
|
|
|
|
// entry as long as the value written is not too large, but can differ.
|
|
|
|
// This kind of complication does not occur for positive type ids because
|
|
|
|
// type infos are output using a fixed width encoding.
|
|
|
|
// FilterOffsets[i] holds the byte offset corresponding to FilterIds[i].
|
|
|
|
SmallVector<int, 16> FilterOffsets;
|
|
|
|
FilterOffsets.reserve(FilterIds.size());
|
|
|
|
int Offset = -1;
|
|
|
|
for(std::vector<unsigned>::const_iterator I = FilterIds.begin(),
|
|
|
|
E = FilterIds.end(); I != E; ++I) {
|
|
|
|
FilterOffsets.push_back(Offset);
|
2008-08-16 12:57:46 +00:00
|
|
|
Offset -= TargetAsmInfo::getULEB128Size(*I);
|
2007-07-06 12:46:24 +00:00
|
|
|
}
|
|
|
|
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
// Compute the actions table and gather the first action index for each
|
|
|
|
// landing pad site.
|
|
|
|
SmallVector<ActionEntry, 32> Actions;
|
|
|
|
SmallVector<unsigned, 64> FirstActions;
|
|
|
|
FirstActions.reserve(LandingPads.size());
|
2007-02-21 22:48:45 +00:00
|
|
|
|
2007-06-06 15:37:31 +00:00
|
|
|
int FirstAction = 0;
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
unsigned SizeActions = 0;
|
2007-02-21 22:48:45 +00:00
|
|
|
for (unsigned i = 0, N = LandingPads.size(); i != N; ++i) {
|
2007-06-06 15:37:31 +00:00
|
|
|
const LandingPadInfo *LP = LandingPads[i];
|
|
|
|
const std::vector<int> &TypeIds = LP->TypeIds;
|
|
|
|
const unsigned NumShared = i ? SharedTypeIds(LP, LandingPads[i-1]) : 0;
|
2007-02-21 22:48:45 +00:00
|
|
|
unsigned SizeSiteActions = 0;
|
2007-05-21 18:50:28 +00:00
|
|
|
|
2007-06-06 15:37:31 +00:00
|
|
|
if (NumShared < TypeIds.size()) {
|
2007-05-21 18:50:28 +00:00
|
|
|
unsigned SizeAction = 0;
|
2007-06-06 15:37:31 +00:00
|
|
|
ActionEntry *PrevAction = 0;
|
|
|
|
|
|
|
|
if (NumShared) {
|
|
|
|
const unsigned SizePrevIds = LandingPads[i-1]->TypeIds.size();
|
|
|
|
assert(Actions.size());
|
|
|
|
PrevAction = &Actions.back();
|
2008-08-16 12:57:46 +00:00
|
|
|
SizeAction = TargetAsmInfo::getSLEB128Size(PrevAction->NextAction) +
|
|
|
|
TargetAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
|
2007-06-06 15:37:31 +00:00
|
|
|
for (unsigned j = NumShared; j != SizePrevIds; ++j) {
|
2008-08-16 12:57:46 +00:00
|
|
|
SizeAction -=
|
|
|
|
TargetAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
|
2007-06-06 15:37:31 +00:00
|
|
|
SizeAction += -PrevAction->NextAction;
|
|
|
|
PrevAction = PrevAction->Previous;
|
2007-05-21 18:50:28 +00:00
|
|
|
}
|
2007-06-06 15:37:31 +00:00
|
|
|
}
|
2007-05-21 18:50:28 +00:00
|
|
|
|
2007-06-06 15:37:31 +00:00
|
|
|
// Compute the actions.
|
|
|
|
for (unsigned I = NumShared, M = TypeIds.size(); I != M; ++I) {
|
|
|
|
int TypeID = TypeIds[I];
|
2007-07-06 12:46:24 +00:00
|
|
|
assert(-1-TypeID < (int)FilterOffsets.size() && "Unknown filter id!");
|
|
|
|
int ValueForTypeID = TypeID < 0 ? FilterOffsets[-1 - TypeID] : TypeID;
|
2008-08-16 12:57:46 +00:00
|
|
|
unsigned SizeTypeID = TargetAsmInfo::getSLEB128Size(ValueForTypeID);
|
2007-06-06 15:37:31 +00:00
|
|
|
|
|
|
|
int NextAction = SizeAction ? -(SizeAction + SizeTypeID) : 0;
|
2008-08-16 12:57:46 +00:00
|
|
|
SizeAction = SizeTypeID + TargetAsmInfo::getSLEB128Size(NextAction);
|
2007-06-06 15:37:31 +00:00
|
|
|
SizeSiteActions += SizeAction;
|
|
|
|
|
2007-07-06 12:46:24 +00:00
|
|
|
ActionEntry Action = {ValueForTypeID, NextAction, PrevAction};
|
2007-06-06 15:37:31 +00:00
|
|
|
Actions.push_back(Action);
|
|
|
|
|
|
|
|
PrevAction = &Actions.back();
|
2007-03-01 20:26:43 +00:00
|
|
|
}
|
2007-05-21 18:50:28 +00:00
|
|
|
|
2007-06-06 15:37:31 +00:00
|
|
|
// Record the first action of the landing pad site.
|
|
|
|
FirstAction = SizeActions + SizeSiteActions - SizeAction + 1;
|
|
|
|
} // else identical - re-use previous FirstAction
|
|
|
|
|
|
|
|
FirstActions.push_back(FirstAction);
|
2007-05-21 18:50:28 +00:00
|
|
|
|
2007-05-11 08:23:57 +00:00
|
|
|
// Compute this sites contribution to size.
|
2007-05-11 08:47:35 +00:00
|
|
|
SizeActions += SizeSiteActions;
|
2007-02-21 22:48:45 +00:00
|
|
|
}
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
|
2007-12-19 07:36:31 +00:00
|
|
|
// 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.
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
SmallVector<CallSiteEntry, 64> CallSites;
|
|
|
|
|
|
|
|
RangeMapType PadMap;
|
2007-12-19 07:36:31 +00:00
|
|
|
// 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.
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
for (unsigned i = 0, N = LandingPads.size(); i != N; ++i) {
|
|
|
|
const LandingPadInfo *LandingPad = LandingPads[i];
|
2007-12-19 07:36:31 +00:00
|
|
|
for (unsigned j = 0, E = LandingPad->BeginLabels.size(); j != E; ++j) {
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
unsigned BeginLabel = LandingPad->BeginLabels[j];
|
|
|
|
assert(!PadMap.count(BeginLabel) && "Duplicate landing pad labels!");
|
|
|
|
PadRange P = { i, j };
|
|
|
|
PadMap[BeginLabel] = P;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-12-19 07:36:31 +00:00
|
|
|
// The end label of the previous invoke or nounwind try-range.
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
unsigned LastLabel = 0;
|
2007-12-19 07:36:31 +00:00
|
|
|
|
|
|
|
// 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.
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
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) {
|
2008-07-01 00:05:16 +00:00
|
|
|
if (!MI->isLabel()) {
|
2008-01-07 07:27:27 +00:00
|
|
|
SawPotentiallyThrowing |= MI->getDesc().isCall();
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2007-12-30 20:50:28 +00:00
|
|
|
unsigned BeginLabel = MI->getOperand(0).getImm();
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
assert(BeginLabel && "Invalid label!");
|
2007-09-05 14:12:46 +00:00
|
|
|
|
2007-12-19 07:36:31 +00:00
|
|
|
// End of the previous try-range?
|
2007-09-05 14:12:46 +00:00
|
|
|
if (BeginLabel == LastLabel)
|
2007-12-19 07:36:31 +00:00
|
|
|
SawPotentiallyThrowing = false;
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
|
2007-12-19 07:36:31 +00:00
|
|
|
// Beginning of a new try-range?
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
RangeMapType::iterator L = PadMap.find(BeginLabel);
|
|
|
|
if (L == PadMap.end())
|
2007-12-19 07:36:31 +00:00
|
|
|
// Nope, it was just some random label.
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
PadRange P = L->second;
|
|
|
|
const LandingPadInfo *LandingPad = LandingPads[P.PadIndex];
|
|
|
|
|
|
|
|
assert(BeginLabel == LandingPad->BeginLabels[P.RangeIndex] &&
|
|
|
|
"Inconsistent landing pad map!");
|
|
|
|
|
|
|
|
// 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.
|
2007-12-19 07:36:31 +00:00
|
|
|
if (SawPotentiallyThrowing) {
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
CallSiteEntry Site = {LastLabel, BeginLabel, 0, 0};
|
|
|
|
CallSites.push_back(Site);
|
2007-12-19 07:36:31 +00:00
|
|
|
PreviousIsInvoke = false;
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
LastLabel = LandingPad->EndLabels[P.RangeIndex];
|
2007-12-19 07:36:31 +00:00
|
|
|
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) {
|
2008-06-21 22:00:54 +00:00
|
|
|
CallSiteEntry &Prev = CallSites.back();
|
2007-12-19 07:36:31 +00:00
|
|
|
if (Site.PadLabel == Prev.PadLabel && Site.Action == Prev.Action) {
|
|
|
|
// Extend the range of the previous entry.
|
|
|
|
Prev.EndLabel = Site.EndLabel;
|
|
|
|
continue;
|
|
|
|
}
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
}
|
|
|
|
|
2007-12-19 07:36:31 +00:00
|
|
|
// Otherwise, create a new call-site.
|
|
|
|
CallSites.push_back(Site);
|
|
|
|
PreviousIsInvoke = true;
|
|
|
|
} else {
|
|
|
|
// Create a gap.
|
|
|
|
PreviousIsInvoke = false;
|
|
|
|
}
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// 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.
|
2007-12-19 07:36:31 +00:00
|
|
|
if (SawPotentiallyThrowing) {
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
CallSiteEntry Site = {LastLabel, 0, 0, 0};
|
|
|
|
CallSites.push_back(Site);
|
|
|
|
}
|
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
// Final tallies.
|
2008-05-07 19:11:09 +00:00
|
|
|
|
|
|
|
// 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);
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
for (unsigned i = 0, e = CallSites.size(); i < e; ++i)
|
2008-08-16 12:57:46 +00:00
|
|
|
SizeSites += TargetAsmInfo::getULEB128Size(CallSites[i].Action);
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
|
2008-05-07 19:11:09 +00:00
|
|
|
// Type infos.
|
|
|
|
const unsigned TypeInfoSize = TD->getPointerSize(); // DW_EH_PE_absptr
|
|
|
|
unsigned SizeTypes = TypeInfos.size() * TypeInfoSize;
|
2007-05-12 22:36:25 +00:00
|
|
|
|
|
|
|
unsigned TypeOffset = sizeof(int8_t) + // Call site format
|
2008-08-16 12:57:46 +00:00
|
|
|
TargetAsmInfo::getULEB128Size(SizeSites) + // Call-site table length
|
2007-05-12 22:36:25 +00:00
|
|
|
SizeSites + SizeActions + SizeTypes;
|
|
|
|
|
|
|
|
unsigned TotalSize = sizeof(int8_t) + // LPStart format
|
|
|
|
sizeof(int8_t) + // TType format
|
2008-08-16 12:57:46 +00:00
|
|
|
TargetAsmInfo::getULEB128Size(TypeOffset) + // TType base offset
|
2007-05-12 22:36:25 +00:00
|
|
|
TypeOffset;
|
|
|
|
|
|
|
|
unsigned SizeAlign = (4 - TotalSize) & 3;
|
2007-05-10 18:40:24 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
// Begin the exception table.
|
|
|
|
Asm->SwitchToDataSection(TAI->getDwarfExceptionSection());
|
2008-02-29 19:36:59 +00:00
|
|
|
Asm->EmitAlignment(2, 0, 0, false);
|
2008-10-08 21:50:21 +00:00
|
|
|
O << "GCC_except_table" << SubprogramCount << ":\n";
|
2007-05-12 22:36:25 +00:00
|
|
|
for (unsigned i = 0; i != SizeAlign; ++i) {
|
|
|
|
Asm->EmitInt8(0);
|
|
|
|
Asm->EOL("Padding");
|
|
|
|
}
|
2007-02-21 22:48:45 +00:00
|
|
|
EmitLabel("exception", SubprogramCount);
|
2007-05-10 18:40:24 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
// Emit the header.
|
|
|
|
Asm->EmitInt8(DW_EH_PE_omit);
|
|
|
|
Asm->EOL("LPStart format (DW_EH_PE_omit)");
|
|
|
|
Asm->EmitInt8(DW_EH_PE_absptr);
|
|
|
|
Asm->EOL("TType format (DW_EH_PE_absptr)");
|
|
|
|
Asm->EmitULEB128Bytes(TypeOffset);
|
|
|
|
Asm->EOL("TType base offset");
|
|
|
|
Asm->EmitInt8(DW_EH_PE_udata4);
|
|
|
|
Asm->EOL("Call site format (DW_EH_PE_udata4)");
|
|
|
|
Asm->EmitULEB128Bytes(SizeSites);
|
|
|
|
Asm->EOL("Call-site table length");
|
2007-05-16 12:12:23 +00:00
|
|
|
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
// Emit the landing pad site information.
|
|
|
|
for (unsigned i = 0; i < CallSites.size(); ++i) {
|
|
|
|
CallSiteEntry &S = CallSites[i];
|
|
|
|
const char *BeginTag;
|
|
|
|
unsigned BeginNumber;
|
2007-05-16 12:12:23 +00:00
|
|
|
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
if (!S.BeginLabel) {
|
|
|
|
BeginTag = "eh_func_begin";
|
|
|
|
BeginNumber = SubprogramCount;
|
|
|
|
} else {
|
|
|
|
BeginTag = "label";
|
|
|
|
BeginNumber = S.BeginLabel;
|
2007-05-16 12:12:23 +00:00
|
|
|
}
|
|
|
|
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
EmitSectionOffset(BeginTag, "eh_func_begin", BeginNumber, SubprogramCount,
|
2008-05-07 19:11:09 +00:00
|
|
|
true, true);
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
Asm->EOL("Region start");
|
2007-05-16 12:12:23 +00:00
|
|
|
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
if (!S.EndLabel) {
|
2008-01-15 23:24:56 +00:00
|
|
|
EmitDifference("eh_func_end", SubprogramCount, BeginTag, BeginNumber,
|
2008-05-07 19:11:09 +00:00
|
|
|
true);
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
} else {
|
2008-05-07 19:11:09 +00:00
|
|
|
EmitDifference("label", S.EndLabel, BeginTag, BeginNumber, true);
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
}
|
|
|
|
Asm->EOL("Region length");
|
2007-05-16 12:12:23 +00:00
|
|
|
|
2008-05-07 19:11:09 +00:00
|
|
|
if (!S.PadLabel)
|
|
|
|
Asm->EmitInt32(0);
|
|
|
|
else
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
EmitSectionOffset("label", "eh_func_begin", S.PadLabel, SubprogramCount,
|
2008-05-07 19:11:09 +00:00
|
|
|
true, true);
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
Asm->EOL("Landing pad");
|
|
|
|
|
|
|
|
Asm->EmitULEB128Bytes(S.Action);
|
|
|
|
Asm->EOL("Action");
|
2007-02-21 22:48:45 +00:00
|
|
|
}
|
2007-05-16 12:12:23 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
// Emit the actions.
|
2007-06-06 15:37:31 +00:00
|
|
|
for (unsigned I = 0, N = Actions.size(); I != N; ++I) {
|
|
|
|
ActionEntry &Action = Actions[I];
|
2007-05-21 18:50:28 +00:00
|
|
|
|
2007-07-06 12:46:24 +00:00
|
|
|
Asm->EmitSLEB128Bytes(Action.ValueForTypeID);
|
2007-06-06 15:37:31 +00:00
|
|
|
Asm->EOL("TypeInfo index");
|
|
|
|
Asm->EmitSLEB128Bytes(Action.NextAction);
|
|
|
|
Asm->EOL("Next action");
|
2007-02-21 22:48:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Emit the type ids.
|
|
|
|
for (unsigned M = TypeInfos.size(); M; --M) {
|
|
|
|
GlobalVariable *GV = TypeInfos[M - 1];
|
2007-09-02 22:07:21 +00:00
|
|
|
|
|
|
|
PrintRelDirective();
|
2007-02-21 22:48:45 +00:00
|
|
|
|
2009-04-10 00:12:49 +00:00
|
|
|
if (GV) {
|
|
|
|
std::string GLN;
|
|
|
|
O << Asm->getGlobalLinkName(GV, GLN);
|
|
|
|
} else {
|
2007-02-21 22:48:45 +00:00
|
|
|
O << "0";
|
2009-04-10 00:12:49 +00:00
|
|
|
}
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
|
2007-02-21 22:48:45 +00:00
|
|
|
Asm->EOL("TypeInfo");
|
|
|
|
}
|
|
|
|
|
2007-06-02 16:53:42 +00:00
|
|
|
// Emit the filter typeids.
|
|
|
|
for (unsigned j = 0, M = FilterIds.size(); j < M; ++j) {
|
|
|
|
unsigned TypeID = FilterIds[j];
|
2007-07-12 13:51:39 +00:00
|
|
|
Asm->EmitULEB128Bytes(TypeID);
|
2007-06-02 16:53:42 +00:00
|
|
|
Asm->EOL("Filter TypeInfo index");
|
2007-03-01 20:26:43 +00:00
|
|
|
}
|
Fix PR1628. When exception handling is turned on,
labels are generated bracketing each call (not just
invokes). This is used to generate entries in
the exception table required by the C++ personality.
However it gets in the way of tail-merging. This
patch solves the problem by no longer placing labels
around ordinary calls. Instead we generate entries
in the exception table that cover every instruction
in the function that wasn't covered by an invoke
range (the range given by the labels around the invoke).
As an optimization, such entries are only generated for
parts of the function that contain a call, since for
the moment those are the only instructions that can
throw an exception [1]. As a happy consequence, we
now get a smaller exception table, since the same
region can cover many calls. While there, I also
implemented folding of invoke ranges - successive
ranges are merged when safe to do so. Finally, if
a selector contains only a cleanup, there's a special
shorthand for it - place a 0 in the call-site entry.
I implemented this while there. As a result, the
exception table output (excluding filters) is now
optimal - it cannot be made smaller [2]. The
problem with throw filters is that folding them
optimally is hard, and the benefit of folding them is
minimal.
[1] I tested that having trapping instructions (eg
divide by zero) in such a region doesn't cause trouble.
[2] It could be made smaller with the help of higher
layers, eg by having branch folding reorder basic blocks
ending in invokes with the same landing pad so they
follow each other. I don't know if this is worth doing.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41718 91177308-0d34-0410-b5e6-96231b3b80d8
2007-09-05 11:27:52 +00:00
|
|
|
|
2008-02-29 19:36:59 +00:00
|
|
|
Asm->EmitAlignment(2, 0, 0, false);
|
2007-02-01 16:31:34 +00:00
|
|
|
}
|
|
|
|
|
2007-01-29 18:51:14 +00:00
|
|
|
public:
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
// Main entry points.
|
|
|
|
//
|
2008-08-21 00:14:44 +00:00
|
|
|
DwarfException(raw_ostream &OS, AsmPrinter *A, const TargetAsmInfo *T)
|
2009-03-10 21:23:25 +00:00
|
|
|
: Dwarf(OS, A, T, "eh"), shouldEmitTable(false), shouldEmitMoves(false),
|
|
|
|
shouldEmitTableModule(false), shouldEmitMovesModule(false),
|
|
|
|
ExceptionTimer(0) {
|
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
ExceptionTimer = new Timer("Dwarf Exception Writer",
|
2009-03-10 22:58:53 +00:00
|
|
|
getDwarfTimerGroup());
|
2009-03-10 21:23:25 +00:00
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2009-03-10 21:23:25 +00:00
|
|
|
virtual ~DwarfException() {
|
|
|
|
delete ExceptionTimer;
|
|
|
|
}
|
2007-01-29 18:51:14 +00:00
|
|
|
|
|
|
|
/// SetModuleInfo - Set machine module information when it's known that pass
|
|
|
|
/// manager has created it. Set by the target AsmPrinter.
|
|
|
|
void SetModuleInfo(MachineModuleInfo *mmi) {
|
2007-02-28 18:38:31 +00:00
|
|
|
MMI = mmi;
|
2007-01-29 18:51:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// BeginModule - Emit all exception information that should come prior to the
|
|
|
|
/// content.
|
|
|
|
void BeginModule(Module *M) {
|
|
|
|
this->M = M;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// EndModule - Emit all exception information that should come after the
|
|
|
|
/// content.
|
|
|
|
void EndModule() {
|
2009-03-10 21:23:25 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
ExceptionTimer->startTimer();
|
|
|
|
|
2008-04-02 00:25:04 +00:00
|
|
|
if (shouldEmitMovesModule || shouldEmitTableModule) {
|
|
|
|
const std::vector<Function *> Personalities = MMI->getPersonalities();
|
2009-02-25 07:04:34 +00:00
|
|
|
for (unsigned i = 0; i < Personalities.size(); ++i)
|
2008-04-02 00:25:04 +00:00
|
|
|
EmitCommonEHFrame(Personalities[i], i);
|
|
|
|
|
|
|
|
for (std::vector<FunctionEHFrameInfo>::iterator I = EHFrames.begin(),
|
|
|
|
E = EHFrames.end(); I != E; ++I)
|
|
|
|
EmitEHFrame(*I);
|
|
|
|
}
|
2009-03-10 21:23:25 +00:00
|
|
|
|
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
ExceptionTimer->stopTimer();
|
2007-01-29 18:51:14 +00:00
|
|
|
}
|
|
|
|
|
2008-08-16 12:57:46 +00:00
|
|
|
/// BeginFunction - Gather pre-function exception information. Assumes being
|
2007-01-29 18:51:14 +00:00
|
|
|
/// emitted immediately after the function entry point.
|
|
|
|
void BeginFunction(MachineFunction *MF) {
|
2009-03-10 21:23:25 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
ExceptionTimer->startTimer();
|
|
|
|
|
2007-01-29 18:51:14 +00:00
|
|
|
this->MF = MF;
|
2008-04-02 00:25:04 +00:00
|
|
|
shouldEmitTable = shouldEmitMoves = false;
|
|
|
|
|
2009-03-10 21:23:25 +00:00
|
|
|
if (MMI && TAI->doesSupportExceptionHandling()) {
|
2008-04-02 00:25:04 +00:00
|
|
|
// Map all labels and get rid of any dead landing pads.
|
|
|
|
MMI->TidyLandingPads();
|
2009-03-10 21:23:25 +00:00
|
|
|
|
2008-04-02 00:25:04 +00:00
|
|
|
// If any landing pads survive, we need an EH table.
|
|
|
|
if (MMI->getLandingPads().size())
|
|
|
|
shouldEmitTable = true;
|
|
|
|
|
|
|
|
// See if we need frame move info.
|
2008-07-04 09:55:48 +00:00
|
|
|
if (!MF->getFunction()->doesNotThrow() || UnwindTablesMandatory)
|
2008-04-02 00:25:04 +00:00
|
|
|
shouldEmitMoves = true;
|
|
|
|
|
|
|
|
if (shouldEmitMoves || shouldEmitTable)
|
|
|
|
// Assumes in correct section after the entry point.
|
|
|
|
EmitLabel("eh_func_begin", ++SubprogramCount);
|
2007-02-28 18:38:31 +00:00
|
|
|
}
|
2009-03-10 21:23:25 +00:00
|
|
|
|
2008-04-02 00:25:04 +00:00
|
|
|
shouldEmitTableModule |= shouldEmitTable;
|
|
|
|
shouldEmitMovesModule |= shouldEmitMoves;
|
2009-03-10 21:23:25 +00:00
|
|
|
|
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
ExceptionTimer->stopTimer();
|
2007-01-29 18:51:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// EndFunction - Gather and emit post-function exception information.
|
|
|
|
///
|
|
|
|
void EndFunction() {
|
2009-03-10 21:23:25 +00:00
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
ExceptionTimer->startTimer();
|
|
|
|
|
2008-04-02 00:25:04 +00:00
|
|
|
if (shouldEmitMoves || shouldEmitTable) {
|
|
|
|
EmitLabel("eh_func_end", SubprogramCount);
|
|
|
|
EmitExceptionTable();
|
2007-02-01 16:31:34 +00:00
|
|
|
|
2008-04-02 00:25:04 +00:00
|
|
|
// Save EH frame information
|
2009-04-10 00:12:49 +00:00
|
|
|
std::string Name;
|
|
|
|
EHFrames.push_back(
|
|
|
|
FunctionEHFrameInfo(getAsm()->getCurrentFunctionEHName(MF, Name),
|
|
|
|
SubprogramCount,
|
|
|
|
MMI->getPersonalityIndex(),
|
|
|
|
MF->getFrameInfo()->hasCalls(),
|
|
|
|
!MMI->getLandingPads().empty(),
|
|
|
|
MMI->getFrameMoves(),
|
|
|
|
MF->getFunction()));
|
2009-03-10 21:23:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (TimePassesIsEnabled)
|
|
|
|
ExceptionTimer->stopTimer();
|
2007-01-29 18:51:14 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
} // End of namespace llvm
|
2006-04-07 16:34:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-04-07 16:34:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Emit - Print the abbreviation using the specified Dwarf writer.
|
2006-01-17 20:41:40 +00:00
|
|
|
///
|
2007-01-29 18:51:14 +00:00
|
|
|
void DIEAbbrev::Emit(const DwarfDebug &DD) const {
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit its Dwarf tag type.
|
2007-01-29 18:51:14 +00:00
|
|
|
DD.getAsm()->EmitULEB128Bytes(Tag);
|
|
|
|
DD.getAsm()->EOL(TagString(Tag));
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit whether it has children DIEs.
|
2007-01-29 18:51:14 +00:00
|
|
|
DD.getAsm()->EmitULEB128Bytes(ChildrenFlag);
|
|
|
|
DD.getAsm()->EOL(ChildrenString(ChildrenFlag));
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// For each attribute description.
|
|
|
|
for (unsigned i = 0, N = Data.size(); i < N; ++i) {
|
|
|
|
const DIEAbbrevData &AttrData = Data[i];
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit attribute type.
|
2007-01-29 18:51:14 +00:00
|
|
|
DD.getAsm()->EmitULEB128Bytes(AttrData.getAttribute());
|
|
|
|
DD.getAsm()->EOL(AttributeString(AttrData.getAttribute()));
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
// Emit form type.
|
2007-01-29 18:51:14 +00:00
|
|
|
DD.getAsm()->EmitULEB128Bytes(AttrData.getForm());
|
|
|
|
DD.getAsm()->EOL(FormEncodingString(AttrData.getForm()));
|
2006-01-20 20:34:06 +00:00
|
|
|
}
|
2006-11-02 20:12:39 +00:00
|
|
|
|
|
|
|
// Mark end of abbreviation.
|
2007-01-29 18:51:14 +00:00
|
|
|
DD.getAsm()->EmitULEB128Bytes(0); DD.getAsm()->EOL("EOM(1)");
|
|
|
|
DD.getAsm()->EmitULEB128Bytes(0); DD.getAsm()->EOL("EOM(2)");
|
2006-01-17 20:41:40 +00:00
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
void DIEAbbrev::print(std::ostream &O) {
|
|
|
|
O << "Abbreviation @"
|
|
|
|
<< std::hex << (intptr_t)this << std::dec
|
|
|
|
<< " "
|
|
|
|
<< TagString(Tag)
|
|
|
|
<< " "
|
|
|
|
<< ChildrenString(ChildrenFlag)
|
|
|
|
<< "\n";
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
for (unsigned i = 0, N = Data.size(); i < N; ++i) {
|
|
|
|
O << " "
|
|
|
|
<< AttributeString(Data[i].getAttribute())
|
|
|
|
<< " "
|
|
|
|
<< FormEncodingString(Data[i].getForm())
|
|
|
|
<< "\n";
|
2006-01-20 20:34:06 +00:00
|
|
|
}
|
2006-01-17 20:41:40 +00:00
|
|
|
}
|
2006-12-07 01:30:32 +00:00
|
|
|
void DIEAbbrev::dump() { print(cerr); }
|
2006-11-02 20:12:39 +00:00
|
|
|
#endif
|
2006-01-17 20:41:40 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef NDEBUG
|
|
|
|
void DIEValue::dump() {
|
2006-12-07 01:30:32 +00:00
|
|
|
print(cerr);
|
2006-01-17 20:41:40 +00:00
|
|
|
}
|
2006-11-02 20:12:39 +00:00
|
|
|
#endif
|
2006-01-17 20:41:40 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-01-18 16:54:26 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// EmitValue - Emit integer of appropriate size.
|
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
void DIEInteger::EmitValue(DwarfDebug &DD, unsigned Form) {
|
2006-11-02 20:12:39 +00:00
|
|
|
switch (Form) {
|
|
|
|
case DW_FORM_flag: // Fall thru
|
|
|
|
case DW_FORM_ref1: // Fall thru
|
2007-01-29 18:51:14 +00:00
|
|
|
case DW_FORM_data1: DD.getAsm()->EmitInt8(Integer); break;
|
2007-01-25 15:12:02 +00:00
|
|
|
case DW_FORM_ref2: // Fall thru
|
2007-01-29 18:51:14 +00:00
|
|
|
case DW_FORM_data2: DD.getAsm()->EmitInt16(Integer); break;
|
2007-01-25 15:12:02 +00:00
|
|
|
case DW_FORM_ref4: // Fall thru
|
2007-01-29 18:51:14 +00:00
|
|
|
case DW_FORM_data4: DD.getAsm()->EmitInt32(Integer); break;
|
2007-01-25 15:12:02 +00:00
|
|
|
case DW_FORM_ref8: // Fall thru
|
2007-01-29 18:51:14 +00:00
|
|
|
case DW_FORM_data8: DD.getAsm()->EmitInt64(Integer); break;
|
|
|
|
case DW_FORM_udata: DD.getAsm()->EmitULEB128Bytes(Integer); break;
|
|
|
|
case DW_FORM_sdata: DD.getAsm()->EmitSLEB128Bytes(Integer); break;
|
2007-01-25 15:12:02 +00:00
|
|
|
default: assert(0 && "DIE Value form not supported yet"); break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// SizeOf - Determine size of integer value in bytes.
|
|
|
|
///
|
2007-01-29 18:51:14 +00:00
|
|
|
unsigned DIEInteger::SizeOf(const DwarfDebug &DD, unsigned Form) const {
|
2007-01-25 15:12:02 +00:00
|
|
|
switch (Form) {
|
|
|
|
case DW_FORM_flag: // Fall thru
|
|
|
|
case DW_FORM_ref1: // Fall thru
|
|
|
|
case DW_FORM_data1: return sizeof(int8_t);
|
2006-11-02 20:12:39 +00:00
|
|
|
case DW_FORM_ref2: // Fall thru
|
2007-01-25 15:12:02 +00:00
|
|
|
case DW_FORM_data2: return sizeof(int16_t);
|
2006-11-02 20:12:39 +00:00
|
|
|
case DW_FORM_ref4: // Fall thru
|
2007-01-25 15:12:02 +00:00
|
|
|
case DW_FORM_data4: return sizeof(int32_t);
|
2006-11-02 20:12:39 +00:00
|
|
|
case DW_FORM_ref8: // Fall thru
|
2007-01-25 15:12:02 +00:00
|
|
|
case DW_FORM_data8: return sizeof(int64_t);
|
2008-08-16 12:57:46 +00:00
|
|
|
case DW_FORM_udata: return TargetAsmInfo::getULEB128Size(Integer);
|
|
|
|
case DW_FORM_sdata: return TargetAsmInfo::getSLEB128Size(Integer);
|
2006-11-02 20:12:39 +00:00
|
|
|
default: assert(0 && "DIE Value form not supported yet"); break;
|
|
|
|
}
|
2007-01-25 15:12:02 +00:00
|
|
|
return 0;
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2006-01-18 16:54:26 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-01-18 16:54:26 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// EmitValue - Emit string value.
|
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
void DIEString::EmitValue(DwarfDebug &DD, unsigned Form) {
|
2009-03-10 23:57:09 +00:00
|
|
|
DD.getAsm()->EmitString(Str);
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2006-01-18 16:54:26 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-01-18 16:54:26 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// EmitValue - Emit label value.
|
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
void DIEDwarfLabel::EmitValue(DwarfDebug &DD, unsigned Form) {
|
2007-09-28 16:50:28 +00:00
|
|
|
bool IsSmall = Form == DW_FORM_data4;
|
|
|
|
DD.EmitReference(Label, false, IsSmall);
|
2006-01-17 20:41:40 +00:00
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// SizeOf - Determine size of label value in bytes.
|
2006-01-17 20:41:40 +00:00
|
|
|
///
|
2007-01-29 18:51:14 +00:00
|
|
|
unsigned DIEDwarfLabel::SizeOf(const DwarfDebug &DD, unsigned Form) const {
|
2007-09-28 16:50:28 +00:00
|
|
|
if (Form == DW_FORM_data4) return 4;
|
2007-09-27 23:12:31 +00:00
|
|
|
return DD.getTargetData()->getPointerSize();
|
2006-01-17 20:41:40 +00:00
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
/// EmitValue - Emit label value.
|
2006-01-17 20:41:40 +00:00
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
void DIEObjectLabel::EmitValue(DwarfDebug &DD, unsigned Form) {
|
2007-09-28 16:50:28 +00:00
|
|
|
bool IsSmall = Form == DW_FORM_data4;
|
|
|
|
DD.EmitReference(Label, false, IsSmall);
|
2006-01-17 20:41:40 +00:00
|
|
|
}
|
2006-01-17 17:31:53 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// SizeOf - Determine size of label value in bytes.
|
|
|
|
///
|
2007-01-29 18:51:14 +00:00
|
|
|
unsigned DIEObjectLabel::SizeOf(const DwarfDebug &DD, unsigned Form) const {
|
2007-09-28 16:50:28 +00:00
|
|
|
if (Form == DW_FORM_data4) return 4;
|
2007-09-27 23:12:31 +00:00
|
|
|
return DD.getTargetData()->getPointerSize();
|
2006-01-24 00:49:18 +00:00
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-01-24 00:49:18 +00:00
|
|
|
|
2008-06-18 19:27:37 +00:00
|
|
|
/// 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();
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2008-06-18 19:27:37 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// EmitValue - Emit delta value.
|
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
void DIEDelta::EmitValue(DwarfDebug &DD, unsigned Form) {
|
2006-12-06 17:43:18 +00:00
|
|
|
bool IsSmall = Form == DW_FORM_data4;
|
2007-01-29 18:51:14 +00:00
|
|
|
DD.EmitDifference(LabelHi, LabelLo, IsSmall);
|
2006-01-24 00:49:18 +00:00
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// SizeOf - Determine size of delta value in bytes.
|
|
|
|
///
|
2007-01-29 18:51:14 +00:00
|
|
|
unsigned DIEDelta::SizeOf(const DwarfDebug &DD, unsigned Form) const {
|
2006-12-06 17:43:18 +00:00
|
|
|
if (Form == DW_FORM_data4) return 4;
|
2007-09-27 23:12:31 +00:00
|
|
|
return DD.getTargetData()->getPointerSize();
|
2006-02-22 19:02:11 +00:00
|
|
|
}
|
2006-01-24 00:49:18 +00:00
|
|
|
|
2006-01-17 17:31:53 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// EmitValue - Emit debug information entry offset.
|
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
void DIEntry::EmitValue(DwarfDebug &DD, unsigned Form) {
|
2007-01-29 18:51:14 +00:00
|
|
|
DD.getAsm()->EmitInt32(Entry->getOffset());
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2006-06-14 11:35:03 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// ComputeSize - calculate the size of the block.
|
|
|
|
///
|
2007-01-29 18:51:14 +00:00
|
|
|
unsigned DIEBlock::ComputeSize(DwarfDebug &DD) {
|
2006-11-02 20:12:39 +00:00
|
|
|
if (!Size) {
|
2008-06-24 21:44:59 +00:00
|
|
|
const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev.getData();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
for (unsigned i = 0, N = Values.size(); i < N; ++i) {
|
2007-01-29 18:51:14 +00:00
|
|
|
Size += Values[i]->SizeOf(DD, AbbrevData[i].getForm());
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2006-06-14 11:35:03 +00:00
|
|
|
}
|
2006-11-02 20:12:39 +00:00
|
|
|
return Size;
|
2006-04-07 16:34:46 +00:00
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// EmitValue - Emit block data.
|
2006-01-04 22:28:25 +00:00
|
|
|
///
|
2007-03-07 08:25:02 +00:00
|
|
|
void DIEBlock::EmitValue(DwarfDebug &DD, unsigned Form) {
|
2006-11-02 20:12:39 +00:00
|
|
|
switch (Form) {
|
2007-01-29 18:51:14 +00:00
|
|
|
case DW_FORM_block1: DD.getAsm()->EmitInt8(Size); break;
|
|
|
|
case DW_FORM_block2: DD.getAsm()->EmitInt16(Size); break;
|
|
|
|
case DW_FORM_block4: DD.getAsm()->EmitInt32(Size); break;
|
|
|
|
case DW_FORM_block: DD.getAsm()->EmitULEB128Bytes(Size); break;
|
2007-01-25 15:12:02 +00:00
|
|
|
default: assert(0 && "Improper form for block"); break;
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2008-06-24 21:44:59 +00:00
|
|
|
const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev.getData();
|
2006-11-02 20:12:39 +00:00
|
|
|
|
|
|
|
for (unsigned i = 0, N = Values.size(); i < N; ++i) {
|
2007-02-21 22:48:45 +00:00
|
|
|
DD.getAsm()->EOL();
|
2007-01-29 18:51:14 +00:00
|
|
|
Values[i]->EmitValue(DD, AbbrevData[i].getForm());
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
2006-01-04 22:28:25 +00:00
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// SizeOf - Determine size of block data in bytes.
|
2006-01-04 13:52:30 +00:00
|
|
|
///
|
2007-01-29 18:51:14 +00:00
|
|
|
unsigned DIEBlock::SizeOf(const DwarfDebug &DD, unsigned Form) const {
|
2006-11-02 20:12:39 +00:00
|
|
|
switch (Form) {
|
|
|
|
case DW_FORM_block1: return Size + sizeof(int8_t);
|
|
|
|
case DW_FORM_block2: return Size + sizeof(int16_t);
|
|
|
|
case DW_FORM_block4: return Size + sizeof(int32_t);
|
2008-08-16 12:57:46 +00:00
|
|
|
case DW_FORM_block: return Size + TargetAsmInfo::getULEB128Size(Size);
|
2006-11-02 20:12:39 +00:00
|
|
|
default: assert(0 && "Improper form for block"); break;
|
2006-06-23 12:51:53 +00:00
|
|
|
}
|
2006-11-02 20:12:39 +00:00
|
|
|
return 0;
|
2006-01-04 13:52:30 +00:00
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// DIE Implementation
|
2006-06-23 12:51:53 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
DIE::~DIE() {
|
|
|
|
for (unsigned i = 0, N = Children.size(); i < N; ++i)
|
|
|
|
delete Children[i];
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// AddSiblingOffset - Add a sibling offset field to the front of the DIE.
|
|
|
|
///
|
|
|
|
void DIE::AddSiblingOffset() {
|
|
|
|
DIEInteger *DI = new DIEInteger(0);
|
|
|
|
Values.insert(Values.begin(), DI);
|
|
|
|
Abbrev.AddFirstAttribute(DW_AT_sibling, DW_FORM_ref4);
|
2006-01-04 13:52:30 +00:00
|
|
|
}
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
/// Profile - Used to gather unique data for the value folding set.
|
2006-01-04 13:52:30 +00:00
|
|
|
///
|
2006-11-02 20:12:39 +00:00
|
|
|
void DIE::Profile(FoldingSetNodeID &ID) {
|
|
|
|
Abbrev.Profile(ID);
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
for (unsigned i = 0, N = Children.size(); i < N; ++i)
|
|
|
|
ID.AddPointer(Children[i]);
|
2006-06-23 12:51:53 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
for (unsigned j = 0, M = Values.size(); j < M; ++j)
|
|
|
|
ID.AddPointer(Values[j]);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef NDEBUG
|
|
|
|
void DIE::print(std::ostream &O, unsigned IncIndent) {
|
|
|
|
static unsigned IndentCount = 0;
|
|
|
|
IndentCount += IncIndent;
|
|
|
|
const std::string Indent(IndentCount, ' ');
|
|
|
|
bool isBlock = Abbrev.getTag() == 0;
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
if (!isBlock) {
|
|
|
|
O << Indent
|
|
|
|
<< "Die: "
|
|
|
|
<< "0x" << std::hex << (intptr_t)this << std::dec
|
|
|
|
<< ", Offset: " << Offset
|
|
|
|
<< ", Size: " << Size
|
2008-08-16 12:57:46 +00:00
|
|
|
<< "\n";
|
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
O << Indent
|
|
|
|
<< TagString(Abbrev.getTag())
|
|
|
|
<< " "
|
|
|
|
<< ChildrenString(Abbrev.getChildrenFlag());
|
|
|
|
} else {
|
|
|
|
O << "Size: " << Size;
|
2006-06-14 11:35:03 +00:00
|
|
|
}
|
2006-11-02 20:12:39 +00:00
|
|
|
O << "\n";
|
|
|
|
|
2008-06-24 21:44:59 +00:00
|
|
|
const SmallVector<DIEAbbrevData, 8> &Data = Abbrev.getData();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
IndentCount += 2;
|
|
|
|
for (unsigned i = 0, N = Data.size(); i < N; ++i) {
|
|
|
|
O << Indent;
|
2008-07-22 00:28:47 +00:00
|
|
|
|
|
|
|
if (!isBlock)
|
2006-11-02 20:12:39 +00:00
|
|
|
O << AttributeString(Data[i].getAttribute());
|
2008-07-22 00:28:47 +00:00
|
|
|
else
|
2006-11-02 20:12:39 +00:00
|
|
|
O << "Blk[" << i << "]";
|
2008-07-22 00:28:47 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
O << " "
|
|
|
|
<< FormEncodingString(Data[i].getForm())
|
|
|
|
<< " ";
|
|
|
|
Values[i]->print(O);
|
|
|
|
O << "\n";
|
|
|
|
}
|
|
|
|
IndentCount -= 2;
|
2006-06-23 12:51:53 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
for (unsigned j = 0, M = Children.size(); j < M; ++j) {
|
|
|
|
Children[j]->print(O, 4);
|
|
|
|
}
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
if (!isBlock) O << "\n";
|
|
|
|
IndentCount -= IncIndent;
|
2006-01-04 13:52:30 +00:00
|
|
|
}
|
2006-10-30 13:35:07 +00:00
|
|
|
|
2006-11-02 20:12:39 +00:00
|
|
|
void DIE::dump() {
|
2006-12-07 01:30:32 +00:00
|
|
|
print(cerr);
|
2006-11-02 20:12:39 +00:00
|
|
|
}
|
|
|
|
#endif
|
2006-10-30 13:35:07 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// DwarfWriter Implementation
|
2006-11-02 20:12:39 +00:00
|
|
|
///
|
2006-10-30 13:35:07 +00:00
|
|
|
|
2009-03-10 20:41:52 +00:00
|
|
|
DwarfWriter::DwarfWriter()
|
2009-03-10 21:23:25 +00:00
|
|
|
: ImmutablePass(&ID), DD(0), DE(0) {}
|
2006-10-30 13:35:07 +00:00
|
|
|
|
|
|
|
DwarfWriter::~DwarfWriter() {
|
2007-01-29 18:51:14 +00:00
|
|
|
delete DE;
|
|
|
|
delete DD;
|
2006-10-30 13:35:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// BeginModule - Emit all Dwarf sections that should come prior to the
|
|
|
|
/// content.
|
2009-01-08 23:40:34 +00:00
|
|
|
void DwarfWriter::BeginModule(Module *M,
|
|
|
|
MachineModuleInfo *MMI,
|
|
|
|
raw_ostream &OS, AsmPrinter *A,
|
|
|
|
const TargetAsmInfo *T) {
|
|
|
|
DE = new DwarfException(OS, A, T);
|
|
|
|
DD = new DwarfDebug(OS, A, T);
|
2007-01-29 18:51:14 +00:00
|
|
|
DE->BeginModule(M);
|
|
|
|
DD->BeginModule(M);
|
2009-01-13 00:20:51 +00:00
|
|
|
DD->SetDebugInfo(MMI);
|
2009-01-08 23:40:34 +00:00
|
|
|
DE->SetModuleInfo(MMI);
|
2006-10-30 13:35:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// EndModule - Emit all Dwarf sections that should come after the content.
|
|
|
|
///
|
|
|
|
void DwarfWriter::EndModule() {
|
2007-01-29 18:51:14 +00:00
|
|
|
DE->EndModule();
|
|
|
|
DD->EndModule();
|
2006-10-30 13:35:07 +00:00
|
|
|
}
|
|
|
|
|
2008-08-16 12:57:46 +00:00
|
|
|
/// BeginFunction - Gather pre-function debug information. Assumes being
|
2006-10-30 13:35:07 +00:00
|
|
|
/// emitted immediately after the function entry point.
|
|
|
|
void DwarfWriter::BeginFunction(MachineFunction *MF) {
|
2007-01-29 18:51:14 +00:00
|
|
|
DE->BeginFunction(MF);
|
|
|
|
DD->BeginFunction(MF);
|
2006-10-30 13:35:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// EndFunction - Gather and emit post-function debug information.
|
|
|
|
///
|
2008-09-26 00:28:12 +00:00
|
|
|
void DwarfWriter::EndFunction(MachineFunction *MF) {
|
|
|
|
DD->EndFunction(MF);
|
2007-02-01 16:31:34 +00:00
|
|
|
DE->EndFunction();
|
2008-08-16 12:57:46 +00:00
|
|
|
|
2008-07-22 00:53:37 +00:00
|
|
|
if (MachineModuleInfo *MMI = DD->getMMI() ? DD->getMMI() : DE->getMMI())
|
2007-02-01 16:31:34 +00:00
|
|
|
// Clear function debug information.
|
|
|
|
MMI->EndFunction();
|
2006-10-30 13:35:07 +00:00
|
|
|
}
|
2009-01-12 19:17:34 +00:00
|
|
|
|
|
|
|
/// RecordSourceLine - Records location information and associates it with a
|
|
|
|
/// label. Returns a unique label ID used to generate a label and provide
|
|
|
|
/// correspondence to the source line list.
|
|
|
|
unsigned DwarfWriter::RecordSourceLine(unsigned Line, unsigned Col,
|
2009-04-30 23:22:31 +00:00
|
|
|
DICompileUnit CU) {
|
|
|
|
return DD->RecordSourceLine(Line, Col, CU);
|
2009-01-12 19:17:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// RecordRegionStart - Indicate the start of a region.
|
|
|
|
unsigned DwarfWriter::RecordRegionStart(GlobalVariable *V) {
|
2009-03-10 21:23:25 +00:00
|
|
|
return DD->RecordRegionStart(V);
|
2009-01-12 19:17:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// RecordRegionEnd - Indicate the end of a region.
|
2009-05-07 19:46:24 +00:00
|
|
|
unsigned DwarfWriter::RecordRegionEnd(GlobalVariable *V) {
|
|
|
|
return DD->RecordRegionEnd(V);
|
2009-01-12 19:17:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// getRecordSourceLineCount - Count source lines.
|
|
|
|
unsigned DwarfWriter::getRecordSourceLineCount() {
|
2009-03-10 21:23:25 +00:00
|
|
|
return DD->getRecordSourceLineCount();
|
2009-01-12 19:17:34 +00:00
|
|
|
}
|
2009-01-13 21:25:00 +00:00
|
|
|
|
2009-01-13 21:44:10 +00:00
|
|
|
/// RecordVariable - Indicate the declaration of a local variable.
|
|
|
|
///
|
2009-04-15 00:10:26 +00:00
|
|
|
void DwarfWriter::RecordVariable(GlobalVariable *GV, unsigned FrameIndex,
|
|
|
|
const MachineInstr *MI) {
|
|
|
|
DD->RecordVariable(GV, FrameIndex, MI);
|
2009-01-13 21:44:10 +00:00
|
|
|
}
|
2009-01-13 23:54:55 +00:00
|
|
|
|
2009-02-20 00:44:43 +00:00
|
|
|
/// ShouldEmitDwarfDebug - Returns true if Dwarf debugging declarations should
|
|
|
|
/// be emitted.
|
|
|
|
bool DwarfWriter::ShouldEmitDwarfDebug() const {
|
2009-05-03 08:50:41 +00:00
|
|
|
return DD && DD->ShouldEmitDwarfDebug();
|
2009-02-20 00:44:43 +00:00
|
|
|
}
|
2009-04-13 17:02:03 +00:00
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
//// RecordInlinedFnStart - Global variable GV is inlined at the location marked
|
2009-04-13 17:02:03 +00:00
|
|
|
//// by LabelID label.
|
2009-05-07 00:16:31 +00:00
|
|
|
unsigned DwarfWriter::RecordInlinedFnStart(DISubprogram SP, DICompileUnit CU,
|
|
|
|
unsigned Line, unsigned Col) {
|
|
|
|
return DD->RecordInlinedFnStart(SP, CU, Line, Col);
|
2009-04-15 00:10:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// RecordInlinedFnEnd - Indicate the end of inlined subroutine.
|
2009-05-07 00:16:31 +00:00
|
|
|
unsigned DwarfWriter::RecordInlinedFnEnd(DISubprogram SP) {
|
2009-04-15 00:10:26 +00:00
|
|
|
return DD->RecordInlinedFnEnd(SP);
|
2009-04-13 17:02:03 +00:00
|
|
|
}
|
|
|
|
|
2009-04-15 00:10:26 +00:00
|
|
|
/// RecordVariableScope - Record scope for the variable declared by
|
|
|
|
/// DeclareMI. DeclareMI must describe TargetInstrInfo::DECLARE.
|
|
|
|
void DwarfWriter::RecordVariableScope(DIVariable &DV,
|
|
|
|
const MachineInstr *DeclareMI) {
|
|
|
|
DD->RecordVariableScope(DV, DeclareMI);
|
|
|
|
}
|