Remove demangle package

Instead of including it the demangle package with pprof,
point to its own repo.

internal/binutils/disasm.go

@@ -21,7 +21,7 @@ import (
 	"strconv"
 
 	"github.com/google/pprof/internal/plugin"
-	"github.com/google/pprof/third_party/golang/demangle"
+	"github.com/ianlancetaylor/demangle"
 )
 
 var (

internal/symbolizer/symbolizer.go

@@ -28,7 +28,7 @@ import (
 	"github.com/google/pprof/internal/plugin"
 	"github.com/google/pprof/internal/symbolz"
 	"github.com/google/pprof/profile"
-	"github.com/google/pprof/third_party/golang/demangle"
+	"github.com/ianlancetaylor/demangle"
 )
 
 // Symbolizer implements the plugin.Symbolize interface.

third_party/golang/demangle/LICENSE

@@ -1,27 +0,0 @@
-Copyright (c) 2015 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

third_party/golang/demangle/README.md

@@ -1,3 +0,0 @@
-# github.com/ianlancetaylor/demangle
-
-A Go package that can be used to demangle C++ symbol names.

third_party/golang/demangle/ast_test.go

@@ -1,42 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package demangle
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestASTToString(t *testing.T) {
-	var tests = []struct {
-		input     AST
-		want      string
-		formatted string
-	}{
-		{
-			&Qualified{Scope: &Name{Name: "s"}, Name: &Name{Name: "C"}},
-			"s::C",
-			`Qualified:
-  Scope: s
-  Name: C`,
-		},
-		{
-			&Typed{Name: &Name{Name: "v"}, Type: &BuiltinType{"int"}},
-			"int v",
-			`Typed:
-  Name: v
-  Type: BuiltinType: int`,
-		},
-	}
-
-	for i, test := range tests {
-		if got := ASTToString(test.input); got != test.want {
-			t.Errorf("ASTToString of test %d == %s, want %s", i, test.input, test.want)
-		}
-		if got := fmt.Sprintf("%#v", test.input); got != test.formatted {
-			t.Errorf("Formatted test %d == %s, want %s", i, got, test.formatted)
-		}
-	}
-}

third_party/golang/demangle/c++filt.go

@@ -1,144 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-// This is a program that works like the GNU c++filt program.
-// It's here for testing purposes and as an example.
-
-package main
-
-import (
-	"bufio"
-	"flag"
-	"fmt"
-	"io"
-	"os"
-	"strings"
-	"unicode"
-
-	"github.com/ianlancetaylor/demangle"
-)
-
-func flagUsage() {
-	usage(os.Stderr, 2)
-}
-
-func usage(w io.Writer, status int) {
-	fmt.Fprintf(w, "Usage: %s [options] [mangled names]\n", os.Args[0])
-	flag.CommandLine.SetOutput(w)
-	flag.PrintDefaults()
-	fmt.Fprintln(w, `Demangled names are displayed to stdout
-If a name cannot be demangled it is just echoed to stdout.
-If no names are provided on the command line, stdin is read.`)
-	os.Exit(status)
-}
-
-var stripUnderscore = flag.Bool("_", false, "Ignore first leading underscore")
-var noParams = flag.Bool("p", false, "Do not display function argument types")
-var noVerbose = flag.Bool("i", false, "Do not show implementation details (if any)")
-var help = flag.Bool("h", false, "Display help information")
-var debug = flag.Bool("d", false, "Display debugging information for strings on command line")
-
-// Unimplemented c++filt flags:
-// -n (opposite of -_)
-// -t (demangle types)
-// -s (set demangling style)
-// -V (print version information)
-
-// Characters considered to be part of a symbol.
-const symbolChars = "_$."
-
-func main() {
-	flag.Usage = func() { usage(os.Stderr, 1) }
-	flag.Parse()
-
-	if *help {
-		usage(os.Stdout, 0)
-	}
-
-	out := bufio.NewWriter(os.Stdout)
-
-	if flag.NArg() > 0 {
-		for _, f := range flag.Args() {
-			if *debug {
-				a, err := demangle.ToAST(f, options()...)
-				if err != nil {
-					fmt.Fprintf(os.Stderr, "%s: %v\n", f, err)
-				} else {
-					fmt.Fprintf(out, "%#v\n", a)
-				}
-			} else {
-				doDemangle(out, f)
-			}
-			out.WriteByte('\n')
-		}
-		if err := out.Flush(); err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(2)
-		}
-		return
-	}
-
-	scanner := bufio.NewScanner(bufio.NewReader(os.Stdin))
-	for scanner.Scan() {
-		line := scanner.Text()
-		start := -1
-		for i, c := range line {
-			if unicode.IsLetter(c) || unicode.IsNumber(c) || strings.ContainsRune(symbolChars, c) {
-				if start < 0 {
-					start = i
-				}
-			} else {
-				if start >= 0 {
-					doDemangle(out, line[start:i])
-				}
-				out.WriteRune(c)
-				start = -1
-			}
-		}
-		if start >= 0 {
-			doDemangle(out, line[start:])
-			start = -1
-		}
-		out.WriteByte('\n')
-		if err := out.Flush(); err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(2)
-		}
-	}
-}
-
-// Demangle a string just as the GNU c++filt program does.
-func doDemangle(out *bufio.Writer, name string) {
-	skip := 0
-	if name[0] == '.' || name[0] == '$' {
-		skip++
-	}
-	if *stripUnderscore && name[skip] == '_' {
-		skip++
-	}
-	result := demangle.Filter(name[skip:], options()...)
-	if result == name[skip:] {
-		out.WriteString(name)
-	} else {
-		if name[0] == '.' {
-			out.WriteByte('.')
-		}
-		out.WriteString(result)
-	}
-}
-
-// options returns the demangling options to use based on the command
-// line flags.
-func options() []demangle.Option {
-	var options []demangle.Option
-	if *noParams {
-		options = append(options, demangle.NoParams)
-	}
-	if !*noVerbose {
-		options = append(options, demangle.Verbose)
-	}
-	return options
-}

third_party/golang/demangle/demangle_test.go

@@ -1,292 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package demangle
-
-import (
-	"strconv"
-	"strings"
-	"testing"
-)
-
-// Check test cases discovered after the code passed the tests in
-// demangle-expected (which are tested by TestExpected).  Some of this
-// are cases where we differ from the standard demangler, some we are
-// the same but we weren't initially.
-func TestDemangler(t *testing.T) {
-	var tests = []struct {
-		input                string
-		want                 string
-		wantNoParams         string
-		wantNoTemplateParams string
-		wantMinimal          string
-	}{
-		{
-			"_ZNSaIcEC1ERKS_",
-			"std::allocator<char>::allocator(std::allocator<char> const&)",
-			"std::allocator<char>::allocator",
-			"std::allocator::allocator(std::allocator const&)",
-			"std::allocator::allocator",
-		},
-		{
-			"_ZN9__gnu_cxx13stdio_filebufIcSt11char_traitsIcEEC1EP8_IO_FILESt13_Ios_Openmodem",
-			"__gnu_cxx::stdio_filebuf<char, std::char_traits<char> >::stdio_filebuf(_IO_FILE*, std::_Ios_Openmode, unsigned long)",
-			"__gnu_cxx::stdio_filebuf<char, std::char_traits<char> >::stdio_filebuf",
-			"__gnu_cxx::stdio_filebuf::stdio_filebuf(_IO_FILE*, std::_Ios_Openmode, unsigned long)",
-			"__gnu_cxx::stdio_filebuf::stdio_filebuf",
-		},
-		{
-			"_ZN1n1CcvNS_1DIT_EEI1EEEv",
-			"n::C::operator n::D<E><E>()",
-			"n::C::operator n::D<E><E>",
-			"n::C::operator n::D()",
-			"n::C::operator n::D",
-		},
-		{
-			"_Z1CIvPN1D1E1FIdJEEEdEPN1GILb0ET_T0_T1_E1HEPFS6_S7_S8_EN1H1I1JIS7_E1KENSG_IS8_E1KE",
-			"G<false, void, D::E::F<double>*, double>::H* C<void, D::E::F<double>*, double>(void (*)(D::E::F<double>*, double), H::I::J<D::E::F<double>*>::K, H::I::J<double>::K)",
-			"C<void, D::E::F<double>*, double>",
-			"G::H* C(void (*)(D::E::F*, double), H::I::J::K, H::I::J::K)",
-			"C",
-		},
-		{
-			"_ZZNK1CI1DIcSt1EIcESaIcEEJEE1FEvE1F",
-			"C<D<char, std::E<char>, std::allocator<char> > >::F() const::F",
-			"C<D<char, std::E<char>, std::allocator<char> > >::F() const::F",
-			"C::F() const::F",
-			"C::F() const::F",
-		},
-		{
-			"_ZN1CI1DSt1EIK1FN1G1HEEE1I1JIJRKS6_EEEvDpOT_",
-			"void C<D, std::E<F const, G::H> >::I::J<std::E<F const, G::H> const&>(std::E<F const, G::H> const&)",
-			"C<D, std::E<F const, G::H> >::I::J<std::E<F const, G::H> const&>",
-			"void C::I::J(std::E const&)",
-			"C::I::J",
-		},
-		{
-			"_ZN1C1D1E1FIJEEEvi1GDpT_",
-			"void C::D::E::F<>(int, G)",
-			"C::D::E::F<>",
-			"void C::D::E::F(int, G)",
-			"C::D::E::F",
-		},
-		{
-			"_ZN1CILj50ELb1EE1DEv",
-			"C<50u, true>::D()",
-			"C<50u, true>::D",
-			"C::D()",
-			"C::D",
-		},
-		{
-			"_ZN1CUt_C2Ev",
-			"C::{unnamed type#1}::{unnamed type#1}()",
-			"C::{unnamed type#1}::{unnamed type#1}",
-			"C::{unnamed type#1}::{unnamed type#1}()",
-			"C::{unnamed type#1}::{unnamed type#1}",
-		},
-		{
-			"_ZN1C12_GLOBAL__N_11DINS_1EEEEN1F1GIDTadcldtcvT__E1HEEEERKS5_NS_1I1JE",
-			"F::G<decltype (&((((C::E)()).H)()))> C::(anonymous namespace)::D<C::E>(C::E const&, C::I::J)",
-			"C::(anonymous namespace)::D<C::E>",
-			"F::G C::(anonymous namespace)::D(C::E const&, C::I::J)",
-			"C::(anonymous namespace)::D",
-		},
-		{
-			"_ZN1CI1DE1EIJiRiRPKcRA1_S4_S8_bS6_S3_RjRPKN1F1GERPKN1H1IEEEEvDpOT_",
-			"void C<D>::E<int, int&, char const*&, char const (&) [1], char const (&) [1], bool, char const*&, int&, unsigned int&, F::G const*&, H::I const*&>(int&&, int&, char const*&, char const (&) [1], char const (&) [1], bool&&, char const*&, int&, unsigned int&, F::G const*&, H::I const*&)",
-			"C<D>::E<int, int&, char const*&, char const (&) [1], char const (&) [1], bool, char const*&, int&, unsigned int&, F::G const*&, H::I const*&>",
-			"void C::E(int&&, int&, char const*&, char const (&) [1], char const (&) [1], bool&&, char const*&, int&, unsigned int&, F::G const*&, H::I const*&)",
-			"C::E",
-		},
-		{
-			"_ZN1C12_GLOBAL__N_11DIFbPKNS_1EEEEEvPNS_1FERKT_",
-			"void C::(anonymous namespace)::D<bool (C::E const*)>(C::F*, bool (&)(C::E const*) const)",
-			"C::(anonymous namespace)::D<bool (C::E const*)>",
-			"void C::(anonymous namespace)::D(C::F*, bool (&)(C::E const*) const)",
-			"C::(anonymous namespace)::D",
-		},
-		{
-			"_ZN1C1D1EIJRFviSt1FIFvRKN1G1H1IEEERKSt6vectorINS_1JESaISB_EEERiS9_EvEENS0_1K1LIJDpNSt1MIT_E1NEEEEDpOSM_",
-			"C::D::K::L<std::M<void (&)(int, std::F<void (G::H::I const&)>, std::vector<C::J, std::allocator<C::J> > const&)>::N, std::M<int&>::N, std::M<std::F<void (G::H::I const&)> >::N> C::D::E<void (&)(int, std::F<void (G::H::I const&)>, std::vector<C::J, std::allocator<C::J> > const&), int&, std::F<void (G::H::I const&)>, void>(void (&)(int, std::F<void (G::H::I const&)>, std::vector<C::J, std::allocator<C::J> > const&), int&, std::F<void (G::H::I const&)>&&)",
-			"C::D::E<void (&)(int, std::F<void (G::H::I const&)>, std::vector<C::J, std::allocator<C::J> > const&), int&, std::F<void (G::H::I const&)>, void>",
-			"C::D::K::L C::D::E(void (&)(int, std::F, std::vector const&), int&, std::F&&)",
-			"C::D::E",
-		},
-		{
-			"_ZN1C1D1E1FcvNS_1GIT_EEI1HEEv",
-			"C::D::E::F::operator C::G<H><H>()",
-			"C::D::E::F::operator C::G<H><H>",
-			"C::D::E::F::operator C::G()",
-			"C::D::E::F::operator C::G",
-		},
-		{
-			"_ZN9__gnu_cxx17__normal_iteratorIPK1EIN1F1G1HEESt6vectorIS5_SaIS5_EEEC2IPS5_EERKNS0_IT_NS_11__enable_ifIXsr3std10__are_sameISE_SD_EE7__valueESA_E1IEEE",
-			"__gnu_cxx::__normal_iterator<E<F::G::H> const*, std::vector<E<F::G::H>, std::allocator<E<F::G::H> > > >::__normal_iterator<E<F::G::H>*>(__gnu_cxx::__normal_iterator<E<F::G::H>*, __gnu_cxx::__enable_if<std::__are_same<E<F::G::H>*, E<F::G::H>*>::__value, std::vector<E<F::G::H>, std::allocator<E<F::G::H> > > >::I> const&)",
-			"__gnu_cxx::__normal_iterator<E<F::G::H> const*, std::vector<E<F::G::H>, std::allocator<E<F::G::H> > > >::__normal_iterator<E<F::G::H>*>",
-			"__gnu_cxx::__normal_iterator::__normal_iterator(__gnu_cxx::__normal_iterator const&)",
-			"__gnu_cxx::__normal_iterator::__normal_iterator",
-		},
-		{
-			"_ZNKSt1CIM1DKFjvEEclIJEvEEjPKS0_DpOT_",
-			"unsigned int std::C<unsigned int (D::*)() const>::operator()<void>(D const*) const",
-			"std::C<unsigned int (D::*)() const>::operator()<void>",
-			"unsigned int std::C::operator()(D const*) const",
-			"std::C::operator()",
-		},
-		{
-			"_ZNSt10_HashtableI12basic_stringIcSt11char_traitsIcESaIcEESt4pairIKS4_N1C1D1EEESaISA_ENSt8__detail10_Select1stESt8equal_toIS4_ESt4hashIS4_ENSC_18_Mod_range_hashingENSC_20_Default_ranged_hashENSC_20_Prime_rehash_policyENSC_17_Hashtable_traitsILb1ELb0ELb1EEEE9_M_assignIZNSN_C1ERKSN_EUlPKNSC_10_Hash_nodeISA_Lb1EEEE_EEvSQ_RKT_",
-			"void std::_Hashtable<basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E>, std::allocator<std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E> >, std::__detail::_Select1st, std::equal_to<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::hash<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<true, false, true> >::_M_assign<std::_Hashtable<basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E>, std::allocator<std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E> >, std::__detail::_Select1st, std::equal_to<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::hash<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<true, false, true> >::_Hashtable(std::_Hashtable<basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E>, std::allocator<std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E> >, std::__detail::_Select1st, std::equal_to<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::hash<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<true, false, true> > const&)::{lambda(std::__detail::_Hash_node<std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E>, true> const*)#1}>(std::_Hashtable<basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E>, std::allocator<std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E> >, std::__detail::_Select1st, std::equal_to<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::hash<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<true, false, true> > const&, std::_Hashtable<basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E>, std::allocator<std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E> >, std::__detail::_Select1st, std::equal_to<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::hash<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<true, false, true> >::_Hashtable(std::_Hashtable<basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E>, std::allocator<std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E> >, std::__detail::_Select1st, std::equal_to<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::hash<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<true, false, true> > const&)::{lambda(std::__detail::_Hash_node<std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E>, true> const*)#1} const&)",
-			"std::_Hashtable<basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E>, std::allocator<std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E> >, std::__detail::_Select1st, std::equal_to<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::hash<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<true, false, true> >::_M_assign<std::_Hashtable<basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E>, std::allocator<std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E> >, std::__detail::_Select1st, std::equal_to<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::hash<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<true, false, true> >::_Hashtable(std::_Hashtable<basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E>, std::allocator<std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E> >, std::__detail::_Select1st, std::equal_to<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::hash<basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<true, false, true> > const&)::{lambda(std::__detail::_Hash_node<std::pair<basic_string<char, std::char_traits<char>, std::allocator<char> > const, C::D::E>, true> const*)#1}>",
-			"void std::_Hashtable::_M_assign(std::_Hashtable const&, std::_Hashtable::_Hashtable(std::_Hashtable const&)::{lambda(std::__detail::_Hash_node const*)#1} const&)",
-			"std::_Hashtable::_M_assign",
-		},
-		{
-			"_ZSt3maxIVdERKT_S3_S3_",
-			"double const volatile& std::max<double volatile>(double const volatile&, double const volatile&)",
-			"std::max<double volatile>",
-			"double const volatile& std::max(double const volatile&, double const volatile&)",
-			"std::max",
-		},
-		{
-			"_ZZN1C1D1E1F1G1HEvENUlvE_C2EOS4_",
-			"C::D::E::F::G::H()::{lambda()#1}::{lambda()#1}({lambda()#1}&&)",
-			"C::D::E::F::G::H()::{lambda()#1}::{lambda()#1}",
-			"C::D::E::F::G::H()::{lambda()#1}::{lambda()#1}({lambda()#1}&&)",
-			"C::D::E::F::G::H()::{lambda()#1}::{lambda()#1}",
-		},
-		{
-			"_ZThn8_NK1C1D1EEv",
-			"non-virtual thunk to C::D::E() const",
-			"non-virtual thunk to C::D::E() const",
-			"non-virtual thunk to C::D::E() const",
-			"non-virtual thunk to C::D::E() const",
-		},
-		{
-			"_ZTv0_n96_NK1C1D1E1FEv",
-			"virtual thunk to C::D::E::F() const",
-			"virtual thunk to C::D::E::F() const",
-			"virtual thunk to C::D::E::F() const",
-			"virtual thunk to C::D::E::F() const",
-		},
-		{
-			"_ZTCSt9strstream16_So",
-			"construction vtable for std::ostream-in-std::strstream",
-			"construction vtable for std::ostream-in-std::strstream",
-			"construction vtable for std::ostream-in-std::strstream",
-			"construction vtable for std::ostream-in-std::strstream",
-		},
-		{
-			"_ZGVZZN1C1D1EEvENK3$_0clEvE1F",
-			"guard variable for C::D::E()::$_0::operator()() const::F",
-			"guard variable for C::D::E()::$_0::operator()() const::F",
-			"guard variable for C::D::E()::$_0::operator()() const::F",
-			"guard variable for C::D::E()::$_0::operator()() const::F",
-		},
-		{
-			"_Z1fICiEvT_",
-			"void f<int _Complex>(int _Complex)",
-			"f<int _Complex>",
-			"void f(int _Complex)",
-			"f",
-		},
-		{
-			"_GLOBAL__D__Z2fnv",
-			"global destructors keyed to fn()",
-			"global destructors keyed to fn()",
-			"global destructors keyed to fn()",
-			"global destructors keyed to fn()",
-		},
-		{
-			"_Z1fIXadL_Z1hvEEEvv",
-			"void f<&h>()",
-			"f<&h>",
-			"void f()",
-			"f",
-		},
-		{
-			"_Z1CIP1DEiRK1EPT_N1F1GIS5_Xaasr1HIS5_E1IntsrSA_1JEE1KE",
-			"int C<D*>(E const&, D**, F::G<D*, H<D*>::I&&(!H<D*>::J)>::K)",
-			"C<D*>",
-			"int C(E const&, D**, F::G::K)",
-			"C",
-		},
-	}
-
-	for _, test := range tests {
-		if got, err := ToString(test.input); err != nil {
-			t.Errorf("demangling %s: unexpected error %v", test.input, err)
-		} else if got != test.want {
-			t.Errorf("demangling %s: got %s, want %s", test.input, got, test.want)
-		}
-
-		if got, err := ToString(test.input, NoParams); err != nil {
-			t.Errorf("demangling NoParams  %s: unexpected error %v", test.input, err)
-		} else if got != test.wantNoParams {
-			t.Errorf("demangling NoParams %s: got %s, want %s", test.input, got, test.wantNoParams)
-		}
-
-		if got, err := ToString(test.input, NoTemplateParams); err != nil {
-			t.Errorf("demangling NoTemplateParams %s: unexpected error %v", test.input, err)
-		} else if got != test.wantNoTemplateParams {
-			t.Errorf("demangling NoTemplateParams %s: got %s, want %s", test.input, got, test.wantNoTemplateParams)
-		}
-
-		if got, err := ToString(test.input, NoParams, NoTemplateParams); err != nil {
-			t.Errorf("demangling NoTemplateParams %s: unexpected error %v", test.input, err)
-		} else if got != test.wantMinimal {
-			t.Errorf("demangling Minimal %s: got %s, want %s", test.input, got, test.wantMinimal)
-		}
-
-		// Test Filter also.
-		if got := Filter(test.input); got != test.want {
-			t.Errorf("Filter(%s) == %s, want %s", test.input, got, test.want)
-		}
-	}
-}
-
-// Test for some failure cases.
-func TestFailure(t *testing.T) {
-	var tests = []struct {
-		input string
-		error string
-		off   int
-	}{
-		{
-			"_Z1FE",
-			"unparsed characters at end of mangled name",
-			4,
-		},
-		{
-			"_Z1FQ",
-			"unrecognized type code",
-			4,
-		},
-	}
-
-	for _, test := range tests {
-		got, err := ToString(test.input)
-		if err == nil {
-			t.Errorf("unexpected success for %s: %s", test.input, got)
-		} else if !strings.Contains(err.Error(), test.error) {
-			t.Errorf("unexpected error for %s: %v", test.input, err)
-		} else {
-			s := err.Error()
-			i := strings.LastIndex(s, " at ")
-			if i < 0 {
-				t.Errorf("missing offset in error for %s: %v", test.input, err)
-			} else {
-				off, oerr := strconv.Atoi(s[i+4:])
-				if oerr != nil {
-					t.Errorf("can't parse offset (%s) for %s: %v", s[i+4:], test.input, err)
-				} else if off != test.off {
-					t.Errorf("unexpected offset for %s: got %d, want %d", test.input, off, test.off)
-				}
-			}
-		}
-
-		if got := Filter(test.input); got != test.input {
-			t.Errorf("Filter(%s) == %s, want %s", test.input, got, test.input)
-		}
-	}
-}

third_party/golang/demangle/expected_test.go

@@ -1,182 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package demangle
-
-import (
-	"bufio"
-	"flag"
-	"fmt"
-	"os"
-	"strings"
-	"testing"
-)
-
-var verbose = flag.Bool("verbose", false, "print each demangle-expected symbol")
-
-const filename = "testdata/demangle-expected"
-
-// A list of exceptions from demangle-expected that we do not handle
-// the same as the standard demangler.  We keep a list of exceptions
-// so that we can use an exact copy of the file.  These exceptions are
-// all based on different handling of a substitution that refers to a
-// template parameter.  The standard demangler seems to have a bug in
-// which template it uses when a reference or rvalue-reference refers
-// to a substitution that resolves to a template parameter.
-var exceptions = map[string]bool{
-	"_ZSt7forwardIRN1x14refobjiteratorINS0_3refINS0_4mime30multipart_section_processorObjIZ15get_body_parserIZZN14mime_processor21make_section_iteratorERKNS2_INS3_10sectionObjENS0_10ptrrefBaseEEEbENKUlvE_clEvEUlSB_bE_ZZNS6_21make_section_iteratorESB_bENKSC_clEvEUlSB_E0_ENS1_INS2_INS0_20outputrefiteratorObjIiEES8_EEEERKSsSB_OT_OT0_EUlmE_NS3_32make_multipart_default_discarderISP_EEEES8_EEEEEOT_RNSt16remove_referenceISW_E4typeE": true,
-	"_ZN3mdr16in_cached_threadIRZNK4cudr6GPUSet17parallel_for_eachIZN5tns3d20shape_representation7compute7GPUImpl7executeERKNS_1AINS_7ptr_refIKjEELl3ELl3ENS_8c_strideILl1ELl0EEEEERKNS8_INS9_IjEELl4ELl1ESD_EEEUliRKNS1_7ContextERNS7_5StateEE_JSt6vectorISO_SaISO_EEEEEvOT_DpRT0_EUlSP_E_JSt17reference_wrapperISO_EEEENS_12ScopedFutureIDTclfp_spcl7forwardISW_Efp0_EEEEESV_DpOSW_":                                                        true,
-	"_ZNSt9_Any_data9_M_accessIPZN3sel8Selector6SetObjI3FooJPKcMS4_FviEEEEvRT_DpT0_EUlvE_EESA_v":                                                                                                                   true,
-	"_ZNSt9_Any_data9_M_accessIPZN13ThreadManager7newTaskIRSt5_BindIFSt7_Mem_fnIM5DiaryFivEEPS5_EEIEEESt6futureINSt9result_ofIFT_DpT0_EE4typeEEOSF_DpOSG_EUlvE_EERSF_v":                                            true,
-	"_ZNSt9_Any_data9_M_accessIPZN6cereal18polymorphic_detail15getInputBindingINS1_16JSONInputArchiveEEENS1_6detail15InputBindingMapIT_E11SerializersERS7_jEUlPvRSt10unique_ptrIvNS5_12EmptyDeleterIvEEEE0_EESA_v": true,
-	"_ZNSt9_Any_data9_M_accessIPZ4postISt8functionIFvvEEEvOT_EUlvE_EERS5_v":                                                                                                                                        true,
-}
-
-// For simplicity, this test reads an exact copy of
-// libiberty/testsuite/demangle-expected from GCC.  See that file for
-// the syntax.  We ignore all tests that are not --format=gnu-v3 or
-// --format=auto with a string starting with _Z.
-func TestExpected(t *testing.T) {
-	f, err := os.Open(filename)
-	if err != nil {
-		t.Fatal(err)
-	}
-	scanner := bufio.NewScanner(f)
-	lineno := 1
-	for {
-		format, got := getOptLine(t, scanner, &lineno)
-		if !got {
-			break
-		}
-		report := lineno
-		input := getLine(t, scanner, &lineno)
-		expect := getLine(t, scanner, &lineno)
-
-		testNoParams := false
-		skip := false
-		if len(format) > 0 && format[0] == '-' {
-			for _, arg := range strings.Fields(format) {
-				switch arg {
-				case "--format=gnu-v3":
-				case "--format=auto":
-					if !strings.HasPrefix(input, "_Z") {
-						skip = true
-					}
-				case "--no-params":
-					testNoParams = true
-				case "--ret-postfix", "--ret-drop":
-					skip = true
-				case "--is-v3-ctor", "--is-v3-dtor":
-					skip = true
-				default:
-					if !strings.HasPrefix(arg, "--format=") {
-						t.Errorf("%s:%d: unrecognized argument %s", filename, report, arg)
-					}
-					skip = true
-				}
-			}
-		}
-
-		// The libiberty testsuite passes DMGL_TYPES to
-		// demangle type names, but that doesn't seem useful
-		// and we don't support it.
-		if !strings.HasPrefix(input, "_Z") && !strings.HasPrefix(input, "_GLOBAL_") {
-			skip = true
-		}
-
-		var expectNoParams string
-		if testNoParams {
-			expectNoParams = getLine(t, scanner, &lineno)
-		}
-
-		if skip {
-			continue
-		}
-
-		oneTest(t, report, input, expect, true)
-		if testNoParams {
-			oneTest(t, report, input, expectNoParams, false)
-		}
-	}
-	if err := scanner.Err(); err != nil {
-		t.Error(err)
-	}
-}
-
-// oneTest tests one entry from demangle-expected.
-func oneTest(t *testing.T, report int, input, expect string, params bool) {
-	if *verbose {
-		fmt.Println(input)
-	}
-
-	exception := exceptions[input]
-
-	var s string
-	var err error
-	if params {
-		s, err = ToString(input)
-	} else {
-		s, err = ToString(input, NoParams)
-	}
-	if err != nil {
-		if exception {
-			t.Logf("%s:%d: ignore expected difference: got %q, expected %q", filename, report, err, expect)
-			return
-		}
-
-		if err != ErrNotMangledName {
-			if input == expect {
-				return
-			}
-			t.Errorf("%s:%d: %v", filename, report, err)
-			return
-		}
-		s = input
-	}
-
-	if s != expect {
-		if exception {
-			t.Logf("%s:%d: ignore expected difference: got %q, expected %q", filename, report, s, expect)
-		} else {
-			var a AST
-			if params {
-				a, err = ToAST(input)
-			} else {
-				a, err = ToAST(input, NoParams)
-			}
-			if err != nil {
-				t.Logf("ToAST error: %v", err)
-			} else {
-				t.Logf("\n%#v", a)
-			}
-			t.Errorf("%s:%d: params: %t: got %q, expected %q", filename, report, params, s, expect)
-		}
-	} else if exception && params {
-		t.Errorf("%s:%d: unexpected success (input listed in exceptions)", filename, report)
-	}
-}
-
-// getLine reads a line from demangle-expected.
-func getLine(t *testing.T, scanner *bufio.Scanner, lineno *int) string {
-	s, got := getOptLine(t, scanner, lineno)
-	if !got {
-		t.Fatalf("%s:%d: unexpected EOF", filename, *lineno)
-	}
-	return s
-}
-
-// getOptLine reads an optional line from demangle-expected, returning
-// false at EOF.  It skips comment lines and updates *lineno.
-func getOptLine(t *testing.T, scanner *bufio.Scanner, lineno *int) (string, bool) {
-	for {
-		if !scanner.Scan() {
-			return "", false
-		}
-		*lineno++
-		line := scanner.Text()
-		if !strings.HasPrefix(line, "#") {
-			return line, true
-		}
-	}
-}