//
// The LLVM Compiler Infrastructure
//
-// This file was developed by James M. Laskey and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
#include "llvm/Support/Dwarf.h"
#include "llvm/Support/DataTypes.h"
+#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/UniqueVector.h"
+#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/GlobalValue.h"
#include "llvm/Pass.h"
// Dwarf writers.
protected:
- DebugInfoDesc(unsigned T) : Tag(T | LLVMDebugVersion) {}
+ explicit DebugInfoDesc(unsigned T) : Tag(T | LLVMDebugVersion) {}
public:
virtual ~DebugInfoDesc() {}
public:
AnchorDesc();
- AnchorDesc(AnchoredDesc *D);
+ explicit AnchorDesc(AnchoredDesc *D);
// Accessors
unsigned getAnchorTag() const { return AnchorTag; }
protected:
- AnchoredDesc(unsigned T);
+ explicit AnchoredDesc(unsigned T);
public:
// Accessors.
/// getAnchorString - Return a string used to label this descriptor's anchor.
///
- static const char *AnchorString;
+ static const char *const AnchorString;
virtual const char *getAnchorString() const;
#ifndef NDEBUG
unsigned Flags; // Miscellaneous flags.
public:
- TypeDesc(unsigned T);
+ explicit TypeDesc(unsigned T);
// Accessors
DebugInfoDesc *getContext() const { return Context; }
DebugInfoDesc *FromType; // Type derived from.
public:
- DerivedTypeDesc(unsigned T);
+ explicit DerivedTypeDesc(unsigned T);
// Accessors
TypeDesc *getFromType() const {
std::vector<DebugInfoDesc *> Elements;// Information used to compose type.
public:
- CompositeTypeDesc(unsigned T);
+ explicit CompositeTypeDesc(unsigned T);
// Accessors
std::vector<DebugInfoDesc *> &getElements() { return Elements; }
DebugInfoDesc *TyDesc; // Type of variable.
public:
- VariableDesc(unsigned T);
+ explicit VariableDesc(unsigned T);
// Accessors
DebugInfoDesc *getContext() const { return Context; }
bool IsDefinition; // Is the global defined in context.
protected:
- GlobalDesc(unsigned T);
+ explicit GlobalDesc(unsigned T);
public:
// Accessors
/// getAnchorString - Return a string used to label this descriptor's anchor.
///
- static const char *AnchorString;
+ static const char *const AnchorString;
virtual const char *getAnchorString() const;
#ifndef NDEBUG
/// getAnchorString - Return a string used to label this descriptor's anchor.
///
- static const char *AnchorString;
+ static const char *const AnchorString;
virtual const char *getAnchorString() const;
#ifndef NDEBUG
DIDeserializer() {}
~DIDeserializer() {}
+ const std::map<GlobalVariable *, DebugInfoDesc *> &getGlobalDescs() const {
+ return GlobalDescs;
+ }
+
/// Deserialize - Reconstitute a GlobalVariable into it's component
/// DebugInfoDesc objects.
DebugInfoDesc *Deserialize(Value *V);
/// Serialize - Recursively cast the specified descriptor into a
/// GlobalVariable so that it can be serialized to a .bc or .ll file.
GlobalVariable *Serialize(DebugInfoDesc *DD);
+
+ /// addDescriptor - Directly connect DD with existing GV.
+ void addDescriptor(DebugInfoDesc *DD, GlobalVariable *GV);
};
//===----------------------------------------------------------------------===//
/// serialization of a DebugInfoDesc.
bool Verify(Value *V);
bool Verify(GlobalVariable *GV);
+
+ /// isVerified - Return true if the specified GV has already been
+ /// verified as a debug information descriptor.
+ bool isVerified(GlobalVariable *GV);
};
//===----------------------------------------------------------------------===//
///
struct LandingPadInfo {
MachineBasicBlock *LandingPadBlock; // Landing pad block.
- unsigned BeginLabel; // Label prior to invoke.
- unsigned EndLabel; // Label after invoke.
+ SmallVector<unsigned, 1> BeginLabels; // Labels prior to invoke.
+ SmallVector<unsigned, 1> EndLabels; // Labels after invoke.
unsigned LandingPadLabel; // Label at beginning of landing pad.
Function *Personality; // Personality function.
- std::vector<unsigned> TypeIds; // List of type ids.
- bool IsFilter; // Indicate if the landing pad is a
- // throw filter.
-
- LandingPadInfo(MachineBasicBlock *MBB)
+ std::vector<int> TypeIds; // List of type ids (filters negative)
+
+ explicit LandingPadInfo(MachineBasicBlock *MBB)
: LandingPadBlock(MBB)
- , BeginLabel(0)
- , EndLabel(0)
, LandingPadLabel(0)
- , TypeIds()
- , IsFilter(false)
+ , Personality(NULL)
{}
};
//
std::vector<GlobalVariable *> TypeInfos;
+ // FilterIds - List of typeids encoding filters used in the current function.
+ //
+ std::vector<unsigned> FilterIds;
+
+ // FilterEnds - List of the indices in FilterIds corresponding to filter
+ // terminators.
+ //
+ std::vector<unsigned> FilterEnds;
+
+ // Personalities - Vector of all personality functions ever seen. Used to emit
+ // common EH frames.
+ std::vector<Function *> Personalities;
+
+ // UsedFunctions - the functions in the llvm.used list in a more easily
+ // searchable format.
+ SmallPtrSet<const Function *, 32> UsedFunctions;
+
+ bool CallsEHReturn;
+ bool CallsUnwindInit;
public:
- static const char ID; // Pass identifcation, replacement for typeid
+ static char ID; // Pass identification, replacement for typeid
MachineModuleInfo();
~MachineModuleInfo();
/// Verify - Verify that a Value is debug information descriptor.
///
- bool Verify(Value *V);
+ bool Verify(Value *V) { return VR.Verify(V); }
+
+ /// isVerified - Return true if the specified GV has already been
+ /// verified as a debug information descriptor.
+ bool isVerified(GlobalVariable *GV) { return VR.isVerified(GV); }
/// AnalyzeModule - Scan the module for global debug information.
///
///
bool hasDebugInfo() const { return !CompileUnits.empty(); }
- /// needsFrameInfo - Returns true if we need to gather callee-saved register
- /// move info for the frame.
- bool needsFrameInfo() const;
+ bool callsEHReturn() const { return CallsEHReturn; }
+ void setCallsEHReturn(bool b) { CallsEHReturn = b; }
+
+ bool callsUnwindInit() const { return CallsUnwindInit; }
+ void setCallsUnwindInit(bool b) { CallsUnwindInit = b; }
/// NextLabelID - Return the next unique label id.
///
return ID;
}
- /// RecordLabel - Records location information and associates it with a
+ /// 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 RecordLabel(unsigned Line, unsigned Column, unsigned Source);
+ unsigned RecordSourceLine(unsigned Line, unsigned Column, unsigned Source);
/// InvalidateLabel - Inhibit use of the specified label # from
/// MachineModuleInfo, for example because the code was deleted.
std::vector<T *> AnchoredDescs;
for (unsigned i = 0, N = Globals.size(); i < N; ++i) {
GlobalVariable *GV = Globals[i];
-
+
// FIXME - In the short term, changes are too drastic to continue.
if (DebugInfoDesc::TagFromGlobal(GV) == Desc.getTag() &&
DebugInfoDesc::VersionFromGlobal(GV) == LLVMDebugVersion) {
/// RecordVariable - Indicate the declaration of a local variable.
///
- void RecordVariable(Value *V, unsigned FrameIndex);
+ void RecordVariable(GlobalValue *GV, unsigned FrameIndex);
/// getRootScope - Return current functions root scope.
///
/// addPersonality - Provide the personality function for the exception
/// information.
void addPersonality(MachineBasicBlock *LandingPad, Function *Personality);
-
+
+ /// getPersonalityIndex - Get index of the current personality function inside
+ /// Personalitites array
+ unsigned getPersonalityIndex() const;
+
+ /// getPersonalities - Return array of personality functions ever seen.
+ const std::vector<Function *>& getPersonalities() const {
+ return Personalities;
+ }
+
+ // UsedFunctions - Return set of the functions in the llvm.used list.
+ const SmallPtrSet<const Function *, 32>& getUsedFunctions() const {
+ return UsedFunctions;
+ }
+
/// addCatchTypeInfo - Provide the catch typeinfo for a landing pad.
///
void addCatchTypeInfo(MachineBasicBlock *LandingPad,
std::vector<GlobalVariable *> &TyInfo);
-
- /// setIsFilterLandingPad - Indicates that the landing pad is a throw filter.
+
+ /// addFilterTypeInfo - Provide the filter typeinfo for a landing pad.
///
- void setIsFilterLandingPad(MachineBasicBlock *LandingPad);
-
+ void addFilterTypeInfo(MachineBasicBlock *LandingPad,
+ std::vector<GlobalVariable *> &TyInfo);
+
+ /// addCleanup - Add a cleanup action for a landing pad.
+ ///
+ void addCleanup(MachineBasicBlock *LandingPad);
+
/// getTypeIDFor - Return the type id for the specified typeinfo. This is
/// function wide.
unsigned getTypeIDFor(GlobalVariable *TI);
-
+
+ /// getFilterIDFor - Return the id of the filter encoded by TyIds. This is
+ /// function wide.
+ int getFilterIDFor(std::vector<unsigned> &TyIds);
+
/// TidyLandingPads - Remap landing pad labels and remove any deleted landing
/// pads.
void TidyLandingPads();
- /// getLandingPadInfos - Return a reference to the landing pad info for the
+ /// getLandingPads - Return a reference to the landing pad info for the
/// current function.
const std::vector<LandingPadInfo> &getLandingPads() const {
return LandingPads;
const std::vector<GlobalVariable *> &getTypeInfos() const {
return TypeInfos;
}
-
+
+ /// getFilterIds - Return a reference to the typeids encoding filters used in
+ /// the current function.
+ const std::vector<unsigned> &getFilterIds() const {
+ return FilterIds;
+ }
+
/// getPersonality - Return a personality function if available. The presence
/// of one is required to emit exception handling info.
Function *getPersonality() const;
+ DIDeserializer *getDIDeserializer() { return &DR; }
}; // End class MachineModuleInfo
} // End llvm namespace
projects / oota-llvm.git / blobdiff