6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-10 02:36:06 +00:00
Code Issues Projects Releases Wiki Activity

[Debug Info] replace DIUnspecifiedParameter with DITrivialType.

Browse Source 
This is the first of a series of patches to handle type uniqueing of the
type array for a subroutine type.

This commit makes sure unspecified_parameter is a DIType to enable converting
the type array for a subroutine type to an array of DITypes.

This commit should have no functionality change. With this commit, we may
change unspecified type to be a DITrivialType instead of a DIType.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@214111 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Manman Ren 2014-07-28 18:52:30 +00:00
parent 40a0707ee7
commit f9b5976bbd
4 changed files with 54 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/IR/DIBuilder.h
View File

@ -463,9 +463,9 @@ namespace llvm {
/// through debug info anchors.
void retainType(DIType T);
/// createUnspecifiedParameter - Create unspecified type descriptor
/// createUnspecifiedParameter - Create unspecified parameter type
/// for a subroutine type.
DIDescriptor createUnspecifiedParameter();
DITrivialType createUnspecifiedParameter();
/// getOrCreateArray - Get a DIArray, create one if required.
DIArray getOrCreateArray(ArrayRef<Value *> Elements);

50
include/llvm/IR/DebugInfo.h
View File

@ -128,6 +128,7 @@ public:
bool isDerivedType() const;
bool isCompositeType() const;
bool isBasicType() const;
bool isTrivialType() const;
bool isVariable() const;
bool isSubprogram() const;
bool isGlobalVariable() const;
@ -302,15 +303,36 @@ public:
/// Verify - Verify that a type descriptor is well formed.
bool Verify() const;
DIScopeRef getContext() const { return getFieldAs<DIScopeRef>(2); }
StringRef getName() const { return getStringField(3); }
unsigned getLineNumber() const { return getUnsignedField(4); }
uint64_t getSizeInBits() const { return getUInt64Field(5); }
uint64_t getAlignInBits() const { return getUInt64Field(6); }
DIScopeRef getContext() const {
assert(!isTrivialType() && "no context for DITrivialType");
return getFieldAs<DIScopeRef>(2);
}
StringRef getName() const {
assert(!isTrivialType() && "no name for DITrivialType");
return getStringField(3);
}
unsigned getLineNumber() const {
assert(!isTrivialType() && "no line number for DITrivialType");
return getUnsignedField(4);
}
uint64_t getSizeInBits() const {
assert(!isTrivialType() && "no SizeInBits for DITrivialType");
return getUInt64Field(5);
}
uint64_t getAlignInBits() const {
assert(!isTrivialType() && "no AlignInBits for DITrivialType");
return getUInt64Field(6);
}
// FIXME: Offset is only used for DW_TAG_member nodes. Making every type
// carry this is just plain insane.
uint64_t getOffsetInBits() const { return getUInt64Field(7); }
unsigned getFlags() const { return getUnsignedField(8); }
uint64_t getOffsetInBits() const {
assert(!isTrivialType() && "no OffsetInBits for DITrivialType");
return getUInt64Field(7);
}
unsigned getFlags() const {
assert(!isTrivialType() && "no flag for DITrivialType");
return getUnsignedField(8);
}
bool isPrivate() const { return (getFlags() & FlagPrivate) != 0; }
bool isProtected() const { return (getFlags() & FlagProtected) != 0; }
bool isForwardDecl() const { return (getFlags() & FlagFwdDecl) != 0; }
@ -343,6 +365,12 @@ public:
void replaceAllUsesWith(MDNode *D);
};
class DITrivialType : public DIType {
public:
explicit DITrivialType(const MDNode *N = nullptr) : DIType(N) {}
bool Verify() const;
};
/// DIBasicType - A basic type, like 'int' or 'float'.
class DIBasicType : public DIType {
public:
@ -571,14 +599,6 @@ public:
bool Verify() const;
};
/// DIUnspecifiedParameter - This is a wrapper for unspecified parameters.
class DIUnspecifiedParameter : public DIDescriptor {
public:
explicit DIUnspecifiedParameter(const MDNode *N = nullptr)
: DIDescriptor(N) {}
bool Verify() const;
};
/// DITemplateTypeParameter - This is a wrapper for template type parameter.
class DITemplateTypeParameter : public DIDescriptor {
public:

4
lib/IR/DIBuilder.cpp
View File

@ -875,11 +875,11 @@ void DIBuilder::retainType(DIType T) {
/// createUnspecifiedParameter - Create unspeicified type descriptor
/// for the subroutine type.
DIDescriptor DIBuilder::createUnspecifiedParameter() {
DITrivialType DIBuilder::createUnspecifiedParameter() {
Value *Elts[] = {
GetTagConstant(VMContext, dwarf::DW_TAG_unspecified_parameters)
};
return DIDescriptor(MDNode::get(VMContext, Elts));
return DITrivialType(MDNode::get(VMContext, Elts));
}
/// createForwardDecl - Create a temporary forward-declared type that

24
lib/IR/DebugInfo.cpp
View File

@ -39,6 +39,7 @@ bool DIDescriptor::Verify() const {
return DbgNode &&
(DIDerivedType(DbgNode).Verify() ||
DICompositeType(DbgNode).Verify() || DIBasicType(DbgNode).Verify() ||
DITrivialType(DbgNode).Verify() ||
DIVariable(DbgNode).Verify() || DISubprogram(DbgNode).Verify() ||
DIGlobalVariable(DbgNode).Verify() || DIFile(DbgNode).Verify() ||
DICompileUnit(DbgNode).Verify() || DINameSpace(DbgNode).Verify() ||
@ -46,7 +47,6 @@ bool DIDescriptor::Verify() const {
DILexicalBlockFile(DbgNode).Verify() ||
DISubrange(DbgNode).Verify() || DIEnumerator(DbgNode).Verify() ||
DIObjCProperty(DbgNode).Verify() ||
DIUnspecifiedParameter(DbgNode).Verify() ||
DITemplateTypeParameter(DbgNode).Verify() ||
DITemplateValueParameter(DbgNode).Verify() ||
DIImportedEntity(DbgNode).Verify());
@ -155,6 +155,10 @@ MDNode *DIVariable::getInlinedAt() const { return getNodeField(DbgNode, 7); }
// Predicates
//===----------------------------------------------------------------------===//
bool DIDescriptor::isTrivialType() const {
return DbgNode && getTag() == dwarf::DW_TAG_unspecified_parameters;
}
/// isBasicType - Return true if the specified tag is legal for
/// DIBasicType.
bool DIDescriptor::isBasicType() const {
@ -225,7 +229,8 @@ bool DIDescriptor::isVariable() const {
/// isType - Return true if the specified tag is legal for DIType.
bool DIDescriptor::isType() const {
return isBasicType() || isCompositeType() || isDerivedType();
return isBasicType() || isCompositeType() || isDerivedType() ||
isTrivialType();
}
/// isSubprogram - Return true if the specified tag is legal for
@ -456,7 +461,7 @@ bool DIType::Verify() const {
// FIXME: Sink this into the various subclass verifies.
uint16_t Tag = getTag();
if (!isBasicType() && Tag != dwarf::DW_TAG_const_type &&
if (!isBasicType() && !isTrivialType() && Tag != dwarf::DW_TAG_const_type &&
Tag != dwarf::DW_TAG_volatile_type && Tag != dwarf::DW_TAG_pointer_type &&
Tag != dwarf::DW_TAG_ptr_to_member_type &&
Tag != dwarf::DW_TAG_reference_type &&
@ -471,6 +476,8 @@ bool DIType::Verify() const {
// a CompositeType.
if (isBasicType())
return DIBasicType(DbgNode).Verify();
else if (isTrivialType())
return DITrivialType(DbgNode).Verify();
else if (isCompositeType())
return DICompositeType(DbgNode).Verify();
else if (isDerivedType())
@ -484,6 +491,10 @@ bool DIBasicType::Verify() const {
return isBasicType() && DbgNode->getNumOperands() == 10;
}
bool DITrivialType::Verify() const {
return isTrivialType() && DbgNode->getNumOperands() == 1;
}
/// Verify - Verify that a derived type descriptor is well formed.
bool DIDerivedType::Verify() const {
// Make sure DerivedFrom @ field 9 is TypeRef.
@ -624,11 +635,6 @@ bool DILexicalBlockFile::Verify() const {
return isLexicalBlockFile() && DbgNode->getNumOperands() == 3;
}
/// \brief Verify that an unspecified parameter descriptor is well formed.
bool DIUnspecifiedParameter::Verify() const {
return isUnspecifiedParameter() && DbgNode->getNumOperands() == 1;
}
/// \brief Verify that the template type parameter descriptor is well formed.
bool DITemplateTypeParameter::Verify() const {
return isTemplateTypeParameter() && DbgNode->getNumOperands() == 7;
@ -1290,7 +1296,7 @@ void DIEnumerator::printInternal(raw_ostream &OS) const {
}
void DIType::printInternal(raw_ostream &OS) const {
if (!DbgNode)
if (!DbgNode || isTrivialType())
return;
StringRef Res = getName();