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  
   274  	if expr, ok := s.(*ir.AddStringExpr); ok {
   275  		return walkAddString(n.Type(), expr, init)
   276  	}
   277  
   278  	if ir.IsConst(s, constant.String) {
   279  		sc := ir.StringVal(s)
   280  
   281  		// Allocate a [n]byte of the right size.
   282  		t := types.NewArray(types.Types[types.TUINT8], int64(len(sc)))
   283  		var a ir.Node
   284  		if n.Esc() == ir.EscNone && len(sc) <= int(ir.MaxImplicitStackVarSize) {
   285  			a = stackBufAddr(t.NumElem(), t.Elem())
   286  		} else {
   287  			types.CalcSize(t)
   288  			a = ir.NewUnaryExpr(base.Pos, ir.ONEW, nil)
   289  			a.SetType(types.NewPtr(t))
   290  			a.SetTypecheck(1)
   291  			a.MarkNonNil()
   292  		}
   293  		p := typecheck.TempAt(base.Pos, ir.CurFunc, t.PtrTo()) // *[n]byte
   294  		init.Append(typecheck.Stmt(ir.NewAssignStmt(base.Pos, p, a)))
   295  
   296  		// Copy from the static string data to the [n]byte.
   297  		if len(sc) > 0 {
   298  			sptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, s)
   299  			sptr.SetBounded(true)
   300  			as := ir.NewAssignStmt(base.Pos, ir.NewStarExpr(base.Pos, p), ir.NewStarExpr(base.Pos, typecheck.ConvNop(sptr, t.PtrTo())))
   301  			appendWalkStmt(init, as)
   302  		}
   303  
   304  		// Slice the [n]byte to a []byte.
   305  		slice := ir.NewSliceExpr(n.Pos(), ir.OSLICEARR, p, nil, nil, nil)
   306  		slice.SetType(n.Type())
   307  		slice.SetTypecheck(1)
   308  		return walkExpr(slice, init)
   309  	}
   310  
   311  	a := typecheck.NodNil()
   312  	if n.Esc() == ir.EscNone {
   313  		// Create temporary buffer for slice on stack.
   314  		a = stackBufAddr(tmpstringbufsize, types.Types[types.TUINT8])
   315  	}
   316  	// stringtoslicebyte(*32[byte], string) []byte
   317  	return mkcall("stringtoslicebyte", n.Type(), init, a, typecheck.Conv(s, types.Types[types.TSTRING]))
   318  }
   319  
   320  // walkStringToBytesTemp walks an OSTR2BYTESTMP node.
   321  func walkStringToBytesTemp(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
   322  	// []byte(string) conversion that creates a slice
   323  	// referring to the actual string bytes.
   324  	// This conversion is handled later by the backend and
   325  	// is only for use by internal compiler optimizations
   326  	// that know that the slice won't be mutated.
   327  	// The only such case today is:
   328  	// for i, c := range []byte(string)
   329  	n.X = walkExpr(n.X, init)
   330  	return n
   331  }
   332  
   333  // walkStringToRunes walks an OSTR2RUNES node.
   334  func walkStringToRunes(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
   335  	a := typecheck.NodNil()
   336  	if n.Esc() == ir.EscNone {
   337  		// Create temporary buffer for slice on stack.
   338  		a = stackBufAddr(tmpstringbufsize, types.Types[types.TINT32])
   339  	}
   340  	// stringtoslicerune(*[32]rune, string) []rune
   341  	return mkcall("stringtoslicerune", n.Type(), init, a, typecheck.Conv(n.X, types.Types[types.TSTRING]))
   342  }
   343  
   344  // dataWordFuncName returns the name of the function used to convert a value of type "from"
   345  // to the data word of an interface.
   346  // argType is the type the argument needs to be coerced to.
   347  // needsaddr reports whether the value should be passed (needaddr==false) or its address (needsaddr==true).
   348  func dataWordFuncName(from *types.Type) (fnname string, argType *types.Type, needsaddr bool) {
   349  	if from.IsInterface() {
   350  		base.Fatalf("can only handle non-interfaces")
   351  	}
   352  	switch {
   353  	case from.Size() == 2 && uint8(from.Alignment()) == 2:
   354  		return "convT16", types.Types[types.TUINT16], false
   355  	case from.Size() == 4 && uint8(from.Alignment()) == 4 && !from.HasPointers():
   356  		return "convT32", types.Types[types.TUINT32], false
   357  	case from.Size() == 8 && uint8(from.Alignment()) == uint8(types.Types[types.TUINT64].Alignment()) && !from.HasPointers():
   358  		return "convT64", types.Types[types.TUINT64], false
   359  	}
   360  	if sc := from.SoleComponent(); sc != nil {
   361  		switch {
   362  		case sc.IsString():
   363  			return "convTstring", types.Types[types.TSTRING], false
   364  		case sc.IsSlice():
   365  			return "convTslice", types.NewSlice(types.Types[types.TUINT8]), false // the element type doesn't matter
   366  		}
   367  	}
   368  
   369  	if from.HasPointers() {
   370  		return "convT", types.Types[types.TUNSAFEPTR], true
   371  	}
   372  	return "convTnoptr", types.Types[types.TUNSAFEPTR], true
   373  }
   374  
   375  // rtconvfn returns the parameter and result types that will be used by a
   376  // runtime function to convert from type src to type dst. The runtime function
   377  // name can be derived from the names of the returned types.
   378  //
   379  // If no such function is necessary, it returns (Txxx, Txxx).
   380  func rtconvfn(src, dst *types.Type) (param, result types.Kind) {
   381  	if ssagen.Arch.SoftFloat {
   382  		return types.Txxx, types.Txxx
   383  	}
   384  
   385  	switch ssagen.Arch.LinkArch.Family {
   386  	case sys.ARM, sys.MIPS:
   387  		if src.IsFloat() {
   388  			switch dst.Kind() {
   389  			case types.TINT64, types.TUINT64:
   390  				return types.TFLOAT64, dst.Kind()
   391  			}
   392  		}
   393  		if dst.IsFloat() {
   394  			switch src.Kind() {
   395  			case types.TINT64, types.TUINT64:
   396  				return src.Kind(), dst.Kind()
   397  			}
   398  		}
   399  
   400  	case sys.I386:
   401  		if src.IsFloat() {
   402  			switch dst.Kind() {
   403  			case types.TINT64, types.TUINT64:
   404  				return types.TFLOAT64, dst.Kind()
   405  			case types.TUINT32, types.TUINT, types.TUINTPTR:
   406  				return types.TFLOAT64, types.TUINT32
   407  			}
   408  		}
   409  		if dst.IsFloat() {
   410  			switch src.Kind() {
   411  			case types.TINT64, types.TUINT64:
   412  				return src.Kind(), dst.Kind()
   413  			case types.TUINT32, types.TUINT, types.TUINTPTR:
   414  				return types.TUINT32, types.TFLOAT64
   415  			}
   416  		}
   417  	}
   418  	return types.Txxx, types.Txxx
   419  }
   420  
   421  func soleComponent(init *ir.Nodes, n ir.Node) ir.Node {
   422  	if n.Type().SoleComponent() == nil {
   423  		return n
   424  	}
   425  	// Keep in sync with cmd/compile/internal/types/type.go:Type.SoleComponent.
   426  	for {
   427  		switch {
   428  		case n.Type().IsStruct():
   429  			if n.Type().Field(0).Sym.IsBlank() {
   430  				// Treat blank fields as the zero value as the Go language requires.
   431  				n = typecheck.TempAt(base.Pos, ir.CurFunc, n.Type().Field(0).Type)
   432  				appendWalkStmt(init, ir.NewAssignStmt(base.Pos, n, nil))
   433  				continue
   434  			}
   435  			n = typecheck.DotField(n.Pos(), n, 0)
   436  		case n.Type().IsArray():
   437  			n = typecheck.Expr(ir.NewIndexExpr(n.Pos(), n, ir.NewInt(base.Pos, 0)))
   438  		default:
   439  			return n
   440  		}
   441  	}
   442  }
   443  
   444  // byteindex converts n, which is byte-sized, to an int used to index into an array.
   445  // We cannot use conv, because we allow converting bool to int here,
   446  // which is forbidden in user code.
   447  func byteindex(n ir.Node) ir.Node {
   448  	// We cannot convert from bool to int directly.
   449  	// While converting from int8 to int is possible, it would yield
   450  	// the wrong result for negative values.
   451  	// Reinterpreting the value as an unsigned byte solves both cases.
   452  	if !types.Identical(n.Type(), types.Types[types.TUINT8]) {
   453  		n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
   454  		n.SetType(types.Types[types.TUINT8])
   455  		n.SetTypecheck(1)
   456  	}
   457  	n = ir.NewConvExpr(base.Pos, ir.OCONV, nil, n)
   458  	n.SetType(types.Types[types.TINT])
   459  	n.SetTypecheck(1)
   460  	return n
   461  }
   462  
   463  func walkCheckPtrArithmetic(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
   464  	// Calling cheapExpr(n, init) below leads to a recursive call to
   465  	// walkExpr, which leads us back here again. Use n.Checkptr to
   466  	// prevent infinite loops.
   467  	if n.CheckPtr() {
   468  		return n
   469  	}
   470  	n.SetCheckPtr(true)
   471  	defer n.SetCheckPtr(false)
   472  
   473  	// TODO(mdempsky): Make stricter. We only need to exempt
   474  	// reflect.Value.Pointer and reflect.Value.UnsafeAddr.
   475  	switch n.X.Op() {
   476  	case ir.OCALLMETH:
   477  		base.FatalfAt(n.X.Pos(), "OCALLMETH missed by typecheck")
   478  	case ir.OCALLFUNC, ir.OCALLINTER:
   479  		return n
   480  	}
   481  
   482  	if n.X.Op() == ir.ODOTPTR && ir.IsReflectHeaderDataField(n.X) {
   483  		return n
   484  	}
   485  
   486  	// Find original unsafe.Pointer operands involved in this
   487  	// arithmetic expression.
   488  	//
   489  	// "It is valid both to add and to subtract offsets from a
   490  	// pointer in this way. It is also valid to use &^ to round
   491  	// pointers, usually for alignment."
   492  	var originals []ir.Node
   493  	var walk func(n ir.Node)
   494  	walk = func(n ir.Node) {
   495  		switch n.Op() {
   496  		case ir.OADD:
   497  			n := n.(*ir.BinaryExpr)
   498  			walk(n.X)
   499  			walk(n.Y)
   500  		case ir.OSUB, ir.OANDNOT:
   501  			n := n.(*ir.BinaryExpr)
   502  			walk(n.X)
   503  		case ir.OCONVNOP:
   504  			n := n.(*ir.ConvExpr)
   505  			if n.X.Type().IsUnsafePtr() {
   506  				n.X = cheapExpr(n.X, init)
   507  				originals = append(originals, typecheck.ConvNop(n.X, types.Types[types.TUNSAFEPTR]))
   508  			}
   509  		}
   510  	}
   511  	walk(n.X)
   512  
   513  	cheap := cheapExpr(n, init)
   514  
   515  	slice := typecheck.MakeDotArgs(base.Pos, types.NewSlice(types.Types[types.TUNSAFEPTR]), originals)
   516  	slice.SetEsc(ir.EscNone)
   517  
   518  	init.Append(mkcall("checkptrArithmetic", nil, init, typecheck.ConvNop(cheap, types.Types[types.TUNSAFEPTR]), slice))
   519  	// TODO(khr): Mark backing store of slice as dead. This will allow us to reuse
   520  	// the backing store for multiple calls to checkptrArithmetic.
   521  
   522  	return cheap
   523  }
   524  
   525  // walkSliceToArray walks an OSLICE2ARR expression.
   526  func walkSliceToArray(n *ir.ConvExpr, init *ir.Nodes) ir.Node {
   527  	// Replace T(x) with *(*T)(x).
   528  	conv := typecheck.Expr(ir.NewConvExpr(base.Pos, ir.OCONV, types.NewPtr(n.Type()), n.X)).(*ir.ConvExpr)
   529  	deref := typecheck.Expr(ir.NewStarExpr(base.Pos, conv)).(*ir.StarExpr)
   530  
   531  	// The OSLICE2ARRPTR conversion handles checking the slice length,
   532  	// so the dereference can't fail.
   533  	//
   534  	// However, this is more than just an optimization: if T is a
   535  	// zero-length array, then x (and thus (*T)(x)) can be nil, but T(x)
   536  	// should *not* panic. So suppressing the nil check here is
   537  	// necessary for correctness in that case.
   538  	deref.SetBounded(true)
   539  
   540  	return walkExpr(deref, init)
   541  }
   542
View as plain text