DIObjCProperty(DbgNode).Verify() ||
DITemplateTypeParameter(DbgNode).Verify() ||
DITemplateValueParameter(DbgNode).Verify() ||
- DIImportedEntity(DbgNode).Verify());
+ DIImportedEntity(DbgNode).Verify() || DIExpression(DbgNode).Verify());
}
static Value *getField(const MDNode *DbgNode, unsigned Elt) {
}
}
-uint64_t DIVariable::getAddrElement(unsigned Idx) const {
- DIDescriptor ComplexExpr = getDescriptorField(8);
- if (Idx < ComplexExpr->getNumOperands())
- if (auto *CI = dyn_cast_or_null<ConstantInt>(ComplexExpr->getOperand(Idx)))
- return CI->getZExtValue();
-
- assert(false && "non-existing complex address element requested");
- return 0;
-}
-
/// getInlinedAt - If this variable is inlined then return inline location.
MDNode *DIVariable::getInlinedAt() const { return getNodeField(DbgNode, 7); }
-bool DIVariable::isVariablePiece() const {
- return hasComplexAddress() && getAddrElement(0) == DIBuilder::OpPiece;
-}
-
-uint64_t DIVariable::getPieceOffset() const {
- assert(isVariablePiece());
- return getAddrElement(1);
-}
-
-uint64_t DIVariable::getPieceSize() const {
- assert(isVariablePiece());
- return getAddrElement(2);
-}
-
/// Return the size reported by the variable's type.
unsigned DIVariable::getSizeInBits(const DITypeIdentifierMap &Map) {
DIType Ty = getType().resolve(Map);
return Ty.getSizeInBits();
}
+uint64_t DIExpression::getElement(unsigned Idx) const {
+ unsigned I = Idx + 1;
+ if (I < DbgNode->getNumOperands())
+ if (auto *CI = dyn_cast_or_null<ConstantInt>(DbgNode->getOperand(I)))
+ return CI->getZExtValue();
+
+ assert(false && "non-existing complex address element requested");
+ return 0;
+}
+
+bool DIExpression::isVariablePiece() const {
+ return getNumElements() && getElement(0) == dwarf::DW_OP_piece;
+}
+uint64_t DIExpression::getPieceOffset() const {
+ assert(isVariablePiece());
+ return getElement(1);
+}
+uint64_t DIExpression::getPieceSize() const {
+ assert(isVariablePiece());
+ return getElement(2);
+}
//===----------------------------------------------------------------------===//
// Predicates
getTag() == dwarf::DW_TAG_imported_declaration);
}
+/// \brief Return true if the specified tag is DW_TAG_imported_module or
+/// DW_TAG_imported_declaration.
+bool DIDescriptor::isExpression() const {
+ return DbgNode && (getTag() == dwarf::DW_TAG_expression);
+}
+
//===----------------------------------------------------------------------===//
// Simple Descriptor Constructors and other Methods
//===----------------------------------------------------------------------===//
/// replaceAllUsesWith - Replace all uses of the MDNode used by this
/// type with the one in the passed descriptor.
-void DIType::replaceAllUsesWith(LLVMContext &VMContext, DIDescriptor D) {
+void DIDescriptor::replaceAllUsesWith(LLVMContext &VMContext, DIDescriptor D) {
assert(DbgNode && "Trying to replace an unverified type!");
const Value *V = cast_or_null<Value>(DN);
Node->replaceAllUsesWith(const_cast<Value *>(V));
MDNode::deleteTemporary(Node);
- DbgNode = D;
+ DbgNode = DN;
}
/// replaceAllUsesWith - Replace all uses of the MDNode used by this
/// type with the one in D.
-void DIType::replaceAllUsesWith(MDNode *D) {
+void DIDescriptor::replaceAllUsesWith(MDNode *D) {
assert(DbgNode && "Trying to replace an unverified type!");
assert(DbgNode != D && "This replacement should always happen");
Tag != dwarf::DW_TAG_inheritance && Tag != dwarf::DW_TAG_friend &&
getFilename().empty())
return false;
+
// DIType is abstract, it should be a BasicType, a DerivedType or
// a CompositeType.
if (isBasicType())
if (!fieldIsTypeRef(DbgNode, 5))
return false;
- // Variable without a complex expression.
- if (DbgNode->getNumOperands() == 8)
+ // Variable without an inline location.
+ if (DbgNode->getNumOperands() == 7)
+ return true;
+
+ return DbgNode->getNumOperands() == 8;
+}
+
+/// Verify - Verify that a variable descriptor is well formed.
+bool DIExpression::Verify() const {
+ // Empty DIExpressions may be represented as a nullptr.
+ if (!DbgNode)
return true;
- // Make sure the complex expression is an MDNode.
- return (DbgNode->getNumOperands() == 9 && fieldIsMDNode(DbgNode, 8));
+ return isExpression();
}
/// Verify - Verify that a location descriptor is well formed.
return DIVariable(MDNode::get(VMContext, Elts));
}
-
-/// getEntireVariable - Remove OpPiece exprs from the variable.
-DIVariable llvm::getEntireVariable(DIVariable DV) {
- if (!DV.isVariablePiece())
- return DV;
-
- SmallVector<Value *, 8> Elts;
- for (unsigned i = 0; i < 8; ++i)
- Elts.push_back(DV->getOperand(i));
-
- return DIVariable(MDNode::get(DV->getContext(), Elts));
-}
-
/// getDISubprogram - Find subprogram that is enclosing this scope.
DISubprogram llvm::getDISubprogram(const MDNode *Scope) {
DIDescriptor D(Scope);
DINameSpace(DbgNode).printInternal(OS);
} else if (this->isScope()) {
DIScope(DbgNode).printInternal(OS);
+ } else if (this->isExpression()) {
+ DIExpression(DbgNode).printInternal(OS);
}
}
OS << " [private]";
else if (isProtected())
OS << " [protected]";
+ else if (isPublic())
+ OS << " [public]";
if (isArtificial())
OS << " [artificial]";
OS << " [private]";
else if (isProtected())
OS << " [protected]";
+ else if (isPublic())
+ OS << " [public]";
if (isLValueReference())
OS << " [reference]";
OS << " [" << Res << ']';
OS << " [line " << getLineNumber() << ']';
+}
- if (isVariablePiece())
- OS << " [piece, size " << getPieceSize()
- << ", offset " << getPieceOffset() << ']';
+void DIExpression::printInternal(raw_ostream &OS) const {
+ for (unsigned I = 0; I < getNumElements(); ++I) {
+ uint64_t OpCode = getElement(I);
+ OS << " [" << OperationEncodingString(OpCode);
+ switch (OpCode) {
+ case DW_OP_plus: {
+ OS << " " << getElement(++I);
+ break;
+ }
+ case DW_OP_piece: {
+ unsigned Offset = getElement(++I);
+ unsigned Size = getElement(++I);
+ OS << " offset=" << Offset << ", size= " << Size;
+ break;
+ }
+ default:
+ // Else bail out early. This may be a line table entry.
+ OS << "Unknown]";
+ return;
+ }
+ OS << "]";
+ }
}
void DIObjCProperty::printInternal(raw_ostream &OS) const {
projects / oota-llvm.git / blobdiff