pointer_unsafe.go (7028B)
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 // Static check that MessageState does not exceed the size of a pointer. 142 const _ = uint(unsafe.Sizeof(unsafe.Pointer(nil)) - unsafe.Sizeof(MessageState{})) 143 144 func (Export) MessageStateOf(p Pointer) *messageState { 145 // Super-tricky - see documentation on MessageState. 146 return (*messageState)(unsafe.Pointer(p)) 147 } 148 func (ms *messageState) pointer() pointer { 149 // Super-tricky - see documentation on MessageState. 150 return pointer{p: unsafe.Pointer(ms)} 151 } 152 func (ms *messageState) messageInfo() *MessageInfo { 153 mi := ms.LoadMessageInfo() 154 if mi == nil { 155 panic("invalid nil message info; this suggests memory corruption due to a race or shallow copy on the message struct") 156 } 157 return mi 158 } 159 func (ms *messageState) LoadMessageInfo() *MessageInfo { 160 return (*MessageInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo)))) 161 } 162 func (ms *messageState) StoreMessageInfo(mi *MessageInfo) { 163 atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&ms.atomicMessageInfo)), unsafe.Pointer(mi)) 164 } 165 166 type atomicNilMessage struct{ p unsafe.Pointer } // p is a *messageReflectWrapper 167 168 func (m *atomicNilMessage) Init(mi *MessageInfo) *messageReflectWrapper { 169 if p := atomic.LoadPointer(&m.p); p != nil { 170 return (*messageReflectWrapper)(p) 171 } 172 w := &messageReflectWrapper{mi: mi} 173 atomic.CompareAndSwapPointer(&m.p, nil, (unsafe.Pointer)(w)) 174 return (*messageReflectWrapper)(atomic.LoadPointer(&m.p)) 175 }