Author: stefan.graenitz
Date: Tue Aug 14 04:32:51 2018
New Revision: 339671

URL: http://llvm.org/viewvc/llvm-project?rev=339671&view=rev
Log:
Remove unused FastDemangle sources

Removed:
    lldb/trunk/include/lldb/Utility/FastDemangle.h
    lldb/trunk/source/Utility/FastDemangle.cpp
Modified:
    lldb/trunk/lldb.xcodeproj/project.pbxproj
    lldb/trunk/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
    lldb/trunk/source/Utility/CMakeLists.txt

Removed: lldb/trunk/include/lldb/Utility/FastDemangle.h
URL: 
http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Utility/FastDemangle.h?rev=339670&view=auto
==============================================================================
--- lldb/trunk/include/lldb/Utility/FastDemangle.h (original)
+++ lldb/trunk/include/lldb/Utility/FastDemangle.h (removed)
@@ -1,26 +0,0 @@
-//===-- FastDemangle.h ------------------------------------------*- C++ 
-*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_FastDemangle_h_
-#define liblldb_FastDemangle_h_
-
-#include <cstddef>
-
-#include <functional>
-
-namespace lldb_private {
-
-char *FastDemangle(const char *mangled_name);
-
-char *
-FastDemangle(const char *mangled_name, size_t mangled_name_length,
-             std::function<void(const char *s)> primitive_type_hook = nullptr);
-}
-
-#endif

Modified: lldb/trunk/lldb.xcodeproj/project.pbxproj
URL: 
http://llvm.org/viewvc/llvm-project/lldb/trunk/lldb.xcodeproj/project.pbxproj?rev=339671&r1=339670&r2=339671&view=diff
==============================================================================
--- lldb/trunk/lldb.xcodeproj/project.pbxproj (original)
+++ lldb/trunk/lldb.xcodeproj/project.pbxproj Tue Aug 14 04:32:51 2018
@@ -295,7 +295,6 @@
                49A1CAC51430E8DE00306AC9 /* ExpressionSourceCode.cpp in Sources 
*/ = {isa = PBXBuildFile; fileRef = 49A1CAC31430E8BD00306AC9 /* 
ExpressionSourceCode.cpp */; };
                4984BA161B979973008658D4 /* ExpressionVariable.cpp in Sources 
*/ = {isa = PBXBuildFile; fileRef = 4984BA151B979973008658D4 /* 
ExpressionVariable.cpp */; };
                4984BA181B979C08008658D4 /* ExpressionVariable.h in Headers */ 
= {isa = PBXBuildFile; fileRef = 4984BA171B979C08008658D4 /* 
ExpressionVariable.h */; };
-               AFC2DCE71E6E2ED000283714 /* FastDemangle.cpp in Sources */ = 
{isa = PBXBuildFile; fileRef = AFC2DCE61E6E2ED000283714 /* FastDemangle.cpp */; 
};
                2689006E13353E1A00698AC0 /* File.cpp in Sources */ = {isa = 
PBXBuildFile; fileRef = 260C6EA213011581005E16B0 /* File.cpp */; };
                3FDFDDBD199C3A06009756A7 /* FileAction.cpp in Sources */ = {isa 
= PBXBuildFile; fileRef = 3FDFDDBC199C3A06009756A7 /* FileAction.cpp */; };
                3FDFDDBF199D345E009756A7 /* FileCache.cpp in Sources */ = {isa 
= PBXBuildFile; fileRef = 3FDFDDBE199D345E009756A7 /* FileCache.cpp */; };
@@ -1807,8 +1806,6 @@
                4C29E77D1BA2403F00DFF855 /* ExpressionTypeSystemHelper.h */ = 
{isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; name = 
ExpressionTypeSystemHelper.h; path = 
include/lldb/Expression/ExpressionTypeSystemHelper.h; sourceTree = "<group>"; };
                4984BA151B979973008658D4 /* ExpressionVariable.cpp */ = {isa = 
PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; 
name = ExpressionVariable.cpp; path = source/Expression/ExpressionVariable.cpp; 
sourceTree = "<group>"; };
                4984BA171B979C08008658D4 /* ExpressionVariable.h */ = {isa = 
PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = 
ExpressionVariable.h; path = include/lldb/Expression/ExpressionVariable.h; 
sourceTree = "<group>"; };
-               AFC2DCE61E6E2ED000283714 /* FastDemangle.cpp */ = {isa = 
PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; 
name = FastDemangle.cpp; path = source/Utility/FastDemangle.cpp; sourceTree = 
"<group>"; };
-               AFC2DCED1E6E2F9800283714 /* FastDemangle.h */ = {isa = 
PBXFileReference; lastKnownFileType = sourcecode.c.h; name = FastDemangle.h; 
path = include/lldb/Utility/FastDemangle.h; sourceTree = "<group>"; };
                260C6EA213011581005E16B0 /* File.cpp */ = {isa = 
PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; 
path = File.cpp; sourceTree = "<group>"; };
                260C6EA013011578005E16B0 /* File.h */ = {isa = 
PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = 
File.h; path = include/lldb/Host/File.h; sourceTree = "<group>"; };
                3FDFDDBC199C3A06009756A7 /* FileAction.cpp */ = {isa = 
PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; 
name = FileAction.cpp; path = source/Target/FileAction.cpp; sourceTree = 
"<group>"; };
@@ -4510,8 +4507,6 @@
                                49CA96F41E6AAC8E00C03FEE /* DataExtractor.h */,
                                49CA96E91E6AAC6600C03FEE /* DataExtractor.cpp 
*/,
                                26BC7DD310F1B7D500F91463 /* Endian.h */,
-                               AFC2DCE61E6E2ED000283714 /* FastDemangle.cpp */,
-                               AFC2DCED1E6E2F9800283714 /* FastDemangle.h */,
                                4CBFF0471F579A36004AFA92 /* Flags.h */,
                                236124A61986B50E004EFC37 /* IOObject.h */,
                                236124A21986B4E2004EFC37 /* IOObject.cpp */,
@@ -8005,7 +8000,6 @@
                                268900FF13353E6F00698AC0 /* 
ThreadPlanShouldStopHere.cpp in Sources */,
                                2579065F1BD0488D00178368 /* DomainSocket.cpp in 
Sources */,
                                2689010013353E6F00698AC0 /* 
ThreadPlanStepInstruction.cpp in Sources */,
-                               AFC2DCE71E6E2ED000283714 /* FastDemangle.cpp in 
Sources */,
                                232CB61B191E00CD00EF39FC /* 
NativeThreadProtocol.cpp in Sources */,
                                4CD44CFB20B37C440003557C /* DWARFIndex.cpp in 
Sources */,
                                2689010113353E6F00698AC0 /* 
ThreadPlanStepOut.cpp in Sources */,

Modified: lldb/trunk/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
URL: 
http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp?rev=339671&r1=339670&r2=339671&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp 
(original)
+++ lldb/trunk/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp Tue Aug 
14 04:32:51 2018
@@ -323,7 +323,7 @@ static ConstString SubsPrimitiveParmItan
     }
   };
 
-  // FastDemangle will call back for each instance of a primitive type,
+  // The demangler will call back for each instance of a primitive type,
   // allowing us to perform substitution
   PrimitiveParmSubs parmSubs(mangled, search, replace);
   assert(mangled.data()[mangled.size()] == '\0' && "Expect C-String");

Modified: lldb/trunk/source/Utility/CMakeLists.txt
URL: 
http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Utility/CMakeLists.txt?rev=339671&r1=339670&r2=339671&view=diff
==============================================================================
--- lldb/trunk/source/Utility/CMakeLists.txt (original)
+++ lldb/trunk/source/Utility/CMakeLists.txt Tue Aug 14 04:32:51 2018
@@ -51,7 +51,6 @@ add_lldb_library(lldbUtility
   DataEncoder.cpp
   DataExtractor.cpp
   Environment.cpp
-  FastDemangle.cpp
   FileSpec.cpp
   IOObject.cpp
   JSON.cpp

Removed: lldb/trunk/source/Utility/FastDemangle.cpp
URL: 
http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Utility/FastDemangle.cpp?rev=339670&view=auto
==============================================================================
--- lldb/trunk/source/Utility/FastDemangle.cpp (original)
+++ lldb/trunk/source/Utility/FastDemangle.cpp (removed)
@@ -1,2393 +0,0 @@
-//===-- FastDemangle.cpp ----------------------------------------*- C++ 
-*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/Utility/FastDemangle.h"
-
-#include "llvm/Support/Compiler.h" // for LLVM_FALLTHROUGH
-
-#include <functional>
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-//#define DEBUG_FAILURES 1
-//#define DEBUG_SUBSTITUTIONS 1
-//#define DEBUG_TEMPLATE_ARGS 1
-//#define DEBUG_HIGHWATER 1
-//#define DEBUG_REORDERING 1
-
-namespace {
-
-/// Represents the collection of qualifiers on a type
-
-enum Qualifiers {
-  QualifierNone = 0,
-  QualifierConst = 1,
-  QualifierRestrict = 2,
-  QualifierVolatile = 4,
-  QualifierReference = 8,
-  QualifierRValueReference = 16,
-  QualifierPointer = 32
-};
-
-/// Categorizes the recognized operators
-
-enum class OperatorKind {
-  Unary,
-  Postfix,
-  Binary,
-  Ternary,
-  Other,
-  ConversionOperator,
-  Vendor,
-  NoMatch
-};
-
-/// Represents one of the recognized two-character operator abbreviations used
-/// when parsing operators as names and expressions
-
-struct Operator {
-  const char *name;
-  OperatorKind kind;
-};
-
-/// Represents a range of characters in the output buffer, typically for use
-/// with RewriteRange()
-
-struct BufferRange {
-  int offset;
-  int length;
-};
-
-/// Transient state required while parsing a name
-
-struct NameState {
-  bool parse_function_params;
-  bool is_last_generic;
-  bool has_no_return_type;
-  BufferRange last_name_range;
-};
-
-/// LLDB's fast C++ demangler
-///
-/// This is an incomplete implementation designed to speed up the demangling
-/// process that is often a bottleneck when LLDB stops a process for the first
-/// time.  Where the implementation doesn't know how to demangle a symbol it
-/// fails gracefully to allow the caller to fall back to the existing
-/// demangler.
-///
-/// Over time the full mangling spec should be supported without compromising
-/// performance for the most common cases.
-
-class SymbolDemangler {
-public:
-  //----------------------------------------------------
-  // Public API
-  //----------------------------------------------------
-
-  /// Create a SymbolDemangler
-  ///
-  /// The newly created demangler allocates and owns scratch memory sufficient
-  /// for demangling typical symbols.  Additional memory will be allocated if
-  /// needed and managed by the demangler instance.
-
-  SymbolDemangler() {
-    m_buffer = (char *)malloc(8192);
-    m_buffer_end = m_buffer + 8192;
-    m_owns_buffer = true;
-
-    m_rewrite_ranges = (BufferRange *)malloc(128 * sizeof(BufferRange));
-    m_rewrite_ranges_size = 128;
-    m_owns_m_rewrite_ranges = true;
-  }
-
-  /// Create a SymbolDemangler that uses provided scratch memory
-  ///
-  /// The provided memory is not owned by the demangler.  It will be
-  /// overwritten during calls to GetDemangledCopy() but can be used for other
-  /// purposes between calls.  The provided memory will not be freed when this
-  /// instance is destroyed.
-  ///
-  /// If demangling a symbol requires additional space it will be allocated
-  /// and managed by the demangler instance.
-  ///
-  /// @param storage_ptr Valid pointer to at least storage_size bytes of space
-  /// that the SymbolDemangler can use during demangling
-  ///
-  /// @param storage_size Number of bytes of space available scratch memory
-  /// referenced by storage_ptr
-
-  SymbolDemangler(void *storage_ptr, size_t storage_size,
-                  std::function<void(const char *)> builtins_hook = nullptr)
-      : m_builtins_hook(builtins_hook) {
-    // Use up to 1/8th of the provided space for rewrite ranges
-    m_rewrite_ranges_size = (storage_size >> 3) / sizeof(BufferRange);
-    m_rewrite_ranges = (BufferRange *)storage_ptr;
-    m_owns_m_rewrite_ranges = false;
-
-    // Use the rest for the character buffer
-    m_buffer =
-        (char *)storage_ptr + m_rewrite_ranges_size * sizeof(BufferRange);
-    m_buffer_end = (const char *)storage_ptr + storage_size;
-    m_owns_buffer = false;
-  }
-
-  /// Destroys the SymbolDemangler and deallocates any scratch memory that it
-  /// owns
-
-  ~SymbolDemangler() {
-    if (m_owns_buffer)
-      free(m_buffer);
-    if (m_owns_m_rewrite_ranges)
-      free(m_rewrite_ranges);
-  }
-
-#ifdef DEBUG_HIGHWATER
-  int highwater_store = 0;
-  int highwater_buffer = 0;
-#endif
-
-  /// Parses the provided mangled name and returns a newly allocated
-  /// demangling
-  ///
-  /// @param mangled_name Valid null-terminated C++ mangled name following the
-  /// Itanium C++ ABI mangling specification as implemented by Clang
-  ///
-  /// @result Newly allocated null-terminated demangled name when demangling
-  /// is successful, and nullptr when demangling fails.  The caller is
-  /// responsible for freeing the allocated memory.
-
-  char *GetDemangledCopy(const char *mangled_name,
-                         long mangled_name_length = 0) {
-    if (!ParseMangling(mangled_name, mangled_name_length))
-      return nullptr;
-
-#ifdef DEBUG_HIGHWATER
-    int rewrite_count = m_next_substitute_index +
-                        (m_rewrite_ranges_size - 1 - 
m_next_template_arg_index);
-    int buffer_size = (int)(m_write_ptr - m_buffer);
-    if (rewrite_count > highwater_store)
-      highwater_store = rewrite_count;
-    if (buffer_size > highwater_buffer)
-      highwater_buffer = buffer_size;
-#endif
-
-    int length = (int)(m_write_ptr - m_buffer);
-    char *copy = (char *)malloc(length + 1);
-    memcpy(copy, m_buffer, length);
-    copy[length] = '\0';
-    return copy;
-  }
-
-private:
-  //----------------------------------------------------
-  // Grow methods
-  //
-  // Manage the storage used during demangling
-  //----------------------------------------------------
-
-  void GrowBuffer(long min_growth = 0) {
-    // By default, double the size of the buffer
-    long growth = m_buffer_end - m_buffer;
-
-    // Avoid growing by more than 1MB at a time
-    if (growth > 1 << 20)
-      growth = 1 << 20;
-
-    // ... but never grow by less than requested, or 1K, whichever is greater
-    if (min_growth < 1024)
-      min_growth = 1024;
-    if (growth < min_growth)
-      growth = min_growth;
-
-    // Allocate the new m_buffer and migrate content
-    long new_size = (m_buffer_end - m_buffer) + growth;
-    char *new_buffer = (char *)malloc(new_size);
-    memcpy(new_buffer, m_buffer, m_write_ptr - m_buffer);
-    if (m_owns_buffer)
-      free(m_buffer);
-    m_owns_buffer = true;
-
-    // Update references to the new buffer
-    m_write_ptr = new_buffer + (m_write_ptr - m_buffer);
-    m_buffer = new_buffer;
-    m_buffer_end = m_buffer + new_size;
-  }
-
-  void GrowRewriteRanges() {
-    // By default, double the size of the array
-    int growth = m_rewrite_ranges_size;
-
-    // Apply reasonable minimum and maximum sizes for growth
-    if (growth > 128)
-      growth = 128;
-    if (growth < 16)
-      growth = 16;
-
-    // Allocate the new array and migrate content
-    int bytes = (m_rewrite_ranges_size + growth) * sizeof(BufferRange);
-    BufferRange *new_ranges = (BufferRange *)malloc(bytes);
-    for (int index = 0; index < m_next_substitute_index; index++) {
-      new_ranges[index] = m_rewrite_ranges[index];
-    }
-    for (int index = m_rewrite_ranges_size - 1;
-         index > m_next_template_arg_index; index--) {
-      new_ranges[index + growth] = m_rewrite_ranges[index];
-    }
-    if (m_owns_m_rewrite_ranges)
-      free(m_rewrite_ranges);
-    m_owns_m_rewrite_ranges = true;
-
-    // Update references to the new array
-    m_rewrite_ranges = new_ranges;
-    m_rewrite_ranges_size += growth;
-    m_next_template_arg_index += growth;
-  }
-
-  //----------------------------------------------------
-  // Range and state management
-  //----------------------------------------------------
-
-  int GetStartCookie() { return (int)(m_write_ptr - m_buffer); }
-
-  BufferRange EndRange(int start_cookie) {
-    return {start_cookie, (int)(m_write_ptr - (m_buffer + start_cookie))};
-  }
-
-  void ReorderRange(BufferRange source_range, int insertion_point_cookie) {
-    // Ensure there's room the preserve the source range
-    if (m_write_ptr + source_range.length > m_buffer_end) {
-      GrowBuffer(m_write_ptr + source_range.length - m_buffer_end);
-    }
-
-    // Reorder the content
-    memcpy(m_write_ptr, m_buffer + source_range.offset, source_range.length);
-    memmove(m_buffer + insertion_point_cookie + source_range.length,
-            m_buffer + insertion_point_cookie,
-            source_range.offset - insertion_point_cookie);
-    memcpy(m_buffer + insertion_point_cookie, m_write_ptr, 
source_range.length);
-
-    // Fix up rewritable ranges, covering both substitutions and templates
-    int index = 0;
-    while (true) {
-      if (index == m_next_substitute_index)
-        index = m_next_template_arg_index + 1;
-      if (index == m_rewrite_ranges_size)
-        break;
-
-      // Affected ranges are either shuffled forward when after the insertion
-      // but before the source, or backward when inside the source
-      int candidate_offset = m_rewrite_ranges[index].offset;
-      if (candidate_offset >= insertion_point_cookie) {
-        if (candidate_offset < source_range.offset) {
-          m_rewrite_ranges[index].offset += source_range.length;
-        } else if (candidate_offset >= source_range.offset) {
-          m_rewrite_ranges[index].offset -=
-              (source_range.offset - insertion_point_cookie);
-        }
-      }
-      ++index;
-    }
-  }
-
-  void EndSubstitution(int start_cookie) {
-    if (m_next_substitute_index == m_next_template_arg_index)
-      GrowRewriteRanges();
-
-    int index = m_next_substitute_index++;
-    m_rewrite_ranges[index] = EndRange(start_cookie);
-#ifdef DEBUG_SUBSTITUTIONS
-    printf("Saved substitution # %d = %.*s\n", index,
-           m_rewrite_ranges[index].length, m_buffer + start_cookie);
-#endif
-  }
-
-  void EndTemplateArg(int start_cookie) {
-    if (m_next_substitute_index == m_next_template_arg_index)
-      GrowRewriteRanges();
-
-    int index = m_next_template_arg_index--;
-    m_rewrite_ranges[index] = EndRange(start_cookie);
-#ifdef DEBUG_TEMPLATE_ARGS
-    printf("Saved template arg # %d = %.*s\n",
-           m_rewrite_ranges_size - index - 1, m_rewrite_ranges[index].length,
-           m_buffer + start_cookie);
-#endif
-  }
-
-  void ResetTemplateArgs() {
-    // TODO: this works, but is it the right thing to do?
-    // Should we push/pop somehow at the call sites?
-    m_next_template_arg_index = m_rewrite_ranges_size - 1;
-  }
-
-  //----------------------------------------------------
-  // Write methods
-  //
-  // Appends content to the existing output buffer
-  //----------------------------------------------------
-
-  void Write(char character) {
-    if (m_write_ptr == m_buffer_end)
-      GrowBuffer();
-    *m_write_ptr++ = character;
-  }
-
-  void Write(const char *content) { Write(content, strlen(content)); }
-
-  void Write(const char *content, long content_length) {
-    char *end_m_write_ptr = m_write_ptr + content_length;
-    if (end_m_write_ptr > m_buffer_end) {
-      if (content >= m_buffer && content < m_buffer_end) {
-        long offset = content - m_buffer;
-        GrowBuffer(end_m_write_ptr - m_buffer_end);
-        content = m_buffer + offset;
-      } else {
-        GrowBuffer(end_m_write_ptr - m_buffer_end);
-      }
-      end_m_write_ptr = m_write_ptr + content_length;
-    }
-    memcpy(m_write_ptr, content, content_length);
-    m_write_ptr = end_m_write_ptr;
-  }
-#define WRITE(x) Write(x, sizeof(x) - 1)
-
-  void WriteTemplateStart() { Write('<'); }
-
-  void WriteTemplateEnd() {
-    // Put a space between terminal > characters when nesting templates
-    if (m_write_ptr != m_buffer && *(m_write_ptr - 1) == '>')
-      WRITE(" >");
-    else
-      Write('>');
-  }
-
-  void WriteCommaSpace() { WRITE(", "); }
-
-  void WriteNamespaceSeparator() { WRITE("::"); }
-
-  void WriteStdPrefix() { WRITE("std::"); }
-
-  void WriteQualifiers(int qualifiers, bool space_before_reference = true) {
-    if (qualifiers & QualifierPointer)
-      Write('*');
-    if (qualifiers & QualifierConst)
-      WRITE(" const");
-    if (qualifiers & QualifierVolatile)
-      WRITE(" volatile");
-    if (qualifiers & QualifierRestrict)
-      WRITE(" restrict");
-    if (qualifiers & QualifierReference) {
-      if (space_before_reference)
-        WRITE(" &");
-      else
-        Write('&');
-    }
-    if (qualifiers & QualifierRValueReference) {
-      if (space_before_reference)
-        WRITE(" &&");
-      else
-        WRITE("&&");
-    }
-  }
-
-  //----------------------------------------------------
-  // Rewrite methods
-  //
-  // Write another copy of content already present earlier in the output buffer
-  //----------------------------------------------------
-
-  void RewriteRange(BufferRange range) {
-    Write(m_buffer + range.offset, range.length);
-  }
-
-  bool RewriteSubstitution(int index) {
-    if (index < 0 || index >= m_next_substitute_index) {
-#ifdef DEBUG_FAILURES
-      printf("*** Invalid substitution #%d\n", index);
-#endif
-      return false;
-    }
-    RewriteRange(m_rewrite_ranges[index]);
-    return true;
-  }
-
-  bool RewriteTemplateArg(int template_index) {
-    int index = m_rewrite_ranges_size - 1 - template_index;
-    if (template_index < 0 || index <= m_next_template_arg_index) {
-#ifdef DEBUG_FAILURES
-      printf("*** Invalid template arg reference #%d\n", template_index);
-#endif
-      return false;
-    }
-    RewriteRange(m_rewrite_ranges[index]);
-    return true;
-  }
-
-  //----------------------------------------------------
-  // TryParse methods
-  //
-  // Provide information with return values instead of writing to the output
-  // buffer
-  //
-  // Values indicating failure guarantee that the pre- call m_read_ptr is
-  // unchanged
-  //----------------------------------------------------
-
-  int TryParseNumber() {
-    unsigned char digit = *m_read_ptr - '0';
-    if (digit > 9)
-      return -1;
-
-    int count = digit;
-    while (true) {
-      digit = *++m_read_ptr - '0';
-      if (digit > 9)
-        break;
-
-      count = count * 10 + digit;
-    }
-    return count;
-  }
-
-  int TryParseBase36Number() {
-    char digit = *m_read_ptr;
-    int count;
-    if (digit >= '0' && digit <= '9')
-      count = digit -= '0';
-    else if (digit >= 'A' && digit <= 'Z')
-      count = digit -= ('A' - 10);
-    else
-      return -1;
-
-    while (true) {
-      digit = *++m_read_ptr;
-      if (digit >= '0' && digit <= '9')
-        digit -= '0';
-      else if (digit >= 'A' && digit <= 'Z')
-        digit -= ('A' - 10);
-      else
-        break;
-
-      count = count * 36 + digit;
-    }
-    return count;
-  }
-
-  // <builtin-type> ::= v    # void
-  //                ::= w    # wchar_t
-  //                ::= b    # bool
-  //                ::= c    # char
-  //                ::= a    # signed char
-  //                ::= h    # unsigned char
-  //                ::= s    # short
-  //                ::= t    # unsigned short
-  //                ::= i    # int
-  //                ::= j    # unsigned int
-  //                ::= l    # long
-  //                ::= m    # unsigned long
-  //                ::= x    # long long, __int64
-  //                ::= y    # unsigned long long, __int64
-  //                ::= n    # __int128
-  //                ::= o    # unsigned __int128
-  //                ::= f    # float
-  //                ::= d    # double
-  //                ::= e    # long double, __float80
-  //                ::= g    # __float128
-  //                ::= z    # ellipsis
-  //                ::= Dd   # IEEE 754r decimal floating point (64 bits)
-  //                ::= De   # IEEE 754r decimal floating point (128 bits)
-  //                ::= Df   # IEEE 754r decimal floating point (32 bits)
-  //                ::= Dh   # IEEE 754r half-precision floating point (16 
bits)
-  //                ::= Di   # char32_t
-  //                ::= Ds   # char16_t
-  //                ::= Da   # auto (in dependent new-expressions)
-  //                ::= Dn   # std::nullptr_t (i.e., decltype(nullptr))
-  //                ::= u <source-name>    # vendor extended type
-
-  const char *TryParseBuiltinType() {
-    if (m_builtins_hook)
-      m_builtins_hook(m_read_ptr);
-
-    switch (*m_read_ptr++) {
-    case 'v':
-      return "void";
-    case 'w':
-      return "wchar_t";
-    case 'b':
-      return "bool";
-    case 'c':
-      return "char";
-    case 'a':
-      return "signed char";
-    case 'h':
-      return "unsigned char";
-    case 's':
-      return "short";
-    case 't':
-      return "unsigned short";
-    case 'i':
-      return "int";
-    case 'j':
-      return "unsigned int";
-    case 'l':
-      return "long";
-    case 'm':
-      return "unsigned long";
-    case 'x':
-      return "long long";
-    case 'y':
-      return "unsigned long long";
-    case 'n':
-      return "__int128";
-    case 'o':
-      return "unsigned __int128";
-    case 'f':
-      return "float";
-    case 'd':
-      return "double";
-    case 'e':
-      return "long double";
-    case 'g':
-      return "__float128";
-    case 'z':
-      return "...";
-    case 'D': {
-      switch (*m_read_ptr++) {
-      case 'd':
-        return "decimal64";
-      case 'e':
-        return "decimal128";
-      case 'f':
-        return "decimal32";
-      case 'h':
-        return "decimal16";
-      case 'i':
-        return "char32_t";
-      case 's':
-        return "char16_t";
-      case 'a':
-        return "auto";
-      case 'c':
-        return "decltype(auto)";
-      case 'n':
-        return "std::nullptr_t";
-      default:
-        --m_read_ptr;
-      }
-    }
-    }
-    --m_read_ptr;
-    return nullptr;
-  }
-
-  //   <operator-name>
-  //                   ::= aa    # &&
-  //                   ::= ad    # & (unary)
-  //                   ::= an    # &
-  //                   ::= aN    # &=
-  //                   ::= aS    # =
-  //                   ::= cl    # ()
-  //                   ::= cm    # ,
-  //                   ::= co    # ~
-  //                   ::= da    # delete[]
-  //                   ::= de    # * (unary)
-  //                   ::= dl    # delete
-  //                   ::= dv    # /
-  //                   ::= dV    # /=
-  //                   ::= eo    # ^
-  //                   ::= eO    # ^=
-  //                   ::= eq    # ==
-  //                   ::= ge    # >=
-  //                   ::= gt    # >
-  //                   ::= ix    # []
-  //                   ::= le    # <=
-  //                   ::= ls    # <<
-  //                   ::= lS    # <<=
-  //                   ::= lt    # <
-  //                   ::= mi    # -
-  //                   ::= mI    # -=
-  //                   ::= ml    # *
-  //                   ::= mL    # *=
-  //                   ::= mm    # -- (postfix in <expression> context)
-  //                   ::= na    # new[]
-  //                   ::= ne    # !=
-  //                   ::= ng    # - (unary)
-  //                   ::= nt    # !
-  //                   ::= nw    # new
-  //                   ::= oo    # ||
-  //                   ::= or    # |
-  //                   ::= oR    # |=
-  //                   ::= pm    # ->*
-  //                   ::= pl    # +
-  //                   ::= pL    # +=
-  //                   ::= pp    # ++ (postfix in <expression> context)
-  //                   ::= ps    # + (unary)
-  //                   ::= pt    # ->
-  //                   ::= qu    # ?
-  //                   ::= rm    # %
-  //                   ::= rM    # %=
-  //                   ::= rs    # >>
-  //                   ::= rS    # >>=
-  //                   ::= cv <type>    # (cast)
-  //                   ::= v <digit> <source-name>        # vendor extended
-  //                   operator
-
-  Operator TryParseOperator() {
-    switch (*m_read_ptr++) {
-    case 'a':
-      switch (*m_read_ptr++) {
-      case 'a':
-        return {"&&", OperatorKind::Binary};
-      case 'd':
-        return {"&", OperatorKind::Unary};
-      case 'n':
-        return {"&", OperatorKind::Binary};
-      case 'N':
-        return {"&=", OperatorKind::Binary};
-      case 'S':
-        return {"=", OperatorKind::Binary};
-      }
-      --m_read_ptr;
-      break;
-    case 'c':
-      switch (*m_read_ptr++) {
-      case 'l':
-        return {"()", OperatorKind::Other};
-      case 'm':
-        return {",", OperatorKind::Other};
-      case 'o':
-        return {"~", OperatorKind::Unary};
-      case 'v':
-        return {nullptr, OperatorKind::ConversionOperator};
-      }
-      --m_read_ptr;
-      break;
-    case 'd':
-      switch (*m_read_ptr++) {
-      case 'a':
-        return {" delete[]", OperatorKind::Other};
-      case 'e':
-        return {"*", OperatorKind::Unary};
-      case 'l':
-        return {" delete", OperatorKind::Other};
-      case 'v':
-        return {"/", OperatorKind::Binary};
-      case 'V':
-        return {"/=", OperatorKind::Binary};
-      }
-      --m_read_ptr;
-      break;
-    case 'e':
-      switch (*m_read_ptr++) {
-      case 'o':
-        return {"^", OperatorKind::Binary};
-      case 'O':
-        return {"^=", OperatorKind::Binary};
-      case 'q':
-        return {"==", OperatorKind::Binary};
-      }
-      --m_read_ptr;
-      break;
-    case 'g':
-      switch (*m_read_ptr++) {
-      case 'e':
-        return {">=", OperatorKind::Binary};
-      case 't':
-        return {">", OperatorKind::Binary};
-      }
-      --m_read_ptr;
-      break;
-    case 'i':
-      switch (*m_read_ptr++) {
-      case 'x':
-        return {"[]", OperatorKind::Other};
-      }
-      --m_read_ptr;
-      break;
-    case 'l':
-      switch (*m_read_ptr++) {
-      case 'e':
-        return {"<=", OperatorKind::Binary};
-      case 's':
-        return {"<<", OperatorKind::Binary};
-      case 'S':
-        return {"<<=", OperatorKind::Binary};
-      case 't':
-        return {"<", OperatorKind::Binary};
-        // case 'i': return { "?", OperatorKind::Binary };
-      }
-      --m_read_ptr;
-      break;
-    case 'm':
-      switch (*m_read_ptr++) {
-      case 'i':
-        return {"-", OperatorKind::Binary};
-      case 'I':
-        return {"-=", OperatorKind::Binary};
-      case 'l':
-        return {"*", OperatorKind::Binary};
-      case 'L':
-        return {"*=", OperatorKind::Binary};
-      case 'm':
-        return {"--", OperatorKind::Postfix};
-      }
-      --m_read_ptr;
-      break;
-    case 'n':
-      switch (*m_read_ptr++) {
-      case 'a':
-        return {" new[]", OperatorKind::Other};
-      case 'e':
-        return {"!=", OperatorKind::Binary};
-      case 'g':
-        return {"-", OperatorKind::Unary};
-      case 't':
-        return {"!", OperatorKind::Unary};
-      case 'w':
-        return {" new", OperatorKind::Other};
-      }
-      --m_read_ptr;
-      break;
-    case 'o':
-      switch (*m_read_ptr++) {
-      case 'o':
-        return {"||", OperatorKind::Binary};
-      case 'r':
-        return {"|", OperatorKind::Binary};
-      case 'R':
-        return {"|=", OperatorKind::Binary};
-      }
-      --m_read_ptr;
-      break;
-    case 'p':
-      switch (*m_read_ptr++) {
-      case 'm':
-        return {"->*", OperatorKind::Binary};
-      case 's':
-        return {"+", OperatorKind::Unary};
-      case 'l':
-        return {"+", OperatorKind::Binary};
-      case 'L':
-        return {"+=", OperatorKind::Binary};
-      case 'p':
-        return {"++", OperatorKind::Postfix};
-      case 't':
-        return {"->", OperatorKind::Binary};
-      }
-      --m_read_ptr;
-      break;
-    case 'q':
-      switch (*m_read_ptr++) {
-      case 'u':
-        return {"?", OperatorKind::Ternary};
-      }
-      --m_read_ptr;
-      break;
-    case 'r':
-      switch (*m_read_ptr++) {
-      case 'm':
-        return {"%", OperatorKind::Binary};
-      case 'M':
-        return {"%=", OperatorKind::Binary};
-      case 's':
-        return {">>", OperatorKind::Binary};
-      case 'S':
-        return {">=", OperatorKind::Binary};
-      }
-      --m_read_ptr;
-      break;
-    case 'v':
-      char digit = *m_read_ptr;
-      if (digit >= '0' && digit <= '9') {
-        m_read_ptr++;
-        return {nullptr, OperatorKind::Vendor};
-      }
-      --m_read_ptr;
-      break;
-    }
-    --m_read_ptr;
-    return {nullptr, OperatorKind::NoMatch};
-  }
-
-  // <CV-qualifiers> ::= [r] [V] [K]
-  // <ref-qualifier> ::= R                   # & ref-qualifier <ref-qualifier>
-  // ::= O                   # && ref-qualifier
-
-  int TryParseQualifiers(bool allow_cv, bool allow_ro) {
-    int qualifiers = QualifierNone;
-    char next = *m_read_ptr;
-    if (allow_cv) {
-      if (next == 'r') // restrict
-      {
-        qualifiers |= QualifierRestrict;
-        next = *++m_read_ptr;
-      }
-      if (next == 'V') // volatile
-      {
-        qualifiers |= QualifierVolatile;
-        next = *++m_read_ptr;
-      }
-      if (next == 'K') // const
-      {
-        qualifiers |= QualifierConst;
-        next = *++m_read_ptr;
-      }
-    }
-    if (allow_ro) {
-      if (next == 'R') {
-        ++m_read_ptr;
-        qualifiers |= QualifierReference;
-      } else if (next == 'O') {
-        ++m_read_ptr;
-        qualifiers |= QualifierRValueReference;
-      }
-    }
-    return qualifiers;
-  }
-
-  // <discriminator> := _ <non-negative number>      # when number < 10
-  //                 := __ <non-negative number> _   # when number >= 10
-  //  extension      := decimal-digit+
-
-  int TryParseDiscriminator() {
-    const char *discriminator_start = m_read_ptr;
-
-    // Test the extension first, since it's what Clang uses
-    int discriminator_value = TryParseNumber();
-    if (discriminator_value != -1)
-      return discriminator_value;
-
-    char next = *m_read_ptr;
-    if (next == '_') {
-      next = *++m_read_ptr;
-      if (next == '_') {
-        ++m_read_ptr;
-        discriminator_value = TryParseNumber();
-        if (discriminator_value != -1 && *m_read_ptr++ != '_') {
-          return discriminator_value;
-        }
-      } else if (next >= '0' && next <= '9') {
-        ++m_read_ptr;
-        return next - '0';
-      }
-    }
-
-    // Not a valid discriminator
-    m_read_ptr = discriminator_start;
-    return -1;
-  }
-
-  //----------------------------------------------------
-  // Parse methods
-  //
-  // Consume input starting from m_read_ptr and produce buffered output at
-  // m_write_ptr
-  //
-  // Failures return false and may leave m_read_ptr in an indeterminate state
-  //----------------------------------------------------
-
-  bool Parse(char character) {
-    if (*m_read_ptr++ == character)
-      return true;
-#ifdef DEBUG_FAILURES
-    printf("*** Expected '%c'\n", character);
-#endif
-    return false;
-  }
-
-  // <number> ::= [n] <non-negative decimal integer>
-
-  bool ParseNumber(bool allow_negative = false) {
-    if (allow_negative && *m_read_ptr == 'n') {
-      Write('-');
-      ++m_read_ptr;
-    }
-    const char *before_digits = m_read_ptr;
-    while (true) {
-      unsigned char digit = *m_read_ptr - '0';
-      if (digit > 9)
-        break;
-      ++m_read_ptr;
-    }
-    if (int digit_count = (int)(m_read_ptr - before_digits)) {
-      Write(before_digits, digit_count);
-      return true;
-    }
-#ifdef DEBUG_FAILURES
-    printf("*** Expected number\n");
-#endif
-    return false;
-  }
-
-  // <substitution> ::= S <seq-id> _
-  //                ::= S_
-  // <substitution> ::= Sa # ::std::allocator <substitution> ::= Sb #
-  // ::std::basic_string <substitution> ::= Ss # ::std::basic_string < char,
-  //                                               ::std::char_traits<char>,
-  //                                               ::std::allocator<char> >
-  // <substitution> ::= Si # ::std::basic_istream<char,  std::char_traits<char>
-  // > <substitution> ::= So # ::std::basic_ostream<char,
-  // std::char_traits<char> > <substitution> ::= Sd #
-  // ::std::basic_iostream<char, std::char_traits<char> >
-
-  bool ParseSubstitution() {
-    const char *substitution;
-    switch (*m_read_ptr) {
-    case 'a':
-      substitution = "std::allocator";
-      break;
-    case 'b':
-      substitution = "std::basic_string";
-      break;
-    case 's':
-      substitution = "std::string";
-      break;
-    case 'i':
-      substitution = "std::istream";
-      break;
-    case 'o':
-      substitution = "std::ostream";
-      break;
-    case 'd':
-      substitution = "std::iostream";
-      break;
-    default:
-      // A failed attempt to parse a number will return -1 which turns out to 
be
-      // perfect here as S_ is the first substitution, S0_ the next and so
-      // forth
-      int substitution_index = TryParseBase36Number();
-      if (*m_read_ptr++ != '_') {
-#ifdef DEBUG_FAILURES
-        printf("*** Expected terminal _ in substitution\n");
-#endif
-        return false;
-      }
-      return RewriteSubstitution(substitution_index + 1);
-    }
-    Write(substitution);
-    ++m_read_ptr;
-    return true;
-  }
-
-  // <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E
-  //
-  // <bare-function-type> ::= <signature type>+      # types are possible
-  // return type, then parameter types
-
-  bool ParseFunctionType(int inner_qualifiers = QualifierNone) {
-#ifdef DEBUG_FAILURES
-    printf("*** Function types not supported\n");
-#endif
-    // TODO: first steps toward an implementation follow, but they're far
-    // from complete.  Function types tend to bracket other types eg: int (*)()
-    // when used as the type for "name" becomes int (*name)(). This makes
-    // substitution et al ... interesting.
-    return false;
-
-#if 0  // TODO
-        if (*m_read_ptr == 'Y')
-            ++m_read_ptr;
-
-        int return_type_start_cookie = GetStartCookie();
-        if (!ParseType())
-            return false;
-        Write(' ');
-
-        int insert_cookie = GetStartCookie();
-        Write('(');
-        bool first_param = true;
-        int qualifiers = QualifierNone;
-        while (true)
-        {
-            switch (*m_read_ptr)
-            {
-                case 'E':
-                    ++m_read_ptr;
-                    Write(')');
-                    break;
-                case 'v':
-                    ++m_read_ptr;
-                    continue;
-                case 'R':
-                case 'O':
-                    if (*(m_read_ptr + 1) == 'E')
-                    {
-                        qualifiers = TryParseQualifiers (false, true);
-                        Parse('E');
-                        break;
-                    }
-                    // fallthrough
-                default:
-                {
-                    if (first_param)
-                        first_param = false;
-                    else WriteCommaSpace();
-
-                    if (!ParseType())
-                        return false;
-                    continue;
-                }
-            }
-            break;
-        }
-
-        if (qualifiers)
-        {
-            WriteQualifiers (qualifiers);
-            EndSubstitution (return_type_start_cookie);
-        }
-
-        if (inner_qualifiers)
-        {
-            int qualifier_start_cookie = GetStartCookie();
-            Write ('(');
-            WriteQualifiers (inner_qualifiers);
-            Write (')');
-            ReorderRange (EndRange (qualifier_start_cookie), insert_cookie);
-        }
-        return true;
-#endif // TODO
-  }
-
-  // <array-type> ::= A <positive dimension number> _ <element type>
-  //              ::= A [<dimension expression>] _ <element type>
-
-  bool ParseArrayType(int qualifiers = QualifierNone) {
-#ifdef DEBUG_FAILURES
-    printf("*** Array type unsupported\n");
-#endif
-    // TODO: We fail horribly when recalling these as substitutions or
-    // templates and trying to constify them eg:
-    // _ZN4llvm2cl5applyIA28_cNS0_3optIbLb0ENS0_6parserIbEEEEEEvRKT_PT0_
-    //
-    // TODO: Chances are we don't do any better with references and pointers
-    // that should be type (&) [] instead of type & []
-
-    return false;
-
-#if 0  // TODO
-        if (*m_read_ptr == '_')
-        {
-            ++m_read_ptr;
-            if (!ParseType())
-                return false;
-            if (qualifiers)
-                WriteQualifiers(qualifiers);
-            WRITE(" []");
-            return true;
-        }
-        else
-        {
-            const char *before_digits = m_read_ptr;
-            if (TryParseNumber() != -1)
-            {
-                const char *after_digits = m_read_ptr;
-                if (!Parse('_'))
-                    return false;
-                if (!ParseType())
-                    return false;
-                if (qualifiers)
-                    WriteQualifiers(qualifiers);
-                Write(' ');
-                Write('[');
-                Write(before_digits, after_digits - before_digits);
-            }
-            else
-            {
-                int type_insertion_cookie = GetStartCookie();
-                if (!ParseExpression())
-                    return false;
-                if (!Parse('_'))
-                    return false;
-
-                int type_start_cookie = GetStartCookie();
-                if (!ParseType())
-                    return false;
-                if (qualifiers)
-                    WriteQualifiers(qualifiers);
-                Write(' ');
-                Write('[');
-                ReorderRange (EndRange (type_start_cookie), 
type_insertion_cookie);
-            }
-            Write(']');
-            return true;
-        }
-#endif // TODO
-  }
-
-  // <pointer-to-member-type> ::= M <class type> <member type>
-
-  // TODO: Determine how to handle pointers to function members correctly,
-  // currently not an issue because we don't have function types at all...
-  bool ParsePointerToMemberType() {
-    int insertion_cookie = GetStartCookie();
-    Write(' ');
-    if (!ParseType())
-      return false;
-    WRITE("::*");
-
-    int type_cookie = GetStartCookie();
-    if (!ParseType())
-      return false;
-    ReorderRange(EndRange(type_cookie), insertion_cookie);
-    return true;
-  }
-
-  // <template-param> ::= T_    # first template parameter
-  //                  ::= T <parameter-2 non-negative number> _
-
-  bool ParseTemplateParam() {
-    int count = TryParseNumber();
-    if (!Parse('_'))
-      return false;
-
-    // When no number is present we get -1, which is convenient since T_ is the
-    // zeroth element T0_ is element 1, and so on
-    return RewriteTemplateArg(count + 1);
-  }
-
-  // <vector-type>
-  // Dv <dimension number> _ <vector type>
-  bool TryParseVectorType() {
-    const int dimension = TryParseNumber();
-    if (dimension == -1)
-      return false;
-
-    if (*m_read_ptr++ != '_')
-      return false;
-
-    char vec_dimens[32] = {'\0'};
-    ::snprintf(vec_dimens, sizeof vec_dimens - 1, " __vector(%d)", dimension);
-    ParseType();
-    Write(vec_dimens);
-    return true;
-  }
-
-  // <type> ::= <builtin-type>
-  //        ::= <function-type>
-  //        ::= <class-enum-type>
-  //        ::= <array-type>
-  //        ::= <pointer-to-member-type>
-  //        ::= <template-param>
-  //        ::= <template-template-param> <template-args>
-  //        ::= <decltype>
-  //        ::= <substitution>
-  //        ::= <CV-qualifiers> <type>
-  //        ::= P <type>        # pointer-to
-  //        ::= R <type>        # reference-to
-  //        ::= O <type>        # rvalue reference-to (C++0x)
-  //        ::= C <type>        # complex pair (C 2000)
-  //        ::= G <type>        # imaginary (C 2000)
-  //        ::= Dp <type>       # pack expansion (C++0x)
-  //        ::= U <source-name> <type>  # vendor extended type qualifier
-  // extension := U <objc-name> <objc-type>  # objc-type<identifier> extension
-  // := <vector-type> # <vector-type> starts with Dv
-
-  // <objc-name> ::= <k0 number> objcproto <k1 number> <identifier>  # k0 = 9 +
-  // <number of digits in k1> + k1 <objc-type> := <source-name>  #
-  // PU<11+>objcproto 11objc_object<source-name> 11objc_object -> id<source-
-  // name>
-
-  bool ParseType() {
-#ifdef DEBUG_FAILURES
-    const char *failed_type = m_read_ptr;
-#endif
-    int type_start_cookie = GetStartCookie();
-    bool suppress_substitution = false;
-
-    int qualifiers = TryParseQualifiers(true, false);
-    switch (*m_read_ptr) {
-    case 'D':
-      ++m_read_ptr;
-      switch (*m_read_ptr++) {
-      case 'p':
-        if (!ParseType())
-          return false;
-        break;
-      case 'v':
-        if (!TryParseVectorType())
-          return false;
-        break;
-      case 'T':
-      case 't':
-      default:
-#ifdef DEBUG_FAILURES
-        printf("*** Unsupported type: %.3s\n", failed_type);
-#endif
-        return false;
-      }
-      break;
-    case 'T':
-      ++m_read_ptr;
-      if (!ParseTemplateParam())
-        return false;
-      break;
-    case 'M':
-      ++m_read_ptr;
-      if (!ParsePointerToMemberType())
-        return false;
-      break;
-    case 'A':
-      ++m_read_ptr;
-      if (!ParseArrayType())
-        return false;
-      break;
-    case 'F':
-      ++m_read_ptr;
-      if (!ParseFunctionType())
-        return false;
-      break;
-    case 'S':
-      if (*++m_read_ptr == 't') {
-        ++m_read_ptr;
-        WriteStdPrefix();
-        if (!ParseName())
-          return false;
-      } else {
-        suppress_substitution = true;
-        if (!ParseSubstitution())
-          return false;
-      }
-      break;
-    case 'P': {
-      switch (*++m_read_ptr) {
-      case 'F':
-        ++m_read_ptr;
-        if (!ParseFunctionType(QualifierPointer))
-          return false;
-        break;
-      default:
-        if (!ParseType())
-          return false;
-        Write('*');
-        break;
-      }
-      break;
-    }
-    case 'R': {
-      ++m_read_ptr;
-      if (!ParseType())
-        return false;
-      Write('&');
-      break;
-    }
-    case 'O': {
-      ++m_read_ptr;
-      if (!ParseType())
-        return false;
-      Write('&');
-      Write('&');
-      break;
-    }
-    case 'C':
-    case 'G':
-    case 'U':
-#ifdef DEBUG_FAILURES
-      printf("*** Unsupported type: %.3s\n", failed_type);
-#endif
-      return false;
-    // Test for common cases to avoid TryParseBuiltinType() overhead
-    case 'N':
-    case 'Z':
-    case 'L':
-      if (!ParseName())
-        return false;
-      break;
-    default:
-      if (const char *builtin = TryParseBuiltinType()) {
-        Write(builtin);
-        suppress_substitution = true;
-      } else {
-        if (!ParseName())
-          return false;
-      }
-      break;
-    }
-
-    // Allow base substitutions to be suppressed, but always record
-    // substitutions for the qualified variant
-    if (!suppress_substitution)
-      EndSubstitution(type_start_cookie);
-    if (qualifiers) {
-      WriteQualifiers(qualifiers, false);
-      EndSubstitution(type_start_cookie);
-    }
-    return true;
-  }
-
-  // <unnamed-type-name> ::= Ut [ <nonnegative number> ] _
-  //                     ::= <closure-type-name>
-  //
-  // <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
-  //
-  // <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda
-  // has no parameters
-
-  bool ParseUnnamedTypeName(NameState &name_state) {
-    switch (*m_read_ptr++) {
-    case 't': {
-      int cookie = GetStartCookie();
-      WRITE("'unnamed");
-      const char *before_digits = m_read_ptr;
-      if (TryParseNumber() != -1)
-        Write(before_digits, m_read_ptr - before_digits);
-      if (!Parse('_'))
-        return false;
-      Write('\'');
-      name_state.last_name_range = EndRange(cookie);
-      return true;
-    }
-    case 'b': {
-      int cookie = GetStartCookie();
-      WRITE("'block");
-      const char *before_digits = m_read_ptr;
-      if (TryParseNumber() != -1)
-        Write(before_digits, m_read_ptr - before_digits);
-      if (!Parse('_'))
-        return false;
-      Write('\'');
-      name_state.last_name_range = EndRange(cookie);
-      return true;
-    }
-    case 'l':
-#ifdef DEBUG_FAILURES
-      printf("*** Lambda type names unsupported\n");
-#endif
-      return false;
-    }
-#ifdef DEBUG_FAILURES
-    printf("*** Unknown unnamed type %.3s\n", m_read_ptr - 2);
-#endif
-    return false;
-  }
-
-  // <ctor-dtor-name> ::= C1      # complete object constructor
-  //                  ::= C2      # base object constructor
-  //                  ::= C3      # complete object allocating constructor
-
-  bool ParseCtor(NameState &name_state) {
-    char next = *m_read_ptr;
-    if (next == '1' || next == '2' || next == '3' || next == '5') {
-      RewriteRange(name_state.last_name_range);
-      name_state.has_no_return_type = true;
-      ++m_read_ptr;
-      return true;
-    }
-#ifdef DEBUG_FAILURES
-    printf("*** Broken constructor\n");
-#endif
-    return false;
-  }
-
-  // <ctor-dtor-name> ::= D0      # deleting destructor
-  //                  ::= D1      # complete object destructor
-  //                  ::= D2      # base object destructor
-
-  bool ParseDtor(NameState &name_state) {
-    char next = *m_read_ptr;
-    if (next == '0' || next == '1' || next == '2' || next == '5') {
-      Write('~');
-      RewriteRange(name_state.last_name_range);
-      name_state.has_no_return_type = true;
-      ++m_read_ptr;
-      return true;
-    }
-#ifdef DEBUG_FAILURES
-    printf("*** Broken destructor\n");
-#endif
-    return false;
-  }
-
-  // See TryParseOperator()
-
-  bool ParseOperatorName(NameState &name_state) {
-#ifdef DEBUG_FAILURES
-    const char *operator_ptr = m_read_ptr;
-#endif
-    Operator parsed_operator = TryParseOperator();
-    if (parsed_operator.name) {
-      WRITE("operator");
-      Write(parsed_operator.name);
-      return true;
-    }
-
-    // Handle special operators
-    switch (parsed_operator.kind) {
-    case OperatorKind::Vendor:
-      WRITE("operator ");
-      return ParseSourceName();
-    case OperatorKind::ConversionOperator:
-      ResetTemplateArgs();
-      name_state.has_no_return_type = true;
-      WRITE("operator ");
-      return ParseType();
-    default:
-#ifdef DEBUG_FAILURES
-      printf("*** Unknown operator: %.2s\n", operator_ptr);
-#endif
-      return false;
-    }
-  }
-
-  // <source-name> ::= <positive length number> <identifier>
-
-  bool ParseSourceName() {
-    int count = TryParseNumber();
-    if (count == -1) {
-#ifdef DEBUG_FAILURES
-      printf("*** Malformed source name, missing length count\n");
-#endif
-      return false;
-    }
-
-    const char *next_m_read_ptr = m_read_ptr + count;
-    if (next_m_read_ptr > m_read_end) {
-#ifdef DEBUG_FAILURES
-      printf("*** Malformed source name, premature termination\n");
-#endif
-      return false;
-    }
-
-    if (count >= 10 && strncmp(m_read_ptr, "_GLOBAL__N", 10) == 0)
-      WRITE("(anonymous namespace)");
-    else
-      Write(m_read_ptr, count);
-
-    m_read_ptr = next_m_read_ptr;
-    return true;
-  }
-
-  // <unqualified-name> ::= <operator-name>
-  //                    ::= <ctor-dtor-name>
-  //                    ::= <source-name>
-  //                    ::= <unnamed-type-name>
-
-  bool ParseUnqualifiedName(NameState &name_state) {
-    // Note that these are detected directly in ParseNestedName for performance
-    // rather than switching on the same options twice
-    char next = *m_read_ptr;
-    switch (next) {
-    case 'C':
-      ++m_read_ptr;
-      return ParseCtor(name_state);
-    case 'D':
-      ++m_read_ptr;
-      return ParseDtor(name_state);
-    case 'U':
-      ++m_read_ptr;
-      return ParseUnnamedTypeName(name_state);
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9': {
-      int name_start_cookie = GetStartCookie();
-      if (!ParseSourceName())
-        return false;
-      name_state.last_name_range = EndRange(name_start_cookie);
-      return true;
-    }
-    default:
-      return ParseOperatorName(name_state);
-    };
-  }
-
-  // <unscoped-name> ::= <unqualified-name>
-  //                 ::= St <unqualified-name>   # ::std::
-  // extension       ::= StL<unqualified-name>
-
-  bool ParseUnscopedName(NameState &name_state) {
-    if (*m_read_ptr == 'S' && *(m_read_ptr + 1) == 't') {
-      WriteStdPrefix();
-      if (*(m_read_ptr += 2) == 'L')
-        ++m_read_ptr;
-    }
-    return ParseUnqualifiedName(name_state);
-  }
-
-  bool ParseIntegerLiteral(const char *prefix, const char *suffix,
-                           bool allow_negative) {
-    if (prefix)
-      Write(prefix);
-    if (!ParseNumber(allow_negative))
-      return false;
-    if (suffix)
-      Write(suffix);
-    return Parse('E');
-  }
-
-  bool ParseBooleanLiteral() {
-    switch (*m_read_ptr++) {
-    case '0':
-      WRITE("false");
-      break;
-    case '1':
-      WRITE("true");
-      break;
-    default:
-#ifdef DEBUG_FAILURES
-      printf("*** Boolean literal not 0 or 1\n");
-#endif
-      return false;
-    }
-    return Parse('E');
-  }
-
-  // <expr-primary> ::= L <type> <value number> E                          #
-  // integer literal
-  //                ::= L <type> <value float> E                           #
-  //                floating literal
-  //                ::= L <string type> E                                  #
-  //                string literal
-  //                ::= L <nullptr type> E                                 #
-  //                nullptr literal (i.e., "LDnE")
-  //                ::= L <type> <real-part float> _ <imag-part float> E   #
-  //                complex floating point literal (C 2000)
-  //                ::= L <mangled-name> E                                 #
-  //                external name
-
-  bool ParseExpressionPrimary() {
-    switch (*m_read_ptr++) {
-    case 'b':
-      return ParseBooleanLiteral();
-    case 'x':
-      return ParseIntegerLiteral(nullptr, "ll", true);
-    case 'l':
-      return ParseIntegerLiteral(nullptr, "l", true);
-    case 'i':
-      return ParseIntegerLiteral(nullptr, nullptr, true);
-    case 'n':
-      return ParseIntegerLiteral("(__int128)", nullptr, true);
-    case 'j':
-      return ParseIntegerLiteral(nullptr, "u", false);
-    case 'm':
-      return ParseIntegerLiteral(nullptr, "ul", false);
-    case 'y':
-      return ParseIntegerLiteral(nullptr, "ull", false);
-    case 'o':
-      return ParseIntegerLiteral("(unsigned __int128)", nullptr, false);
-    case '_':
-      if (*m_read_ptr++ == 'Z') {
-        if (!ParseEncoding())
-          return false;
-        return Parse('E');
-      }
-      --m_read_ptr;
-      LLVM_FALLTHROUGH;
-    case 'w':
-    case 'c':
-    case 'a':
-    case 'h':
-    case 's':
-    case 't':
-    case 'f':
-    case 'd':
-    case 'e':
-#ifdef DEBUG_FAILURES
-      printf("*** Unsupported primary expression %.5s\n", m_read_ptr - 1);
-#endif
-      return false;
-    case 'T':
-// Invalid mangled name per
-//   http://sourcerytools.com/pipermail/cxx-abi-dev/2011-August/002422.html
-#ifdef DEBUG_FAILURES
-      printf("*** Invalid primary expr encoding\n");
-#endif
-      return false;
-    default:
-      --m_read_ptr;
-      Write('(');
-      if (!ParseType())
-        return false;
-      Write(')');
-      if (!ParseNumber())
-        return false;
-      return Parse('E');
-    }
-  }
-
-  // <unresolved-type> ::= <template-param>
-  //                   ::= <decltype>
-  //                   ::= <substitution>
-
-  bool ParseUnresolvedType() {
-    int type_start_cookie = GetStartCookie();
-    switch (*m_read_ptr++) {
-    case 'T':
-      if (!ParseTemplateParam())
-        return false;
-      EndSubstitution(type_start_cookie);
-      return true;
-    case 'S': {
-      if (*m_read_ptr != 't')
-        return ParseSubstitution();
-
-      ++m_read_ptr;
-      WriteStdPrefix();
-      NameState type_name = {};
-      if (!ParseUnqualifiedName(type_name))
-        return false;
-      EndSubstitution(type_start_cookie);
-      return true;
-    }
-    case 'D':
-    default:
-#ifdef DEBUG_FAILURES
-      printf("*** Unsupported unqualified type: %3s\n", m_read_ptr - 1);
-#endif
-      return false;
-    }
-  }
-
-  // <base-unresolved-name> ::= <simple-id>                                #
-  // unresolved name
-  //          extension     ::= <operator-name>                            #
-  //          unresolved operator-function-id
-  //          extension     ::= <operator-name> <template-args>            #
-  //          unresolved operator template-id
-  //                        ::= on <operator-name>                         #
-  //                        unresolved operator-function-id
-  //                        ::= on <operator-name> <template-args>         #
-  //                        unresolved operator template-id
-  //                        ::= dn <destructor-name>                       #
-  //                        destructor or pseudo-destructor;
-  //                                                                         #
-  //                                                                         
e.g.
-  //                                                                         ~X
-  //                                                                         or
-  //                                                                         
~X<N-1>
-
-  bool ParseBaseUnresolvedName() {
-#ifdef DEBUG_FAILURES
-    printf("*** Base unresolved name unsupported\n");
-#endif
-    return false;
-  }
-
-  // <unresolved-name>
-  //  extension        ::= srN <unresolved-type> [<template-args>]
-  //  <unresolved-qualifier-level>* E <base-unresolved-name>
-  //                   ::= [gs] <base-unresolved-name>                     # x
-  //                   or (with "gs") ::x
-  //                   ::= [gs] sr <unresolved-qualifier-level>+ E
-  //                   <base-unresolved-name>
-  //                                                                       #
-  //                                                                       
A::x,
-  //                                                                       
N::y,
-  //                                                                       
A<T>::z;
-  //                                                                       "gs"
-  //                                                                       
means
-  //                                                                       
leading
-  //                                                                       "::"
-  //                   ::= sr <unresolved-type> <base-unresolved-name>     #
-  //                   T::x / decltype(p)::x
-  //  extension        ::= sr <unresolved-type> <template-args>
-  //  <base-unresolved-name>
-  //                                                                       #
-  //                                                                       
T::N::x
-  //                                                                       
/decltype(p)::N::x
-  //  (ignored)        ::= srN <unresolved-type>  <unresolved-qualifier-level>+
-  //  E <base-unresolved-name>
-
-  bool ParseUnresolvedName() {
-#ifdef DEBUG_FAILURES
-    printf("*** Unresolved names not supported\n");
-#endif
-    // TODO: grammar for all of this seems unclear...
-    return false;
-
-#if 0  // TODO
-        if (*m_read_ptr == 'g' && *(m_read_ptr + 1) == 's')
-        {
-            m_read_ptr += 2;
-            WriteNamespaceSeparator();
-        }
-#endif // TODO
-  }
-
-  // <expression> ::= <unary operator-name> <expression>
-  //              ::= <binary operator-name> <expression> <expression>
-  //              ::= <ternary operator-name> <expression> <expression>
-  //              <expression>
-  //              ::= cl <expression>+ E                                   #
-  //              call
-  //              ::= cv <type> <expression>                               #
-  //              conversion with one argument
-  //              ::= cv <type> _ <expression>* E                          #
-  //              conversion with a different number of arguments
-  //              ::= [gs] nw <expression>* _ <type> E                     # 
new
-  //              (expr-list) type
-  //              ::= [gs] nw <expression>* _ <type> <initializer>         # 
new
-  //              (expr-list) type (init)
-  //              ::= [gs] na <expression>* _ <type> E                     #
-  //              new[] (expr-list) type
-  //              ::= [gs] na <expression>* _ <type> <initializer>         #
-  //              new[] (expr-list) type (init)
-  //              ::= [gs] dl <expression>                                 #
-  //              delete expression
-  //              ::= [gs] da <expression>                                 #
-  //              delete[] expression
-  //              ::= pp_ <expression>                                     #
-  //              prefix ++
-  //              ::= mm_ <expression>                                     #
-  //              prefix --
-  //              ::= ti <type>                                            #
-  //              typeid (type)
-  //              ::= te <expression>                                      #
-  //              typeid (expression)
-  //              ::= dc <type> <expression>                               #
-  //              dynamic_cast<type> (expression)
-  //              ::= sc <type> <expression>                               #
-  //              static_cast<type> (expression)
-  //              ::= cc <type> <expression>                               #
-  //              const_cast<type> (expression)
-  //              ::= rc <type> <expression>                               #
-  //              reinterpret_cast<type> (expression)
-  //              ::= st <type>                                            #
-  //              sizeof (a type)
-  //              ::= sz <expression>                                      #
-  //              sizeof (an expression)
-  //              ::= at <type>                                            #
-  //              alignof (a type)
-  //              ::= az <expression>                                      #
-  //              alignof (an expression)
-  //              ::= nx <expression>                                      #
-  //              noexcept (expression)
-  //              ::= <template-param>
-  //              ::= <function-param>
-  //              ::= dt <expression> <unresolved-name>                    #
-  //              expr.name
-  //              ::= pt <expression> <unresolved-name>                    #
-  //              expr->name
-  //              ::= ds <expression> <expression>                         #
-  //              expr.*expr
-  //              ::= sZ <template-param>                                  #
-  //              size of a parameter pack
-  //              ::= sZ <function-param>                                  #
-  //              size of a function parameter pack
-  //              ::= sp <expression>                                      #
-  //              pack expansion
-  //              ::= tw <expression>                                      #
-  //              throw expression
-  //              ::= tr                                                   #
-  //              throw with no operand (rethrow)
-  //              ::= <unresolved-name>                                    #
-  //              f(p), N::f(p), ::f(p),
-  //                                                                       #
-  //                                                                       
freestanding
-  //                                                                       
dependent
-  //                                                                       name
-  //                                                                       
(e.g.,
-  //                                                                       
T::x),
-  //                                                                       #
-  //                                                                       
objectless
-  //                                                                       
nonstatic
-  //                                                                       
member
-  //                                                                       
reference
-  //              ::= <expr-primary>
-
-  bool ParseExpression() {
-    Operator expression_operator = TryParseOperator();
-    switch (expression_operator.kind) {
-    case OperatorKind::Unary:
-      Write(expression_operator.name);
-      Write('(');
-      if (!ParseExpression())
-        return false;
-      Write(')');
-      return true;
-    case OperatorKind::Binary:
-      if (!ParseExpression())
-        return false;
-      Write(expression_operator.name);
-      return ParseExpression();
-    case OperatorKind::Ternary:
-      if (!ParseExpression())
-        return false;
-      Write('?');
-      if (!ParseExpression())
-        return false;
-      Write(':');
-      return ParseExpression();
-    case OperatorKind::NoMatch:
-      break;
-    case OperatorKind::Other:
-    default:
-#ifdef DEBUG_FAILURES
-      printf("*** Unsupported operator: %s\n", expression_operator.name);
-#endif
-      return false;
-    }
-
-    switch (*m_read_ptr++) {
-    case 'T':
-      return ParseTemplateParam();
-    case 'L':
-      return ParseExpressionPrimary();
-    case 's':
-      if (*m_read_ptr++ == 'r')
-        return ParseUnresolvedName();
-      --m_read_ptr;
-      LLVM_FALLTHROUGH;
-    default:
-      return ParseExpressionPrimary();
-    }
-  }
-
-  // <template-arg> ::= <type>                                             #
-  // type or template
-  //                ::= X <expression> E                                   #
-  //                expression
-  //                ::= <expr-primary>                                     #
-  //                simple expressions
-  //                ::= J <template-arg>* E                                #
-  //                argument pack
-  //                ::= LZ <encoding> E                                    #
-  //                extension
-
-  bool ParseTemplateArg() {
-    switch (*m_read_ptr) {
-    case 'J':
-#ifdef DEBUG_FAILURES
-      printf("*** Template argument packs unsupported\n");
-#endif
-      return false;
-    case 'X':
-      ++m_read_ptr;
-      if (!ParseExpression())
-        return false;
-      return Parse('E');
-    case 'L':
-      ++m_read_ptr;
-      return ParseExpressionPrimary();
-    default:
-      return ParseType();
-    }
-  }
-
-  // <template-args> ::= I <template-arg>* E
-  //     extension, the abi says <template-arg>+
-
-  bool ParseTemplateArgs(bool record_template_args = false) {
-    if (record_template_args)
-      ResetTemplateArgs();
-
-    bool first_arg = true;
-    while (*m_read_ptr != 'E') {
-      if (first_arg)
-        first_arg = false;
-      else
-        WriteCommaSpace();
-
-      int template_start_cookie = GetStartCookie();
-      if (!ParseTemplateArg())
-        return false;
-      if (record_template_args)
-        EndTemplateArg(template_start_cookie);
-    }
-    ++m_read_ptr;
-    return true;
-  }
-
-  // <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix>
-  // <unqualified-name> E
-  //               ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix>
-  //               <template-args> E
-  //
-  // <prefix> ::= <prefix> <unqualified-name>
-  //          ::= <template-prefix> <template-args>
-  //          ::= <template-param>
-  //          ::= <decltype>
-  //          ::= # empty
-  //          ::= <substitution>
-  //          ::= <prefix> <data-member-prefix>
-  //  extension ::= L
-  //
-  // <template-prefix> ::= <prefix> <template unqualified-name>
-  //                   ::= <template-param>
-  //                   ::= <substitution>
-  //
-  // <unqualified-name> ::= <operator-name>
-  //                    ::= <ctor-dtor-name>
-  //                    ::= <source-name>
-  //                    ::= <unnamed-type-name>
-
-  bool ParseNestedName(NameState &name_state,
-                       bool parse_discriminator = false) {
-    int qualifiers = TryParseQualifiers(true, true);
-    bool first_part = true;
-    bool suppress_substitution = true;
-    int name_start_cookie = GetStartCookie();
-    while (true) {
-      char next = *m_read_ptr;
-      if (next == 'E') {
-        ++m_read_ptr;
-        break;
-      }
-
-      // Record a substitution candidate for all prefixes, but not the full
-      // name
-      if (suppress_substitution)
-        suppress_substitution = false;
-      else
-        EndSubstitution(name_start_cookie);
-
-      if (next == 'I') {
-        ++m_read_ptr;
-        name_state.is_last_generic = true;
-        WriteTemplateStart();
-        if (!ParseTemplateArgs(name_state.parse_function_params))
-          return false;
-        WriteTemplateEnd();
-        continue;
-      }
-
-      if (first_part)
-        first_part = false;
-      else
-        WriteNamespaceSeparator();
-
-      name_state.is_last_generic = false;
-      switch (next) {
-      case '0':
-      case '1':
-      case '2':
-      case '3':
-      case '4':
-      case '5':
-      case '6':
-      case '7':
-      case '8':
-      case '9': {
-        int name_start_cookie = GetStartCookie();
-        if (!ParseSourceName())
-          return false;
-        name_state.last_name_range = EndRange(name_start_cookie);
-        continue;
-      }
-      case 'S':
-        if (*++m_read_ptr == 't') {
-          WriteStdPrefix();
-          ++m_read_ptr;
-          if (!ParseUnqualifiedName(name_state))
-            return false;
-        } else {
-          if (!ParseSubstitution())
-            return false;
-          suppress_substitution = true;
-        }
-        continue;
-      case 'T':
-        ++m_read_ptr;
-        if (!ParseTemplateParam())
-          return false;
-        continue;
-      case 'C':
-        ++m_read_ptr;
-        if (!ParseCtor(name_state))
-          return false;
-        continue;
-      case 'D': {
-        switch (*(m_read_ptr + 1)) {
-        case 't':
-        case 'T':
-#ifdef DEBUG_FAILURES
-          printf("*** Decltype unsupported\n");
-#endif
-          return false;
-        }
-        ++m_read_ptr;
-        if (!ParseDtor(name_state))
-          return false;
-        continue;
-      }
-      case 'U':
-        ++m_read_ptr;
-        if (!ParseUnnamedTypeName(name_state))
-          return false;
-        continue;
-      case 'L':
-        ++m_read_ptr;
-        if (!ParseUnqualifiedName(name_state))
-          return false;
-        continue;
-      default:
-        if (!ParseOperatorName(name_state))
-          return false;
-      }
-    }
-
-    if (parse_discriminator)
-      TryParseDiscriminator();
-    if (name_state.parse_function_params &&
-        !ParseFunctionArgs(name_state, name_start_cookie)) {
-      return false;
-    }
-    if (qualifiers)
-      WriteQualifiers(qualifiers);
-    return true;
-  }
-
-  // <local-name> := Z <function encoding> E <entity name> [<discriminator>]
-  //              := Z <function encoding> E s [<discriminator>]
-  //              := Z <function encoding> Ed [ <parameter number> ] _ <entity
-  //              name>
-
-  bool ParseLocalName(bool parse_function_params) {
-    if (!ParseEncoding())
-      return false;
-    if (!Parse('E'))
-      return false;
-
-    switch (*m_read_ptr) {
-    case 's':
-      ++m_read_ptr;
-      TryParseDiscriminator(); // Optional and ignored
-      WRITE("::string literal");
-      break;
-    case 'd':
-      ++m_read_ptr;
-      TryParseNumber(); // Optional and ignored
-      if (!Parse('_'))
-        return false;
-      WriteNamespaceSeparator();
-      if (!ParseName())
-        return false;
-      break;
-    default:
-      WriteNamespaceSeparator();
-      if (!ParseName(parse_function_params, true))
-        return false;
-      TryParseDiscriminator(); // Optional and ignored
-    }
-    return true;
-  }
-
-  // <name> ::= <nested-name>
-  //        ::= <local-name>
-  //        ::= <unscoped-template-name> <template-args>
-  //        ::= <unscoped-name>
-
-  // <unscoped-template-name> ::= <unscoped-name>
-  //                          ::= <substitution>
-
-  bool ParseName(bool parse_function_params = false,
-                 bool parse_discriminator = false) {
-    NameState name_state = {parse_function_params, false, false, {0, 0}};
-    int name_start_cookie = GetStartCookie();
-
-    switch (*m_read_ptr) {
-    case 'N':
-      ++m_read_ptr;
-      return ParseNestedName(name_state, parse_discriminator);
-    case 'Z': {
-      ++m_read_ptr;
-      if (!ParseLocalName(parse_function_params))
-        return false;
-      break;
-    }
-    case 'L':
-      ++m_read_ptr;
-      LLVM_FALLTHROUGH;
-    default: {
-      if (!ParseUnscopedName(name_state))
-        return false;
-
-      if (*m_read_ptr == 'I') {
-        EndSubstitution(name_start_cookie);
-
-        ++m_read_ptr;
-        name_state.is_last_generic = true;
-        WriteTemplateStart();
-        if (!ParseTemplateArgs(parse_function_params))
-          return false;
-        WriteTemplateEnd();
-      }
-      break;
-    }
-    }
-    if (parse_discriminator)
-      TryParseDiscriminator();
-    if (parse_function_params &&
-        !ParseFunctionArgs(name_state, name_start_cookie)) {
-      return false;
-    }
-    return true;
-  }
-
-  // <call-offset> ::= h <nv-offset> _
-  //               ::= v <v-offset> _
-  //
-  // <nv-offset> ::= <offset number>
-  //                 # non-virtual base override
-  //
-  // <v-offset>  ::= <offset number> _ <virtual offset number>
-  //                 # virtual base override, with vcall offset
-
-  bool ParseCallOffset() {
-    switch (*m_read_ptr++) {
-    case 'h':
-      if (*m_read_ptr == 'n')
-        ++m_read_ptr;
-      if (TryParseNumber() == -1 || *m_read_ptr++ != '_')
-        break;
-      return true;
-    case 'v':
-      if (*m_read_ptr == 'n')
-        ++m_read_ptr;
-      if (TryParseNumber() == -1 || *m_read_ptr++ != '_')
-        break;
-      if (*m_read_ptr == 'n')
-        ++m_read_ptr;
-      if (TryParseNumber() == -1 || *m_read_ptr++ != '_')
-        break;
-      return true;
-    }
-#ifdef DEBUG_FAILURES
-    printf("*** Malformed call offset\n");
-#endif
-    return false;
-  }
-
-  // <special-name> ::= TV <type>    # virtual table
-  //                ::= TT <type>    # VTT structure (construction vtable 
index)
-  //                ::= TI <type>    # typeinfo structure
-  //                ::= TS <type>    # typeinfo name (null-terminated byte
-  //                string)
-  //                ::= Tc <call-offset> <call-offset> <base encoding>
-  //                    # base is the nominal target function of thunk
-  //                    # first call-offset is 'this' adjustment
-  //                    # second call-offset is result adjustment
-  //                ::= T <call-offset> <base encoding>
-  //                    # base is the nominal target function of thunk
-  //      extension ::= TC <first type> <number> _ <second type> # construction
-  //      vtable for second-in-first
-
-  bool ParseSpecialNameT() {
-    switch (*m_read_ptr++) {
-    case 'V':
-      WRITE("vtable for ");
-      return ParseType();
-    case 'T':
-      WRITE("VTT for ");
-      return ParseType();
-    case 'I':
-      WRITE("typeinfo for ");
-      return ParseType();
-    case 'S':
-      WRITE("typeinfo name for ");
-      return ParseType();
-    case 'c':
-    case 'C':
-#ifdef DEBUG_FAILURES
-      printf("*** Unsupported thunk or construction vtable name: %.3s\n",
-             m_read_ptr - 1);
-#endif
-      return false;
-    default:
-      if (*--m_read_ptr == 'v') {
-        WRITE("virtual thunk to ");
-      } else {
-        WRITE("non-virtual thunk to ");
-      }
-      if (!ParseCallOffset())
-        return false;
-      return ParseEncoding();
-    }
-  }
-
-  // <special-name> ::= GV <object name> # Guard variable for one-time
-  // initialization
-  //                                     # No <type>
-  //      extension ::= GR <object name> # reference temporary for object
-
-  bool ParseSpecialNameG() {
-    switch (*m_read_ptr++) {
-    case 'V':
-      WRITE("guard variable for ");
-      if (!ParseName(true))
-        return false;
-      break;
-    case 'R':
-      WRITE("reference temporary for ");
-      if (!ParseName(true))
-        return false;
-      break;
-    default:
-#ifdef DEBUG_FAILURES
-      printf("*** Unknown G encoding\n");
-#endif
-      return false;
-    }
-    return true;
-  }
-
-  // <bare-function-type> ::= <signature type>+        # types are possible
-  // return type, then parameter types
-
-  bool ParseFunctionArgs(NameState &name_state, int return_insert_cookie) {
-    char next = *m_read_ptr;
-    if (next == 'E' || next == '\0' || next == '.')
-      return true;
-
-    // Clang has a bad habit of making unique manglings by just sticking
-    // numbers on the end of a symbol, which is ambiguous with malformed source
-    // name manglings
-    const char *before_clang_uniquing_test = m_read_ptr;
-    if (TryParseNumber()) {
-      if (*m_read_ptr == '\0')
-        return true;
-      m_read_ptr = before_clang_uniquing_test;
-    }
-
-    if (name_state.is_last_generic && !name_state.has_no_return_type) {
-      int return_type_start_cookie = GetStartCookie();
-      if (!ParseType())
-        return false;
-      Write(' ');
-      ReorderRange(EndRange(return_type_start_cookie), return_insert_cookie);
-    }
-
-    Write('(');
-    bool first_param = true;
-    while (true) {
-      switch (*m_read_ptr) {
-      case '\0':
-      case 'E':
-      case '.':
-        break;
-      case 'v':
-        ++m_read_ptr;
-        continue;
-      case '_':
-        // Not a formal part of the mangling specification, but clang emits
-        // suffixes starting with _block_invoke
-        if (strncmp(m_read_ptr, "_block_invoke", 13) == 0) {
-          m_read_ptr += strlen(m_read_ptr);
-          break;
-        }
-        LLVM_FALLTHROUGH;
-      default:
-        if (first_param)
-          first_param = false;
-        else
-          WriteCommaSpace();
-
-        if (!ParseType())
-          return false;
-        continue;
-      }
-      break;
-    }
-    Write(')');
-    return true;
-  }
-
-  // <encoding> ::= <function name> <bare-function-type>
-  //            ::= <data name>
-  //            ::= <special-name>
-
-  bool ParseEncoding() {
-    switch (*m_read_ptr) {
-    case 'T':
-      ++m_read_ptr;
-      if (!ParseSpecialNameT())
-        return false;
-      break;
-    case 'G':
-      ++m_read_ptr;
-      if (!ParseSpecialNameG())
-        return false;
-      break;
-    default:
-      if (!ParseName(true))
-        return false;
-      break;
-    }
-    return true;
-  }
-
-  bool ParseMangling(const char *mangled_name, long mangled_name_length = 0) {
-    if (!mangled_name_length)
-      mangled_name_length = strlen(mangled_name);
-    m_read_end = mangled_name + mangled_name_length;
-    m_read_ptr = mangled_name;
-    m_write_ptr = m_buffer;
-    m_next_substitute_index = 0;
-    m_next_template_arg_index = m_rewrite_ranges_size - 1;
-
-    if (*m_read_ptr++ != '_' || *m_read_ptr++ != 'Z') {
-#ifdef DEBUG_FAILURES
-      printf("*** Missing _Z prefix\n");
-#endif
-      return false;
-    }
-    if (!ParseEncoding())
-      return false;
-    switch (*m_read_ptr) {
-    case '.':
-      Write(' ');
-      Write('(');
-      Write(m_read_ptr, m_read_end - m_read_ptr);
-      Write(')');
-      LLVM_FALLTHROUGH;
-    case '\0':
-      return true;
-    default:
-#ifdef DEBUG_FAILURES
-      printf("*** Unparsed mangled content\n");
-#endif
-      return false;
-    }
-  }
-
-private:
-  // External scratch storage used during demanglings
-
-  char *m_buffer;
-  const char *m_buffer_end;
-  BufferRange *m_rewrite_ranges;
-  int m_rewrite_ranges_size;
-  bool m_owns_buffer;
-  bool m_owns_m_rewrite_ranges;
-
-  // Internal state used during demangling
-
-  const char *m_read_ptr;
-  const char *m_read_end;
-  char *m_write_ptr;
-  int m_next_template_arg_index;
-  int m_next_substitute_index;
-  std::function<void(const char *s)> m_builtins_hook;
-};
-
-} // Anonymous namespace
-
-// Public entry points referenced from Mangled.cpp
-namespace lldb_private {
-char *FastDemangle(const char *mangled_name) {
-  char buffer[16384];
-  SymbolDemangler demangler(buffer, sizeof(buffer));
-  return demangler.GetDemangledCopy(mangled_name);
-}
-
-char *FastDemangle(const char *mangled_name, size_t mangled_name_length,
-                   std::function<void(const char *s)> builtins_hook) {
-  char buffer[16384];
-  SymbolDemangler demangler(buffer, sizeof(buffer), builtins_hook);
-  return demangler.GetDemangledCopy(mangled_name, mangled_name_length);
-}
-} // lldb_private namespace


_______________________________________________
lldb-commits mailing list
lldb-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits

Reply via email to