Use structured MSVC template backrefs

Author: plafosse

demangler/gnu3/demangled_type_node.cpp

@@ -63,6 +63,24 @@ namespace
 		return out;
 	}
 
+	static void AppendTemplateArgumentList(string& out, const vector<DemangledTypeNode::Param>& args)
+	{
+		if (args.empty())
+			return;
+
+		out += '<';
+		for (size_t i = 0; i < args.size(); i++)
+		{
+			if (i > 0)
+				out += ',';
+			if (args[i].type)
+				args[i].type->AppendString(out);
+		}
+		if (out.back() == '>')
+			out += ' ';
+		out += '>';
+	}
+
 	static size_t ResolveAddressWidth(Architecture* arch, Platform* platform)
 	{
 		if (arch)
@@ -256,6 +274,12 @@ DemangledTypeNode DemangledTypeNode::ValueType(const string& value)
 }
 
 
+DemangledTypeNode DemangledTypeNode::NameSegment(const string& name)
+{
+	return ValueType(name);
+}
+
+
 DemangledTypeNode DemangledTypeNode::VarArgsType()
 {
 	DemangledTypeNode n;
@@ -292,6 +316,15 @@ DemangledTypeNode DemangledTypeNode::MemberPointerType(DemangledTypeNode child,
 }
 
 
+DemangledTypeNode DemangledTypeNode::MemberPointerType(
+	DemangledTypeNode child, vector<DemangledTypeNode> ownerName, bool cnst, bool vltl)
+{
+	DemangledTypeNode n = MemberPointerType(std::move(child), StringList(), cnst, vltl);
+	n.m_memberPointerOwnerNameNodes = std::move(ownerName);
+	return n;
+}
+
+
 DemangledTypeNode DemangledTypeNode::ArrayType(DemangledTypeNode child, uint64_t count)
 {
 	DemangledTypeNode n;
@@ -331,6 +364,18 @@ DemangledTypeNode DemangledTypeNode::NamedType(BNNamedTypeReferenceClass cls,
 	return n;
 }
 
+DemangledTypeNode DemangledTypeNode::NamedType(BNNamedTypeReferenceClass cls,
+	vector<DemangledTypeNode> nameSegments, size_t width, bool isSigned)
+{
+	DemangledTypeNode n;
+	n.m_typeClass = NamedTypeReferenceClass;
+	n.m_ntrClass = cls;
+	n.m_nameSegmentNodes = std::move(nameSegments);
+	n.m_width = width;
+	n.m_signed = isSigned;
+	return n;
+}
+
 DemangledTypeNode DemangledTypeNode::NamedTypeWithDefaultIntegerWidth(BNNamedTypeReferenceClass cls,
 	StringList nameSegments, bool isSigned)
 {
@@ -339,6 +384,14 @@ DemangledTypeNode DemangledTypeNode::NamedTypeWithDefaultIntegerWidth(BNNamedTyp
 	return n;
 }
 
+DemangledTypeNode DemangledTypeNode::NamedTypeWithDefaultIntegerWidth(BNNamedTypeReferenceClass cls,
+	vector<DemangledTypeNode> nameSegments, bool isSigned)
+{
+	DemangledTypeNode n = NamedType(cls, std::move(nameSegments), 0, isSigned);
+	n.m_widthKind = DefaultIntegerWidth;
+	return n;
+}
+
 uint8_t DemangledTypeNode::PointerSuffixBit(BNPointerSuffix ps)
 {
 	switch (ps)
@@ -374,6 +427,71 @@ size_t DemangledTypeNode::ResolveWidth(Architecture* arch, Platform* platform) c
 }
 
 
+bool DemangledTypeNode::HasTemplateArguments() const
+{
+	if (m_hasTemplateArgs || !m_templateArgs.empty())
+		return true;
+	for (const auto& segment: m_nameSegmentNodes)
+		if (segment.HasTemplateArguments())
+			return true;
+	return false;
+}
+
+
+void DemangledTypeNode::SetTemplateArguments(vector<Param> args)
+{
+	m_templateArgs = std::move(args);
+	m_hasTemplateArgs = true;
+}
+
+
+string DemangledTypeNode::GetNameSegmentBase() const
+{
+	if (m_typeClass == ValueTypeClass)
+		return m_altName;
+	if (!m_nameSegments.empty())
+		return m_nameSegments.back();
+	if (!m_nameSegmentNodes.empty())
+		return m_nameSegmentNodes.back().GetNameSegmentBase();
+	return {};
+}
+
+
+void DemangledTypeNode::SetNameSegmentBase(const string& name)
+{
+	if (m_typeClass == ValueTypeClass)
+	{
+		m_altName = name;
+		return;
+	}
+	if (!m_nameSegments.empty())
+	{
+		m_nameSegments.back() = name;
+		return;
+	}
+	if (!m_nameSegmentNodes.empty())
+	{
+		m_nameSegmentNodes.back().SetNameSegmentBase(name);
+		return;
+	}
+	m_typeClass = ValueTypeClass;
+	m_altName = name;
+}
+
+
+StringList DemangledTypeNode::RenderTypeNameSegments() const
+{
+	if (m_nameSegmentNodes.empty())
+		return m_nameSegments;
+
+	StringList result;
+	result.reserve(m_nameSegmentNodes.size());
+	for (const auto& segment: m_nameSegmentNodes)
+		result.push_back(segment.GetString());
+	return result;
+}
+
+
 void DemangledTypeNode::AddPointerSuffixes(TypeBuilder& tb, bool omitPtr64) const
 {
 	if (HAS_POINTER_SUFFIX(DemangledPtr64Bit) && !omitPtr64)
@@ -391,6 +509,13 @@ void DemangledTypeNode::AddPointerSuffixes(TypeBuilder& tb, bool omitPtr64) cons
 
 string DemangledTypeNode::GetTypeNameString() const
 {
+	if (!m_nameSegmentNodes.empty())
+	{
+		string result;
+		AppendTypeName(result);
+		return result;
+	}
+
 	const auto& segs = m_nameSegments;
 	size_t n = segs.size();
 	if (n == 0)
@@ -418,8 +543,31 @@ string DemangledTypeNode::GetTypeNameString() const
 size_t DemangledTypeNode::NameStringSize() const
 {
 	size_t total = 0;
-	for (const auto& s : m_nameSegments)
-		total += s.size();
+	if (!m_nameSegmentNodes.empty())
+	{
+		for (const auto& s : m_nameSegmentNodes)
+			total += s.NameStringSize();
+		if (m_nameSegmentNodes.size() > 1)
+			total += (m_nameSegmentNodes.size() - 1) * 2;
+	}
+	else
+	{
+		for (const auto& s : m_nameSegments)
+			total += s.size();
+		if (m_nameSegments.size() > 1)
+			total += (m_nameSegments.size() - 1) * 2;
+	}
+	if (m_typeClass == ValueTypeClass)
+		total += m_altName.size();
+	if (!m_templateArgs.empty() || (m_hasTemplateArgs && m_typeClass == ValueTypeClass))
+	{
+		total += 2;
+		if (m_templateArgs.size() > 1)
+			total += m_templateArgs.size() - 1;
+		for (const auto& arg: m_templateArgs)
+			if (arg.type)
+				total += arg.type->NameStringSize();
+	}
 	return total;
 }
 
@@ -448,18 +596,70 @@ void DemangledTypeNode::AppendPointerSuffix(string& out) const
 }
 
 
+void DemangledTypeNode::AppendTemplateArguments(string& out) const
+{
+	if (m_templateArgs.empty() && m_hasTemplateArgs && m_typeClass == ValueTypeClass)
+	{
+		out += "<>";
+		return;
+	}
+	AppendTemplateArgumentList(out, m_templateArgs);
+}
+
+
+void DemangledTypeNode::AppendNameSegment(string& out) const
+{
+	if (m_typeClass == ValueTypeClass)
+	{
+		out += m_altName;
+		AppendTemplateArguments(out);
+		return;
+	}
+	if (m_typeClass == NamedTypeReferenceClass)
+	{
+		AppendTypeName(out);
+		return;
+	}
+	AppendString(out);
+}
+
+
+void DemangledTypeNode::AppendNameSegmentList(string& out, const vector<DemangledTypeNode>& name)
+{
+	if (name.empty())
+		return;
+	name[0].AppendNameSegment(out);
+	for (size_t i = 1; i < name.size(); i++)
+	{
+		out += "::";
+		name[i].AppendNameSegment(out);
+	}
+}
+
+
 void DemangledTypeNode::AppendTypeName(string& out) const
 {
+	if (!m_nameSegmentNodes.empty())
+	{
+		AppendNameSegmentList(out, m_nameSegmentNodes);
+		AppendTemplateArguments(out);
+		return;
+	}
+
 	const auto& segs = m_nameSegments;
 	size_t n = segs.size();
 	if (n == 0)
+	{
+		AppendTemplateArguments(out);
 		return;
+	}
 	out += segs[0];
 	for (size_t i = 1; i < n; i++)
 	{
 		out += "::";
 		out += segs[i];
 	}
+	AppendTemplateArguments(out);
 }
 
 
@@ -570,7 +770,10 @@ void DemangledTypeNode::AppendBeforeName(string& out, const DemangledTypeNode* p
 		{
 			if (!out.empty() && out.back() != ' ' && out.back() != '(')
 				out += ' ';
-			out += JoinNameList(m_memberPointerOwnerName);
+			if (!m_memberPointerOwnerNameNodes.empty())
+				AppendNameSegmentList(out, m_memberPointerOwnerNameNodes);
+			else
+				out += JoinNameList(m_memberPointerOwnerName);
 			out += "::*";
 		}
 		else
@@ -622,6 +825,7 @@ void DemangledTypeNode::AppendBeforeName(string& out, const DemangledTypeNode* p
 
 	case ValueTypeClass:
 		out += m_altName;
+		AppendTemplateArguments(out);
 		break;
 
 	default:
@@ -853,14 +1057,14 @@ Ref<Type> DemangledTypeNode::Finalize(Architecture* arch, Platform* platform) co
 
 	case NamedTypeReferenceClass:
 	{
-		QualifiedName name(m_nameSegments);
+		QualifiedName name(RenderTypeNameSegments());
 		TypeBuilder tb = TypeBuilder::NamedType(
 			NamedTypeReference::GenerateAutoDemangledTypeReference(m_ntrClass, name), ResolveWidth(arch, platform), 1);
 		tb.SetConst(m_const);
 		tb.SetVolatile(m_volatile);
 		AddPointerSuffixes(tb);
 		tb.SetNameType(m_nameType);
-		tb.SetHasTemplateArguments(m_hasTemplateArgs);
+		tb.SetHasTemplateArguments(HasTemplateArguments());
 		return tb.Finalize();
 	}