src/cmd/compile/internal/walk/convert.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 walk
   6
   7 import (
   8         "encoding/binary"
   9         "go/constant"
  10
  11         "cmd/compile/internal/base"
  12         "cmd/compile/internal/ir"
  13         "cmd/compile/internal/reflectdata"
  14         "cmd/compile/internal/ssagen"
  15         "cmd/compile/internal/typecheck"
  16         "cmd/compile/internal/types"
  17         "cmd/internal/sys"
  18 )
  19
  20 // walkConv walks an OCONV or OCONVNOP (but not OCONVIFACE) node.
  21 func walkConv(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
  22         n.X = walkExpr(n.X, init)
  23         if n.Op() == ir.OCONVNOP && n.Type() == n.X.Type() {
  24                 return n.X
  25         }
  26         if n.Op() == ir.OCONVNOP && ir.ShouldCheckPtr(ir.CurFunc, 1) {
  27                 if n.Type().IsUnsafePtr() && n.X.Type().IsUintptr() { // uintptr to unsafe.Pointer
  28                         return walkCheckPtrArithmetic(n, init)
  29                 }
  30         }
  31         param, result := rtconvfn(n.X.Type(), n.Type())
  32         if param == types.Txxx {
  33                 return n
  34         }
  35         fn := types.BasicTypeNames[param] + "to" + types.BasicTypeNames[result]
  36         return typecheck.Conv(mkcall(fn, types.Types[result], init, typecheck.Conv(n.X, types.Types[param])), n.Type())
  37 }
  38
  39 // walkConvInterface walks an OCONVIFACE node.
  40 func walkConvInterface(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
  41
  42         n.X = walkExpr(n.X, init)
  43
  44         fromType := n.X.Type()
  45         toType := n.Type()
  46         if !fromType.IsInterface() && !ir.IsBlank(ir.CurFunc.Nname) {
  47                 // skip unnamed functions (func _())
  48                 if fromType.HasShape() {
  49                         // Unified IR uses OCONVIFACE for converting all derived types
  50                         // to interface type. Avoid assertion failure in
  51                         // MarkTypeUsedInInterface, because we've marked used types
  52                         // separately anyway.
  53                 } else {
  54                         reflectdata.MarkTypeUsedInInterface(fromType, ir.CurFunc.LSym)
  55                 }
  56         }
  57
  58         if !fromType.IsInterface() {
  59                 typeWord := reflectdata.ConvIfaceTypeWord(base.Pos, n)
  60                 l := ir.NewBinaryExpr(base.Pos, ir.OMAKEFACE, typeWord, dataWord(n, init))
  61                 l.SetType(toType)
  62                 l.SetTypecheck(n.Typecheck())
  63                 return l
  64         }
  65         if fromType.IsEmptyInterface() {
  66                 base.Fatalf("OCONVIFACE can't operate on an empty interface")
  67         }
  68
  69         // Evaluate the input interface.
  70         c := typecheck.TempAt(base.Pos, ir.CurFunc, fromType)
  71         init.Append(ir.NewAssignStmt(base.Pos, c, n.X))
  72
  73         if toType.IsEmptyInterface() {
  74                 // Implement interface to empty interface conversion:
  75                 //
  76                 // var res *uint8
  77                 // res = (*uint8)(unsafe.Pointer(itab))
  78                 // if res != nil {
  79                 //    res = res.type
  80                 // }
  81
  82                 // Grab its parts.
  83                 itab := ir.NewUnaryExpr(base.Pos, ir.OITAB, c)
  84                 itab.SetType(types.Types[types.TUINTPTR].PtrTo())
  85                 itab.SetTypecheck(1)
  86                 data := ir.NewUnaryExpr(n.Pos(), ir.OIDATA, c)
  87                 data.SetType(types.Types[types.TUINT8].PtrTo()) // Type is generic pointer - we're just passing it through.
  88                 data.SetTypecheck(1)
  89
  90                 typeWord := typecheck.TempAt(base.Pos, ir.CurFunc, types.NewPtr(types.Types[types.TUINT8]))
  91                 init.Append(ir.NewAssignStmt(base.Pos, typeWord, typecheck.Conv(typecheck.Conv(itab, types.Types[types.TUNSAFEPTR]), typeWord.Type())))
  92                 nif := ir.NewIfStmt(base.Pos, typecheck.Expr(ir.NewBinaryExpr(base.Pos, ir.ONE, typeWord, typecheck.NodNil())), nil, nil)
  93                 nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, typeWord, itabType(typeWord))}
  94                 init.Append(nif)
  95
  96                 // Build the result.
  97                 // e = iface{typeWord, data}
  98                 e := ir.NewBinaryExpr(base.Pos, ir.OMAKEFACE, typeWord, data)
  99                 e.SetType(toType) // assign type manually, typecheck doesn't understand OEFACE.
 100                 e.SetTypecheck(1)
 101                 return e
 102         }
 103
 104         // Must be converting I2I (more specific to less specific interface).
 105         // Use the same code as e, _ = c.(T).
 106         var rhs ir.Node
 107         if n.TypeWord == nil || n.TypeWord.Op() == ir.OADDR && n.TypeWord.(*ir.AddrExpr).X.Op() == ir.OLINKSYMOFFSET {
 108                 // Fixed (not loaded from a dictionary) type.
 109                 ta := ir.NewTypeAssertExpr(base.Pos, c, toType)
 110                 ta.SetOp(ir.ODOTTYPE2)
 111                 // Allocate a descriptor for this conversion to pass to the runtime.
 112                 ta.Descriptor = makeTypeAssertDescriptor(toType, true)
 113                 rhs = ta
 114         } else {
 115                 ta := ir.NewDynamicTypeAssertExpr(base.Pos, ir.ODYNAMICDOTTYPE2, c, n.TypeWord)
 116                 rhs = ta
 117         }
 118         rhs.SetType(toType)
 119         rhs.SetTypecheck(1)
 120
 121         res := typecheck.TempAt(base.Pos, ir.CurFunc, toType)
 122         as := ir.NewAssignListStmt(base.Pos, ir.OAS2DOTTYPE, []ir.Node{res, ir.BlankNode}, []ir.Node{rhs})
 123         init.Append(as)
 124         return res
 125 }
 126
 127 // Returns the data word (the second word) used to represent conv.X in
 128 // an interface.
 129 func dataWord(conv *ir.ConvExpr, init *ir.Nodes) ir.Node {
 130         pos, n := conv.Pos(), conv.X
 131         fromType := n.Type()
 132
 133         // If it's a pointer, it is its own representation.
 134         if types.IsDirectIface(fromType) {
 135                 return n
 136         }
 137
 138         isInteger := fromType.IsInteger()
 139         isBool := fromType.IsBoolean()
 140         if sc := fromType.SoleComponent(); sc != nil {
 141                 isInteger = sc.IsInteger()
 142                 isBool = sc.IsBoolean()
 143         }
 144         // Try a bunch of cases to avoid an allocation.
 145         var value ir.Node
 146         switch {
 147         case fromType.Size() == 0:
 148                 // n is zero-sized. Use zerobase.
 149                 cheapExpr(n, init) // Evaluate n for side-effects. See issue 19246.
 150                 value = ir.NewLinksymExpr(base.Pos, ir.Syms.Zerobase, types.Types[types.TUINTPTR])
 151         case isBool || fromType.Size() == 1 && isInteger:
 152                 // n is a bool/byte. Use staticuint64s[n * 8] on little-endian
 153                 // and staticuint64s[n * 8 + 7] on big-endian.
 154                 n = cheapExpr(n, init)
 155                 n = soleComponent(init, n)
 156                 // byteindex widens n so that the multiplication doesn't overflow.
 157                 index := ir.NewBinaryExpr(base.Pos, ir.OLSH, byteindex(n), ir.NewInt(base.Pos, 3))
 158                 if ssagen.Arch.LinkArch.ByteOrder == binary.BigEndian {
 159                         index = ir.NewBinaryExpr(base.Pos, ir.OADD, index, ir.NewInt(base.Pos, 7))
 160                 }
 161                 // The actual type is [256]uint64, but we use [256*8]uint8 so we can address
 162                 // individual bytes.
 163                 staticuint64s := ir.NewLinksymExpr(base.Pos, ir.Syms.Staticuint64s, types.NewArray(types.Types[types.TUINT8], 256*8))
 164                 xe := ir.NewIndexExpr(base.Pos, staticuint64s, index)
 165                 xe.SetBounded(true)
 166                 value = xe
 167         case n.Op() == ir.ONAME && n.(*ir.Name).Class == ir.PEXTERN && n.(*ir.Name).Readonly():
 168                 // n is a readonly global; use it directly.
 169                 value = n
 170         case conv.Esc() == ir.EscNone && fromType.Size() <= 1024:
 171                 // n does not escape. Use a stack temporary initialized to n.
 172                 value = typecheck.TempAt(base.Pos, ir.CurFunc, fromType)
 173                 init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, value, n)))
 174         }
 175         if value != nil {
 176                 // The interface data word is &value.
 177                 return typecheck.Expr(typecheck.NodAddr(value))
 178         }
 179
 180         // Time to do an allocation. We'll call into the runtime for that.
 181         fnname, argType, needsaddr := dataWordFuncName(fromType)
 182         var fn *ir.Name
 183
 184         var args []ir.Node
 185         if needsaddr {
 186                 // Types of large or unknown size are passed by reference.
 187                 // Orderexpr arranged for n to be a temporary for all
 188                 // the conversions it could see. Comparison of an interface
 189                 // with a non-interface, especially in a switch on interface value
 190                 // with non-interface cases, is not visible to order.stmt, so we
 191                 // have to fall back on allocating a temp here.
 192                 if !ir.IsAddressable(n) {
 193                         n = copyExpr(n, fromType, init)
 194                 }
 195                 fn = typecheck.LookupRuntime(fnname, fromType)
 196                 args = []ir.Node{reflectdata.ConvIfaceSrcRType(base.Pos, conv), typecheck.NodAddr(n)}
 197         } else {
 198                 // Use a specialized conversion routine that takes the type being
 199                 // converted by value, not by pointer.
 200                 fn = typecheck.LookupRuntime(fnname)
 201                 var arg ir.Node
 202                 switch {
 203                 case fromType == argType:
 204                         // already in the right type, nothing to do
 205                         arg = n
 206                 case fromType.Kind() == argType.Kind(),
 207                         fromType.IsPtrShaped() && argType.IsPtrShaped():
 208                         // can directly convert (e.g. named type to underlying type, or one pointer to another)
 209                         // TODO: never happens because pointers are directIface?
 210                         arg = ir.NewConvExpr(pos, ir.OCONVNOP, argType, n)
 211                 case fromType.IsInteger() && argType.IsInteger():
 212                         // can directly convert (e.g. int32 to uint32)
 213                         arg = ir.NewConvExpr(pos, ir.OCONV, argType, n)
 214                 default:
 215                         // unsafe cast through memory
 216                         arg = copyExpr(n, fromType, init)
 217                         var addr ir.Node = typecheck.NodAddr(arg)
 218                         addr = ir.NewConvExpr(pos, ir.OCONVNOP, argType.PtrTo(), addr)
 219                         arg = ir.NewStarExpr(pos, addr)
 220                         arg.SetType(argType)
 221                 }
 222                 args = []ir.Node{arg}
 223         }
 224         call := ir.NewCallExpr(base.Pos, ir.OCALL, fn, nil)
 225         call.Args = args
 226         return safeExpr(walkExpr(typecheck.Expr(call), init), init)
 227 }
 228
 229 // walkBytesRunesToString walks an OBYTES2STR or ORUNES2STR node.
 230 func walkBytesRunesToString(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 231         a := typecheck.NodNil()
 232         if n.Esc() == ir.EscNone {
 233                 // Create temporary buffer for string on stack.
 234                 a = stackBufAddr(tmpstringbufsize, types.Types[types.TUINT8])
 235         }
 236         if n.Op() == ir.ORUNES2STR {
 237                 // slicerunetostring(*[32]byte, []rune) string
 238                 return mkcall("slicerunetostring", n.Type(), init, a, n.X)
 239         }
 240         // slicebytetostring(*[32]byte, ptr *byte, n int) string
 241         n.X = cheapExpr(n.X, init)
 242         ptr, len := backingArrayPtrLen(n.X)
 243         return mkcall("slicebytetostring", n.Type(), init, a, ptr, len)
 244 }
 245
 246 // walkBytesToStringTemp walks an OBYTES2STRTMP node.
 247 func walkBytesToStringTemp(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 248         n.X = walkExpr(n.X, init)
 249         if !base.Flag.Cfg.Instrumenting {
 250                 // Let the backend handle OBYTES2STRTMP directly
 251                 // to avoid a function call to slicebytetostringtmp.
 252                 return n
 253         }
 254         // slicebytetostringtmp(ptr *byte, n int) string
 255         n.X = cheapExpr(n.X, init)
 256         ptr, len := backingArrayPtrLen(n.X)
 257         return mkcall("slicebytetostringtmp", n.Type(), init, ptr, len)
 258 }
 259
 260 // walkRuneToString walks an ORUNESTR node.
 261 func walkRuneToString(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 262         a := typecheck.NodNil()
 263         if n.Esc() == ir.EscNone {
 264                 a = stackBufAddr(4, types.Types[types.TUINT8])
 265         }
 266         // intstring(*[4]byte, rune)
 267         return mkcall("intstring", n.Type(), init, a, typecheck.Conv(n.X, types.Types[types.TINT64]))
 268 }
 269
 270 // walkStringToBytes walks an OSTR2BYTES node.
 271 func walkStringToBytes(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 272         s := n.X
 273         if ir.IsConst(s, constant.String) {
 274                 sc := ir.StringVal(s)
 275
 276                 // Allocate a [n]byte of the right size.
 277                 t := types.NewArray(types.Types[types.TUINT8], int64(len(sc)))
 278                 var a ir.Node
 279                 if n.Esc() == ir.EscNone && len(sc) <= int(ir.MaxImplicitStackVarSize) {
 280                         a = stackBufAddr(t.NumElem(), t.Elem())
 281                 } else {
 282                         types.CalcSize(t)
 283                         a = ir.NewUnaryExpr(base.Pos, ir.ONEW, nil)
 284                         a.SetType(types.NewPtr(t))
 285                         a.SetTypecheck(1)
 286                         a.MarkNonNil()
 287                 }
 288                 p := typecheck.TempAt(base.Pos, ir.CurFunc, t.PtrTo()) // *[n]byte
 289                 init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, p, a)))
 290
 291                 // Copy from the static string data to the [n]byte.
 292                 if len(sc) > 0 {
 293                         sptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, s)
 294                         sptr.SetBounded(true)
 295                         as := ir.NewAssignStmt(base.Pos, ir.NewStarExpr(base.Pos, p), ir.NewStarExpr(base.Pos, typecheck.ConvNop(sptr, t.PtrTo())))
 296                         appendWalkStmt(init, as)
 297                 }
 298
 299                 // Slice the [n]byte to a []byte.
 300                 slice := ir.NewSliceExpr(n.Pos(), ir.OSLICEARR, p, nil, nil, nil)
 301                 slice.SetType(n.Type())
 302                 slice.SetTypecheck(1)
 303                 return walkExpr(slice, init)
 304         }
 305
 306         a := typecheck.NodNil()
 307         if n.Esc() == ir.EscNone {
 308                 // Create temporary buffer for slice on stack.
 309                 a = stackBufAddr(tmpstringbufsize, types.Types[types.TUINT8])
 310         }
 311         // stringtoslicebyte(*32[byte], string) []byte
 312         return mkcall("stringtoslicebyte", n.Type(), init, a, typecheck.Conv(s, types.Types[types.TSTRING]))
 313 }
 314
 315 // walkStringToBytesTemp walks an OSTR2BYTESTMP node.
 316 func walkStringToBytesTemp(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 317         // []byte(string) conversion that creates a slice
 318         // referring to the actual string bytes.
 319         // This conversion is handled later by the backend and
 320         // is only for use by internal compiler optimizations
 321         // that know that the slice won't be mutated.
 322         // The only such case today is:
 323         // for i, c := range []byte(string)
 324         n.X = walkExpr(n.X, init)
 325         return n
 326 }
 327
 328 // walkStringToRunes walks an OSTR2RUNES node.
 329 func walkStringToRunes(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 330         a := typecheck.NodNil()
 331         if n.Esc() == ir.EscNone {
 332                 // Create temporary buffer for slice on stack.
 333                 a = stackBufAddr(tmpstringbufsize, types.Types[types.TINT32])
 334         }
 335         // stringtoslicerune(*[32]rune, string) []rune
 336         return mkcall("stringtoslicerune", n.Type(), init, a, typecheck.Conv(n.X, types.Types[types.TSTRING]))
 337 }
 338
 339 // dataWordFuncName returns the name of the function used to convert a value of type "from"
 340 // to the data word of an interface.
 341 // argType is the type the argument needs to be coerced to.
 342 // needsaddr reports whether the value should be passed (needaddr==false) or its address (needsaddr==true).
 343 func dataWordFuncName(from *types.Type) (fnname string, argType *types.Type, needsaddr bool) {
 344         if from.IsInterface() {
 345                 base.Fatalf("can only handle non-interfaces")
 346         }
 347         switch {
 348         case from.Size() == 2 && uint8(from.Alignment()) == 2:
 349                 return "convT16", types.Types[types.TUINT16], false
 350         case from.Size() == 4 && uint8(from.Alignment()) == 4 && !from.HasPointers():
 351                 return "convT32", types.Types[types.TUINT32], false
 352         case from.Size() == 8 && uint8(from.Alignment()) == uint8(types.Types[types.TUINT64].Alignment()) && !from.HasPointers():
 353                 return "convT64", types.Types[types.TUINT64], false
 354         }
 355         if sc := from.SoleComponent(); sc != nil {
 356                 switch {
 357                 case sc.IsString():
 358                         return "convTstring", types.Types[types.TSTRING], false
 359                 case sc.IsSlice():
 360                         return "convTslice", types.NewSlice(types.Types[types.TUINT8]), false // the element type doesn't matter
 361                 }
 362         }
 363
 364         if from.HasPointers() {
 365                 return "convT", types.Types[types.TUNSAFEPTR], true
 366         }
 367         return "convTnoptr", types.Types[types.TUNSAFEPTR], true
 368 }
 369
 370 // rtconvfn returns the parameter and result types that will be used by a
 371 // runtime function to convert from type src to type dst. The runtime function
 372 // name can be derived from the names of the returned types.
 373 //
 374 // If no such function is necessary, it returns (Txxx, Txxx).
 375 func rtconvfn(src, dst *types.Type) (param, result types.Kind) {
 376         if ssagen.Arch.SoftFloat {
 377                 return types.Txxx, types.Txxx
 378         }
 379
 380         switch ssagen.Arch.LinkArch.Family {
 381         case sys.ARM, sys.MIPS:
 382                 if src.IsFloat() {
 383                         switch dst.Kind() {
 384                         case types.TINT64, types.TUINT64:
 385                                 return types.TFLOAT64, dst.Kind()
 386                         }
 387                 }
 388                 if dst.IsFloat() {
 389                         switch src.Kind() {
 390                         case types.TINT64, types.TUINT64:
 391                                 return src.Kind(), dst.Kind()
 392                         }
 393                 }
 394
 395         case sys.I386:
 396                 if src.IsFloat() {
 397                         switch dst.Kind() {
 398                         case types.TINT64, types.TUINT64:
 399                                 return types.TFLOAT64, dst.Kind()
 400                         case types.TUINT32, types.TUINT, types.TUINTPTR:
 401                                 return types.TFLOAT64, types.TUINT32
 402                         }
 403                 }
 404                 if dst.IsFloat() {
 405                         switch src.Kind() {
 406                         case types.TINT64, types.TUINT64:
 407                                 return src.Kind(), dst.Kind()
 408                         case types.TUINT32, types.TUINT, types.TUINTPTR:
 409                                 return types.TUINT32, types.TFLOAT64
 410                         }
 411                 }
 412         }
 413         return types.Txxx, types.Txxx
 414 }
 415
 416 func soleComponent(init *ir.Nodes, n ir.Node) ir.Node {
 417         if n.Type().SoleComponent() == nil {
 418                 return n
 419         }
 420         // Keep in sync with cmd/compile/internal/types/type.go:Type.SoleComponent.
 421         for {
 422                 switch {
 423                 case n.Type().IsStruct():
 424                         if n.Type().Field(0).Sym.IsBlank() {
 425                                 // Treat blank fields as the zero value as the Go language requires.
 426                                 n = typecheck.TempAt(base.Pos, ir.CurFunc, n.Type().Field(0).Type)
 427                                 appendWalkStmt(init, ir.NewAssignStmt(base.Pos, n, nil))
 428                                 continue
 429                         }
 430                         n = typecheck.DotField(n.Pos(), n, 0)
 431                 case n.Type().IsArray():
 432                         n = typecheck.Expr(ir.NewIndexExpr(n.Pos(), n, ir.NewInt(base.Pos, 0)))
 433                 default:
 434                         return n
 435                 }
 436         }
 437 }
 438
 439 // byteindex converts n, which is byte-sized, to an int used to index into an array.
 440 // We cannot use conv, because we allow converting bool to int here,
 441 // which is forbidden in user code.
 442 func byteindex(n ir.Node) ir.Node {
 443         // We cannot convert from bool to int directly.
 444         // While converting from int8 to int is possible, it would yield
 445         // the wrong result for negative values.
 446         // Reinterpreting the value as an unsigned byte solves both cases.
 447         if !types.Identical(n.Type(), types.Types[types.TUINT8]) {
 448                 n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
 449                 n.SetType(types.Types[types.TUINT8])
 450                 n.SetTypecheck(1)
 451         }
 452         n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
 453         n.SetType(types.Types[types.TINT])
 454         n.SetTypecheck(1)
 455         return n
 456 }
 457
 458 func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 459         // Calling cheapExpr(n, init) below leads to a recursive call to
 460         // walkExpr, which leads us back here again. Use n.Checkptr to
 461         // prevent infinite loops.
 462         if n.CheckPtr() {
 463                 return n
 464         }
 465         n.SetCheckPtr(true)
 466         defer n.SetCheckPtr(false)
 467
 468         // TODO(mdempsky): Make stricter. We only need to exempt
 469         // reflect.Value.Pointer and reflect.Value.UnsafeAddr.
 470         switch n.X.Op() {
 471         case ir.OCALLMETH:
 472                 base.FatalfAt(n.X.Pos(), "OCALLMETH missed by typecheck")
 473         case ir.OCALLFUNC, ir.OCALLINTER:
 474                 return n
 475         }
 476
 477         if n.X.Op() == ir.ODOTPTR && ir.IsReflectHeaderDataField(n.X) {
 478                 return n
 479         }
 480
 481         // Find original unsafe.Pointer operands involved in this
 482         // arithmetic expression.
 483         //
 484         // "It is valid both to add and to subtract offsets from a
 485         // pointer in this way. It is also valid to use &^ to round
 486         // pointers, usually for alignment."
 487         var originals []ir.Node
 488         var walk func(n ir.Node)
 489         walk = func(n ir.Node) {
 490                 switch n.Op() {
 491                 case ir.OADD:
 492                         n := n.(*ir.BinaryExpr)
 493                         walk(n.X)
 494                         walk(n.Y)
 495                 case ir.OSUB, ir.OANDNOT:
 496                         n := n.(*ir.BinaryExpr)
 497                         walk(n.X)
 498                 case ir.OCONVNOP:
 499                         n := n.(*ir.ConvExpr)
 500                         if n.X.Type().IsUnsafePtr() {
 501                                 n.X = cheapExpr(n.X, init)
 502                                 originals = append(originals, typecheck.ConvNop(n.X, types.Types[types.TUNSAFEPTR]))
 503                         }
 504                 }
 505         }
 506         walk(n.X)
 507
 508         cheap := cheapExpr(n, init)
 509
 510         slice := typecheck.MakeDotArgs(base.Pos, types.NewSlice(types.Types[types.TUNSAFEPTR]), originals)
 511         slice.SetEsc(ir.EscNone)
 512
 513         init.Append(mkcall("checkptrArithmetic", nil, init, typecheck.ConvNop(cheap, types.Types[types.TUNSAFEPTR]), slice))
 514         // TODO(khr): Mark backing store of slice as dead. This will allow us to reuse
 515         // the backing store for multiple calls to checkptrArithmetic.
 516
 517         return cheap
 518 }
 519
 520 // walkSliceToArray walks an OSLICE2ARR expression.
 521 func walkSliceToArray(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
 522         // Replace T(x) with *(*T)(x).
 523         conv := typecheck.Expr(ir.NewConvExpr(base.Pos, ir.OCONV, types.NewPtr(n.Type()), n.X)).(*ir.ConvExpr)
 524         deref := typecheck.Expr(ir.NewStarExpr(base.Pos, conv)).(*ir.StarExpr)
 525
 526         // The OSLICE2ARRPTR conversion handles checking the slice length,
 527         // so the dereference can't fail.
 528         //
 529         // However, this is more than just an optimization: if T is a
 530         // zero-length array, then x (and thus (*T)(x)) can be nil, but T(x)
 531         // should *not* panic. So suppressing the nil check here is
 532         // necessary for correctness in that case.
 533         deref.SetBounded(true)
 534
 535         return walkExpr(deref, init)
 536 }