...
Run Format

Source file src/runtime/pprof/internal/profile/proto.go

Documentation: runtime/pprof/internal/profile

     1  // Copyright 2014 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // This file is a simple protocol buffer encoder and decoder.
     6  //
     7  // A protocol message must implement the message interface:
     8  //   decoder() []decoder
     9  //   encode(*buffer)
    10  //
    11  // The decode method returns a slice indexed by field number that gives the
    12  // function to decode that field.
    13  // The encode method encodes its receiver into the given buffer.
    14  //
    15  // The two methods are simple enough to be implemented by hand rather than
    16  // by using a protocol compiler.
    17  //
    18  // See profile.go for examples of messages implementing this interface.
    19  //
    20  // There is no support for groups, message sets, or "has" bits.
    21  
    22  package profile
    23  
    24  import "errors"
    25  
    26  type buffer struct {
    27  	field int
    28  	typ   int
    29  	u64   uint64
    30  	data  []byte
    31  	tmp   [16]byte
    32  }
    33  
    34  type decoder func(*buffer, message) error
    35  
    36  type message interface {
    37  	decoder() []decoder
    38  	encode(*buffer)
    39  }
    40  
    41  func marshal(m message) []byte {
    42  	var b buffer
    43  	m.encode(&b)
    44  	return b.data
    45  }
    46  
    47  func encodeVarint(b *buffer, x uint64) {
    48  	for x >= 128 {
    49  		b.data = append(b.data, byte(x)|0x80)
    50  		x >>= 7
    51  	}
    52  	b.data = append(b.data, byte(x))
    53  }
    54  
    55  func encodeLength(b *buffer, tag int, len int) {
    56  	encodeVarint(b, uint64(tag)<<3|2)
    57  	encodeVarint(b, uint64(len))
    58  }
    59  
    60  func encodeUint64(b *buffer, tag int, x uint64) {
    61  	// append varint to b.data
    62  	encodeVarint(b, uint64(tag)<<3|0)
    63  	encodeVarint(b, x)
    64  }
    65  
    66  func encodeUint64s(b *buffer, tag int, x []uint64) {
    67  	if len(x) > 2 {
    68  		// Use packed encoding
    69  		n1 := len(b.data)
    70  		for _, u := range x {
    71  			encodeVarint(b, u)
    72  		}
    73  		n2 := len(b.data)
    74  		encodeLength(b, tag, n2-n1)
    75  		n3 := len(b.data)
    76  		copy(b.tmp[:], b.data[n2:n3])
    77  		copy(b.data[n1+(n3-n2):], b.data[n1:n2])
    78  		copy(b.data[n1:], b.tmp[:n3-n2])
    79  		return
    80  	}
    81  	for _, u := range x {
    82  		encodeUint64(b, tag, u)
    83  	}
    84  }
    85  
    86  func encodeUint64Opt(b *buffer, tag int, x uint64) {
    87  	if x == 0 {
    88  		return
    89  	}
    90  	encodeUint64(b, tag, x)
    91  }
    92  
    93  func encodeInt64(b *buffer, tag int, x int64) {
    94  	u := uint64(x)
    95  	encodeUint64(b, tag, u)
    96  }
    97  
    98  func encodeInt64Opt(b *buffer, tag int, x int64) {
    99  	if x == 0 {
   100  		return
   101  	}
   102  	encodeInt64(b, tag, x)
   103  }
   104  
   105  func encodeInt64s(b *buffer, tag int, x []int64) {
   106  	if len(x) > 2 {
   107  		// Use packed encoding
   108  		n1 := len(b.data)
   109  		for _, u := range x {
   110  			encodeVarint(b, uint64(u))
   111  		}
   112  		n2 := len(b.data)
   113  		encodeLength(b, tag, n2-n1)
   114  		n3 := len(b.data)
   115  		copy(b.tmp[:], b.data[n2:n3])
   116  		copy(b.data[n1+(n3-n2):], b.data[n1:n2])
   117  		copy(b.data[n1:], b.tmp[:n3-n2])
   118  		return
   119  	}
   120  	for _, u := range x {
   121  		encodeInt64(b, tag, u)
   122  	}
   123  }
   124  
   125  func encodeString(b *buffer, tag int, x string) {
   126  	encodeLength(b, tag, len(x))
   127  	b.data = append(b.data, x...)
   128  }
   129  
   130  func encodeStrings(b *buffer, tag int, x []string) {
   131  	for _, s := range x {
   132  		encodeString(b, tag, s)
   133  	}
   134  }
   135  
   136  func encodeStringOpt(b *buffer, tag int, x string) {
   137  	if x == "" {
   138  		return
   139  	}
   140  	encodeString(b, tag, x)
   141  }
   142  
   143  func encodeBool(b *buffer, tag int, x bool) {
   144  	if x {
   145  		encodeUint64(b, tag, 1)
   146  	} else {
   147  		encodeUint64(b, tag, 0)
   148  	}
   149  }
   150  
   151  func encodeBoolOpt(b *buffer, tag int, x bool) {
   152  	if x == false {
   153  		return
   154  	}
   155  	encodeBool(b, tag, x)
   156  }
   157  
   158  func encodeMessage(b *buffer, tag int, m message) {
   159  	n1 := len(b.data)
   160  	m.encode(b)
   161  	n2 := len(b.data)
   162  	encodeLength(b, tag, n2-n1)
   163  	n3 := len(b.data)
   164  	copy(b.tmp[:], b.data[n2:n3])
   165  	copy(b.data[n1+(n3-n2):], b.data[n1:n2])
   166  	copy(b.data[n1:], b.tmp[:n3-n2])
   167  }
   168  
   169  func unmarshal(data []byte, m message) (err error) {
   170  	b := buffer{data: data, typ: 2}
   171  	return decodeMessage(&b, m)
   172  }
   173  
   174  func le64(p []byte) uint64 {
   175  	return uint64(p[0]) | uint64(p[1])<<8 | uint64(p[2])<<16 | uint64(p[3])<<24 | uint64(p[4])<<32 | uint64(p[5])<<40 | uint64(p[6])<<48 | uint64(p[7])<<56
   176  }
   177  
   178  func le32(p []byte) uint32 {
   179  	return uint32(p[0]) | uint32(p[1])<<8 | uint32(p[2])<<16 | uint32(p[3])<<24
   180  }
   181  
   182  func decodeVarint(data []byte) (uint64, []byte, error) {
   183  	var i int
   184  	var u uint64
   185  	for i = 0; ; i++ {
   186  		if i >= 10 || i >= len(data) {
   187  			return 0, nil, errors.New("bad varint")
   188  		}
   189  		u |= uint64(data[i]&0x7F) << uint(7*i)
   190  		if data[i]&0x80 == 0 {
   191  			return u, data[i+1:], nil
   192  		}
   193  	}
   194  }
   195  
   196  func decodeField(b *buffer, data []byte) ([]byte, error) {
   197  	x, data, err := decodeVarint(data)
   198  	if err != nil {
   199  		return nil, err
   200  	}
   201  	b.field = int(x >> 3)
   202  	b.typ = int(x & 7)
   203  	b.data = nil
   204  	b.u64 = 0
   205  	switch b.typ {
   206  	case 0:
   207  		b.u64, data, err = decodeVarint(data)
   208  		if err != nil {
   209  			return nil, err
   210  		}
   211  	case 1:
   212  		if len(data) < 8 {
   213  			return nil, errors.New("not enough data")
   214  		}
   215  		b.u64 = le64(data[:8])
   216  		data = data[8:]
   217  	case 2:
   218  		var n uint64
   219  		n, data, err = decodeVarint(data)
   220  		if err != nil {
   221  			return nil, err
   222  		}
   223  		if n > uint64(len(data)) {
   224  			return nil, errors.New("too much data")
   225  		}
   226  		b.data = data[:n]
   227  		data = data[n:]
   228  	case 5:
   229  		if len(data) < 4 {
   230  			return nil, errors.New("not enough data")
   231  		}
   232  		b.u64 = uint64(le32(data[:4]))
   233  		data = data[4:]
   234  	default:
   235  		return nil, errors.New("unknown type: " + string(b.typ))
   236  	}
   237  
   238  	return data, nil
   239  }
   240  
   241  func checkType(b *buffer, typ int) error {
   242  	if b.typ != typ {
   243  		return errors.New("type mismatch")
   244  	}
   245  	return nil
   246  }
   247  
   248  func decodeMessage(b *buffer, m message) error {
   249  	if err := checkType(b, 2); err != nil {
   250  		return err
   251  	}
   252  	dec := m.decoder()
   253  	data := b.data
   254  	for len(data) > 0 {
   255  		// pull varint field# + type
   256  		var err error
   257  		data, err = decodeField(b, data)
   258  		if err != nil {
   259  			return err
   260  		}
   261  		if b.field >= len(dec) || dec[b.field] == nil {
   262  			continue
   263  		}
   264  		if err := dec[b.field](b, m); err != nil {
   265  			return err
   266  		}
   267  	}
   268  	return nil
   269  }
   270  
   271  func decodeInt64(b *buffer, x *int64) error {
   272  	if err := checkType(b, 0); err != nil {
   273  		return err
   274  	}
   275  	*x = int64(b.u64)
   276  	return nil
   277  }
   278  
   279  func decodeInt64s(b *buffer, x *[]int64) error {
   280  	if b.typ == 2 {
   281  		// Packed encoding
   282  		data := b.data
   283  		for len(data) > 0 {
   284  			var u uint64
   285  			var err error
   286  
   287  			if u, data, err = decodeVarint(data); err != nil {
   288  				return err
   289  			}
   290  			*x = append(*x, int64(u))
   291  		}
   292  		return nil
   293  	}
   294  	var i int64
   295  	if err := decodeInt64(b, &i); err != nil {
   296  		return err
   297  	}
   298  	*x = append(*x, i)
   299  	return nil
   300  }
   301  
   302  func decodeUint64(b *buffer, x *uint64) error {
   303  	if err := checkType(b, 0); err != nil {
   304  		return err
   305  	}
   306  	*x = b.u64
   307  	return nil
   308  }
   309  
   310  func decodeUint64s(b *buffer, x *[]uint64) error {
   311  	if b.typ == 2 {
   312  		data := b.data
   313  		// Packed encoding
   314  		for len(data) > 0 {
   315  			var u uint64
   316  			var err error
   317  
   318  			if u, data, err = decodeVarint(data); err != nil {
   319  				return err
   320  			}
   321  			*x = append(*x, u)
   322  		}
   323  		return nil
   324  	}
   325  	var u uint64
   326  	if err := decodeUint64(b, &u); err != nil {
   327  		return err
   328  	}
   329  	*x = append(*x, u)
   330  	return nil
   331  }
   332  
   333  func decodeString(b *buffer, x *string) error {
   334  	if err := checkType(b, 2); err != nil {
   335  		return err
   336  	}
   337  	*x = string(b.data)
   338  	return nil
   339  }
   340  
   341  func decodeStrings(b *buffer, x *[]string) error {
   342  	var s string
   343  	if err := decodeString(b, &s); err != nil {
   344  		return err
   345  	}
   346  	*x = append(*x, s)
   347  	return nil
   348  }
   349  
   350  func decodeBool(b *buffer, x *bool) error {
   351  	if err := checkType(b, 0); err != nil {
   352  		return err
   353  	}
   354  	if int64(b.u64) == 0 {
   355  		*x = false
   356  	} else {
   357  		*x = true
   358  	}
   359  	return nil
   360  }
   361  

View as plain text