pointer_unsafe.go

Documentation: google.golang.org/protobuf/internal/impl

     1  // Copyright 2018 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  //go:build !purego && !appengine
     6  // +build !purego,!appengine
     7  
     8  package impl
     9  
    10  import (
    11  	"reflect"
    12  	"sync/atomic"
    13  	"unsafe"
    14  )
    15  
    16  const UnsafeEnabled = true
    17  
    18  // Pointer is an opaque pointer type.
    19  type Pointer unsafe.Pointer
    20  
    21  // offset represents the offset to a struct field, accessible from a pointer.
    22  // The offset is the byte offset to the field from the start of the struct.
    23  type offset uintptr
    24  
    25  // offsetOf returns a field offset for the struct field.
    26  func offsetOf(f reflect.StructField, x exporter) offset {
    27  	return offset(f.Offset)
    28  }
    29  
    30  // IsValid reports whether the offset is valid.
    31  func (f offset) IsValid() bool { return f != invalidOffset }
    32  
    33  // invalidOffset is an invalid field offset.
    34  var invalidOffset = ^offset(0)
    35  
    36  // zeroOffset is a noop when calling pointer.Apply.
    37  var zeroOffset = offset(0)
    38  
    39  // pointer is a pointer to a message struct or field.
    40  type pointer struct{ p unsafe.Pointer }
    41  
    42  // pointerOf returns p as a pointer.
    43  func pointerOf(p Pointer) pointer {
    44  	return pointer{p: unsafe.Pointer(p)}
    45  }
    46  
    47  // pointerOfValue returns v as a pointer.
    48  func pointerOfValue(v reflect.Value) pointer {
    49  	return pointer{p: unsafe.Pointer(v.Pointer())}
    50  }
    51  
    52  // pointerOfIface returns the pointer portion of an interface.
    53  func pointerOfIface(v interface{}) pointer {
    54  	type ifaceHeader struct {
    55  		Type unsafe.Pointer
    56  		Data unsafe.Pointer
    57  	}
    58  	return pointer{p: (*ifaceHeader)(unsafe.Pointer(&v)).Data}
    59  }
    60  
    61  // IsNil reports whether the pointer is nil.
    62  func (p pointer) IsNil() bool {
    63  	return p.p == nil
    64  }
    65  
    66  // Apply adds an offset to the pointer to derive a new pointer
    67  // to a specified field. The pointer must be valid and pointing at a struct.
    68  func (p pointer) Apply(f offset) pointer {
    69  	if p.IsNil() {
    70  		panic("invalid nil pointer")
    71  	}
    72  	return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
    73  }
    74  
    75  // AsValueOf treats p as a pointer to an object of type t and returns the value.
    76  // It is equivalent to reflect.ValueOf(p.AsIfaceOf(t))
    77  func (p pointer) AsValueOf(t reflect.Type) reflect.Value {
    78  	return reflect.NewAt(t, p.p)
    79  }
    80  
    81  // AsIfaceOf treats p as a pointer to an object of type t and returns the value.
    82  // It is equivalent to p.AsValueOf(t).Interface()
    83  func (p pointer) AsIfaceOf(t reflect.Type) interface{} {
    84  	// TODO: Use tricky unsafe magic to directly create ifaceHeader.
    85  	return p.AsValueOf(t).Interface()
    86  }
    87  
    88  func (p pointer) Bool() *bool                           { return (*bool)(p.p) }
    89  func (p pointer) BoolPtr() **bool                       { return (**bool)(p.p) }
    90  func (p pointer) BoolSlice() *[]bool                    { return (*[]bool)(p.p) }
    91  func (p pointer) Int32() *int32                         { return (*int32)(p.p) }
    92  func (p pointer) Int32Ptr() **int32                     { return (**int32)(p.p) }
    93  func (p pointer) Int32Slice() *[]int32                  { return (*[]int32)(p.p) }
    94  func (p pointer) Int64() *int64                         { return (*int64)(p.p) }
    95  func (p pointer) Int64Ptr() **int64                     { return (**int64)(p.p) }
    96  func (p pointer) Int64Slice() *[]int64                  { return (*[]int64)(p.p) }
    97  func (p pointer) Uint32() *uint32                       { return (*uint32)(p.p) }
    98  func (p pointer) Uint32Ptr() **uint32                   { return (**uint32)(p.p) }
    99  func (p pointer) Uint32Slice() *[]uint32                { return (*[]uint32)(p.p) }
   100  func (p pointer) Uint64() *uint64                       { return (*uint64)(p.p) }
   101  func (p pointer) Uint64Ptr() **uint64                   { return (**uint64)(p.p) }
   102  func (p pointer) Uint64Slice() *[]uint64                { return (*[]uint64)(p.p) }
   103  func (p pointer) Float32() *float32                     { return (*float32)(p.p) }
   104  func (p pointer) Float32Ptr() **float32                 { return (**float32)(p.p) }
   105  func (p pointer) Float32Slice() *[]float32              { return (*[]float32)(p.p) }
   106  func (p pointer) Float64() *float64                     { return (*float64)(p.p) }
   107  func (p pointer) Float64Ptr() **float64                 { return (**float64)(p.p) }
   108  func (p pointer) Float64Slice() *[]float64              { return (*[]float64)(p.p) }
   109  func (p pointer) String() *string                       { return (*string)(p.p) }
   110  func (p pointer) StringPtr() **string                   { return (**string)(p.p) }
   111  func (p pointer) StringSlice() *[]string                { return (*[]string)(p.p) }
   112  func (p pointer) Bytes() *[]byte                        { return (*[]byte)(p.p) }
   113  func (p pointer) BytesPtr() **[]byte                    { return (**[]byte)(p.p) }
   114  func (p pointer) BytesSlice() *[][]byte                 { return (*[][]byte)(p.p) }
   115  func (p pointer) WeakFields() *weakFields               { return (*weakFields)(p.p) }
   116  func (p pointer) Extensions() *map[int32]ExtensionField { return (*map[int32]ExtensionField)(p.p) }
   117  
   118  func (p pointer) Elem() pointer {
   119  	return pointer{p: *(*unsafe.Pointer)(p.p)}
   120  }
   121  
   122  // PointerSlice loads []*T from p as a []pointer.
   123  // The value returned is aliased with the original slice.
   124  // This behavior differs from the implementation in pointer_reflect.go.
   125  func (p pointer) PointerSlice() []pointer {
   126  	// Super-tricky - p should point to a []*T where T is a
   127  	// message type. We load it as []pointer.
   128  	return *(*[]pointer)(p.p)
   129  }
   130  
   131  // AppendPointerSlice appends v to p, which must be a []*T.
   132  func (p pointer) AppendPointerSlice(v pointer) {
   133  	*(*[]pointer)(p.p) = append(*(*[]pointer)(p.p), v)
   134  }
   135  
   136  // SetPointer sets *p to v.
   137  func (p pointer) SetPointer(v pointer) {
   138  	*(*unsafe.Pointer)(p.p) = (unsafe.Pointer)(v.p)
   139  }
   140  
   141  func (p pointer) growBoolSlice(addCap int) {
   142  	sp := p.BoolSlice()
   143  	s := make([]bool, 0, addCap+len(*sp))
   144  	s = s[:len(*sp)]
   145  	copy(s, *sp)
   146  	*sp = s
   147  }
   148  
   149  func (p pointer) growInt32Slice(addCap int) {
   150  	sp := p.Int32Slice()
   151  	s := make([]int32, 0, addCap+len(*sp))
   152  	s = s[:len(*sp)]
   153  	copy(s, *sp)
   154  	*sp = s
   155  }
   156  
   157  func (p pointer) growUint32Slice(addCap int) {
   158  	p.growInt32Slice(addCap)
   159  }
   160  
   161  func (p pointer) growFloat32Slice(addCap int) {
   162  	p.growInt32Slice(addCap)
   163  }
   164  
   165  func (p pointer) growInt64Slice(addCap int) {
   166  	sp := p.Int64Slice()
   167  	s := make([]int64, 0, addCap+len(*sp))
   168  	s = s[:len(*sp)]
   169  	copy(s, *sp)
   170  	*sp = s
   171  }
   172  
   173  func (p pointer) growUint64Slice(addCap int) {
   174  	p.growInt64Slice(addCap)
   175  }
   176  
   177  func (p pointer) growFloat64Slice(addCap int) {
   178  	p.growInt64Slice(addCap)
   179  }
   180  
   181  // Static check that MessageState does not exceed the size of a pointer.
   182  const _ = uint(unsafe.Sizeof(unsafe.Pointer(nil)) - unsafe.Sizeof(MessageState{}))
   183  
   184  func (Export) MessageStateOf(p Pointer) *messageState {
   185  	// Super-tricky - see documentation on MessageState.
   186  	return (*messageState)(unsafe.Pointer(p))
   187  }
   188  func (ms *messageState) pointer() pointer {
   189  	// Super-tricky - see documentation on MessageState.
   190  	return pointer{p: unsafe.Pointer(ms)}
   191  }
   192  func (ms *messageState) messageInfo() *MessageInfo {
   193  	mi := ms.LoadMessageInfo()
   194  	if mi == nil {
   195  		panic("invalid nil message info; this suggests memory corruption due to a race or shallow copy on the message struct")
   196  	}
   197  	return mi
   198  }
   199  func (ms *messageState) LoadMessageInfo() *MessageInfo {
   200  	return (*MessageInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo))))
   201  }
   202  func (ms *messageState) StoreMessageInfo(mi *MessageInfo) {
   203  	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo)), unsafe.Pointer(mi))
   204  }
   205  
   206  type atomicNilMessage struct{ p unsafe.Pointer } // p is a *messageReflectWrapper
   207  
   208  func (m *atomicNilMessage) Init(mi *MessageInfo) *messageReflectWrapper {
   209  	if p := atomic.LoadPointer(&m.p); p != nil {
   210  		return (*messageReflectWrapper)(p)
   211  	}
   212  	w := &messageReflectWrapper{mi: mi}
   213  	atomic.CompareAndSwapPointer(&m.p, nil, (unsafe.Pointer)(w))
   214  	return (*messageReflectWrapper)(atomic.LoadPointer(&m.p))
   215  }
   216
View as plain text