text: // Copyright 2018 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 !purego,!appengine
  
  package protoreflect
  
  import (
  	"unsafe"
  
  	"google.golang.org/protobuf/internal/pragma"
  )
  
  type (
  	stringHeader struct {
  		Data unsafe.Pointer
  		Len  int
  	}
  	sliceHeader struct {
  		Data unsafe.Pointer
  		Len  int
  		Cap  int
  	}
  	ifaceHeader struct {
  		Type unsafe.Pointer
  		Data unsafe.Pointer
  	}
  )
  
  var (
  	nilType     = typeOf(nil)
  	boolType    = typeOf(*new(bool))
  	int32Type   = typeOf(*new(int32))
  	int64Type   = typeOf(*new(int64))
  	uint32Type  = typeOf(*new(uint32))
  	uint64Type  = typeOf(*new(uint64))
  	float32Type = typeOf(*new(float32))
  	float64Type = typeOf(*new(float64))
  	stringType  = typeOf(*new(string))
  	bytesType   = typeOf(*new([]byte))
  	enumType    = typeOf(*new(EnumNumber))
  )
  
  // typeOf returns a pointer to the Go type information.
  // The pointer is comparable and equal if and only if the types are identical.
  func typeOf(t interface{}) unsafe.Pointer {
  	return (*ifaceHeader)(unsafe.Pointer(&t)).Type
  }
  
  // value is a union where only one type can be represented at a time.
  // The struct is 24B large on 64-bit systems and requires the minimum storage
  // necessary to represent each possible type.
  //
  // The Go GC needs to be able to scan variables containing pointers.
  // As such, pointers and non-pointers cannot be intermixed.
  type value struct {
  	pragma.DoNotCompare // 0B
  
  	// typ stores the type of the value as a pointer to the Go type.
  	typ unsafe.Pointer // 8B
  
  	// ptr stores the data pointer for a String, Bytes, or interface value.
  	ptr unsafe.Pointer // 8B
  
  	// num stores a Bool, Int32, Int64, Uint32, Uint64, Float32, Float64, or
  	// Enum value as a raw uint64.
  	//
  	// It is also used to store the length of a String or Bytes value;
  	// the capacity is ignored.
  	num uint64 // 8B
  }
  
  func valueOfString(v string) Value {
  	p := (*stringHeader)(unsafe.Pointer(&v))
  	return Value{typ: stringType, ptr: p.Data, num: uint64(len(v))}
  }
  func valueOfBytes(v []byte) Value {
  	p := (*sliceHeader)(unsafe.Pointer(&v))
  	return Value{typ: bytesType, ptr: p.Data, num: uint64(len(v))}
  }
  func valueOfIface(v interface{}) Value {
  	p := (*ifaceHeader)(unsafe.Pointer(&v))
  	return Value{typ: p.Type, ptr: p.Data}
  }
  
  func (v Value) getString() (x string) {
  	*(*stringHeader)(unsafe.Pointer(&x)) = stringHeader{Data: v.ptr, Len: int(v.num)}
  	return x
  }
  func (v Value) getBytes() (x []byte) {
  	*(*sliceHeader)(unsafe.Pointer(&x)) = sliceHeader{Data: v.ptr, Len: int(v.num), Cap: int(v.num)}
  	return x
  }
  func (v Value) getIface() (x interface{}) {
  	*(*ifaceHeader)(unsafe.Pointer(&x)) = ifaceHeader{Type: v.typ, Data: v.ptr}
  	return x
  }
  