vendor: Add github.com/cznic/lldb and friends (new recursive dependency)

vendor/github.com/cznic/internal/slice/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2016 The Internal 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 names of the authors nor the names of the
+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.

vendor/github.com/cznic/internal/slice/pool.go

@@ -0,0 +1,173 @@
+// Copyright 2016 The Internal 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 slice implements pools of pointers to slices.
+package slice
+
+import (
+	"sync"
+
+	"github.com/cznic/mathutil"
+)
+
+var (
+	// Bytes is a ready to use *[]byte Pool.
+	Bytes *Pool
+	// Ints is a ready to use *[]int Pool.
+	Ints *Pool
+)
+
+func init() {
+	Bytes = newBytes()
+	Ints = NewPool(
+		func(size int) interface{} { // create
+			b := make([]int, size)
+			return &b
+		},
+		func(s interface{}) { // clear
+			b := *s.(*[]int)
+			b = b[:cap(b)]
+			for i := range b {
+				b[i] = 0
+			}
+		},
+		func(s interface{}, size int) { // setSize
+			p := s.(*[]int)
+			*p = (*p)[:size]
+		},
+		func(s interface{}) int { return cap(*s.(*[]int)) }, // cap
+	)
+}
+
+func newBytes() *Pool {
+	return NewPool(
+		func(size int) interface{} { // create
+			b := make([]byte, size)
+			return &b
+		},
+		func(s interface{}) { // clear
+			b := *s.(*[]byte)
+			b = b[:cap(b)]
+			for i := range b {
+				b[i] = 0
+			}
+		},
+		func(s interface{}, size int) { // setSize
+			p := s.(*[]byte)
+			*p = (*p)[:size]
+		},
+		func(s interface{}) int { return cap(*s.(*[]byte)) }, // cap
+	)
+}
+
+// Pool implements a pool of pointers to slices.
+//
+// Example usage pattern (assuming pool is, for example, a *[]byte Pool)
+//
+//	p := pool.Get(size).(*[]byte)
+//	b := *p	// Now you can use b in any way you need.
+//	...
+//	// When b will not be used anymore
+//	pool.Put(p)
+//	...
+//	// If b or p are not going out of scope soon, optionally
+//	b = nil
+//	p = nil
+//
+// Otherwise the pool cannot release the slice on garbage collection.
+//
+// Do not do
+//
+//	p := pool.Get(size).(*[]byte)
+//	b := *p
+//	...
+//	pool.Put(&b)
+//
+// or
+//
+//	b := *pool.Get(size).(*[]byte)
+//	...
+//	pool.Put(&b)
+type Pool struct {
+	cap     func(interface{}) int
+	clear   func(interface{})
+	m       [63]sync.Pool
+	null    interface{}
+	setSize func(interface{}, int)
+}
+
+// NewPool returns a newly created Pool. Assuming the desired slice type is
+// []T:
+//
+// The create function returns a *[]T of len == cap == size.
+//
+// The argument of clear is *[]T and the function sets all the slice elements
+// to the respective zero value.
+//
+// The setSize function gets a *[]T and sets its len to size.
+//
+// The cap function gets a *[]T and returns its capacity.
+func NewPool(
+	create func(size int) interface{},
+	clear func(interface{}),
+	setSize func(p interface{}, size int),
+	cap func(p interface{}) int,
+) *Pool {
+	p := &Pool{clear: clear, setSize: setSize, cap: cap, null: create(0)}
+	for i := range p.m {
+		size := 1 << uint(i)
+		p.m[i] = sync.Pool{New: func() interface{} {
+			// 0:     1 -      1
+			// 1:    10 -     10
+			// 2:    11 -    100
+			// 3:   101 -   1000
+			// 4:  1001 -  10000
+			// 5: 10001 - 100000
+			return create(size)
+		}}
+	}
+	return p
+}
+
+// CGet returns a *[]T of len size. The pointed to slice is zeroed up to its
+// cap. CGet panics for size < 0.
+//
+// CGet is safe for concurrent use by multiple goroutines.
+func (p *Pool) CGet(size int) interface{} {
+	s := p.Get(size)
+	p.clear(s)
+	return s
+}
+
+// Get returns a *[]T of len size. The pointed to slice is not zeroed. Get
+// panics for size < 0.
+//
+// Get is safe for concurrent use by multiple goroutines.
+func (p *Pool) Get(size int) interface{} {
+	var index int
+	switch {
+	case size < 0:
+		panic("Pool.Get: negative size")
+	case size == 0:
+		return p.null
+	case size > 1:
+		index = mathutil.Log2Uint64(uint64(size-1)) + 1
+	}
+	s := p.m[index].Get()
+	p.setSize(s, size)
+	return s
+}
+
+// Put puts a *[]T into a pool for possible later reuse by CGet or Get. Put
+// panics is its argument is not of type *[]T.
+//
+// Put is safe for concurrent use by multiple goroutines.
+func (p *Pool) Put(b interface{}) {
+	size := p.cap(b)
+	if size == 0 {
+		return
+	}
+
+	p.m[mathutil.Log2Uint64(uint64(size))].Put(b)
+}