Fix LZ function-pointer template args, cl/dt expression formatting, fp_ in decltype

  - DemanglePrimaryExpression: handle LZ<encoding>E (function address without leading
    underscore, used by GCC/Clang for pointer-to-function non-type template args).
    e.g. __ZNK1aI1bIP1cELZN1a1e1fEvELZNS5_1fEEE1iEv -> a<b<c*>, a::e::f(), a::e::f>::i() const

  - fp_/fp<N>_ in decltype return types: return placeholder name ("fp", "fp0", etc.)
    instead of throwing when m_functionSubstitute is empty or too small (params not
    yet parsed at the time the return type DT expression is evaluated).

  - cl expression: format as callable(args) instead of (callable, args).

  - dt/pt expressions: remove unnecessary parens around operands; use obj.member and
    obj->member format directly for clean output.
    e.g. _ZN1a1bIN1c1dINS0_1eEEEE1fIKS3_EEDTcldtfp_1gEERT_i ->
         fp.g() a::b<c::d<a::b::e>>::f<a::b::e const>(a::b::e const&, int32_t)

Author: plafosse

demangler/gnu3/demangle_gnu3.cpp

@@ -1029,6 +1029,21 @@ string DemangleGNU3::DemanglePrimaryExpression()
 		dedent()
 		return out;
 	}
+	// LZ<encoding>E: function address template arg (GCC/Clang, without leading underscore)
+	if (m_reader.Peek() == 'Z')
+	{
+		m_reader.Consume(); // 'Z'
+		auto savedTemplateSubstitute2 = m_templateSubstitute;
+		m_templateSubstitute.clear();
+		oldTopLevel = m_topLevel;
+		m_topLevel = true;
+		DemangledTypeNode t2 = DemangleSymbol(tmpList);
+		m_topLevel = oldTopLevel;
+		m_templateSubstitute = std::move(savedTemplateSubstitute2);
+		out += t2.GetTypeAndName(tmpList);
+		dedent();
+		return out;
+	}
 	switch (m_reader.Read())
 	{
 	case 'b':
@@ -1584,13 +1599,23 @@ string DemangleGNU3::DemangleExpression()
 	case hash('p','p'): // ++ (postfix in <expression> context)
 	case hash('m','m'): // -- (postfix in <expression> context)
 		return DemangleUnarySuffixExpression(GetOperator(elm1, elm2));
+	case hash('d','t'): // .
+	{
+		const string dtObj = DemangleExpression();
+		const string dtMem = DemangleExpression();
+		return dtObj + "." + dtMem;
+	}
+	case hash('p','t'): // ->
+	{
+		const string ptObj = DemangleExpression();
+		const string ptMem = DemangleExpression();
+		return ptObj + "->" + ptMem;
+	}
 	case hash('l','s'): // <<
 	case hash('r','s'): // >>
 	case hash('a','S'): // =
 	case hash('e','q'): // ==
 	case hash('n','e'): // !=
-	case hash('d','t'): // .
-	case hash('p','t'): // ->
 	case hash('m','l'): // *
 	case hash('m','i'): // -
 	case hash('p','l'): // +
@@ -1629,7 +1654,23 @@ string DemangleGNU3::DemangleExpression()
 		       DemangleExpression() + ":" +
 		       DemangleExpression();
 	case hash('c','l'): // ()
-		return "(" + DemangleExpressionList() + ")";
+	{
+		const string callable = DemangleExpression();
+		string args;
+		bool firstArg = true;
+		m_functionSubstitute.push_back({});
+		while (m_reader.Peek() != 'E')
+		{
+			if (!firstArg) args += ", ";
+			const string e = DemangleExpression();
+			args += e;
+			m_functionSubstitute.back().push_back(CreateUnknownType(e));
+			firstArg = false;
+		}
+		m_functionSubstitute.pop_back();
+		m_reader.Consume(); // 'E'
+		return callable + "(" + args + ")";
+	}
 	case hash('c','v'): //type (expression)
 	{
 		DemangledTypeNode type = DemangleType();
@@ -1660,11 +1701,11 @@ string DemangleGNU3::DemangleExpression()
 		int64_t listNumber = 0;
 		int64_t elementNum = 0;
 		char elm;
-		if (m_functionSubstitute.size() == 0)
-			throw DemangleException();
-
 		if (elm2 == 'L')
 		{
+			// fL case requires a valid function substitute frame
+			if (m_functionSubstitute.size() == 0)
+				throw DemangleException();
 			listNumber = DemangleNumber() + 1;
 			if (listNumber < 0 ||
 			    (uint64_t)listNumber >= (uint64_t)m_functionSubstitute.size() ||
@@ -1676,20 +1717,27 @@ string DemangleGNU3::DemangleExpression()
 		if (elm == '_')
 		{
 			m_reader.Consume(1);
-			if ((size_t)elementNum >= m_functionSubstitute[listNumber].size())
+			if ((uint64_t)listNumber >= (uint64_t)m_functionSubstitute.size() ||
+			    (size_t)elementNum >= m_functionSubstitute[listNumber].size())
 			{
-				throw DemangleException();
+				// fp_ used before params are known (e.g., in decltype return type)
+				out = (elementNum == 0) ? "fp" : "fp" + std::to_string(elementNum - 1);
+				break;
 			}
 			type = m_functionSubstitute[listNumber][elementNum];
 		}
 		else if (isdigit(elm) || isupper(elm))
 		{
 			elementNum = DemangleNumber() + 1;
-			if (m_reader.Read() != '_' ||
-			    elementNum < 0 ||
+			if (m_reader.Read() != '_')
+				throw DemangleException();
+			if (elementNum < 0 ||
+			    (uint64_t)listNumber >= (uint64_t)m_functionSubstitute.size() ||
 			    (size_t)elementNum >= m_functionSubstitute[listNumber].size())
 			{
-				throw DemangleException();
+				// fpN_ used before params are known
+				out = "fp" + std::to_string(elementNum - 1);
+				break;
 			}
 			type = m_functionSubstitute[listNumber][elementNum];
 		}
@@ -2246,8 +2294,26 @@ DemangledTypeNode DemangleGNU3::DemangleSymbol(QualifiedName& varName)
 			// Guard variable encoding starts with: N (nested), L (local), S (substitution), digit, etc.
 			char peekChar = m_reader.Peek();
 			bool isVectorABI = (peekChar == 'b' || peekChar == 'c' || peekChar == 'd' || peekChar == 'e' ||
-			                    peekChar == 'x' || peekChar == 'y' || peekChar == 'Y' ||
-			                    peekChar == 'z' || peekChar == 'Z');
+			                    peekChar == 'x' || peekChar == 'y' || peekChar == 'Y');
+			// 'z'/'Z' are ambiguous: also used as Z-local-name prefix in guard variables
+			// (e.g. _ZGVZN1A1BEvE1A = guard variable for A::B()::A).
+			// Disambiguate by verifying the Vector ABI pattern: <isa><mask(M|N)><vlen(digits)><vparam or _>.
+			if (!isVectorABI && (peekChar == 'z' || peekChar == 'Z'))
+			{
+				_STD_STRING ahead = m_reader.PeekString(8);
+				if (ahead.size() >= 3 && (ahead[1] == 'M' || ahead[1] == 'N'))
+				{
+					size_t pos = 2;
+					while (pos < ahead.size() && isdigit((unsigned char)ahead[pos]))
+						pos++;
+					if (pos > 2)
+					{
+						char after = (pos < ahead.size()) ? ahead[pos] : '\0';
+						isVectorABI = (after == '_' || after == 'v' || after == 'l' ||
+						              after == 'u' || after == 'R' || after == 'L');
+					}
+				}
+			}
 			if (!isVectorABI)
 			{
 				// Guard variable (original behavior)