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 reflect 6 7 import ( 8 "math" 9 "runtime" 10 "unsafe" 11 ) 12 13 const ptrSize = 4 << (^uintptr(0) >> 63) // unsafe.Sizeof(uintptr(0)) but an ideal const 14 15 // Value is the reflection interface to a Go value. 16 // 17 // Not all methods apply to all kinds of values. Restrictions, 18 // if any, are noted in the documentation for each method. 19 // Use the Kind method to find out the kind of value before 20 // calling kind-specific methods. Calling a method 21 // inappropriate to the kind of type causes a run time panic. 22 // 23 // The zero Value represents no value. 24 // Its IsValid method returns false, its Kind method returns Invalid, 25 // its String method returns "<invalid Value>", and all other methods panic. 26 // Most functions and methods never return an invalid value. 27 // If one does, its documentation states the conditions explicitly. 28 // 29 // A Value can be used concurrently by multiple goroutines provided that 30 // the underlying Go value can be used concurrently for the equivalent 31 // direct operations. 32 // 33 // To compare two Values, compare the results of the Interface method. 34 // Using == on two Values does not compare the underlying values 35 // they represent. 36 type Value struct { 37 // typ holds the type of the value represented by a Value. 38 typ *rtype 39 40 // Pointer-valued data or, if flagIndir is set, pointer to data. 41 // Valid when either flagIndir is set or typ.pointers() is true. 42 ptr unsafe.Pointer 43 44 // flag holds metadata about the value. 45 // The lowest bits are flag bits: 46 // - flagStickyRO: obtained via unexported not embedded field, so read-only 47 // - flagEmbedRO: obtained via unexported embedded field, so read-only 48 // - flagIndir: val holds a pointer to the data 49 // - flagAddr: v.CanAddr is true (implies flagIndir) 50 // - flagMethod: v is a method value. 51 // The next five bits give the Kind of the value. 52 // This repeats typ.Kind() except for method values. 53 // The remaining 23+ bits give a method number for method values. 54 // If flag.kind() != Func, code can assume that flagMethod is unset. 55 // If ifaceIndir(typ), code can assume that flagIndir is set. 56 flag 57 58 // A method value represents a curried method invocation 59 // like r.Read for some receiver r. The typ+val+flag bits describe 60 // the receiver r, but the flag's Kind bits say Func (methods are 61 // functions), and the top bits of the flag give the method number 62 // in r's type's method table. 63 } 64 65 type flag uintptr 66 67 const ( 68 flagKindWidth = 5 // there are 27 kinds 69 flagKindMask flag = 1<<flagKindWidth - 1 70 flagStickyRO flag = 1 << 5 71 flagEmbedRO flag = 1 << 6 72 flagIndir flag = 1 << 7 73 flagAddr flag = 1 << 8 74 flagMethod flag = 1 << 9 75 flagMethodShift = 10 76 flagRO flag = flagStickyRO | flagEmbedRO 77 ) 78 79 func (f flag) kind() Kind { 80 return Kind(f & flagKindMask) 81 } 82 83 func (f flag) ro() flag { 84 if f&flagRO != 0 { 85 return flagStickyRO 86 } 87 return 0 88 } 89 90 // pointer returns the underlying pointer represented by v. 91 // v.Kind() must be Ptr, Map, Chan, Func, or UnsafePointer 92 func (v Value) pointer() unsafe.Pointer { 93 if v.typ.size != ptrSize || !v.typ.pointers() { 94 panic("can't call pointer on a non-pointer Value") 95 } 96 if v.flag&flagIndir != 0 { 97 return *(*unsafe.Pointer)(v.ptr) 98 } 99 return v.ptr 100 } 101 102 // packEface converts v to the empty interface. 103 func packEface(v Value) interface{} { 104 t := v.typ 105 var i interface{} 106 e := (*emptyInterface)(unsafe.Pointer(&i)) 107 // First, fill in the data portion of the interface. 108 switch { 109 case ifaceIndir(t): 110 if v.flag&flagIndir == 0 { 111 panic("bad indir") 112 } 113 // Value is indirect, and so is the interface we're making. 114 ptr := v.ptr 115 if v.flag&flagAddr != 0 { 116 // TODO: pass safe boolean from valueInterface so 117 // we don't need to copy if safe==true? 118 c := unsafe_New(t) 119 typedmemmove(t, c, ptr) 120 ptr = c 121 } 122 e.word = ptr 123 case v.flag&flagIndir != 0: 124 // Value is indirect, but interface is direct. We need 125 // to load the data at v.ptr into the interface data word. 126 e.word = *(*unsafe.Pointer)(v.ptr) 127 default: 128 // Value is direct, and so is the interface. 129 e.word = v.ptr 130 } 131 // Now, fill in the type portion. We're very careful here not 132 // to have any operation between the e.word and e.typ assignments 133 // that would let the garbage collector observe the partially-built 134 // interface value. 135 e.typ = t 136 return i 137 } 138 139 // unpackEface converts the empty interface i to a Value. 140 func unpackEface(i interface{}) Value { 141 e := (*emptyInterface)(unsafe.Pointer(&i)) 142 // NOTE: don't read e.word until we know whether it is really a pointer or not. 143 t := e.typ 144 if t == nil { 145 return Value{} 146 } 147 f := flag(t.Kind()) 148 if ifaceIndir(t) { 149 f |= flagIndir 150 } 151 return Value{t, e.word, f} 152 } 153 154 // A ValueError occurs when a Value method is invoked on 155 // a Value that does not support it. Such cases are documented 156 // in the description of each method. 157 type ValueError struct { 158 Method string 159 Kind Kind 160 } 161 162 func (e *ValueError) Error() string { 163 if e.Kind == 0 { 164 return "reflect: call of " + e.Method + " on zero Value" 165 } 166 return "reflect: call of " + e.Method + " on " + e.Kind.String() + " Value" 167 } 168 169 // methodName returns the name of the calling method, 170 // assumed to be two stack frames above. 171 func methodName() string { 172 pc, _, _, _ := runtime.Caller(2) 173 f := runtime.FuncForPC(pc) 174 if f == nil { 175 return "unknown method" 176 } 177 return f.Name() 178 } 179 180 // emptyInterface is the header for an interface{} value. 181 type emptyInterface struct { 182 typ *rtype 183 word unsafe.Pointer 184 } 185 186 // nonEmptyInterface is the header for an interface value with methods. 187 type nonEmptyInterface struct { 188 // see ../runtime/iface.go:/Itab 189 itab *struct { 190 ityp *rtype // static interface type 191 typ *rtype // dynamic concrete type 192 hash uint32 // copy of typ.hash 193 _ [4]byte 194 fun [100000]unsafe.Pointer // method table 195 } 196 word unsafe.Pointer 197 } 198 199 // mustBe panics if f's kind is not expected. 200 // Making this a method on flag instead of on Value 201 // (and embedding flag in Value) means that we can write 202 // the very clear v.mustBe(Bool) and have it compile into 203 // v.flag.mustBe(Bool), which will only bother to copy the 204 // single important word for the receiver. 205 func (f flag) mustBe(expected Kind) { 206 // TODO(mvdan): use f.kind() again once mid-stack inlining gets better 207 if Kind(f&flagKindMask) != expected { 208 panic(&ValueError{methodName(), f.kind()}) 209 } 210 } 211 212 // mustBeExported panics if f records that the value was obtained using 213 // an unexported field. 214 func (f flag) mustBeExported() { 215 if f == 0 || f&flagRO != 0 { 216 f.mustBeExportedSlow() 217 } 218 } 219 220 func (f flag) mustBeExportedSlow() { 221 if f == 0 { 222 panic(&ValueError{methodName(), Invalid}) 223 } 224 if f&flagRO != 0 { 225 panic("reflect: " + methodName() + " using value obtained using unexported field") 226 } 227 } 228 229 // mustBeAssignable panics if f records that the value is not assignable, 230 // which is to say that either it was obtained using an unexported field 231 // or it is not addressable. 232 func (f flag) mustBeAssignable() { 233 if f&flagRO != 0 || f&flagAddr == 0 { 234 f.mustBeAssignableSlow() 235 } 236 } 237 238 func (f flag) mustBeAssignableSlow() { 239 if f == 0 { 240 panic(&ValueError{methodName(), Invalid}) 241 } 242 // Assignable if addressable and not read-only. 243 if f&flagRO != 0 { 244 panic("reflect: " + methodName() + " using value obtained using unexported field") 245 } 246 if f&flagAddr == 0 { 247 panic("reflect: " + methodName() + " using unaddressable value") 248 } 249 } 250 251 // Addr returns a pointer value representing the address of v. 252 // It panics if CanAddr() returns false. 253 // Addr is typically used to obtain a pointer to a struct field 254 // or slice element in order to call a method that requires a 255 // pointer receiver. 256 func (v Value) Addr() Value { 257 if v.flag&flagAddr == 0 { 258 panic("reflect.Value.Addr of unaddressable value") 259 } 260 return Value{v.typ.ptrTo(), v.ptr, v.flag.ro() | flag(Ptr)} 261 } 262 263 // Bool returns v's underlying value. 264 // It panics if v's kind is not Bool. 265 func (v Value) Bool() bool { 266 v.mustBe(Bool) 267 return *(*bool)(v.ptr) 268 } 269 270 // Bytes returns v's underlying value. 271 // It panics if v's underlying value is not a slice of bytes. 272 func (v Value) Bytes() []byte { 273 v.mustBe(Slice) 274 if v.typ.Elem().Kind() != Uint8 { 275 panic("reflect.Value.Bytes of non-byte slice") 276 } 277 // Slice is always bigger than a word; assume flagIndir. 278 return *(*[]byte)(v.ptr) 279 } 280 281 // runes returns v's underlying value. 282 // It panics if v's underlying value is not a slice of runes (int32s). 283 func (v Value) runes() []rune { 284 v.mustBe(Slice) 285 if v.typ.Elem().Kind() != Int32 { 286 panic("reflect.Value.Bytes of non-rune slice") 287 } 288 // Slice is always bigger than a word; assume flagIndir. 289 return *(*[]rune)(v.ptr) 290 } 291 292 // CanAddr reports whether the value's address can be obtained with Addr. 293 // Such values are called addressable. A value is addressable if it is 294 // an element of a slice, an element of an addressable array, 295 // a field of an addressable struct, or the result of dereferencing a pointer. 296 // If CanAddr returns false, calling Addr will panic. 297 func (v Value) CanAddr() bool { 298 return v.flag&flagAddr != 0 299 } 300 301 // CanSet reports whether the value of v can be changed. 302 // A Value can be changed only if it is addressable and was not 303 // obtained by the use of unexported struct fields. 304 // If CanSet returns false, calling Set or any type-specific 305 // setter (e.g., SetBool, SetInt) will panic. 306 func (v Value) CanSet() bool { 307 return v.flag&(flagAddr|flagRO) == flagAddr 308 } 309 310 // Call calls the function v with the input arguments in. 311 // For example, if len(in) == 3, v.Call(in) represents the Go call v(in[0], in[1], in[2]). 312 // Call panics if v's Kind is not Func. 313 // It returns the output results as Values. 314 // As in Go, each input argument must be assignable to the 315 // type of the function's corresponding input parameter. 316 // If v is a variadic function, Call creates the variadic slice parameter 317 // itself, copying in the corresponding values. 318 func (v Value) Call(in []Value) []Value { 319 v.mustBe(Func) 320 v.mustBeExported() 321 return v.call("Call", in) 322 } 323 324 // CallSlice calls the variadic function v with the input arguments in, 325 // assigning the slice in[len(in)-1] to v's final variadic argument. 326 // For example, if len(in) == 3, v.CallSlice(in) represents the Go call v(in[0], in[1], in[2]...). 327 // CallSlice panics if v's Kind is not Func or if v is not variadic. 328 // It returns the output results as Values. 329 // As in Go, each input argument must be assignable to the 330 // type of the function's corresponding input parameter. 331 func (v Value) CallSlice(in []Value) []Value { 332 v.mustBe(Func) 333 v.mustBeExported() 334 return v.call("CallSlice", in) 335 } 336 337 var callGC bool // for testing; see TestCallMethodJump 338 339 func (v Value) call(op string, in []Value) []Value { 340 // Get function pointer, type. 341 t := (*funcType)(unsafe.Pointer(v.typ)) 342 var ( 343 fn unsafe.Pointer 344 rcvr Value 345 rcvrtype *rtype 346 ) 347 if v.flag&flagMethod != 0 { 348 rcvr = v 349 rcvrtype, t, fn = methodReceiver(op, v, int(v.flag)>>flagMethodShift) 350 } else if v.flag&flagIndir != 0 { 351 fn = *(*unsafe.Pointer)(v.ptr) 352 } else { 353 fn = v.ptr 354 } 355 356 if fn == nil { 357 panic("reflect.Value.Call: call of nil function") 358 } 359 360 isSlice := op == "CallSlice" 361 n := t.NumIn() 362 if isSlice { 363 if !t.IsVariadic() { 364 panic("reflect: CallSlice of non-variadic function") 365 } 366 if len(in) < n { 367 panic("reflect: CallSlice with too few input arguments") 368 } 369 if len(in) > n { 370 panic("reflect: CallSlice with too many input arguments") 371 } 372 } else { 373 if t.IsVariadic() { 374 n-- 375 } 376 if len(in) < n { 377 panic("reflect: Call with too few input arguments") 378 } 379 if !t.IsVariadic() && len(in) > n { 380 panic("reflect: Call with too many input arguments") 381 } 382 } 383 for _, x := range in { 384 if x.Kind() == Invalid { 385 panic("reflect: " + op + " using zero Value argument") 386 } 387 } 388 for i := 0; i < n; i++ { 389 if xt, targ := in[i].Type(), t.In(i); !xt.AssignableTo(targ) { 390 panic("reflect: " + op + " using " + xt.String() + " as type " + targ.String()) 391 } 392 } 393 if !isSlice && t.IsVariadic() { 394 // prepare slice for remaining values 395 m := len(in) - n 396 slice := MakeSlice(t.In(n), m, m) 397 elem := t.In(n).Elem() 398 for i := 0; i < m; i++ { 399 x := in[n+i] 400 if xt := x.Type(); !xt.AssignableTo(elem) { 401 panic("reflect: cannot use " + xt.String() + " as type " + elem.String() + " in " + op) 402 } 403 slice.Index(i).Set(x) 404 } 405 origIn := in 406 in = make([]Value, n+1) 407 copy(in[:n], origIn) 408 in[n] = slice 409 } 410 411 nin := len(in) 412 if nin != t.NumIn() { 413 panic("reflect.Value.Call: wrong argument count") 414 } 415 nout := t.NumOut() 416 417 // Compute frame type. 418 frametype, _, retOffset, _, framePool := funcLayout(t, rcvrtype) 419 420 // Allocate a chunk of memory for frame. 421 var args unsafe.Pointer 422 if nout == 0 { 423 args = framePool.Get().(unsafe.Pointer) 424 } else { 425 // Can't use pool if the function has return values. 426 // We will leak pointer to args in ret, so its lifetime is not scoped. 427 args = unsafe_New(frametype) 428 } 429 off := uintptr(0) 430 431 // Copy inputs into args. 432 if rcvrtype != nil { 433 storeRcvr(rcvr, args) 434 off = ptrSize 435 } 436 for i, v := range in { 437 v.mustBeExported() 438 targ := t.In(i).(*rtype) 439 a := uintptr(targ.align) 440 off = (off + a - 1) &^ (a - 1) 441 n := targ.size 442 if n == 0 { 443 // Not safe to compute args+off pointing at 0 bytes, 444 // because that might point beyond the end of the frame, 445 // but we still need to call assignTo to check assignability. 446 v.assignTo("reflect.Value.Call", targ, nil) 447 continue 448 } 449 addr := add(args, off, "n > 0") 450 v = v.assignTo("reflect.Value.Call", targ, addr) 451 if v.flag&flagIndir != 0 { 452 typedmemmove(targ, addr, v.ptr) 453 } else { 454 *(*unsafe.Pointer)(addr) = v.ptr 455 } 456 off += n 457 } 458 459 // Call. 460 call(frametype, fn, args, uint32(frametype.size), uint32(retOffset)) 461 462 // For testing; see TestCallMethodJump. 463 if callGC { 464 runtime.GC() 465 } 466 467 var ret []Value 468 if nout == 0 { 469 typedmemclr(frametype, args) 470 framePool.Put(args) 471 } else { 472 // Zero the now unused input area of args, 473 // because the Values returned by this function contain pointers to the args object, 474 // and will thus keep the args object alive indefinitely. 475 typedmemclrpartial(frametype, args, 0, retOffset) 476 477 // Wrap Values around return values in args. 478 ret = make([]Value, nout) 479 off = retOffset 480 for i := 0; i < nout; i++ { 481 tv := t.Out(i) 482 a := uintptr(tv.Align()) 483 off = (off + a - 1) &^ (a - 1) 484 if tv.Size() != 0 { 485 fl := flagIndir | flag(tv.Kind()) 486 ret[i] = Value{tv.common(), add(args, off, "tv.Size() != 0"), fl} 487 // Note: this does introduce false sharing between results - 488 // if any result is live, they are all live. 489 // (And the space for the args is live as well, but as we've 490 // cleared that space it isn't as big a deal.) 491 } else { 492 // For zero-sized return value, args+off may point to the next object. 493 // In this case, return the zero value instead. 494 ret[i] = Zero(tv) 495 } 496 off += tv.Size() 497 } 498 } 499 500 return ret 501 } 502 503 // callReflect is the call implementation used by a function 504 // returned by MakeFunc. In many ways it is the opposite of the 505 // method Value.call above. The method above converts a call using Values 506 // into a call of a function with a concrete argument frame, while 507 // callReflect converts a call of a function with a concrete argument 508 // frame into a call using Values. 509 // It is in this file so that it can be next to the call method above. 510 // The remainder of the MakeFunc implementation is in makefunc.go. 511 // 512 // NOTE: This function must be marked as a "wrapper" in the generated code, 513 // so that the linker can make it work correctly for panic and recover. 514 // The gc compilers know to do that for the name "reflect.callReflect". 515 // 516 // ctxt is the "closure" generated by MakeFunc. 517 // frame is a pointer to the arguments to that closure on the stack. 518 // retValid points to a boolean which should be set when the results 519 // section of frame is set. 520 func callReflect(ctxt *makeFuncImpl, frame unsafe.Pointer, retValid *bool) { 521 ftyp := ctxt.ftyp 522 f := ctxt.fn 523 524 // Copy argument frame into Values. 525 ptr := frame 526 off := uintptr(0) 527 in := make([]Value, 0, int(ftyp.inCount)) 528 for _, typ := range ftyp.in() { 529 off += -off & uintptr(typ.align-1) 530 v := Value{typ, nil, flag(typ.Kind())} 531 if ifaceIndir(typ) { 532 // value cannot be inlined in interface data. 533 // Must make a copy, because f might keep a reference to it, 534 // and we cannot let f keep a reference to the stack frame 535 // after this function returns, not even a read-only reference. 536 v.ptr = unsafe_New(typ) 537 if typ.size > 0 { 538 typedmemmove(typ, v.ptr, add(ptr, off, "typ.size > 0")) 539 } 540 v.flag |= flagIndir 541 } else { 542 v.ptr = *(*unsafe.Pointer)(add(ptr, off, "1-ptr")) 543 } 544 in = append(in, v) 545 off += typ.size 546 } 547 548 // Call underlying function. 549 out := f(in) 550 numOut := ftyp.NumOut() 551 if len(out) != numOut { 552 panic("reflect: wrong return count from function created by MakeFunc") 553 } 554 555 // Copy results back into argument frame. 556 if numOut > 0 { 557 off += -off & (ptrSize - 1) 558 if runtime.GOARCH == "amd64p32" { 559 off = align(off, 8) 560 } 561 for i, typ := range ftyp.out() { 562 v := out[i] 563 if v.typ == nil { 564 panic("reflect: function created by MakeFunc using " + funcName(f) + 565 " returned zero Value") 566 } 567 if v.flag&flagRO != 0 { 568 panic("reflect: function created by MakeFunc using " + funcName(f) + 569 " returned value obtained from unexported field") 570 } 571 off += -off & uintptr(typ.align-1) 572 if typ.size == 0 { 573 continue 574 } 575 addr := add(ptr, off, "typ.size > 0") 576 577 // Convert v to type typ if v is assignable to a variable 578 // of type t in the language spec. 579 // See issue 28761. 580 v = v.assignTo("reflect.MakeFunc", typ, addr) 581 582 // We are writing to stack. No write barrier. 583 if v.flag&flagIndir != 0 { 584 memmove(addr, v.ptr, typ.size) 585 } else { 586 *(*uintptr)(addr) = uintptr(v.ptr) 587 } 588 off += typ.size 589 } 590 } 591 592 // Announce that the return values are valid. 593 // After this point the runtime can depend on the return values being valid. 594 *retValid = true 595 596 // We have to make sure that the out slice lives at least until 597 // the runtime knows the return values are valid. Otherwise, the 598 // return values might not be scanned by anyone during a GC. 599 // (out would be dead, and the return slots not yet alive.) 600 runtime.KeepAlive(out) 601 602 // runtime.getArgInfo expects to be able to find ctxt on the 603 // stack when it finds our caller, makeFuncStub. Make sure it 604 // doesn't get garbage collected. 605 runtime.KeepAlive(ctxt) 606 } 607 608 // methodReceiver returns information about the receiver 609 // described by v. The Value v may or may not have the 610 // flagMethod bit set, so the kind cached in v.flag should 611 // not be used. 612 // The return value rcvrtype gives the method's actual receiver type. 613 // The return value t gives the method type signature (without the receiver). 614 // The return value fn is a pointer to the method code. 615 func methodReceiver(op string, v Value, methodIndex int) (rcvrtype *rtype, t *funcType, fn unsafe.Pointer) { 616 i := methodIndex 617 if v.typ.Kind() == Interface { 618 tt := (*interfaceType)(unsafe.Pointer(v.typ)) 619 if uint(i) >= uint(len(tt.methods)) { 620 panic("reflect: internal error: invalid method index") 621 } 622 m := &tt.methods[i] 623 if !tt.nameOff(m.name).isExported() { 624 panic("reflect: " + op + " of unexported method") 625 } 626 iface := (*nonEmptyInterface)(v.ptr) 627 if iface.itab == nil { 628 panic("reflect: " + op + " of method on nil interface value") 629 } 630 rcvrtype = iface.itab.typ 631 fn = unsafe.Pointer(&iface.itab.fun[i]) 632 t = (*funcType)(unsafe.Pointer(tt.typeOff(m.typ))) 633 } else { 634 rcvrtype = v.typ 635 ms := v.typ.exportedMethods() 636 if uint(i) >= uint(len(ms)) { 637 panic("reflect: internal error: invalid method index") 638 } 639 m := ms[i] 640 if !v.typ.nameOff(m.name).isExported() { 641 panic("reflect: " + op + " of unexported method") 642 } 643 ifn := v.typ.textOff(m.ifn) 644 fn = unsafe.Pointer(&ifn) 645 t = (*funcType)(unsafe.Pointer(v.typ.typeOff(m.mtyp))) 646 } 647 return 648 } 649 650 // v is a method receiver. Store at p the word which is used to 651 // encode that receiver at the start of the argument list. 652 // Reflect uses the "interface" calling convention for 653 // methods, which always uses one word to record the receiver. 654 func storeRcvr(v Value, p unsafe.Pointer) { 655 t := v.typ 656 if t.Kind() == Interface { 657 // the interface data word becomes the receiver word 658 iface := (*nonEmptyInterface)(v.ptr) 659 *(*unsafe.Pointer)(p) = iface.word 660 } else if v.flag&flagIndir != 0 && !ifaceIndir(t) { 661 *(*unsafe.Pointer)(p) = *(*unsafe.Pointer)(v.ptr) 662 } else { 663 *(*unsafe.Pointer)(p) = v.ptr 664 } 665 } 666 667 // align returns the result of rounding x up to a multiple of n. 668 // n must be a power of two. 669 func align(x, n uintptr) uintptr { 670 return (x + n - 1) &^ (n - 1) 671 } 672 673 // callMethod is the call implementation used by a function returned 674 // by makeMethodValue (used by v.Method(i).Interface()). 675 // It is a streamlined version of the usual reflect call: the caller has 676 // already laid out the argument frame for us, so we don't have 677 // to deal with individual Values for each argument. 678 // It is in this file so that it can be next to the two similar functions above. 679 // The remainder of the makeMethodValue implementation is in makefunc.go. 680 // 681 // NOTE: This function must be marked as a "wrapper" in the generated code, 682 // so that the linker can make it work correctly for panic and recover. 683 // The gc compilers know to do that for the name "reflect.callMethod". 684 // 685 // ctxt is the "closure" generated by makeVethodValue. 686 // frame is a pointer to the arguments to that closure on the stack. 687 // retValid points to a boolean which should be set when the results 688 // section of frame is set. 689 func callMethod(ctxt *methodValue, frame unsafe.Pointer, retValid *bool) { 690 rcvr := ctxt.rcvr 691 rcvrtype, t, fn := methodReceiver("call", rcvr, ctxt.method) 692 frametype, argSize, retOffset, _, framePool := funcLayout(t, rcvrtype) 693 694 // Make a new frame that is one word bigger so we can store the receiver. 695 // This space is used for both arguments and return values. 696 scratch := framePool.Get().(unsafe.Pointer) 697 698 // Copy in receiver and rest of args. 699 storeRcvr(rcvr, scratch) 700 // Align the first arg. Only on amd64p32 the alignment can be 701 // larger than ptrSize. 702 argOffset := uintptr(ptrSize) 703 if len(t.in()) > 0 { 704 argOffset = align(argOffset, uintptr(t.in()[0].align)) 705 } 706 // Avoid constructing out-of-bounds pointers if there are no args. 707 if argSize-argOffset > 0 { 708 typedmemmovepartial(frametype, add(scratch, argOffset, "argSize > argOffset"), frame, argOffset, argSize-argOffset) 709 } 710 711 // Call. 712 // Call copies the arguments from scratch to the stack, calls fn, 713 // and then copies the results back into scratch. 714 call(frametype, fn, scratch, uint32(frametype.size), uint32(retOffset)) 715 716 // Copy return values. On amd64p32, the beginning of return values 717 // is 64-bit aligned, so the caller's frame layout (which doesn't have 718 // a receiver) is different from the layout of the fn call, which has 719 // a receiver. 720 // Ignore any changes to args and just copy return values. 721 // Avoid constructing out-of-bounds pointers if there are no return values. 722 if frametype.size-retOffset > 0 { 723 callerRetOffset := retOffset - argOffset 724 if runtime.GOARCH == "amd64p32" { 725 callerRetOffset = align(argSize-argOffset, 8) 726 } 727 // This copies to the stack. Write barriers are not needed. 728 memmove(add(frame, callerRetOffset, "frametype.size > retOffset"), 729 add(scratch, retOffset, "frametype.size > retOffset"), 730 frametype.size-retOffset) 731 } 732 733 // Tell the runtime it can now depend on the return values 734 // being properly initialized. 735 *retValid = true 736 737 // Clear the scratch space and put it back in the pool. 738 // This must happen after the statement above, so that the return 739 // values will always be scanned by someone. 740 typedmemclr(frametype, scratch) 741 framePool.Put(scratch) 742 743 // See the comment in callReflect. 744 runtime.KeepAlive(ctxt) 745 } 746 747 // funcName returns the name of f, for use in error messages. 748 func funcName(f func([]Value) []Value) string { 749 pc := *(*uintptr)(unsafe.Pointer(&f)) 750 rf := runtime.FuncForPC(pc) 751 if rf != nil { 752 return rf.Name() 753 } 754 return "closure" 755 } 756 757 // Cap returns v's capacity. 758 // It panics if v's Kind is not Array, Chan, or Slice. 759 func (v Value) Cap() int { 760 k := v.kind() 761 switch k { 762 case Array: 763 return v.typ.Len() 764 case Chan: 765 return chancap(v.pointer()) 766 case Slice: 767 // Slice is always bigger than a word; assume flagIndir. 768 return (*sliceHeader)(v.ptr).Cap 769 } 770 panic(&ValueError{"reflect.Value.Cap", v.kind()}) 771 } 772 773 // Close closes the channel v. 774 // It panics if v's Kind is not Chan. 775 func (v Value) Close() { 776 v.mustBe(Chan) 777 v.mustBeExported() 778 chanclose(v.pointer()) 779 } 780 781 // Complex returns v's underlying value, as a complex128. 782 // It panics if v's Kind is not Complex64 or Complex128 783 func (v Value) Complex() complex128 { 784 k := v.kind() 785 switch k { 786 case Complex64: 787 return complex128(*(*complex64)(v.ptr)) 788 case Complex128: 789 return *(*complex128)(v.ptr) 790 } 791 panic(&ValueError{"reflect.Value.Complex", v.kind()}) 792 } 793 794 // Elem returns the value that the interface v contains 795 // or that the pointer v points to. 796 // It panics if v's Kind is not Interface or Ptr. 797 // It returns the zero Value if v is nil. 798 func (v Value) Elem() Value { 799 k := v.kind() 800 switch k { 801 case Interface: 802 var eface interface{} 803 if v.typ.NumMethod() == 0 { 804 eface = *(*interface{})(v.ptr) 805 } else { 806 eface = (interface{})(*(*interface { 807 M() 808 })(v.ptr)) 809 } 810 x := unpackEface(eface) 811 if x.flag != 0 { 812 x.flag |= v.flag.ro() 813 } 814 return x 815 case Ptr: 816 ptr := v.ptr 817 if v.flag&flagIndir != 0 { 818 ptr = *(*unsafe.Pointer)(ptr) 819 } 820 // The returned value's address is v's value. 821 if ptr == nil { 822 return Value{} 823 } 824 tt := (*ptrType)(unsafe.Pointer(v.typ)) 825 typ := tt.elem 826 fl := v.flag&flagRO | flagIndir | flagAddr 827 fl |= flag(typ.Kind()) 828 return Value{typ, ptr, fl} 829 } 830 panic(&ValueError{"reflect.Value.Elem", v.kind()}) 831 } 832 833 // Field returns the i'th field of the struct v. 834 // It panics if v's Kind is not Struct or i is out of range. 835 func (v Value) Field(i int) Value { 836 if v.kind() != Struct { 837 panic(&ValueError{"reflect.Value.Field", v.kind()}) 838 } 839 tt := (*structType)(unsafe.Pointer(v.typ)) 840 if uint(i) >= uint(len(tt.fields)) { 841 panic("reflect: Field index out of range") 842 } 843 field := &tt.fields[i] 844 typ := field.typ 845 846 // Inherit permission bits from v, but clear flagEmbedRO. 847 fl := v.flag&(flagStickyRO|flagIndir|flagAddr) | flag(typ.Kind()) 848 // Using an unexported field forces flagRO. 849 if !field.name.isExported() { 850 if field.embedded() { 851 fl |= flagEmbedRO 852 } else { 853 fl |= flagStickyRO 854 } 855 } 856 // Either flagIndir is set and v.ptr points at struct, 857 // or flagIndir is not set and v.ptr is the actual struct data. 858 // In the former case, we want v.ptr + offset. 859 // In the latter case, we must have field.offset = 0, 860 // so v.ptr + field.offset is still the correct address. 861 ptr := add(v.ptr, field.offset(), "same as non-reflect &v.field") 862 return Value{typ, ptr, fl} 863 } 864 865 // FieldByIndex returns the nested field corresponding to index. 866 // It panics if v's Kind is not struct. 867 func (v Value) FieldByIndex(index []int) Value { 868 if len(index) == 1 { 869 return v.Field(index[0]) 870 } 871 v.mustBe(Struct) 872 for i, x := range index { 873 if i > 0 { 874 if v.Kind() == Ptr && v.typ.Elem().Kind() == Struct { 875 if v.IsNil() { 876 panic("reflect: indirection through nil pointer to embedded struct") 877 } 878 v = v.Elem() 879 } 880 } 881 v = v.Field(x) 882 } 883 return v 884 } 885 886 // FieldByName returns the struct field with the given name. 887 // It returns the zero Value if no field was found. 888 // It panics if v's Kind is not struct. 889 func (v Value) FieldByName(name string) Value { 890 v.mustBe(Struct) 891 if f, ok := v.typ.FieldByName(name); ok { 892 return v.FieldByIndex(f.Index) 893 } 894 return Value{} 895 } 896 897 // FieldByNameFunc returns the struct field with a name 898 // that satisfies the match function. 899 // It panics if v's Kind is not struct. 900 // It returns the zero Value if no field was found. 901 func (v Value) FieldByNameFunc(match func(string) bool) Value { 902 if f, ok := v.typ.FieldByNameFunc(match); ok { 903 return v.FieldByIndex(f.Index) 904 } 905 return Value{} 906 } 907 908 // Float returns v's underlying value, as a float64. 909 // It panics if v's Kind is not Float32 or Float64 910 func (v Value) Float() float64 { 911 k := v.kind() 912 switch k { 913 case Float32: 914 return float64(*(*float32)(v.ptr)) 915 case Float64: 916 return *(*float64)(v.ptr) 917 } 918 panic(&ValueError{"reflect.Value.Float", v.kind()}) 919 } 920 921 var uint8Type = TypeOf(uint8(0)).(*rtype) 922 923 // Index returns v's i'th element. 924 // It panics if v's Kind is not Array, Slice, or String or i is out of range. 925 func (v Value) Index(i int) Value { 926 switch v.kind() { 927 case Array: 928 tt := (*arrayType)(unsafe.Pointer(v.typ)) 929 if uint(i) >= uint(tt.len) { 930 panic("reflect: array index out of range") 931 } 932 typ := tt.elem 933 offset := uintptr(i) * typ.size 934 935 // Either flagIndir is set and v.ptr points at array, 936 // or flagIndir is not set and v.ptr is the actual array data. 937 // In the former case, we want v.ptr + offset. 938 // In the latter case, we must be doing Index(0), so offset = 0, 939 // so v.ptr + offset is still the correct address. 940 val := add(v.ptr, offset, "same as &v[i], i < tt.len") 941 fl := v.flag&(flagIndir|flagAddr) | v.flag.ro() | flag(typ.Kind()) // bits same as overall array 942 return Value{typ, val, fl} 943 944 case Slice: 945 // Element flag same as Elem of Ptr. 946 // Addressable, indirect, possibly read-only. 947 s := (*sliceHeader)(v.ptr) 948 if uint(i) >= uint(s.Len) { 949 panic("reflect: slice index out of range") 950 } 951 tt := (*sliceType)(unsafe.Pointer(v.typ)) 952 typ := tt.elem 953 val := arrayAt(s.Data, i, typ.size, "i < s.Len") 954 fl := flagAddr | flagIndir | v.flag.ro() | flag(typ.Kind()) 955 return Value{typ, val, fl} 956 957 case String: 958 s := (*stringHeader)(v.ptr) 959 if uint(i) >= uint(s.Len) { 960 panic("reflect: string index out of range") 961 } 962 p := arrayAt(s.Data, i, 1, "i < s.Len") 963 fl := v.flag.ro() | flag(Uint8) | flagIndir 964 return Value{uint8Type, p, fl} 965 } 966 panic(&ValueError{"reflect.Value.Index", v.kind()}) 967 } 968 969 // Int returns v's underlying value, as an int64. 970 // It panics if v's Kind is not Int, Int8, Int16, Int32, or Int64. 971 func (v Value) Int() int64 { 972 k := v.kind() 973 p := v.ptr 974 switch k { 975 case Int: 976 return int64(*(*int)(p)) 977 case Int8: 978 return int64(*(*int8)(p)) 979 case Int16: 980 return int64(*(*int16)(p)) 981 case Int32: 982 return int64(*(*int32)(p)) 983 case Int64: 984 return *(*int64)(p) 985 } 986 panic(&ValueError{"reflect.Value.Int", v.kind()}) 987 } 988 989 // CanInterface reports whether Interface can be used without panicking. 990 func (v Value) CanInterface() bool { 991 if v.flag == 0 { 992 panic(&ValueError{"reflect.Value.CanInterface", Invalid}) 993 } 994 return v.flag&flagRO == 0 995 } 996 997 // Interface returns v's current value as an interface{}. 998 // It is equivalent to: 999 // var i interface{} = (v's underlying value) 1000 // It panics if the Value was obtained by accessing 1001 // unexported struct fields. 1002 func (v Value) Interface() (i interface{}) { 1003 return valueInterface(v, true) 1004 } 1005 1006 func valueInterface(v Value, safe bool) interface{} { 1007 if v.flag == 0 { 1008 panic(&ValueError{"reflect.Value.Interface", Invalid}) 1009 } 1010 if safe && v.flag&flagRO != 0 { 1011 // Do not allow access to unexported values via Interface, 1012 // because they might be pointers that should not be 1013 // writable or methods or function that should not be callable. 1014 panic("reflect.Value.Interface: cannot return value obtained from unexported field or method") 1015 } 1016 if v.flag&flagMethod != 0 { 1017 v = makeMethodValue("Interface", v) 1018 } 1019 1020 if v.kind() == Interface { 1021 // Special case: return the element inside the interface. 1022 // Empty interface has one layout, all interfaces with 1023 // methods have a second layout. 1024 if v.NumMethod() == 0 { 1025 return *(*interface{})(v.ptr) 1026 } 1027 return *(*interface { 1028 M() 1029 })(v.ptr) 1030 } 1031 1032 // TODO: pass safe to packEface so we don't need to copy if safe==true? 1033 return packEface(v) 1034 } 1035 1036 // InterfaceData returns the interface v's value as a uintptr pair. 1037 // It panics if v's Kind is not Interface. 1038 func (v Value) InterfaceData() [2]uintptr { 1039 // TODO: deprecate this 1040 v.mustBe(Interface) 1041 // We treat this as a read operation, so we allow 1042 // it even for unexported data, because the caller 1043 // has to import "unsafe" to turn it into something 1044 // that can be abused. 1045 // Interface value is always bigger than a word; assume flagIndir. 1046 return *(*[2]uintptr)(v.ptr) 1047 } 1048 1049 // IsNil reports whether its argument v is nil. The argument must be 1050 // a chan, func, interface, map, pointer, or slice value; if it is 1051 // not, IsNil panics. Note that IsNil is not always equivalent to a 1052 // regular comparison with nil in Go. For example, if v was created 1053 // by calling ValueOf with an uninitialized interface variable i, 1054 // i==nil will be true but v.IsNil will panic as v will be the zero 1055 // Value. 1056 func (v Value) IsNil() bool { 1057 k := v.kind() 1058 switch k { 1059 case Chan, Func, Map, Ptr, UnsafePointer: 1060 if v.flag&flagMethod != 0 { 1061 return false 1062 } 1063 ptr := v.ptr 1064 if v.flag&flagIndir != 0 { 1065 ptr = *(*unsafe.Pointer)(ptr) 1066 } 1067 return ptr == nil 1068 case Interface, Slice: 1069 // Both interface and slice are nil if first word is 0. 1070 // Both are always bigger than a word; assume flagIndir. 1071 return *(*unsafe.Pointer)(v.ptr) == nil 1072 } 1073 panic(&ValueError{"reflect.Value.IsNil", v.kind()}) 1074 } 1075 1076 // IsValid reports whether v represents a value. 1077 // It returns false if v is the zero Value. 1078 // If IsValid returns false, all other methods except String panic. 1079 // Most functions and methods never return an invalid value. 1080 // If one does, its documentation states the conditions explicitly. 1081 func (v Value) IsValid() bool { 1082 return v.flag != 0 1083 } 1084 1085 // IsZero reports whether v is the zero value for its type. 1086 // It panics if the argument is invalid. 1087 func (v Value) IsZero() bool { 1088 switch v.kind() { 1089 case Bool: 1090 return !v.Bool() 1091 case Int, Int8, Int16, Int32, Int64: 1092 return v.Int() == 0 1093 case Uint, Uint8, Uint16, Uint32, Uint64, Uintptr: 1094 return v.Uint() == 0 1095 case Float32, Float64: 1096 return math.Float64bits(v.Float()) == 0 1097 case Complex64, Complex128: 1098 c := v.Complex() 1099 return math.Float64bits(real(c)) == 0 && math.Float64bits(imag(c)) == 0 1100 case Array: 1101 for i := 0; i < v.Len(); i++ { 1102 if !v.Index(i).IsZero() { 1103 return false 1104 } 1105 } 1106 return true 1107 case Chan, Func, Interface, Map, Ptr, Slice, UnsafePointer: 1108 return v.IsNil() 1109 case String: 1110 return v.Len() == 0 1111 case Struct: 1112 for i := 0; i < v.NumField(); i++ { 1113 if !v.Field(i).IsZero() { 1114 return false 1115 } 1116 } 1117 return true 1118 default: 1119 // This should never happens, but will act as a safeguard for 1120 // later, as a default value doesn't makes sense here. 1121 panic(&ValueError{"reflect.Value.IsZero", v.Kind()}) 1122 } 1123 } 1124 1125 // Kind returns v's Kind. 1126 // If v is the zero Value (IsValid returns false), Kind returns Invalid. 1127 func (v Value) Kind() Kind { 1128 return v.kind() 1129 } 1130 1131 // Len returns v's length. 1132 // It panics if v's Kind is not Array, Chan, Map, Slice, or String. 1133 func (v Value) Len() int { 1134 k := v.kind() 1135 switch k { 1136 case Array: 1137 tt := (*arrayType)(unsafe.Pointer(v.typ)) 1138 return int(tt.len) 1139 case Chan: 1140 return chanlen(v.pointer()) 1141 case Map: 1142 return maplen(v.pointer()) 1143 case Slice: 1144 // Slice is bigger than a word; assume flagIndir. 1145 return (*sliceHeader)(v.ptr).Len 1146 case String: 1147 // String is bigger than a word; assume flagIndir. 1148 return (*stringHeader)(v.ptr).Len 1149 } 1150 panic(&ValueError{"reflect.Value.Len", v.kind()}) 1151 } 1152 1153 // MapIndex returns the value associated with key in the map v. 1154 // It panics if v's Kind is not Map. 1155 // It returns the zero Value if key is not found in the map or if v represents a nil map. 1156 // As in Go, the key's value must be assignable to the map's key type. 1157 func (v Value) MapIndex(key Value) Value { 1158 v.mustBe(Map) 1159 tt := (*mapType)(unsafe.Pointer(v.typ)) 1160 1161 // Do not require key to be exported, so that DeepEqual 1162 // and other programs can use all the keys returned by 1163 // MapKeys as arguments to MapIndex. If either the map 1164 // or the key is unexported, though, the result will be 1165 // considered unexported. This is consistent with the 1166 // behavior for structs, which allow read but not write 1167 // of unexported fields. 1168 key = key.assignTo("reflect.Value.MapIndex", tt.key, nil) 1169 1170 var k unsafe.Pointer 1171 if key.flag&flagIndir != 0 { 1172 k = key.ptr 1173 } else { 1174 k = unsafe.Pointer(&key.ptr) 1175 } 1176 e := mapaccess(v.typ, v.pointer(), k) 1177 if e == nil { 1178 return Value{} 1179 } 1180 typ := tt.elem 1181 fl := (v.flag | key.flag).ro() 1182 fl |= flag(typ.Kind()) 1183 return copyVal(typ, fl, e) 1184 } 1185 1186 // MapKeys returns a slice containing all the keys present in the map, 1187 // in unspecified order. 1188 // It panics if v's Kind is not Map. 1189 // It returns an empty slice if v represents a nil map. 1190 func (v Value) MapKeys() []Value { 1191 v.mustBe(Map) 1192 tt := (*mapType)(unsafe.Pointer(v.typ)) 1193 keyType := tt.key 1194 1195 fl := v.flag.ro() | flag(keyType.Kind()) 1196 1197 m := v.pointer() 1198 mlen := int(0) 1199 if m != nil { 1200 mlen = maplen(m) 1201 } 1202 it := mapiterinit(v.typ, m) 1203 a := make([]Value, mlen) 1204 var i int 1205 for i = 0; i < len(a); i++ { 1206 key := mapiterkey(it) 1207 if key == nil { 1208 // Someone deleted an entry from the map since we 1209 // called maplen above. It's a data race, but nothing 1210 // we can do about it. 1211 break 1212 } 1213 a[i] = copyVal(keyType, fl, key) 1214 mapiternext(it) 1215 } 1216 return a[:i] 1217 } 1218 1219 // A MapIter is an iterator for ranging over a map. 1220 // See Value.MapRange. 1221 type MapIter struct { 1222 m Value 1223 it unsafe.Pointer 1224 } 1225 1226 // Key returns the key of the iterator's current map entry. 1227 func (it *MapIter) Key() Value { 1228 if it.it == nil { 1229 panic("MapIter.Key called before Next") 1230 } 1231 if mapiterkey(it.it) == nil { 1232 panic("MapIter.Key called on exhausted iterator") 1233 } 1234 1235 t := (*mapType)(unsafe.Pointer(it.m.typ)) 1236 ktype := t.key 1237 return copyVal(ktype, it.m.flag.ro()|flag(ktype.Kind()), mapiterkey(it.it)) 1238 } 1239 1240 // Value returns the value of the iterator's current map entry. 1241 func (it *MapIter) Value() Value { 1242 if it.it == nil { 1243 panic("MapIter.Value called before Next") 1244 } 1245 if mapiterkey(it.it) == nil { 1246 panic("MapIter.Value called on exhausted iterator") 1247 } 1248 1249 t := (*mapType)(unsafe.Pointer(it.m.typ)) 1250 vtype := t.elem 1251 return copyVal(vtype, it.m.flag.ro()|flag(vtype.Kind()), mapiterelem(it.it)) 1252 } 1253 1254 // Next advances the map iterator and reports whether there is another 1255 // entry. It returns false when the iterator is exhausted; subsequent 1256 // calls to Key, Value, or Next will panic. 1257 func (it *MapIter) Next() bool { 1258 if it.it == nil { 1259 it.it = mapiterinit(it.m.typ, it.m.pointer()) 1260 } else { 1261 if mapiterkey(it.it) == nil { 1262 panic("MapIter.Next called on exhausted iterator") 1263 } 1264 mapiternext(it.it) 1265 } 1266 return mapiterkey(it.it) != nil 1267 } 1268 1269 // MapRange returns a range iterator for a map. 1270 // It panics if v's Kind is not Map. 1271 // 1272 // Call Next to advance the iterator, and Key/Value to access each entry. 1273 // Next returns false when the iterator is exhausted. 1274 // MapRange follows the same iteration semantics as a range statement. 1275 // 1276 // Example: 1277 // 1278 // iter := reflect.ValueOf(m).MapRange() 1279 // for iter.Next() { 1280 // k := iter.Key() 1281 // v := iter.Value() 1282 // ... 1283 // } 1284 // 1285 func (v Value) MapRange() *MapIter { 1286 v.mustBe(Map) 1287 return &MapIter{m: v} 1288 } 1289 1290 // copyVal returns a Value containing the map key or value at ptr, 1291 // allocating a new variable as needed. 1292 func copyVal(typ *rtype, fl flag, ptr unsafe.Pointer) Value { 1293 if ifaceIndir(typ) { 1294 // Copy result so future changes to the map 1295 // won't change the underlying value. 1296 c := unsafe_New(typ) 1297 typedmemmove(typ, c, ptr) 1298 return Value{typ, c, fl | flagIndir} 1299 } 1300 return Value{typ, *(*unsafe.Pointer)(ptr), fl} 1301 } 1302 1303 // Method returns a function value corresponding to v's i'th method. 1304 // The arguments to a Call on the returned function should not include 1305 // a receiver; the returned function will always use v as the receiver. 1306 // Method panics if i is out of range or if v is a nil interface value. 1307 func (v Value) Method(i int) Value { 1308 if v.typ == nil { 1309 panic(&ValueError{"reflect.Value.Method", Invalid}) 1310 } 1311 if v.flag&flagMethod != 0 || uint(i) >= uint(v.typ.NumMethod()) { 1312 panic("reflect: Method index out of range") 1313 } 1314 if v.typ.Kind() == Interface && v.IsNil() { 1315 panic("reflect: Method on nil interface value") 1316 } 1317 fl := v.flag & (flagStickyRO | flagIndir) // Clear flagEmbedRO 1318 fl |= flag(Func) 1319 fl |= flag(i)<<flagMethodShift | flagMethod 1320 return Value{v.typ, v.ptr, fl} 1321 } 1322 1323 // NumMethod returns the number of exported methods in the value's method set. 1324 func (v Value) NumMethod() int { 1325 if v.typ == nil { 1326 panic(&ValueError{"reflect.Value.NumMethod", Invalid}) 1327 } 1328 if v.flag&flagMethod != 0 { 1329 return 0 1330 } 1331 return v.typ.NumMethod() 1332 } 1333 1334 // MethodByName returns a function value corresponding to the method 1335 // of v with the given name. 1336 // The arguments to a Call on the returned function should not include 1337 // a receiver; the returned function will always use v as the receiver. 1338 // It returns the zero Value if no method was found. 1339 func (v Value) MethodByName(name string) Value { 1340 if v.typ == nil { 1341 panic(&ValueError{"reflect.Value.MethodByName", Invalid}) 1342 } 1343 if v.flag&flagMethod != 0 { 1344 return Value{} 1345 } 1346 m, ok := v.typ.MethodByName(name) 1347 if !ok { 1348 return Value{} 1349 } 1350 return v.Method(m.Index) 1351 } 1352 1353 // NumField returns the number of fields in the struct v. 1354 // It panics if v's Kind is not Struct. 1355 func (v Value) NumField() int { 1356 v.mustBe(Struct) 1357 tt := (*structType)(unsafe.Pointer(v.typ)) 1358 return len(tt.fields) 1359 } 1360 1361 // OverflowComplex reports whether the complex128 x cannot be represented by v's type. 1362 // It panics if v's Kind is not Complex64 or Complex128. 1363 func (v Value) OverflowComplex(x complex128) bool { 1364 k := v.kind() 1365 switch k { 1366 case Complex64: 1367 return overflowFloat32(real(x)) || overflowFloat32(imag(x)) 1368 case Complex128: 1369 return false 1370 } 1371 panic(&ValueError{"reflect.Value.OverflowComplex", v.kind()}) 1372 } 1373 1374 // OverflowFloat reports whether the float64 x cannot be represented by v's type. 1375 // It panics if v's Kind is not Float32 or Float64. 1376 func (v Value) OverflowFloat(x float64) bool { 1377 k := v.kind() 1378 switch k { 1379 case Float32: 1380 return overflowFloat32(x) 1381 case Float64: 1382 return false 1383 } 1384 panic(&ValueError{"reflect.Value.OverflowFloat", v.kind()}) 1385 } 1386 1387 func overflowFloat32(x float64) bool { 1388 if x < 0 { 1389 x = -x 1390 } 1391 return math.MaxFloat32 < x && x <= math.MaxFloat64 1392 } 1393 1394 // OverflowInt reports whether the int64 x cannot be represented by v's type. 1395 // It panics if v's Kind is not Int, Int8, Int16, Int32, or Int64. 1396 func (v Value) OverflowInt(x int64) bool { 1397 k := v.kind() 1398 switch k { 1399 case Int, Int8, Int16, Int32, Int64: 1400 bitSize := v.typ.size * 8 1401 trunc := (x << (64 - bitSize)) >> (64 - bitSize) 1402 return x != trunc 1403 } 1404 panic(&ValueError{"reflect.Value.OverflowInt", v.kind()}) 1405 } 1406 1407 // OverflowUint reports whether the uint64 x cannot be represented by v's type. 1408 // It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64. 1409 func (v Value) OverflowUint(x uint64) bool { 1410 k := v.kind() 1411 switch k { 1412 case Uint, Uintptr, Uint8, Uint16, Uint32, Uint64: 1413 bitSize := v.typ.size * 8 1414 trunc := (x << (64 - bitSize)) >> (64 - bitSize) 1415 return x != trunc 1416 } 1417 panic(&ValueError{"reflect.Value.OverflowUint", v.kind()}) 1418 } 1419 1420 // Pointer returns v's value as a uintptr. 1421 // It returns uintptr instead of unsafe.Pointer so that 1422 // code using reflect cannot obtain unsafe.Pointers 1423 // without importing the unsafe package explicitly. 1424 // It panics if v's Kind is not Chan, Func, Map, Ptr, Slice, or UnsafePointer. 1425 // 1426 // If v's Kind is Func, the returned pointer is an underlying 1427 // code pointer, but not necessarily enough to identify a 1428 // single function uniquely. The only guarantee is that the 1429 // result is zero if and only if v is a nil func Value. 1430 // 1431 // If v's Kind is Slice, the returned pointer is to the first 1432 // element of the slice. If the slice is nil the returned value 1433 // is 0. If the slice is empty but non-nil the return value is non-zero. 1434 func (v Value) Pointer() uintptr { 1435 // TODO: deprecate 1436 k := v.kind() 1437 switch k { 1438 case Chan, Map, Ptr, UnsafePointer: 1439 return uintptr(v.pointer()) 1440 case Func: 1441 if v.flag&flagMethod != 0 { 1442 // As the doc comment says, the returned pointer is an 1443 // underlying code pointer but not necessarily enough to 1444 // identify a single function uniquely. All method expressions 1445 // created via reflect have the same underlying code pointer, 1446 // so their Pointers are equal. The function used here must 1447 // match the one used in makeMethodValue. 1448 f := methodValueCall 1449 return **(**uintptr)(unsafe.Pointer(&f)) 1450 } 1451 p := v.pointer() 1452 // Non-nil func value points at data block. 1453 // First word of data block is actual code. 1454 if p != nil { 1455 p = *(*unsafe.Pointer)(p) 1456 } 1457 return uintptr(p) 1458 1459 case Slice: 1460 return (*SliceHeader)(v.ptr).Data 1461 } 1462 panic(&ValueError{"reflect.Value.Pointer", v.kind()}) 1463 } 1464 1465 // Recv receives and returns a value from the channel v. 1466 // It panics if v's Kind is not Chan. 1467 // The receive blocks until a value is ready. 1468 // The boolean value ok is true if the value x corresponds to a send 1469 // on the channel, false if it is a zero value received because the channel is closed. 1470 func (v Value) Recv() (x Value, ok bool) { 1471 v.mustBe(Chan) 1472 v.mustBeExported() 1473 return v.recv(false) 1474 } 1475 1476 // internal recv, possibly non-blocking (nb). 1477 // v is known to be a channel. 1478 func (v Value) recv(nb bool) (val Value, ok bool) { 1479 tt := (*chanType)(unsafe.Pointer(v.typ)) 1480 if ChanDir(tt.dir)&RecvDir == 0 { 1481 panic("reflect: recv on send-only channel") 1482 } 1483 t := tt.elem 1484 val = Value{t, nil, flag(t.Kind())} 1485 var p unsafe.Pointer 1486 if ifaceIndir(t) { 1487 p = unsafe_New(t) 1488 val.ptr = p 1489 val.flag |= flagIndir 1490 } else { 1491 p = unsafe.Pointer(&val.ptr) 1492 } 1493 selected, ok := chanrecv(v.pointer(), nb, p) 1494 if !selected { 1495 val = Value{} 1496 } 1497 return 1498 } 1499 1500 // Send sends x on the channel v. 1501 // It panics if v's kind is not Chan or if x's type is not the same type as v's element type. 1502 // As in Go, x's value must be assignable to the channel's element type. 1503 func (v Value) Send(x Value) { 1504 v.mustBe(Chan) 1505 v.mustBeExported() 1506 v.send(x, false) 1507 } 1508 1509 // internal send, possibly non-blocking. 1510 // v is known to be a channel. 1511 func (v Value) send(x Value, nb bool) (selected bool) { 1512 tt := (*chanType)(unsafe.Pointer(v.typ)) 1513 if ChanDir(tt.dir)&SendDir == 0 { 1514 panic("reflect: send on recv-only channel") 1515 } 1516 x.mustBeExported() 1517 x = x.assignTo("reflect.Value.Send", tt.elem, nil) 1518 var p unsafe.Pointer 1519 if x.flag&flagIndir != 0 { 1520 p = x.ptr 1521 } else { 1522 p = unsafe.Pointer(&x.ptr) 1523 } 1524 return chansend(v.pointer(), p, nb) 1525 } 1526 1527 // Set assigns x to the value v. 1528 // It panics if CanSet returns false. 1529 // As in Go, x's value must be assignable to v's type. 1530 func (v Value) Set(x Value) { 1531 v.mustBeAssignable() 1532 x.mustBeExported() // do not let unexported x leak 1533 var target unsafe.Pointer 1534 if v.kind() == Interface { 1535 target = v.ptr 1536 } 1537 x = x.assignTo("reflect.Set", v.typ, target) 1538 if x.flag&flagIndir != 0 { 1539 typedmemmove(v.typ, v.ptr, x.ptr) 1540 } else { 1541 *(*unsafe.Pointer)(v.ptr) = x.ptr 1542 } 1543 } 1544 1545 // SetBool sets v's underlying value. 1546 // It panics if v's Kind is not Bool or if CanSet() is false. 1547 func (v Value) SetBool(x bool) { 1548 v.mustBeAssignable() 1549 v.mustBe(Bool) 1550 *(*bool)(v.ptr) = x 1551 } 1552 1553 // SetBytes sets v's underlying value. 1554 // It panics if v's underlying value is not a slice of bytes. 1555 func (v Value) SetBytes(x []byte) { 1556 v.mustBeAssignable() 1557 v.mustBe(Slice) 1558 if v.typ.Elem().Kind() != Uint8 { 1559 panic("reflect.Value.SetBytes of non-byte slice") 1560 } 1561 *(*[]byte)(v.ptr) = x 1562 } 1563 1564 // setRunes sets v's underlying value. 1565 // It panics if v's underlying value is not a slice of runes (int32s). 1566 func (v Value) setRunes(x []rune) { 1567 v.mustBeAssignable() 1568 v.mustBe(Slice) 1569 if v.typ.Elem().Kind() != Int32 { 1570 panic("reflect.Value.setRunes of non-rune slice") 1571 } 1572 *(*[]rune)(v.ptr) = x 1573 } 1574 1575 // SetComplex sets v's underlying value to x. 1576 // It panics if v's Kind is not Complex64 or Complex128, or if CanSet() is false. 1577 func (v Value) SetComplex(x complex128) { 1578 v.mustBeAssignable() 1579 switch k := v.kind(); k { 1580 default: 1581 panic(&ValueError{"reflect.Value.SetComplex", v.kind()}) 1582 case Complex64: 1583 *(*complex64)(v.ptr) = complex64(x) 1584 case Complex128: 1585 *(*complex128)(v.ptr) = x 1586 } 1587 } 1588 1589 // SetFloat sets v's underlying value to x. 1590 // It panics if v's Kind is not Float32 or Float64, or if CanSet() is false. 1591 func (v Value) SetFloat(x float64) { 1592 v.mustBeAssignable() 1593 switch k := v.kind(); k { 1594 default: 1595 panic(&ValueError{"reflect.Value.SetFloat", v.kind()}) 1596 case Float32: 1597 *(*float32)(v.ptr) = float32(x) 1598 case Float64: 1599 *(*float64)(v.ptr) = x 1600 } 1601 } 1602 1603 // SetInt sets v's underlying value to x. 1604 // It panics if v's Kind is not Int, Int8, Int16, Int32, or Int64, or if CanSet() is false. 1605 func (v Value) SetInt(x int64) { 1606 v.mustBeAssignable() 1607 switch k := v.kind(); k { 1608 default: 1609 panic(&ValueError{"reflect.Value.SetInt", v.kind()}) 1610 case Int: 1611 *(*int)(v.ptr) = int(x) 1612 case Int8: 1613 *(*int8)(v.ptr) = int8(x) 1614 case Int16: 1615 *(*int16)(v.ptr) = int16(x) 1616 case Int32: 1617 *(*int32)(v.ptr) = int32(x) 1618 case Int64: 1619 *(*int64)(v.ptr) = x 1620 } 1621 } 1622 1623 // SetLen sets v's length to n. 1624 // It panics if v's Kind is not Slice or if n is negative or 1625 // greater than the capacity of the slice. 1626 func (v Value) SetLen(n int) { 1627 v.mustBeAssignable() 1628 v.mustBe(Slice) 1629 s := (*sliceHeader)(v.ptr) 1630 if uint(n) > uint(s.Cap) { 1631 panic("reflect: slice length out of range in SetLen") 1632 } 1633 s.Len = n 1634 } 1635 1636 // SetCap sets v's capacity to n. 1637 // It panics if v's Kind is not Slice or if n is smaller than the length or 1638 // greater than the capacity of the slice. 1639 func (v Value) SetCap(n int) { 1640 v.mustBeAssignable() 1641 v.mustBe(Slice) 1642 s := (*sliceHeader)(v.ptr) 1643 if n < s.Len || n > s.Cap { 1644 panic("reflect: slice capacity out of range in SetCap") 1645 } 1646 s.Cap = n 1647 } 1648 1649 // SetMapIndex sets the element associated with key in the map v to elem. 1650 // It panics if v's Kind is not Map. 1651 // If elem is the zero Value, SetMapIndex deletes the key from the map. 1652 // Otherwise if v holds a nil map, SetMapIndex will panic. 1653 // As in Go, key's elem must be assignable to the map's key type, 1654 // and elem's value must be assignable to the map's elem type. 1655 func (v Value) SetMapIndex(key, elem Value) { 1656 v.mustBe(Map) 1657 v.mustBeExported() 1658 key.mustBeExported() 1659 tt := (*mapType)(unsafe.Pointer(v.typ)) 1660 key = key.assignTo("reflect.Value.SetMapIndex", tt.key, nil) 1661 var k unsafe.Pointer 1662 if key.flag&flagIndir != 0 { 1663 k = key.ptr 1664 } else { 1665 k = unsafe.Pointer(&key.ptr) 1666 } 1667 if elem.typ == nil { 1668 mapdelete(v.typ, v.pointer(), k) 1669 return 1670 } 1671 elem.mustBeExported() 1672 elem = elem.assignTo("reflect.Value.SetMapIndex", tt.elem, nil) 1673 var e unsafe.Pointer 1674 if elem.flag&flagIndir != 0 { 1675 e = elem.ptr 1676 } else { 1677 e = unsafe.Pointer(&elem.ptr) 1678 } 1679 mapassign(v.typ, v.pointer(), k, e) 1680 } 1681 1682 // SetUint sets v's underlying value to x. 1683 // It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64, or if CanSet() is false. 1684 func (v Value) SetUint(x uint64) { 1685 v.mustBeAssignable() 1686 switch k := v.kind(); k { 1687 default: 1688 panic(&ValueError{"reflect.Value.SetUint", v.kind()}) 1689 case Uint: 1690 *(*uint)(v.ptr) = uint(x) 1691 case Uint8: 1692 *(*uint8)(v.ptr) = uint8(x) 1693 case Uint16: 1694 *(*uint16)(v.ptr) = uint16(x) 1695 case Uint32: 1696 *(*uint32)(v.ptr) = uint32(x) 1697 case Uint64: 1698 *(*uint64)(v.ptr) = x 1699 case Uintptr: 1700 *(*uintptr)(v.ptr) = uintptr(x) 1701 } 1702 } 1703 1704 // SetPointer sets the unsafe.Pointer value v to x. 1705 // It panics if v's Kind is not UnsafePointer. 1706 func (v Value) SetPointer(x unsafe.Pointer) { 1707 v.mustBeAssignable() 1708 v.mustBe(UnsafePointer) 1709 *(*unsafe.Pointer)(v.ptr) = x 1710 } 1711 1712 // SetString sets v's underlying value to x. 1713 // It panics if v's Kind is not String or if CanSet() is false. 1714 func (v Value) SetString(x string) { 1715 v.mustBeAssignable() 1716 v.mustBe(String) 1717 *(*string)(v.ptr) = x 1718 } 1719 1720 // Slice returns v[i:j]. 1721 // It panics if v's Kind is not Array, Slice or String, or if v is an unaddressable array, 1722 // or if the indexes are out of bounds. 1723 func (v Value) Slice(i, j int) Value { 1724 var ( 1725 cap int 1726 typ *sliceType 1727 base unsafe.Pointer 1728 ) 1729 switch kind := v.kind(); kind { 1730 default: 1731 panic(&ValueError{"reflect.Value.Slice", v.kind()}) 1732 1733 case Array: 1734 if v.flag&flagAddr == 0 { 1735 panic("reflect.Value.Slice: slice of unaddressable array") 1736 } 1737 tt := (*arrayType)(unsafe.Pointer(v.typ)) 1738 cap = int(tt.len) 1739 typ = (*sliceType)(unsafe.Pointer(tt.slice)) 1740 base = v.ptr 1741 1742 case Slice: 1743 typ = (*sliceType)(unsafe.Pointer(v.typ)) 1744 s := (*sliceHeader)(v.ptr) 1745 base = s.Data 1746 cap = s.Cap 1747 1748 case String: 1749 s := (*stringHeader)(v.ptr) 1750 if i < 0 || j < i || j > s.Len { 1751 panic("reflect.Value.Slice: string slice index out of bounds") 1752 } 1753 var t stringHeader 1754 if i < s.Len { 1755 t = stringHeader{arrayAt(s.Data, i, 1, "i < s.Len"), j - i} 1756 } 1757 return Value{v.typ, unsafe.Pointer(&t), v.flag} 1758 } 1759 1760 if i < 0 || j < i || j > cap { 1761 panic("reflect.Value.Slice: slice index out of bounds") 1762 } 1763 1764 // Declare slice so that gc can see the base pointer in it. 1765 var x []unsafe.Pointer 1766 1767 // Reinterpret as *sliceHeader to edit. 1768 s := (*sliceHeader)(unsafe.Pointer(&x)) 1769 s.Len = j - i 1770 s.Cap = cap - i 1771 if cap-i > 0 { 1772 s.Data = arrayAt(base, i, typ.elem.Size(), "i < cap") 1773 } else { 1774 // do not advance pointer, to avoid pointing beyond end of slice 1775 s.Data = base 1776 } 1777 1778 fl := v.flag.ro() | flagIndir | flag(Slice) 1779 return Value{typ.common(), unsafe.Pointer(&x), fl} 1780 } 1781 1782 // Slice3 is the 3-index form of the slice operation: it returns v[i:j:k]. 1783 // It panics if v's Kind is not Array or Slice, or if v is an unaddressable array, 1784 // or if the indexes are out of bounds. 1785 func (v Value) Slice3(i, j, k int) Value { 1786 var ( 1787 cap int 1788 typ *sliceType 1789 base unsafe.Pointer 1790 ) 1791 switch kind := v.kind(); kind { 1792 default: 1793 panic(&ValueError{"reflect.Value.Slice3", v.kind()}) 1794 1795 case Array: 1796 if v.flag&flagAddr == 0 { 1797 panic("reflect.Value.Slice3: slice of unaddressable array") 1798 } 1799 tt := (*arrayType)(unsafe.Pointer(v.typ)) 1800 cap = int(tt.len) 1801 typ = (*sliceType)(unsafe.Pointer(tt.slice)) 1802 base = v.ptr 1803 1804 case Slice: 1805 typ = (*sliceType)(unsafe.Pointer(v.typ)) 1806 s := (*sliceHeader)(v.ptr) 1807 base = s.Data 1808 cap = s.Cap 1809 } 1810 1811 if i < 0 || j < i || k < j || k > cap { 1812 panic("reflect.Value.Slice3: slice index out of bounds") 1813 } 1814 1815 // Declare slice so that the garbage collector 1816 // can see the base pointer in it. 1817 var x []unsafe.Pointer 1818 1819 // Reinterpret as *sliceHeader to edit. 1820 s := (*sliceHeader)(unsafe.Pointer(&x)) 1821 s.Len = j - i 1822 s.Cap = k - i 1823 if k-i > 0 { 1824 s.Data = arrayAt(base, i, typ.elem.Size(), "i < k <= cap") 1825 } else { 1826 // do not advance pointer, to avoid pointing beyond end of slice 1827 s.Data = base 1828 } 1829 1830 fl := v.flag.ro() | flagIndir | flag(Slice) 1831 return Value{typ.common(), unsafe.Pointer(&x), fl} 1832 } 1833 1834 // String returns the string v's underlying value, as a string. 1835 // String is a special case because of Go's String method convention. 1836 // Unlike the other getters, it does not panic if v's Kind is not String. 1837 // Instead, it returns a string of the form "<T value>" where T is v's type. 1838 // The fmt package treats Values specially. It does not call their String 1839 // method implicitly but instead prints the concrete values they hold. 1840 func (v Value) String() string { 1841 switch k := v.kind(); k { 1842 case Invalid: 1843 return "<invalid Value>" 1844 case String: 1845 return *(*string)(v.ptr) 1846 } 1847 // If you call String on a reflect.Value of other type, it's better to 1848 // print something than to panic. Useful in debugging. 1849 return "<" + v.Type().String() + " Value>" 1850 } 1851 1852 // TryRecv attempts to receive a value from the channel v but will not block. 1853 // It panics if v's Kind is not Chan. 1854 // If the receive delivers a value, x is the transferred value and ok is true. 1855 // If the receive cannot finish without blocking, x is the zero Value and ok is false. 1856 // If the channel is closed, x is the zero value for the channel's element type and ok is false. 1857 func (v Value) TryRecv() (x Value, ok bool) { 1858 v.mustBe(Chan) 1859 v.mustBeExported() 1860 return v.recv(true) 1861 } 1862 1863 // TrySend attempts to send x on the channel v but will not block. 1864 // It panics if v's Kind is not Chan. 1865 // It reports whether the value was sent. 1866 // As in Go, x's value must be assignable to the channel's element type. 1867 func (v Value) TrySend(x Value) bool { 1868 v.mustBe(Chan) 1869 v.mustBeExported() 1870 return v.send(x, true) 1871 } 1872 1873 // Type returns v's type. 1874 func (v Value) Type() Type { 1875 f := v.flag 1876 if f == 0 { 1877 panic(&ValueError{"reflect.Value.Type", Invalid}) 1878 } 1879 if f&flagMethod == 0 { 1880 // Easy case 1881 return v.typ 1882 } 1883 1884 // Method value. 1885 // v.typ describes the receiver, not the method type. 1886 i := int(v.flag) >> flagMethodShift 1887 if v.typ.Kind() == Interface { 1888 // Method on interface. 1889 tt := (*interfaceType)(unsafe.Pointer(v.typ)) 1890 if uint(i) >= uint(len(tt.methods)) { 1891 panic("reflect: internal error: invalid method index") 1892 } 1893 m := &tt.methods[i] 1894 return v.typ.typeOff(m.typ) 1895 } 1896 // Method on concrete type. 1897 ms := v.typ.exportedMethods() 1898 if uint(i) >= uint(len(ms)) { 1899 panic("reflect: internal error: invalid method index") 1900 } 1901 m := ms[i] 1902 return v.typ.typeOff(m.mtyp) 1903 } 1904 1905 // Uint returns v's underlying value, as a uint64. 1906 // It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64. 1907 func (v Value) Uint() uint64 { 1908 k := v.kind() 1909 p := v.ptr 1910 switch k { 1911 case Uint: 1912 return uint64(*(*uint)(p)) 1913 case Uint8: 1914 return uint64(*(*uint8)(p)) 1915 case Uint16: 1916 return uint64(*(*uint16)(p)) 1917 case Uint32: 1918 return uint64(*(*uint32)(p)) 1919 case Uint64: 1920 return *(*uint64)(p) 1921 case Uintptr: 1922 return uint64(*(*uintptr)(p)) 1923 } 1924 panic(&ValueError{"reflect.Value.Uint", v.kind()}) 1925 } 1926 1927 // UnsafeAddr returns a pointer to v's data. 1928 // It is for advanced clients that also import the "unsafe" package. 1929 // It panics if v is not addressable. 1930 func (v Value) UnsafeAddr() uintptr { 1931 // TODO: deprecate 1932 if v.typ == nil { 1933 panic(&ValueError{"reflect.Value.UnsafeAddr", Invalid}) 1934 } 1935 if v.flag&flagAddr == 0 { 1936 panic("reflect.Value.UnsafeAddr of unaddressable value") 1937 } 1938 return uintptr(v.ptr) 1939 } 1940 1941 // StringHeader is the runtime representation of a string. 1942 // It cannot be used safely or portably and its representation may 1943 // change in a later release. 1944 // Moreover, the Data field is not sufficient to guarantee the data 1945 // it references will not be garbage collected, so programs must keep 1946 // a separate, correctly typed pointer to the underlying data. 1947 type StringHeader struct { 1948 Data uintptr 1949 Len int 1950 } 1951 1952 // stringHeader is a safe version of StringHeader used within this package. 1953 type stringHeader struct { 1954 Data unsafe.Pointer 1955 Len int 1956 } 1957 1958 // SliceHeader is the runtime representation of a slice. 1959 // It cannot be used safely or portably and its representation may 1960 // change in a later release. 1961 // Moreover, the Data field is not sufficient to guarantee the data 1962 // it references will not be garbage collected, so programs must keep 1963 // a separate, correctly typed pointer to the underlying data. 1964 type SliceHeader struct { 1965 Data uintptr 1966 Len int 1967 Cap int 1968 } 1969 1970 // sliceHeader is a safe version of SliceHeader used within this package. 1971 type sliceHeader struct { 1972 Data unsafe.Pointer 1973 Len int 1974 Cap int 1975 } 1976 1977 func typesMustMatch(what string, t1, t2 Type) { 1978 if t1 != t2 { 1979 panic(what + ": " + t1.String() + " != " + t2.String()) 1980 } 1981 } 1982 1983 // arrayAt returns the i-th element of p, 1984 // an array whose elements are eltSize bytes wide. 1985 // The array pointed at by p must have at least i+1 elements: 1986 // it is invalid (but impossible to check here) to pass i >= len, 1987 // because then the result will point outside the array. 1988 // whySafe must explain why i < len. (Passing "i < len" is fine; 1989 // the benefit is to surface this assumption at the call site.) 1990 func arrayAt(p unsafe.Pointer, i int, eltSize uintptr, whySafe string) unsafe.Pointer { 1991 return add(p, uintptr(i)*eltSize, "i < len") 1992 } 1993 1994 // grow grows the slice s so that it can hold extra more values, allocating 1995 // more capacity if needed. It also returns the old and new slice lengths. 1996 func grow(s Value, extra int) (Value, int, int) { 1997 i0 := s.Len() 1998 i1 := i0 + extra 1999 if i1 < i0 { 2000 panic("reflect.Append: slice overflow") 2001 } 2002 m := s.Cap() 2003 if i1 <= m { 2004 return s.Slice(0, i1), i0, i1 2005 } 2006 if m == 0 { 2007 m = extra 2008 } else { 2009 for m < i1 { 2010 if i0 < 1024 { 2011 m += m 2012 } else { 2013 m += m / 4 2014 } 2015 } 2016 } 2017 t := MakeSlice(s.Type(), i1, m) 2018 Copy(t, s) 2019 return t, i0, i1 2020 } 2021 2022 // Append appends the values x to a slice s and returns the resulting slice. 2023 // As in Go, each x's value must be assignable to the slice's element type. 2024 func Append(s Value, x ...Value) Value { 2025 s.mustBe(Slice) 2026 s, i0, i1 := grow(s, len(x)) 2027 for i, j := i0, 0; i < i1; i, j = i+1, j+1 { 2028 s.Index(i).Set(x[j]) 2029 } 2030 return s 2031 } 2032 2033 // AppendSlice appends a slice t to a slice s and returns the resulting slice. 2034 // The slices s and t must have the same element type. 2035 func AppendSlice(s, t Value) Value { 2036 s.mustBe(Slice) 2037 t.mustBe(Slice) 2038 typesMustMatch("reflect.AppendSlice", s.Type().Elem(), t.Type().Elem()) 2039 s, i0, i1 := grow(s, t.Len()) 2040 Copy(s.Slice(i0, i1), t) 2041 return s 2042 } 2043 2044 // Copy copies the contents of src into dst until either 2045 // dst has been filled or src has been exhausted. 2046 // It returns the number of elements copied. 2047 // Dst and src each must have kind Slice or Array, and 2048 // dst and src must have the same element type. 2049 // 2050 // As a special case, src can have kind String if the element type of dst is kind Uint8. 2051 func Copy(dst, src Value) int { 2052 dk := dst.kind() 2053 if dk != Array && dk != Slice { 2054 panic(&ValueError{"reflect.Copy", dk}) 2055 } 2056 if dk == Array { 2057 dst.mustBeAssignable() 2058 } 2059 dst.mustBeExported() 2060 2061 sk := src.kind() 2062 var stringCopy bool 2063 if sk != Array && sk != Slice { 2064 stringCopy = sk == String && dst.typ.Elem().Kind() == Uint8 2065 if !stringCopy { 2066 panic(&ValueError{"reflect.Copy", sk}) 2067 } 2068 } 2069 src.mustBeExported() 2070 2071 de := dst.typ.Elem() 2072 if !stringCopy { 2073 se := src.typ.Elem() 2074 typesMustMatch("reflect.Copy", de, se) 2075 } 2076 2077 var ds, ss sliceHeader 2078 if dk == Array { 2079 ds.Data = dst.ptr 2080 ds.Len = dst.Len() 2081 ds.Cap = ds.Len 2082 } else { 2083 ds = *(*sliceHeader)(dst.ptr) 2084 } 2085 if sk == Array { 2086 ss.Data = src.ptr 2087 ss.Len = src.Len() 2088 ss.Cap = ss.Len 2089 } else if sk == Slice { 2090 ss = *(*sliceHeader)(src.ptr) 2091 } else { 2092 sh := *(*stringHeader)(src.ptr) 2093 ss.Data = sh.Data 2094 ss.Len = sh.Len 2095 ss.Cap = sh.Len 2096 } 2097 2098 return typedslicecopy(de.common(), ds, ss) 2099 } 2100 2101 // A runtimeSelect is a single case passed to rselect. 2102 // This must match ../runtime/select.go:/runtimeSelect 2103 type runtimeSelect struct { 2104 dir SelectDir // SelectSend, SelectRecv or SelectDefault 2105 typ *rtype // channel type 2106 ch unsafe.Pointer // channel 2107 val unsafe.Pointer // ptr to data (SendDir) or ptr to receive buffer (RecvDir) 2108 } 2109 2110 // rselect runs a select. It returns the index of the chosen case. 2111 // If the case was a receive, val is filled in with the received value. 2112 // The conventional OK bool indicates whether the receive corresponds 2113 // to a sent value. 2114 //go:noescape 2115 func rselect([]runtimeSelect) (chosen int, recvOK bool) 2116 2117 // A SelectDir describes the communication direction of a select case. 2118 type SelectDir int 2119 2120 // NOTE: These values must match ../runtime/select.go:/selectDir. 2121 2122 const ( 2123 _ SelectDir = iota 2124 SelectSend // case Chan <- Send 2125 SelectRecv // case <-Chan: 2126 SelectDefault // default 2127 ) 2128 2129 // A SelectCase describes a single case in a select operation. 2130 // The kind of case depends on Dir, the communication direction. 2131 // 2132 // If Dir is SelectDefault, the case represents a default case. 2133 // Chan and Send must be zero Values. 2134 // 2135 // If Dir is SelectSend, the case represents a send operation. 2136 // Normally Chan's underlying value must be a channel, and Send's underlying value must be 2137 // assignable to the channel's element type. As a special case, if Chan is a zero Value, 2138 // then the case is ignored, and the field Send will also be ignored and may be either zero 2139 // or non-zero. 2140 // 2141 // If Dir is SelectRecv, the case represents a receive operation. 2142 // Normally Chan's underlying value must be a channel and Send must be a zero Value. 2143 // If Chan is a zero Value, then the case is ignored, but Send must still be a zero Value. 2144 // When a receive operation is selected, the received Value is returned by Select. 2145 // 2146 type SelectCase struct { 2147 Dir SelectDir // direction of case 2148 Chan Value // channel to use (for send or receive) 2149 Send Value // value to send (for send) 2150 } 2151 2152 // Select executes a select operation described by the list of cases. 2153 // Like the Go select statement, it blocks until at least one of the cases 2154 // can proceed, makes a uniform pseudo-random choice, 2155 // and then executes that case. It returns the index of the chosen case 2156 // and, if that case was a receive operation, the value received and a 2157 // boolean indicating whether the value corresponds to a send on the channel 2158 // (as opposed to a zero value received because the channel is closed). 2159 func Select(cases []SelectCase) (chosen int, recv Value, recvOK bool) { 2160 // NOTE: Do not trust that caller is not modifying cases data underfoot. 2161 // The range is safe because the caller cannot modify our copy of the len 2162 // and each iteration makes its own copy of the value c. 2163 runcases := make([]runtimeSelect, len(cases)) 2164 haveDefault := false 2165 for i, c := range cases { 2166 rc := &runcases[i] 2167 rc.dir = c.Dir 2168 switch c.Dir { 2169 default: 2170 panic("reflect.Select: invalid Dir") 2171 2172 case SelectDefault: // default 2173 if haveDefault { 2174 panic("reflect.Select: multiple default cases") 2175 } 2176 haveDefault = true 2177 if c.Chan.IsValid() { 2178 panic("reflect.Select: default case has Chan value") 2179 } 2180 if c.Send.IsValid() { 2181 panic("reflect.Select: default case has Send value") 2182 } 2183 2184 case SelectSend: 2185 ch := c.Chan 2186 if !ch.IsValid() { 2187 break 2188 } 2189 ch.mustBe(Chan) 2190 ch.mustBeExported() 2191 tt := (*chanType)(unsafe.Pointer(ch.typ)) 2192 if ChanDir(tt.dir)&SendDir == 0 { 2193 panic("reflect.Select: SendDir case using recv-only channel") 2194 } 2195 rc.ch = ch.pointer() 2196 rc.typ = &tt.rtype 2197 v := c.Send 2198 if !v.IsValid() { 2199 panic("reflect.Select: SendDir case missing Send value") 2200 } 2201 v.mustBeExported() 2202 v = v.assignTo("reflect.Select", tt.elem, nil) 2203 if v.flag&flagIndir != 0 { 2204 rc.val = v.ptr 2205 } else { 2206 rc.val = unsafe.Pointer(&v.ptr) 2207 } 2208 2209 case SelectRecv: 2210 if c.Send.IsValid() { 2211 panic("reflect.Select: RecvDir case has Send value") 2212 } 2213 ch := c.Chan 2214 if !ch.IsValid() { 2215 break 2216 } 2217 ch.mustBe(Chan) 2218 ch.mustBeExported() 2219 tt := (*chanType)(unsafe.Pointer(ch.typ)) 2220 if ChanDir(tt.dir)&RecvDir == 0 { 2221 panic("reflect.Select: RecvDir case using send-only channel") 2222 } 2223 rc.ch = ch.pointer() 2224 rc.typ = &tt.rtype 2225 rc.val = unsafe_New(tt.elem) 2226 } 2227 } 2228 2229 chosen, recvOK = rselect(runcases) 2230 if runcases[chosen].dir == SelectRecv { 2231 tt := (*chanType)(unsafe.Pointer(runcases[chosen].typ)) 2232 t := tt.elem 2233 p := runcases[chosen].val 2234 fl := flag(t.Kind()) 2235 if ifaceIndir(t) { 2236 recv = Value{t, p, fl | flagIndir} 2237 } else { 2238 recv = Value{t, *(*unsafe.Pointer)(p), fl} 2239 } 2240 } 2241 return chosen, recv, recvOK 2242 } 2243 2244 /* 2245 * constructors 2246 */ 2247 2248 // implemented in package runtime 2249 func unsafe_New(*rtype) unsafe.Pointer 2250 func unsafe_NewArray(*rtype, int) unsafe.Pointer 2251 2252 // MakeSlice creates a new zero-initialized slice value 2253 // for the specified slice type, length, and capacity. 2254 func MakeSlice(typ Type, len, cap int) Value { 2255 if typ.Kind() != Slice { 2256 panic("reflect.MakeSlice of non-slice type") 2257 } 2258 if len < 0 { 2259 panic("reflect.MakeSlice: negative len") 2260 } 2261 if cap < 0 { 2262 panic("reflect.MakeSlice: negative cap") 2263 } 2264 if len > cap { 2265 panic("reflect.MakeSlice: len > cap") 2266 } 2267 2268 s := sliceHeader{unsafe_NewArray(typ.Elem().(*rtype), cap), len, cap} 2269 return Value{typ.(*rtype), unsafe.Pointer(&s), flagIndir | flag(Slice)} 2270 } 2271 2272 // MakeChan creates a new channel with the specified type and buffer size. 2273 func MakeChan(typ Type, buffer int) Value { 2274 if typ.Kind() != Chan { 2275 panic("reflect.MakeChan of non-chan type") 2276 } 2277 if buffer < 0 { 2278 panic("reflect.MakeChan: negative buffer size") 2279 } 2280 if typ.ChanDir() != BothDir { 2281 panic("reflect.MakeChan: unidirectional channel type") 2282 } 2283 t := typ.(*rtype) 2284 ch := makechan(t, buffer) 2285 return Value{t, ch, flag(Chan)} 2286 } 2287 2288 // MakeMap creates a new map with the specified type. 2289 func MakeMap(typ Type) Value { 2290 return MakeMapWithSize(typ, 0) 2291 } 2292 2293 // MakeMapWithSize creates a new map with the specified type 2294 // and initial space for approximately n elements. 2295 func MakeMapWithSize(typ Type, n int) Value { 2296 if typ.Kind() != Map { 2297 panic("reflect.MakeMapWithSize of non-map type") 2298 } 2299 t := typ.(*rtype) 2300 m := makemap(t, n) 2301 return Value{t, m, flag(Map)} 2302 } 2303 2304 // Indirect returns the value that v points to. 2305 // If v is a nil pointer, Indirect returns a zero Value. 2306 // If v is not a pointer, Indirect returns v. 2307 func Indirect(v Value) Value { 2308 if v.Kind() != Ptr { 2309 return v 2310 } 2311 return v.Elem() 2312 } 2313 2314 // ValueOf returns a new Value initialized to the concrete value 2315 // stored in the interface i. ValueOf(nil) returns the zero Value. 2316 func ValueOf(i interface{}) Value { 2317 if i == nil { 2318 return Value{} 2319 } 2320 2321 // TODO: Maybe allow contents of a Value to live on the stack. 2322 // For now we make the contents always escape to the heap. It 2323 // makes life easier in a few places (see chanrecv/mapassign 2324 // comment below). 2325 escapes(i) 2326 2327 return unpackEface(i) 2328 } 2329 2330 // Zero returns a Value representing the zero value for the specified type. 2331 // The result is different from the zero value of the Value struct, 2332 // which represents no value at all. 2333 // For example, Zero(TypeOf(42)) returns a Value with Kind Int and value 0. 2334 // The returned value is neither addressable nor settable. 2335 func Zero(typ Type) Value { 2336 if typ == nil { 2337 panic("reflect: Zero(nil)") 2338 } 2339 t := typ.(*rtype) 2340 fl := flag(t.Kind()) 2341 if ifaceIndir(t) { 2342 return Value{t, unsafe_New(t), fl | flagIndir} 2343 } 2344 return Value{t, nil, fl} 2345 } 2346 2347 // New returns a Value representing a pointer to a new zero value 2348 // for the specified type. That is, the returned Value's Type is PtrTo(typ). 2349 func New(typ Type) Value { 2350 if typ == nil { 2351 panic("reflect: New(nil)") 2352 } 2353 t := typ.(*rtype) 2354 ptr := unsafe_New(t) 2355 fl := flag(Ptr) 2356 return Value{t.ptrTo(), ptr, fl} 2357 } 2358 2359 // NewAt returns a Value representing a pointer to a value of the 2360 // specified type, using p as that pointer. 2361 func NewAt(typ Type, p unsafe.Pointer) Value { 2362 fl := flag(Ptr) 2363 t := typ.(*rtype) 2364 return Value{t.ptrTo(), p, fl} 2365 } 2366 2367 // assignTo returns a value v that can be assigned directly to typ. 2368 // It panics if v is not assignable to typ. 2369 // For a conversion to an interface type, target is a suggested scratch space to use. 2370 func (v Value) assignTo(context string, dst *rtype, target unsafe.Pointer) Value { 2371 if v.flag&flagMethod != 0 { 2372 v = makeMethodValue(context, v) 2373 } 2374 2375 switch { 2376 case directlyAssignable(dst, v.typ): 2377 // Overwrite type so that they match. 2378 // Same memory layout, so no harm done. 2379 fl := v.flag&(flagAddr|flagIndir) | v.flag.ro() 2380 fl |= flag(dst.Kind()) 2381 return Value{dst, v.ptr, fl} 2382 2383 case implements(dst, v.typ): 2384 if target == nil { 2385 target = unsafe_New(dst) 2386 } 2387 if v.Kind() == Interface && v.IsNil() { 2388 // A nil ReadWriter passed to nil Reader is OK, 2389 // but using ifaceE2I below will panic. 2390 // Avoid the panic by returning a nil dst (e.g., Reader) explicitly. 2391 return Value{dst, nil, flag(Interface)} 2392 } 2393 x := valueInterface(v, false) 2394 if dst.NumMethod() == 0 { 2395 *(*interface{})(target) = x 2396 } else { 2397 ifaceE2I(dst, x, target) 2398 } 2399 return Value{dst, target, flagIndir | flag(Interface)} 2400 } 2401 2402 // Failed. 2403 panic(context + ": value of type " + v.typ.String() + " is not assignable to type " + dst.String()) 2404 } 2405 2406 // Convert returns the value v converted to type t. 2407 // If the usual Go conversion rules do not allow conversion 2408 // of the value v to type t, Convert panics. 2409 func (v Value) Convert(t Type) Value { 2410 if v.flag&flagMethod != 0 { 2411 v = makeMethodValue("Convert", v) 2412 } 2413 op := convertOp(t.common(), v.typ) 2414 if op == nil { 2415 panic("reflect.Value.Convert: value of type " + v.typ.String() + " cannot be converted to type " + t.String()) 2416 } 2417 return op(v, t) 2418 } 2419 2420 // convertOp returns the function to convert a value of type src 2421 // to a value of type dst. If the conversion is illegal, convertOp returns nil. 2422 func convertOp(dst, src *rtype) func(Value, Type) Value { 2423 switch src.Kind() { 2424 case Int, Int8, Int16, Int32, Int64: 2425 switch dst.Kind() { 2426 case Int, Int8, Int16, Int32, Int64, Uint, Uint8, Uint16, Uint32, Uint64, Uintptr: 2427 return cvtInt 2428 case Float32, Float64: 2429 return cvtIntFloat 2430 case String: 2431 return cvtIntString 2432 } 2433 2434 case Uint, Uint8, Uint16, Uint32, Uint64, Uintptr: 2435 switch dst.Kind() { 2436 case Int, Int8, Int16, Int32, Int64, Uint, Uint8, Uint16, Uint32, Uint64, Uintptr: 2437 return cvtUint 2438 case Float32, Float64: 2439 return cvtUintFloat 2440 case String: 2441 return cvtUintString 2442 } 2443 2444 case Float32, Float64: 2445 switch dst.Kind() { 2446 case Int, Int8, Int16, Int32, Int64: 2447 return cvtFloatInt 2448 case Uint, Uint8, Uint16, Uint32, Uint64, Uintptr: 2449 return cvtFloatUint 2450 case Float32, Float64: 2451 return cvtFloat 2452 } 2453 2454 case Complex64, Complex128: 2455 switch dst.Kind() { 2456 case Complex64, Complex128: 2457 return cvtComplex 2458 } 2459 2460 case String: 2461 if dst.Kind() == Slice && dst.Elem().PkgPath() == "" { 2462 switch dst.Elem().Kind() { 2463 case Uint8: 2464 return cvtStringBytes 2465 case Int32: 2466 return cvtStringRunes 2467 } 2468 } 2469 2470 case Slice: 2471 if dst.Kind() == String && src.Elem().PkgPath() == "" { 2472 switch src.Elem().Kind() { 2473 case Uint8: 2474 return cvtBytesString 2475 case Int32: 2476 return cvtRunesString 2477 } 2478 } 2479 } 2480 2481 // dst and src have same underlying type. 2482 if haveIdenticalUnderlyingType(dst, src, false) { 2483 return cvtDirect 2484 } 2485 2486 // dst and src are non-defined pointer types with same underlying base type. 2487 if dst.Kind() == Ptr && dst.Name() == "" && 2488 src.Kind() == Ptr && src.Name() == "" && 2489 haveIdenticalUnderlyingType(dst.Elem().common(), src.Elem().common(), false) { 2490 return cvtDirect 2491 } 2492 2493 if implements(dst, src) { 2494 if src.Kind() == Interface { 2495 return cvtI2I 2496 } 2497 return cvtT2I 2498 } 2499 2500 return nil 2501 } 2502 2503 // makeInt returns a Value of type t equal to bits (possibly truncated), 2504 // where t is a signed or unsigned int type. 2505 func makeInt(f flag, bits uint64, t Type) Value { 2506 typ := t.common() 2507 ptr := unsafe_New(typ) 2508 switch typ.size { 2509 case 1: 2510 *(*uint8)(ptr) = uint8(bits) 2511 case 2: 2512 *(*uint16)(ptr) = uint16(bits) 2513 case 4: 2514 *(*uint32)(ptr) = uint32(bits) 2515 case 8: 2516 *(*uint64)(ptr) = bits 2517 } 2518 return Value{typ, ptr, f | flagIndir | flag(typ.Kind())} 2519 } 2520 2521 // makeFloat returns a Value of type t equal to v (possibly truncated to float32), 2522 // where t is a float32 or float64 type. 2523 func makeFloat(f flag, v float64, t Type) Value { 2524 typ := t.common() 2525 ptr := unsafe_New(typ) 2526 switch typ.size { 2527 case 4: 2528 *(*float32)(ptr) = float32(v) 2529 case 8: 2530 *(*float64)(ptr) = v 2531 } 2532 return Value{typ, ptr, f | flagIndir | flag(typ.Kind())} 2533 } 2534 2535 // makeComplex returns a Value of type t equal to v (possibly truncated to complex64), 2536 // where t is a complex64 or complex128 type. 2537 func makeComplex(f flag, v complex128, t Type) Value { 2538 typ := t.common() 2539 ptr := unsafe_New(typ) 2540 switch typ.size { 2541 case 8: 2542 *(*complex64)(ptr) = complex64(v) 2543 case 16: 2544 *(*complex128)(ptr) = v 2545 } 2546 return Value{typ, ptr, f | flagIndir | flag(typ.Kind())} 2547 } 2548 2549 func makeString(f flag, v string, t Type) Value { 2550 ret := New(t).Elem() 2551 ret.SetString(v) 2552 ret.flag = ret.flag&^flagAddr | f 2553 return ret 2554 } 2555 2556 func makeBytes(f flag, v []byte, t Type) Value { 2557 ret := New(t).Elem() 2558 ret.SetBytes(v) 2559 ret.flag = ret.flag&^flagAddr | f 2560 return ret 2561 } 2562 2563 func makeRunes(f flag, v []rune, t Type) Value { 2564 ret := New(t).Elem() 2565 ret.setRunes(v) 2566 ret.flag = ret.flag&^flagAddr | f 2567 return ret 2568 } 2569 2570 // These conversion functions are returned by convertOp 2571 // for classes of conversions. For example, the first function, cvtInt, 2572 // takes any value v of signed int type and returns the value converted 2573 // to type t, where t is any signed or unsigned int type. 2574 2575 // convertOp: intXX -> [u]intXX 2576 func cvtInt(v Value, t Type) Value { 2577 return makeInt(v.flag.ro(), uint64(v.Int()), t) 2578 } 2579 2580 // convertOp: uintXX -> [u]intXX 2581 func cvtUint(v Value, t Type) Value { 2582 return makeInt(v.flag.ro(), v.Uint(), t) 2583 } 2584 2585 // convertOp: floatXX -> intXX 2586 func cvtFloatInt(v Value, t Type) Value { 2587 return makeInt(v.flag.ro(), uint64(int64(v.Float())), t) 2588 } 2589 2590 // convertOp: floatXX -> uintXX 2591 func cvtFloatUint(v Value, t Type) Value { 2592 return makeInt(v.flag.ro(), uint64(v.Float()), t) 2593 } 2594 2595 // convertOp: intXX -> floatXX 2596 func cvtIntFloat(v Value, t Type) Value { 2597 return makeFloat(v.flag.ro(), float64(v.Int()), t) 2598 } 2599 2600 // convertOp: uintXX -> floatXX 2601 func cvtUintFloat(v Value, t Type) Value { 2602 return makeFloat(v.flag.ro(), float64(v.Uint()), t) 2603 } 2604 2605 // convertOp: floatXX -> floatXX 2606 func cvtFloat(v Value, t Type) Value { 2607 return makeFloat(v.flag.ro(), v.Float(), t) 2608 } 2609 2610 // convertOp: complexXX -> complexXX 2611 func cvtComplex(v Value, t Type) Value { 2612 return makeComplex(v.flag.ro(), v.Complex(), t) 2613 } 2614 2615 // convertOp: intXX -> string 2616 func cvtIntString(v Value, t Type) Value { 2617 return makeString(v.flag.ro(), string(v.Int()), t) 2618 } 2619 2620 // convertOp: uintXX -> string 2621 func cvtUintString(v Value, t Type) Value { 2622 return makeString(v.flag.ro(), string(v.Uint()), t) 2623 } 2624 2625 // convertOp: []byte -> string 2626 func cvtBytesString(v Value, t Type) Value { 2627 return makeString(v.flag.ro(), string(v.Bytes()), t) 2628 } 2629 2630 // convertOp: string -> []byte 2631 func cvtStringBytes(v Value, t Type) Value { 2632 return makeBytes(v.flag.ro(), []byte(v.String()), t) 2633 } 2634 2635 // convertOp: []rune -> string 2636 func cvtRunesString(v Value, t Type) Value { 2637 return makeString(v.flag.ro(), string(v.runes()), t) 2638 } 2639 2640 // convertOp: string -> []rune 2641 func cvtStringRunes(v Value, t Type) Value { 2642 return makeRunes(v.flag.ro(), []rune(v.String()), t) 2643 } 2644 2645 // convertOp: direct copy 2646 func cvtDirect(v Value, typ Type) Value { 2647 f := v.flag 2648 t := typ.common() 2649 ptr := v.ptr 2650 if f&flagAddr != 0 { 2651 // indirect, mutable word - make a copy 2652 c := unsafe_New(t) 2653 typedmemmove(t, c, ptr) 2654 ptr = c 2655 f &^= flagAddr 2656 } 2657 return Value{t, ptr, v.flag.ro() | f} // v.flag.ro()|f == f? 2658 } 2659 2660 // convertOp: concrete -> interface 2661 func cvtT2I(v Value, typ Type) Value { 2662 target := unsafe_New(typ.common()) 2663 x := valueInterface(v, false) 2664 if typ.NumMethod() == 0 { 2665 *(*interface{})(target) = x 2666 } else { 2667 ifaceE2I(typ.(*rtype), x, target) 2668 } 2669 return Value{typ.common(), target, v.flag.ro() | flagIndir | flag(Interface)} 2670 } 2671 2672 // convertOp: interface -> interface 2673 func cvtI2I(v Value, typ Type) Value { 2674 if v.IsNil() { 2675 ret := Zero(typ) 2676 ret.flag |= v.flag.ro() 2677 return ret 2678 } 2679 return cvtT2I(v.Elem(), typ) 2680 } 2681 2682 // implemented in ../runtime 2683 func chancap(ch unsafe.Pointer) int 2684 func chanclose(ch unsafe.Pointer) 2685 func chanlen(ch unsafe.Pointer) int 2686 2687 // Note: some of the noescape annotations below are technically a lie, 2688 // but safe in the context of this package. Functions like chansend 2689 // and mapassign don't escape the referent, but may escape anything 2690 // the referent points to (they do shallow copies of the referent). 2691 // It is safe in this package because the referent may only point 2692 // to something a Value may point to, and that is always in the heap 2693 // (due to the escapes() call in ValueOf). 2694 2695 //go:noescape 2696 func chanrecv(ch unsafe.Pointer, nb bool, val unsafe.Pointer) (selected, received bool) 2697 2698 //go:noescape 2699 func chansend(ch unsafe.Pointer, val unsafe.Pointer, nb bool) bool 2700 2701 func makechan(typ *rtype, size int) (ch unsafe.Pointer) 2702 func makemap(t *rtype, cap int) (m unsafe.Pointer) 2703 2704 //go:noescape 2705 func mapaccess(t *rtype, m unsafe.Pointer, key unsafe.Pointer) (val unsafe.Pointer) 2706 2707 //go:noescape 2708 func mapassign(t *rtype, m unsafe.Pointer, key, val unsafe.Pointer) 2709 2710 //go:noescape 2711 func mapdelete(t *rtype, m unsafe.Pointer, key unsafe.Pointer) 2712 2713 // m escapes into the return value, but the caller of mapiterinit 2714 // doesn't let the return value escape. 2715 //go:noescape 2716 func mapiterinit(t *rtype, m unsafe.Pointer) unsafe.Pointer 2717 2718 //go:noescape 2719 func mapiterkey(it unsafe.Pointer) (key unsafe.Pointer) 2720 2721 //go:noescape 2722 func mapiterelem(it unsafe.Pointer) (elem unsafe.Pointer) 2723 2724 //go:noescape 2725 func mapiternext(it unsafe.Pointer) 2726 2727 //go:noescape 2728 func maplen(m unsafe.Pointer) int 2729 2730 // call calls fn with a copy of the n argument bytes pointed at by arg. 2731 // After fn returns, reflectcall copies n-retoffset result bytes 2732 // back into arg+retoffset before returning. If copying result bytes back, 2733 // the caller must pass the argument frame type as argtype, so that 2734 // call can execute appropriate write barriers during the copy. 2735 // 2736 //go:linkname call runtime.reflectcall 2737 func call(argtype *rtype, fn, arg unsafe.Pointer, n uint32, retoffset uint32) 2738 2739 func ifaceE2I(t *rtype, src interface{}, dst unsafe.Pointer) 2740 2741 // memmove copies size bytes to dst from src. No write barriers are used. 2742 //go:noescape 2743 func memmove(dst, src unsafe.Pointer, size uintptr) 2744 2745 // typedmemmove copies a value of type t to dst from src. 2746 //go:noescape 2747 func typedmemmove(t *rtype, dst, src unsafe.Pointer) 2748 2749 // typedmemmovepartial is like typedmemmove but assumes that 2750 // dst and src point off bytes into the value and only copies size bytes. 2751 //go:noescape 2752 func typedmemmovepartial(t *rtype, dst, src unsafe.Pointer, off, size uintptr) 2753 2754 // typedmemclr zeros the value at ptr of type t. 2755 //go:noescape 2756 func typedmemclr(t *rtype, ptr unsafe.Pointer) 2757 2758 // typedmemclrpartial is like typedmemclr but assumes that 2759 // dst points off bytes into the value and only clears size bytes. 2760 //go:noescape 2761 func typedmemclrpartial(t *rtype, ptr unsafe.Pointer, off, size uintptr) 2762 2763 // typedslicecopy copies a slice of elemType values from src to dst, 2764 // returning the number of elements copied. 2765 //go:noescape 2766 func typedslicecopy(elemType *rtype, dst, src sliceHeader) int 2767 2768 // Dummy annotation marking that the value x escapes, 2769 // for use in cases where the reflect code is so clever that 2770 // the compiler cannot follow. 2771 func escapes(x interface{}) { 2772 if dummy.b { 2773 dummy.x = x 2774 } 2775 } 2776 2777 var dummy struct { 2778 b bool 2779 x interface{} 2780 } 2781
View as plain text