Source file src/pkg/encoding/gob/encode.go

     1	// Copyright 2009 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	package gob
     6	
     7	import (
     8		"bytes"
     9		"math"
    10		"reflect"
    11		"unsafe"
    12	)
    13	
    14	const uint64Size = int(unsafe.Sizeof(uint64(0)))
    15	
    16	// encoderState is the global execution state of an instance of the encoder.
    17	// Field numbers are delta encoded and always increase. The field
    18	// number is initialized to -1 so 0 comes out as delta(1). A delta of
    19	// 0 terminates the structure.
    20	type encoderState struct {
    21		enc      *Encoder
    22		b        *bytes.Buffer
    23		sendZero bool                 // encoding an array element or map key/value pair; send zero values
    24		fieldnum int                  // the last field number written.
    25		buf      [1 + uint64Size]byte // buffer used by the encoder; here to avoid allocation.
    26		next     *encoderState        // for free list
    27	}
    28	
    29	func (enc *Encoder) newEncoderState(b *bytes.Buffer) *encoderState {
    30		e := enc.freeList
    31		if e == nil {
    32			e = new(encoderState)
    33			e.enc = enc
    34		} else {
    35			enc.freeList = e.next
    36		}
    37		e.sendZero = false
    38		e.fieldnum = 0
    39		e.b = b
    40		return e
    41	}
    42	
    43	func (enc *Encoder) freeEncoderState(e *encoderState) {
    44		e.next = enc.freeList
    45		enc.freeList = e
    46	}
    47	
    48	// Unsigned integers have a two-state encoding.  If the number is less
    49	// than 128 (0 through 0x7F), its value is written directly.
    50	// Otherwise the value is written in big-endian byte order preceded
    51	// by the byte length, negated.
    52	
    53	// encodeUint writes an encoded unsigned integer to state.b.
    54	func (state *encoderState) encodeUint(x uint64) {
    55		if x <= 0x7F {
    56			err := state.b.WriteByte(uint8(x))
    57			if err != nil {
    58				error_(err)
    59			}
    60			return
    61		}
    62		i := uint64Size
    63		for x > 0 {
    64			state.buf[i] = uint8(x)
    65			x >>= 8
    66			i--
    67		}
    68		state.buf[i] = uint8(i - uint64Size) // = loop count, negated
    69		_, err := state.b.Write(state.buf[i : uint64Size+1])
    70		if err != nil {
    71			error_(err)
    72		}
    73	}
    74	
    75	// encodeInt writes an encoded signed integer to state.w.
    76	// The low bit of the encoding says whether to bit complement the (other bits of the)
    77	// uint to recover the int.
    78	func (state *encoderState) encodeInt(i int64) {
    79		var x uint64
    80		if i < 0 {
    81			x = uint64(^i<<1) | 1
    82		} else {
    83			x = uint64(i << 1)
    84		}
    85		state.encodeUint(uint64(x))
    86	}
    87	
    88	// encOp is the signature of an encoding operator for a given type.
    89	type encOp func(i *encInstr, state *encoderState, p unsafe.Pointer)
    90	
    91	// The 'instructions' of the encoding machine
    92	type encInstr struct {
    93		op     encOp
    94		field  int     // field number
    95		indir  int     // how many pointer indirections to reach the value in the struct
    96		offset uintptr // offset in the structure of the field to encode
    97	}
    98	
    99	// update emits a field number and updates the state to record its value for delta encoding.
   100	// If the instruction pointer is nil, it does nothing
   101	func (state *encoderState) update(instr *encInstr) {
   102		if instr != nil {
   103			state.encodeUint(uint64(instr.field - state.fieldnum))
   104			state.fieldnum = instr.field
   105		}
   106	}
   107	
   108	// Each encoder for a composite is responsible for handling any
   109	// indirections associated with the elements of the data structure.
   110	// If any pointer so reached is nil, no bytes are written.  If the
   111	// data item is zero, no bytes are written.  Single values - ints,
   112	// strings etc. - are indirected before calling their encoders.
   113	// Otherwise, the output (for a scalar) is the field number, as an
   114	// encoded integer, followed by the field data in its appropriate
   115	// format.
   116	
   117	// encIndirect dereferences p indir times and returns the result.
   118	func encIndirect(p unsafe.Pointer, indir int) unsafe.Pointer {
   119		for ; indir > 0; indir-- {
   120			p = *(*unsafe.Pointer)(p)
   121			if p == nil {
   122				return unsafe.Pointer(nil)
   123			}
   124		}
   125		return p
   126	}
   127	
   128	// encBool encodes the bool with address p as an unsigned 0 or 1.
   129	func encBool(i *encInstr, state *encoderState, p unsafe.Pointer) {
   130		b := *(*bool)(p)
   131		if b || state.sendZero {
   132			state.update(i)
   133			if b {
   134				state.encodeUint(1)
   135			} else {
   136				state.encodeUint(0)
   137			}
   138		}
   139	}
   140	
   141	// encInt encodes the int with address p.
   142	func encInt(i *encInstr, state *encoderState, p unsafe.Pointer) {
   143		v := int64(*(*int)(p))
   144		if v != 0 || state.sendZero {
   145			state.update(i)
   146			state.encodeInt(v)
   147		}
   148	}
   149	
   150	// encUint encodes the uint with address p.
   151	func encUint(i *encInstr, state *encoderState, p unsafe.Pointer) {
   152		v := uint64(*(*uint)(p))
   153		if v != 0 || state.sendZero {
   154			state.update(i)
   155			state.encodeUint(v)
   156		}
   157	}
   158	
   159	// encInt8 encodes the int8 with address p.
   160	func encInt8(i *encInstr, state *encoderState, p unsafe.Pointer) {
   161		v := int64(*(*int8)(p))
   162		if v != 0 || state.sendZero {
   163			state.update(i)
   164			state.encodeInt(v)
   165		}
   166	}
   167	
   168	// encUint8 encodes the uint8 with address p.
   169	func encUint8(i *encInstr, state *encoderState, p unsafe.Pointer) {
   170		v := uint64(*(*uint8)(p))
   171		if v != 0 || state.sendZero {
   172			state.update(i)
   173			state.encodeUint(v)
   174		}
   175	}
   176	
   177	// encInt16 encodes the int16 with address p.
   178	func encInt16(i *encInstr, state *encoderState, p unsafe.Pointer) {
   179		v := int64(*(*int16)(p))
   180		if v != 0 || state.sendZero {
   181			state.update(i)
   182			state.encodeInt(v)
   183		}
   184	}
   185	
   186	// encUint16 encodes the uint16 with address p.
   187	func encUint16(i *encInstr, state *encoderState, p unsafe.Pointer) {
   188		v := uint64(*(*uint16)(p))
   189		if v != 0 || state.sendZero {
   190			state.update(i)
   191			state.encodeUint(v)
   192		}
   193	}
   194	
   195	// encInt32 encodes the int32 with address p.
   196	func encInt32(i *encInstr, state *encoderState, p unsafe.Pointer) {
   197		v := int64(*(*int32)(p))
   198		if v != 0 || state.sendZero {
   199			state.update(i)
   200			state.encodeInt(v)
   201		}
   202	}
   203	
   204	// encUint encodes the uint32 with address p.
   205	func encUint32(i *encInstr, state *encoderState, p unsafe.Pointer) {
   206		v := uint64(*(*uint32)(p))
   207		if v != 0 || state.sendZero {
   208			state.update(i)
   209			state.encodeUint(v)
   210		}
   211	}
   212	
   213	// encInt64 encodes the int64 with address p.
   214	func encInt64(i *encInstr, state *encoderState, p unsafe.Pointer) {
   215		v := *(*int64)(p)
   216		if v != 0 || state.sendZero {
   217			state.update(i)
   218			state.encodeInt(v)
   219		}
   220	}
   221	
   222	// encInt64 encodes the uint64 with address p.
   223	func encUint64(i *encInstr, state *encoderState, p unsafe.Pointer) {
   224		v := *(*uint64)(p)
   225		if v != 0 || state.sendZero {
   226			state.update(i)
   227			state.encodeUint(v)
   228		}
   229	}
   230	
   231	// encUintptr encodes the uintptr with address p.
   232	func encUintptr(i *encInstr, state *encoderState, p unsafe.Pointer) {
   233		v := uint64(*(*uintptr)(p))
   234		if v != 0 || state.sendZero {
   235			state.update(i)
   236			state.encodeUint(v)
   237		}
   238	}
   239	
   240	// floatBits returns a uint64 holding the bits of a floating-point number.
   241	// Floating-point numbers are transmitted as uint64s holding the bits
   242	// of the underlying representation.  They are sent byte-reversed, with
   243	// the exponent end coming out first, so integer floating point numbers
   244	// (for example) transmit more compactly.  This routine does the
   245	// swizzling.
   246	func floatBits(f float64) uint64 {
   247		u := math.Float64bits(f)
   248		var v uint64
   249		for i := 0; i < 8; i++ {
   250			v <<= 8
   251			v |= u & 0xFF
   252			u >>= 8
   253		}
   254		return v
   255	}
   256	
   257	// encFloat32 encodes the float32 with address p.
   258	func encFloat32(i *encInstr, state *encoderState, p unsafe.Pointer) {
   259		f := *(*float32)(p)
   260		if f != 0 || state.sendZero {
   261			v := floatBits(float64(f))
   262			state.update(i)
   263			state.encodeUint(v)
   264		}
   265	}
   266	
   267	// encFloat64 encodes the float64 with address p.
   268	func encFloat64(i *encInstr, state *encoderState, p unsafe.Pointer) {
   269		f := *(*float64)(p)
   270		if f != 0 || state.sendZero {
   271			state.update(i)
   272			v := floatBits(f)
   273			state.encodeUint(v)
   274		}
   275	}
   276	
   277	// encComplex64 encodes the complex64 with address p.
   278	// Complex numbers are just a pair of floating-point numbers, real part first.
   279	func encComplex64(i *encInstr, state *encoderState, p unsafe.Pointer) {
   280		c := *(*complex64)(p)
   281		if c != 0+0i || state.sendZero {
   282			rpart := floatBits(float64(real(c)))
   283			ipart := floatBits(float64(imag(c)))
   284			state.update(i)
   285			state.encodeUint(rpart)
   286			state.encodeUint(ipart)
   287		}
   288	}
   289	
   290	// encComplex128 encodes the complex128 with address p.
   291	func encComplex128(i *encInstr, state *encoderState, p unsafe.Pointer) {
   292		c := *(*complex128)(p)
   293		if c != 0+0i || state.sendZero {
   294			rpart := floatBits(real(c))
   295			ipart := floatBits(imag(c))
   296			state.update(i)
   297			state.encodeUint(rpart)
   298			state.encodeUint(ipart)
   299		}
   300	}
   301	
   302	// encUint8Array encodes the byte slice whose header has address p.
   303	// Byte arrays are encoded as an unsigned count followed by the raw bytes.
   304	func encUint8Array(i *encInstr, state *encoderState, p unsafe.Pointer) {
   305		b := *(*[]byte)(p)
   306		if len(b) > 0 || state.sendZero {
   307			state.update(i)
   308			state.encodeUint(uint64(len(b)))
   309			state.b.Write(b)
   310		}
   311	}
   312	
   313	// encString encodes the string whose header has address p.
   314	// Strings are encoded as an unsigned count followed by the raw bytes.
   315	func encString(i *encInstr, state *encoderState, p unsafe.Pointer) {
   316		s := *(*string)(p)
   317		if len(s) > 0 || state.sendZero {
   318			state.update(i)
   319			state.encodeUint(uint64(len(s)))
   320			state.b.WriteString(s)
   321		}
   322	}
   323	
   324	// encStructTerminator encodes the end of an encoded struct
   325	// as delta field number of 0.
   326	func encStructTerminator(i *encInstr, state *encoderState, p unsafe.Pointer) {
   327		state.encodeUint(0)
   328	}
   329	
   330	// Execution engine
   331	
   332	// encEngine an array of instructions indexed by field number of the encoding
   333	// data, typically a struct.  It is executed top to bottom, walking the struct.
   334	type encEngine struct {
   335		instr []encInstr
   336	}
   337	
   338	const singletonField = 0
   339	
   340	// encodeSingle encodes a single top-level non-struct value.
   341	func (enc *Encoder) encodeSingle(b *bytes.Buffer, engine *encEngine, basep uintptr) {
   342		state := enc.newEncoderState(b)
   343		state.fieldnum = singletonField
   344		// There is no surrounding struct to frame the transmission, so we must
   345		// generate data even if the item is zero.  To do this, set sendZero.
   346		state.sendZero = true
   347		instr := &engine.instr[singletonField]
   348		p := unsafe.Pointer(basep) // offset will be zero
   349		if instr.indir > 0 {
   350			if p = encIndirect(p, instr.indir); p == nil {
   351				return
   352			}
   353		}
   354		instr.op(instr, state, p)
   355		enc.freeEncoderState(state)
   356	}
   357	
   358	// encodeStruct encodes a single struct value.
   359	func (enc *Encoder) encodeStruct(b *bytes.Buffer, engine *encEngine, basep uintptr) {
   360		state := enc.newEncoderState(b)
   361		state.fieldnum = -1
   362		for i := 0; i < len(engine.instr); i++ {
   363			instr := &engine.instr[i]
   364			p := unsafe.Pointer(basep + instr.offset)
   365			if instr.indir > 0 {
   366				if p = encIndirect(p, instr.indir); p == nil {
   367					continue
   368				}
   369			}
   370			instr.op(instr, state, p)
   371		}
   372		enc.freeEncoderState(state)
   373	}
   374	
   375	// encodeArray encodes the array whose 0th element is at p.
   376	func (enc *Encoder) encodeArray(b *bytes.Buffer, p uintptr, op encOp, elemWid uintptr, elemIndir int, length int) {
   377		state := enc.newEncoderState(b)
   378		state.fieldnum = -1
   379		state.sendZero = true
   380		state.encodeUint(uint64(length))
   381		for i := 0; i < length; i++ {
   382			elemp := p
   383			up := unsafe.Pointer(elemp)
   384			if elemIndir > 0 {
   385				if up = encIndirect(up, elemIndir); up == nil {
   386					errorf("encodeArray: nil element")
   387				}
   388				elemp = uintptr(up)
   389			}
   390			op(nil, state, unsafe.Pointer(elemp))
   391			p += uintptr(elemWid)
   392		}
   393		enc.freeEncoderState(state)
   394	}
   395	
   396	// encodeReflectValue is a helper for maps. It encodes the value v.
   397	func encodeReflectValue(state *encoderState, v reflect.Value, op encOp, indir int) {
   398		for i := 0; i < indir && v.IsValid(); i++ {
   399			v = reflect.Indirect(v)
   400		}
   401		if !v.IsValid() {
   402			errorf("encodeReflectValue: nil element")
   403		}
   404		op(nil, state, unsafe.Pointer(unsafeAddr(v)))
   405	}
   406	
   407	// encodeMap encodes a map as unsigned count followed by key:value pairs.
   408	// Because map internals are not exposed, we must use reflection rather than
   409	// addresses.
   410	func (enc *Encoder) encodeMap(b *bytes.Buffer, mv reflect.Value, keyOp, elemOp encOp, keyIndir, elemIndir int) {
   411		state := enc.newEncoderState(b)
   412		state.fieldnum = -1
   413		state.sendZero = true
   414		keys := mv.MapKeys()
   415		state.encodeUint(uint64(len(keys)))
   416		for _, key := range keys {
   417			encodeReflectValue(state, key, keyOp, keyIndir)
   418			encodeReflectValue(state, mv.MapIndex(key), elemOp, elemIndir)
   419		}
   420		enc.freeEncoderState(state)
   421	}
   422	
   423	// encodeInterface encodes the interface value iv.
   424	// To send an interface, we send a string identifying the concrete type, followed
   425	// by the type identifier (which might require defining that type right now), followed
   426	// by the concrete value.  A nil value gets sent as the empty string for the name,
   427	// followed by no value.
   428	func (enc *Encoder) encodeInterface(b *bytes.Buffer, iv reflect.Value) {
   429		state := enc.newEncoderState(b)
   430		state.fieldnum = -1
   431		state.sendZero = true
   432		if iv.IsNil() {
   433			state.encodeUint(0)
   434			return
   435		}
   436	
   437		ut := userType(iv.Elem().Type())
   438		name, ok := concreteTypeToName[ut.base]
   439		if !ok {
   440			errorf("type not registered for interface: %s", ut.base)
   441		}
   442		// Send the name.
   443		state.encodeUint(uint64(len(name)))
   444		_, err := state.b.WriteString(name)
   445		if err != nil {
   446			error_(err)
   447		}
   448		// Define the type id if necessary.
   449		enc.sendTypeDescriptor(enc.writer(), state, ut)
   450		// Send the type id.
   451		enc.sendTypeId(state, ut)
   452		// Encode the value into a new buffer.  Any nested type definitions
   453		// should be written to b, before the encoded value.
   454		enc.pushWriter(b)
   455		data := new(bytes.Buffer)
   456		data.Write(spaceForLength)
   457		enc.encode(data, iv.Elem(), ut)
   458		if enc.err != nil {
   459			error_(enc.err)
   460		}
   461		enc.popWriter()
   462		enc.writeMessage(b, data)
   463		if enc.err != nil {
   464			error_(err)
   465		}
   466		enc.freeEncoderState(state)
   467	}
   468	
   469	// isZero returns whether the value is the zero of its type.
   470	func isZero(val reflect.Value) bool {
   471		switch val.Kind() {
   472		case reflect.Array:
   473			for i := 0; i < val.Len(); i++ {
   474				if !isZero(val.Index(i)) {
   475					return false
   476				}
   477			}
   478			return true
   479		case reflect.Map, reflect.Slice, reflect.String:
   480			return val.Len() == 0
   481		case reflect.Bool:
   482			return !val.Bool()
   483		case reflect.Complex64, reflect.Complex128:
   484			return val.Complex() == 0
   485		case reflect.Chan, reflect.Func, reflect.Ptr:
   486			return val.IsNil()
   487		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   488			return val.Int() == 0
   489		case reflect.Float32, reflect.Float64:
   490			return val.Float() == 0
   491		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   492			return val.Uint() == 0
   493		case reflect.Struct:
   494			for i := 0; i < val.NumField(); i++ {
   495				if !isZero(val.Field(i)) {
   496					return false
   497				}
   498			}
   499			return true
   500		}
   501		panic("unknown type in isZero " + val.Type().String())
   502	}
   503	
   504	// encGobEncoder encodes a value that implements the GobEncoder interface.
   505	// The data is sent as a byte array.
   506	func (enc *Encoder) encodeGobEncoder(b *bytes.Buffer, v reflect.Value) {
   507		// TODO: should we catch panics from the called method?
   508		// We know it's a GobEncoder, so just call the method directly.
   509		data, err := v.Interface().(GobEncoder).GobEncode()
   510		if err != nil {
   511			error_(err)
   512		}
   513		state := enc.newEncoderState(b)
   514		state.fieldnum = -1
   515		state.encodeUint(uint64(len(data)))
   516		state.b.Write(data)
   517		enc.freeEncoderState(state)
   518	}
   519	
   520	var encOpTable = [...]encOp{
   521		reflect.Bool:       encBool,
   522		reflect.Int:        encInt,
   523		reflect.Int8:       encInt8,
   524		reflect.Int16:      encInt16,
   525		reflect.Int32:      encInt32,
   526		reflect.Int64:      encInt64,
   527		reflect.Uint:       encUint,
   528		reflect.Uint8:      encUint8,
   529		reflect.Uint16:     encUint16,
   530		reflect.Uint32:     encUint32,
   531		reflect.Uint64:     encUint64,
   532		reflect.Uintptr:    encUintptr,
   533		reflect.Float32:    encFloat32,
   534		reflect.Float64:    encFloat64,
   535		reflect.Complex64:  encComplex64,
   536		reflect.Complex128: encComplex128,
   537		reflect.String:     encString,
   538	}
   539	
   540	// encOpFor returns (a pointer to) the encoding op for the base type under rt and
   541	// the indirection count to reach it.
   542	func (enc *Encoder) encOpFor(rt reflect.Type, inProgress map[reflect.Type]*encOp) (*encOp, int) {
   543		ut := userType(rt)
   544		// If the type implements GobEncoder, we handle it without further processing.
   545		if ut.isGobEncoder {
   546			return enc.gobEncodeOpFor(ut)
   547		}
   548		// If this type is already in progress, it's a recursive type (e.g. map[string]*T).
   549		// Return the pointer to the op we're already building.
   550		if opPtr := inProgress[rt]; opPtr != nil {
   551			return opPtr, ut.indir
   552		}
   553		typ := ut.base
   554		indir := ut.indir
   555		k := typ.Kind()
   556		var op encOp
   557		if int(k) < len(encOpTable) {
   558			op = encOpTable[k]
   559		}
   560		if op == nil {
   561			inProgress[rt] = &op
   562			// Special cases
   563			switch t := typ; t.Kind() {
   564			case reflect.Slice:
   565				if t.Elem().Kind() == reflect.Uint8 {
   566					op = encUint8Array
   567					break
   568				}
   569				// Slices have a header; we decode it to find the underlying array.
   570				elemOp, indir := enc.encOpFor(t.Elem(), inProgress)
   571				op = func(i *encInstr, state *encoderState, p unsafe.Pointer) {
   572					slice := (*reflect.SliceHeader)(p)
   573					if !state.sendZero && slice.Len == 0 {
   574						return
   575					}
   576					state.update(i)
   577					state.enc.encodeArray(state.b, slice.Data, *elemOp, t.Elem().Size(), indir, int(slice.Len))
   578				}
   579			case reflect.Array:
   580				// True arrays have size in the type.
   581				elemOp, indir := enc.encOpFor(t.Elem(), inProgress)
   582				op = func(i *encInstr, state *encoderState, p unsafe.Pointer) {
   583					state.update(i)
   584					state.enc.encodeArray(state.b, uintptr(p), *elemOp, t.Elem().Size(), indir, t.Len())
   585				}
   586			case reflect.Map:
   587				keyOp, keyIndir := enc.encOpFor(t.Key(), inProgress)
   588				elemOp, elemIndir := enc.encOpFor(t.Elem(), inProgress)
   589				op = func(i *encInstr, state *encoderState, p unsafe.Pointer) {
   590					// Maps cannot be accessed by moving addresses around the way
   591					// that slices etc. can.  We must recover a full reflection value for
   592					// the iteration.
   593					v := reflect.NewAt(t, unsafe.Pointer(p)).Elem()
   594					mv := reflect.Indirect(v)
   595					// We send zero-length (but non-nil) maps because the
   596					// receiver might want to use the map.  (Maps don't use append.)
   597					if !state.sendZero && mv.IsNil() {
   598						return
   599					}
   600					state.update(i)
   601					state.enc.encodeMap(state.b, mv, *keyOp, *elemOp, keyIndir, elemIndir)
   602				}
   603			case reflect.Struct:
   604				// Generate a closure that calls out to the engine for the nested type.
   605				enc.getEncEngine(userType(typ))
   606				info := mustGetTypeInfo(typ)
   607				op = func(i *encInstr, state *encoderState, p unsafe.Pointer) {
   608					state.update(i)
   609					// indirect through info to delay evaluation for recursive structs
   610					state.enc.encodeStruct(state.b, info.encoder, uintptr(p))
   611				}
   612			case reflect.Interface:
   613				op = func(i *encInstr, state *encoderState, p unsafe.Pointer) {
   614					// Interfaces transmit the name and contents of the concrete
   615					// value they contain.
   616					v := reflect.NewAt(t, unsafe.Pointer(p)).Elem()
   617					iv := reflect.Indirect(v)
   618					if !state.sendZero && (!iv.IsValid() || iv.IsNil()) {
   619						return
   620					}
   621					state.update(i)
   622					state.enc.encodeInterface(state.b, iv)
   623				}
   624			}
   625		}
   626		if op == nil {
   627			errorf("can't happen: encode type %s", rt)
   628		}
   629		return &op, indir
   630	}
   631	
   632	// gobEncodeOpFor returns the op for a type that is known to implement
   633	// GobEncoder.
   634	func (enc *Encoder) gobEncodeOpFor(ut *userTypeInfo) (*encOp, int) {
   635		rt := ut.user
   636		if ut.encIndir == -1 {
   637			rt = reflect.PtrTo(rt)
   638		} else if ut.encIndir > 0 {
   639			for i := int8(0); i < ut.encIndir; i++ {
   640				rt = rt.Elem()
   641			}
   642		}
   643		var op encOp
   644		op = func(i *encInstr, state *encoderState, p unsafe.Pointer) {
   645			var v reflect.Value
   646			if ut.encIndir == -1 {
   647				// Need to climb up one level to turn value into pointer.
   648				v = reflect.NewAt(rt, unsafe.Pointer(&p)).Elem()
   649			} else {
   650				v = reflect.NewAt(rt, p).Elem()
   651			}
   652			if !state.sendZero && isZero(v) {
   653				return
   654			}
   655			state.update(i)
   656			state.enc.encodeGobEncoder(state.b, v)
   657		}
   658		return &op, int(ut.encIndir) // encIndir: op will get called with p == address of receiver.
   659	}
   660	
   661	// compileEnc returns the engine to compile the type.
   662	func (enc *Encoder) compileEnc(ut *userTypeInfo) *encEngine {
   663		srt := ut.base
   664		engine := new(encEngine)
   665		seen := make(map[reflect.Type]*encOp)
   666		rt := ut.base
   667		if ut.isGobEncoder {
   668			rt = ut.user
   669		}
   670		if !ut.isGobEncoder &&
   671			srt.Kind() == reflect.Struct {
   672			for fieldNum, wireFieldNum := 0, 0; fieldNum < srt.NumField(); fieldNum++ {
   673				f := srt.Field(fieldNum)
   674				if !isExported(f.Name) {
   675					continue
   676				}
   677				op, indir := enc.encOpFor(f.Type, seen)
   678				engine.instr = append(engine.instr, encInstr{*op, wireFieldNum, indir, uintptr(f.Offset)})
   679				wireFieldNum++
   680			}
   681			if srt.NumField() > 0 && len(engine.instr) == 0 {
   682				errorf("type %s has no exported fields", rt)
   683			}
   684			engine.instr = append(engine.instr, encInstr{encStructTerminator, 0, 0, 0})
   685		} else {
   686			engine.instr = make([]encInstr, 1)
   687			op, indir := enc.encOpFor(rt, seen)
   688			engine.instr[0] = encInstr{*op, singletonField, indir, 0} // offset is zero
   689		}
   690		return engine
   691	}
   692	
   693	// getEncEngine returns the engine to compile the type.
   694	// typeLock must be held (or we're in initialization and guaranteed single-threaded).
   695	func (enc *Encoder) getEncEngine(ut *userTypeInfo) *encEngine {
   696		info, err1 := getTypeInfo(ut)
   697		if err1 != nil {
   698			error_(err1)
   699		}
   700		if info.encoder == nil {
   701			// mark this engine as underway before compiling to handle recursive types.
   702			info.encoder = new(encEngine)
   703			info.encoder = enc.compileEnc(ut)
   704		}
   705		return info.encoder
   706	}
   707	
   708	// lockAndGetEncEngine is a function that locks and compiles.
   709	// This lets us hold the lock only while compiling, not when encoding.
   710	func (enc *Encoder) lockAndGetEncEngine(ut *userTypeInfo) *encEngine {
   711		typeLock.Lock()
   712		defer typeLock.Unlock()
   713		return enc.getEncEngine(ut)
   714	}
   715	
   716	func (enc *Encoder) encode(b *bytes.Buffer, value reflect.Value, ut *userTypeInfo) {
   717		defer catchError(&enc.err)
   718		engine := enc.lockAndGetEncEngine(ut)
   719		indir := ut.indir
   720		if ut.isGobEncoder {
   721			indir = int(ut.encIndir)
   722		}
   723		for i := 0; i < indir; i++ {
   724			value = reflect.Indirect(value)
   725		}
   726		if !ut.isGobEncoder && value.Type().Kind() == reflect.Struct {
   727			enc.encodeStruct(b, engine, unsafeAddr(value))
   728		} else {
   729			enc.encodeSingle(b, engine, unsafeAddr(value))
   730		}
   731	}