range.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  	"go/constant"
     9  	"unicode/utf8"
    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/src"
    18  	"cmd/internal/sys"
    19  )
    20  
    21  func cheapComputableIndex(width int64) bool {
    22  	switch ssagen.Arch.LinkArch.Family {
    23  	// MIPS does not have R+R addressing
    24  	// Arm64 may lack ability to generate this code in our assembler,
    25  	// but the architecture supports it.
    26  	case sys.Loong64, sys.PPC64, sys.S390X:
    27  		return width == 1
    28  	case sys.AMD64, sys.I386, sys.ARM64, sys.ARM:
    29  		switch width {
    30  		case 1, 2, 4, 8:
    31  			return true
    32  		}
    33  	}
    34  	return false
    35  }
    36  
    37  // walkRange transforms various forms of ORANGE into
    38  // simpler forms.  The result must be assigned back to n.
    39  // Node n may also be modified in place, and may also be
    40  // the returned node.
    41  func (w *walkState) walkRange(nrange *ir.RangeStmt) ir.Node {
    42  	base.Assert(!nrange.DistinctVars) // Should all be rewritten before escape analysis
    43  	if isMapClear(nrange) {
    44  		return w.mapRangeClear(nrange)
    45  	}
    46  
    47  	nfor := ir.NewForStmt(nrange.Pos(), nil, nil, nil, nil, nrange.DistinctVars)
    48  	nfor.SetInit(nrange.Init())
    49  	nfor.Label = nrange.Label
    50  
    51  	// variable name conventions:
    52  	//	ohv1, hv1, hv2: hidden (old) val 1, 2
    53  	//	ha, hit: hidden aggregate, iterator
    54  	//	hn, hp: hidden len, pointer
    55  	//	hb: hidden bool
    56  	//	a, v1, v2: not hidden aggregate, val 1, 2
    57  
    58  	a := nrange.X
    59  	t := a.Type()
    60  	lno := ir.SetPos(a)
    61  
    62  	v1, v2 := nrange.Key, nrange.Value
    63  
    64  	if ir.IsBlank(v2) {
    65  		v2 = nil
    66  	}
    67  
    68  	if ir.IsBlank(v1) && v2 == nil {
    69  		v1 = nil
    70  	}
    71  
    72  	if v1 == nil && v2 != nil {
    73  		base.Fatalf("walkRange: v2 != nil while v1 == nil")
    74  	}
    75  
    76  	var body []ir.Node
    77  	var init []ir.Node
    78  	switch k := t.Kind(); {
    79  	default:
    80  		base.Fatalf("walkRange")
    81  
    82  	case types.IsInt[k]:
    83  		if nn := w.arrayRangeClear(nrange, v1, v2, a); nn != nil {
    84  			base.Pos = lno
    85  			return nn
    86  		}
    87  		hv1 := typecheck.TempAt(base.Pos, w.curfunc, t)
    88  		hn := typecheck.TempAt(base.Pos, w.curfunc, t)
    89  
    90  		init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
    91  		init = append(init, ir.NewAssignStmt(base.Pos, hn, a))
    92  
    93  		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, hn)
    94  		nfor.Post = ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, ir.NewInt(base.Pos, 1)))
    95  
    96  		if v1 != nil {
    97  			body = []ir.Node{rangeAssign(nrange, hv1)}
    98  		}
    99  
   100  	case k == types.TARRAY, k == types.TSLICE, k == types.TPTR: // TPTR is pointer-to-array
   101  		if nn := w.arrayRangeClear(nrange, v1, v2, a); nn != nil {
   102  			base.Pos = lno
   103  			return nn
   104  		}
   105  
   106  		// Element type of the iteration
   107  		var elem *types.Type
   108  		switch t.Kind() {
   109  		case types.TSLICE, types.TARRAY:
   110  			elem = t.Elem()
   111  		case types.TPTR:
   112  			elem = t.Elem().Elem()
   113  		}
   114  
   115  		// order.stmt arranged for a copy of the array/slice variable if needed.
   116  		ha := a
   117  
   118  		hv1 := typecheck.TempAt(base.Pos, w.curfunc, types.Types[types.TINT])
   119  		hn := typecheck.TempAt(base.Pos, w.curfunc, types.Types[types.TINT])
   120  
   121  		init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
   122  		init = append(init, ir.NewAssignStmt(base.Pos, hn, ir.NewUnaryExpr(base.Pos, ir.OLEN, ha)))
   123  
   124  		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, hn)
   125  		nfor.Post = ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, ir.NewInt(base.Pos, 1)))
   126  
   127  		// for range ha { body }
   128  		if v1 == nil {
   129  			break
   130  		}
   131  
   132  		// for v1 := range ha { body }
   133  		if v2 == nil {
   134  			body = []ir.Node{rangeAssign(nrange, hv1)}
   135  			break
   136  		}
   137  
   138  		// for v1, v2 := range ha { body }
   139  		if cheapComputableIndex(elem.Size()) {
   140  			// v1, v2 = hv1, ha[hv1]
   141  			tmp := ir.NewIndexExpr(base.Pos, ha, hv1)
   142  			tmp.SetBounded(true)
   143  			body = []ir.Node{rangeAssign2(nrange, hv1, tmp)}
   144  			break
   145  		}
   146  
   147  		// Slice to iterate over
   148  		var hs ir.Node
   149  		if t.IsSlice() {
   150  			hs = ha
   151  		} else {
   152  			var arr ir.Node
   153  			if t.IsPtr() {
   154  				arr = ha
   155  			} else {
   156  				arr = typecheck.NodAddr(ha)
   157  				arr.SetType(t.PtrTo())
   158  				arr.SetTypecheck(1)
   159  			}
   160  			hs = ir.NewSliceExpr(base.Pos, ir.OSLICEARR, arr, nil, nil, nil)
   161  			// old typechecker doesn't know OSLICEARR, so we set types explicitly
   162  			hs.SetType(types.NewSlice(elem))
   163  			hs.SetTypecheck(1)
   164  		}
   165  
   166  		// We use a "pointer" to keep track of where we are in the backing array
   167  		// of the slice hs. This pointer starts at hs.ptr and gets incremented
   168  		// by the element size each time through the loop.
   169  		//
   170  		// It's tricky, though, as on the last iteration this pointer gets
   171  		// incremented to point past the end of the backing array. We can't
   172  		// let the garbage collector see that final out-of-bounds pointer.
   173  		//
   174  		// To avoid this, we keep the "pointer" alternately in 2 variables, one
   175  		// pointer typed and one uintptr typed. Most of the time it lives in the
   176  		// regular pointer variable, but when it might be out of bounds (after it
   177  		// has been incremented, but before the loop condition has been checked)
   178  		// it lives briefly in the uintptr variable.
   179  		//
   180  		// hp contains the pointer version (of type *T, where T is the element type).
   181  		// It is guaranteed to always be in range, keeps the backing store alive,
   182  		// and is updated on stack copies. If a GC occurs when this function is
   183  		// suspended at any safepoint, this variable ensures correct operation.
   184  		//
   185  		// hu contains the equivalent uintptr version. It may point past the
   186  		// end, but doesn't keep the backing store alive and doesn't get updated
   187  		// on a stack copy. If a GC occurs while this function is on the top of
   188  		// the stack, then the last frame is scanned conservatively and hu will
   189  		// act as a reference to the backing array to ensure it is not collected.
   190  		//
   191  		// The "pointer" we're moving across the backing array lives in one
   192  		// or the other of hp and hu as the loop proceeds.
   193  		//
   194  		// hp is live during most of the body of the loop. But it isn't live
   195  		// at the very top of the loop, when we haven't checked i<n yet, and
   196  		// it could point off the end of the backing store.
   197  		// hu is live only at the very top and very bottom of the loop.
   198  		// In particular, only when it cannot possibly be live across a call.
   199  		//
   200  		// So we do
   201  		//   hu = uintptr(unsafe.Pointer(hs.ptr))
   202  		//   for i := 0; i < hs.len; i++ {
   203  		//     hp = (*T)(unsafe.Pointer(hu))
   204  		//     v1, v2 = i, *hp
   205  		//     ... body of loop ...
   206  		//     hu = uintptr(unsafe.Pointer(hp)) + elemsize
   207  		//   }
   208  		//
   209  		// Between the assignments to hu and the assignment back to hp, there
   210  		// must not be any calls.
   211  
   212  		// Pointer to current iteration position. Start on entry to the loop
   213  		// with the pointer in hu.
   214  		ptr := ir.NewUnaryExpr(base.Pos, ir.OSPTR, hs)
   215  		ptr.SetBounded(true)
   216  		huVal := ir.NewConvExpr(base.Pos, ir.OCONVNOP, types.Types[types.TUNSAFEPTR], ptr)
   217  		huVal = ir.NewConvExpr(base.Pos, ir.OCONVNOP, types.Types[types.TUINTPTR], huVal)
   218  		hu := typecheck.TempAt(base.Pos, w.curfunc, types.Types[types.TUINTPTR])
   219  		init = append(init, ir.NewAssignStmt(base.Pos, hu, huVal))
   220  
   221  		// Convert hu to hp at the top of the loop (after the condition has been checked).
   222  		hpVal := ir.NewConvExpr(base.Pos, ir.OCONVNOP, types.Types[types.TUNSAFEPTR], hu)
   223  		hpVal.SetCheckPtr(true) // disable checkptr on this conversion
   224  		hpVal = ir.NewConvExpr(base.Pos, ir.OCONVNOP, elem.PtrTo(), hpVal)
   225  		hp := typecheck.TempAt(base.Pos, w.curfunc, elem.PtrTo())
   226  		body = append(body, ir.NewAssignStmt(base.Pos, hp, hpVal))
   227  
   228  		// Assign variables on the LHS of the range statement. Use *hp to get the element.
   229  		e := ir.NewStarExpr(base.Pos, hp)
   230  		e.SetBounded(true)
   231  		a := rangeAssign2(nrange, hv1, e)
   232  		body = append(body, a)
   233  
   234  		// Advance pointer for next iteration of the loop.
   235  		// This reads from hp and writes to hu.
   236  		huVal = ir.NewConvExpr(base.Pos, ir.OCONVNOP, types.Types[types.TUNSAFEPTR], hp)
   237  		huVal = ir.NewConvExpr(base.Pos, ir.OCONVNOP, types.Types[types.TUINTPTR], huVal)
   238  		as := ir.NewAssignStmt(base.Pos, hu, ir.NewBinaryExpr(base.Pos, ir.OADD, huVal, ir.NewInt(base.Pos, elem.Size())))
   239  		nfor.Post = ir.NewBlockStmt(base.Pos, []ir.Node{nfor.Post, as})
   240  
   241  	case k == types.TMAP:
   242  		// order.stmt allocated the iterator for us.
   243  		// we only use a once, so no copy needed.
   244  		ha := a
   245  
   246  		hit := nrange.Prealloc
   247  		th := hit.Type()
   248  		// depends on layout of iterator struct.
   249  		// See cmd/compile/internal/reflectdata/map.go:MapIterType
   250  		keysym := th.Field(0).Sym
   251  		elemsym := th.Field(1).Sym // ditto
   252  		iterInit := "mapIterStart"
   253  		iterNext := "mapIterNext"
   254  
   255  		fn := typecheck.LookupRuntime(iterInit, t.Key(), t.Elem(), th)
   256  		init = append(init, w.mkcallstmt1(fn, reflectdata.RangeMapRType(base.Pos, nrange), ha, typecheck.NodAddr(hit)))
   257  		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym), typecheck.NodNil())
   258  
   259  		fn = typecheck.LookupRuntime(iterNext, th)
   260  		nfor.Post = w.mkcallstmt1(fn, typecheck.NodAddr(hit))
   261  
   262  		key := ir.NewStarExpr(base.Pos, typecheck.ConvNop(ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, keysym), types.NewPtr(t.Key())))
   263  		if v1 == nil {
   264  			body = nil
   265  		} else if v2 == nil {
   266  			body = []ir.Node{rangeAssign(nrange, key)}
   267  		} else {
   268  			elem := ir.NewStarExpr(base.Pos, typecheck.ConvNop(ir.NewSelectorExpr(base.Pos, ir.ODOT, hit, elemsym), types.NewPtr(t.Elem())))
   269  			body = []ir.Node{rangeAssign2(nrange, key, elem)}
   270  		}
   271  
   272  	case k == types.TCHAN:
   273  		// order.stmt arranged for a copy of the channel variable.
   274  		ha := a
   275  
   276  		hv1 := typecheck.TempAt(base.Pos, w.curfunc, t.Elem())
   277  		hv1.SetTypecheck(1)
   278  		if t.Elem().HasPointers() {
   279  			init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
   280  		}
   281  		hb := typecheck.TempAt(base.Pos, w.curfunc, types.Types[types.TBOOL])
   282  
   283  		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, hb, ir.NewBool(base.Pos, false))
   284  		lhs := []ir.Node{hv1, hb}
   285  		rhs := []ir.Node{ir.NewUnaryExpr(base.Pos, ir.ORECV, ha)}
   286  		a := ir.NewAssignListStmt(base.Pos, ir.OAS2RECV, lhs, rhs)
   287  		a.SetTypecheck(1)
   288  		nfor.Cond = ir.InitExpr([]ir.Node{a}, nfor.Cond)
   289  		if v1 == nil {
   290  			body = nil
   291  		} else {
   292  			body = []ir.Node{rangeAssign(nrange, hv1)}
   293  		}
   294  		// Zero hv1. This prevents hv1 from being the sole, inaccessible
   295  		// reference to an otherwise GC-able value during the next channel receive.
   296  		// See issue 15281.
   297  		body = append(body, ir.NewAssignStmt(base.Pos, hv1, nil))
   298  
   299  	case k == types.TSTRING:
   300  		// Transform string range statements like "for v1, v2 = range a" into
   301  		//
   302  		// ha := a
   303  		// for hv1 := 0; hv1 < len(ha); {
   304  		//   hv1t := hv1
   305  		//   hv2 := rune(ha[hv1])
   306  		//   if hv2 < utf8.RuneSelf {
   307  		//      hv1++
   308  		//   } else {
   309  		//      hv2, hv1 = decoderune(ha, hv1)
   310  		//   }
   311  		//   v1, v2 = hv1t, hv2
   312  		//   // original body
   313  		// }
   314  
   315  		// order.stmt arranged for a copy of the string variable.
   316  		ha := a
   317  
   318  		hv1 := typecheck.TempAt(base.Pos, w.curfunc, types.Types[types.TINT])
   319  		hv1t := typecheck.TempAt(base.Pos, w.curfunc, types.Types[types.TINT])
   320  		hv2 := typecheck.TempAt(base.Pos, w.curfunc, types.RuneType)
   321  
   322  		// hv1 := 0
   323  		init = append(init, ir.NewAssignStmt(base.Pos, hv1, nil))
   324  
   325  		// hv1 < len(ha)
   326  		nfor.Cond = ir.NewBinaryExpr(base.Pos, ir.OLT, hv1, ir.NewUnaryExpr(base.Pos, ir.OLEN, ha))
   327  
   328  		if v1 != nil {
   329  			// hv1t = hv1
   330  			body = append(body, ir.NewAssignStmt(base.Pos, hv1t, hv1))
   331  		}
   332  
   333  		// hv2 := rune(ha[hv1])
   334  		nind := ir.NewIndexExpr(base.Pos, ha, hv1)
   335  		nind.SetBounded(true)
   336  		body = append(body, ir.NewAssignStmt(base.Pos, hv2, typecheck.Conv(nind, types.RuneType)))
   337  
   338  		// if hv2 < utf8.RuneSelf
   339  		nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
   340  
   341  		// On x86, hv2 <= 127 is shorter to encode than hv2 < 128
   342  		// Doesn't hurt other archs.
   343  		nif.Cond = ir.NewBinaryExpr(base.Pos, ir.OLE, hv2, ir.NewInt(base.Pos, utf8.RuneSelf-1))
   344  
   345  		// hv1++
   346  		nif.Body = []ir.Node{ir.NewAssignStmt(base.Pos, hv1, ir.NewBinaryExpr(base.Pos, ir.OADD, hv1, ir.NewInt(base.Pos, 1)))}
   347  
   348  		// } else {
   349  		// hv2, hv1 = decoderune(ha, hv1)
   350  		fn := typecheck.LookupRuntime("decoderune")
   351  		// decoderune expects a uint, but hv1 is an int.
   352  		// This is safe because hv1 is always >= 0.
   353  		call := w.mkcall1(fn, fn.Type().ResultsTuple(), &nif.Else, ha, hv1)
   354  		a := ir.NewAssignListStmt(base.Pos, ir.OAS2, []ir.Node{hv2, hv1}, []ir.Node{call})
   355  		nif.Else.Append(a)
   356  
   357  		body = append(body, nif)
   358  
   359  		if v1 != nil {
   360  			if v2 != nil {
   361  				// v1, v2 = hv1t, hv2
   362  				body = append(body, rangeAssign2(nrange, hv1t, hv2))
   363  			} else {
   364  				// v1 = hv1t
   365  				body = append(body, rangeAssign(nrange, hv1t))
   366  			}
   367  		}
   368  	}
   369  
   370  	typecheck.Stmts(init)
   371  
   372  	nfor.PtrInit().Append(init...)
   373  
   374  	typecheck.Stmts(nfor.Cond.Init())
   375  
   376  	nfor.Cond = typecheck.Expr(nfor.Cond)
   377  	nfor.Cond = typecheck.DefaultLit(nfor.Cond, nil)
   378  	nfor.Post = typecheck.Stmt(nfor.Post)
   379  	typecheck.Stmts(body)
   380  	nfor.Body.Append(body...)
   381  	nfor.Body.Append(nrange.Body...)
   382  
   383  	var n ir.Node = nfor
   384  
   385  	n = w.walkStmt(n)
   386  
   387  	base.Pos = lno
   388  	return n
   389  }
   390  
   391  // rangeAssign returns "n.Key = key".
   392  func rangeAssign(n *ir.RangeStmt, key ir.Node) ir.Node {
   393  	key = rangeConvert(n, n.Key.Type(), key, n.KeyTypeWord, n.KeySrcRType)
   394  	return ir.NewAssignStmt(n.Pos(), n.Key, key)
   395  }
   396  
   397  // rangeAssign2 returns "n.Key, n.Value = key, value".
   398  func rangeAssign2(n *ir.RangeStmt, key, value ir.Node) ir.Node {
   399  	// Use OAS2 to correctly handle assignments
   400  	// of the form "v1, a[v1] = range".
   401  	key = rangeConvert(n, n.Key.Type(), key, n.KeyTypeWord, n.KeySrcRType)
   402  	value = rangeConvert(n, n.Value.Type(), value, n.ValueTypeWord, n.ValueSrcRType)
   403  	return ir.NewAssignListStmt(n.Pos(), ir.OAS2, []ir.Node{n.Key, n.Value}, []ir.Node{key, value})
   404  }
   405  
   406  // rangeConvert returns src, converted to dst if necessary. If a
   407  // conversion is necessary, then typeWord and srcRType are copied to
   408  // their respective ConvExpr fields.
   409  func rangeConvert(nrange *ir.RangeStmt, dst *types.Type, src, typeWord, srcRType ir.Node) ir.Node {
   410  	src = typecheck.Expr(src)
   411  	if dst.Kind() == types.TBLANK || types.Identical(dst, src.Type()) {
   412  		return src
   413  	}
   414  
   415  	n := ir.NewConvExpr(nrange.Pos(), ir.OCONV, dst, src)
   416  	n.TypeWord = typeWord
   417  	n.SrcRType = srcRType
   418  	return typecheck.Expr(n)
   419  }
   420  
   421  // isMapClear checks if n is of the form:
   422  //
   423  //	for k := range m {
   424  //		delete(m, k)
   425  //	}
   426  //
   427  // where == for keys of map m is reflexive.
   428  func isMapClear(n *ir.RangeStmt) bool {
   429  	if base.Flag.N != 0 || base.Flag.Cfg.Instrumenting {
   430  		return false
   431  	}
   432  
   433  	t := n.X.Type()
   434  	if n.Op() != ir.ORANGE || t.Kind() != types.TMAP || n.Key == nil || n.Value != nil {
   435  		return false
   436  	}
   437  
   438  	k := n.Key
   439  	// Require k to be a new variable name.
   440  	if !ir.DeclaredBy(k, n) {
   441  		return false
   442  	}
   443  
   444  	if len(n.Body) != 1 {
   445  		return false
   446  	}
   447  
   448  	stmt := n.Body[0] // only stmt in body
   449  	if stmt == nil || stmt.Op() != ir.ODELETE {
   450  		return false
   451  	}
   452  
   453  	m := n.X
   454  	if delete := stmt.(*ir.CallExpr); !ir.SameSafeExpr(delete.Args[0], m) || !ir.SameSafeExpr(delete.Args[1], k) {
   455  		return false
   456  	}
   457  
   458  	// Keys where equality is not reflexive can not be deleted from maps.
   459  	if !types.IsReflexive(t.Key()) {
   460  		return false
   461  	}
   462  
   463  	return true
   464  }
   465  
   466  // mapRangeClear constructs a call to runtime.mapclear for the map range idiom.
   467  func (w *walkState) mapRangeClear(nrange *ir.RangeStmt) ir.Node {
   468  	m := nrange.X
   469  	origPos := ir.SetPos(m)
   470  	defer func() { base.Pos = origPos }()
   471  
   472  	return w.mapClear(m, reflectdata.RangeMapRType(base.Pos, nrange))
   473  }
   474  
   475  // mapClear constructs a call to runtime.mapclear for the map m.
   476  func (w *walkState) mapClear(m, rtyp ir.Node) ir.Node {
   477  	t := m.Type()
   478  
   479  	// instantiate mapclear(typ *type, hmap map[any]any)
   480  	fn := typecheck.LookupRuntime("mapclear", t.Key(), t.Elem())
   481  	n := w.mkcallstmt1(fn, rtyp, m)
   482  	return typecheck.Stmt(n)
   483  }
   484  
   485  // arrayRangeClearTargetSafe reports whether evaluating n once before the loop
   486  // produces the same clear target as evaluating it on every loop iteration.
   487  func arrayRangeClearTargetSafe(n ir.Node) bool {
   488  	if !n.Type().IsArray() {
   489  		return !ir.Any(n, readsMemory)
   490  	}
   491  
   492  	return arrayRangeClearAddressSafe(n)
   493  }
   494  
   495  // arrayRangeClearAddressSafe reports whether n's address is stable. Pointer
   496  // and slice values used to compute the address must not be reloadable from
   497  // memory that an earlier loop iteration could overwrite.
   498  func arrayRangeClearAddressSafe(n ir.Node) bool {
   499  	switch n.Op() {
   500  	case ir.ONAME:
   501  		return true
   502  	case ir.ODOT:
   503  		return arrayRangeClearAddressSafe(n.(*ir.SelectorExpr).X)
   504  	case ir.ODOTPTR:
   505  		return !ir.Any(n.(*ir.SelectorExpr).X, readsMemory)
   506  	case ir.ODEREF:
   507  		return !ir.Any(n.(*ir.StarExpr).X, readsMemory)
   508  	case ir.OINDEX:
   509  		n := n.(*ir.IndexExpr)
   510  		var baseSafe bool
   511  		if n.X.Type().IsArray() {
   512  			baseSafe = arrayRangeClearAddressSafe(n.X)
   513  		} else {
   514  			baseSafe = !ir.Any(n.X, readsMemory)
   515  		}
   516  		return baseSafe && !ir.Any(n.Index, readsMemory)
   517  	case ir.OCONVNOP:
   518  		return arrayRangeClearAddressSafe(n.(*ir.ConvExpr).X)
   519  	}
   520  	return false
   521  }
   522  
   523  // Lower n into runtime·memclr if possible, for
   524  // fast zeroing of slices and arrays (issue 5373).
   525  // Look for instances of
   526  //
   527  //	for i := range a {
   528  //		a[i] = zero
   529  //	}
   530  //
   531  // in which the evaluation of a is side-effect-free.
   532  //
   533  // Parameters are as in walkRange: "for v1, v2 = range a".
   534  func (w *walkState) arrayRangeClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
   535  	if base.Flag.N != 0 || base.Flag.Cfg.Instrumenting {
   536  		return nil
   537  	}
   538  
   539  	if v1 == nil || v2 != nil {
   540  		return nil
   541  	}
   542  
   543  	if len(loop.Body) != 1 || loop.Body[0] == nil {
   544  		return nil
   545  	}
   546  
   547  	stmt1 := loop.Body[0] // only stmt in body
   548  	if stmt1.Op() != ir.OAS {
   549  		return nil
   550  	}
   551  	stmt := stmt1.(*ir.AssignStmt)
   552  	if !ir.IsZero(stmt.Y) {
   553  		return nil
   554  	}
   555  	if stmt.X.Op() != ir.OINDEX {
   556  		return nil
   557  	}
   558  	lhs := stmt.X.(*ir.IndexExpr)
   559  	x := lhs.X
   560  	if !ir.SameSafeExpr(lhs.Index, v1) {
   561  		return nil
   562  	}
   563  	// arrayClear evaluates x only once. Reject side effects and target selectors
   564  	// that could be modified by one of the loop assignments.
   565  	if !ir.SameSafeExpr(x, x) || !arrayRangeClearTargetSafe(x) {
   566  		return nil
   567  	}
   568  	// The range loop assigns a new value to v1 before each iteration, so the
   569  	// clear target must not use v1 directly or indirectly (issue 80519).
   570  	name, ok := v1.(*ir.Name)
   571  	if !ok || !name.OnStack() || name.Addrtaken() || ir.Any(x, func(n ir.Node) bool { return ir.Uses(n, name) }) {
   572  		return nil
   573  	}
   574  
   575  	// Get constant number of iterations for int and array cases.
   576  	n := int64(-1)
   577  	if ir.IsConst(a, constant.Int) {
   578  		n = ir.Int64Val(a)
   579  	} else if a.Type().IsArray() {
   580  		n = a.Type().NumElem()
   581  	} else if a.Type().IsPtr() && a.Type().Elem().IsArray() {
   582  		n = a.Type().Elem().NumElem()
   583  	}
   584  
   585  	if n >= 0 {
   586  		// Int/Array case.
   587  		if !x.Type().IsArray() {
   588  			return nil
   589  		}
   590  		if x.Type().NumElem() != n {
   591  			return nil
   592  		}
   593  	} else {
   594  		// Slice case.
   595  		if !ir.SameSafeExpr(x, a) {
   596  			return nil
   597  		}
   598  	}
   599  
   600  	return w.arrayClear(stmt.Pos(), x, loop)
   601  }
   602  
   603  // arrayClear constructs a call to runtime.memclr for fast zeroing of slices and arrays.
   604  func (w *walkState) arrayClear(wbPos src.XPos, a ir.Node, nrange *ir.RangeStmt) ir.Node {
   605  	elemsize := typecheck.RangeExprType(a.Type()).Elem().Size()
   606  	if elemsize <= 0 {
   607  		return nil
   608  	}
   609  
   610  	// Convert to
   611  	// if ln := len(a); ln != 0 {
   612  	// 	hp = &a[0]
   613  	// 	hn = len(a)*sizeof(elem(a))
   614  	// 	memclr{NoHeap,Has}Pointers(hp, hn)
   615  	// 	i = ln - 1
   616  	// }
   617  	n := ir.NewIfStmt(base.Pos, nil, nil, nil)
   618  	ln := typecheck.TempAt(base.Pos, w.curfunc, types.Types[types.TINT])
   619  	as := ir.NewAssignStmt(base.Pos, ln, ir.NewUnaryExpr(base.Pos, ir.OLEN, a))
   620  	n.PtrInit().Append(typecheck.Stmt(as))
   621  	n.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, ln, ir.NewInt(base.Pos, 0))
   622  
   623  	// hp = &a[0]
   624  	hp := typecheck.TempAt(base.Pos, w.curfunc, types.Types[types.TUNSAFEPTR])
   625  
   626  	ix := ir.NewIndexExpr(base.Pos, a, ir.NewInt(base.Pos, 0))
   627  	ix.SetBounded(true)
   628  	addr := typecheck.ConvNop(typecheck.NodAddr(ix), types.Types[types.TUNSAFEPTR])
   629  	n.Body.Append(ir.NewAssignStmt(base.Pos, hp, addr))
   630  
   631  	// hn = len(a) * sizeof(elem(a))
   632  	hn := typecheck.TempAt(base.Pos, w.curfunc, types.Types[types.TUINTPTR])
   633  	mul := typecheck.Conv(ir.NewBinaryExpr(base.Pos, ir.OMUL, ln, ir.NewInt(base.Pos, elemsize)), types.Types[types.TUINTPTR])
   634  	n.Body.Append(ir.NewAssignStmt(base.Pos, hn, mul))
   635  
   636  	var fn ir.Node
   637  	if a.Type().Elem().HasPointers() {
   638  		// memclrHasPointers(hp, hn)
   639  		w.curfunc.SetWBPos(wbPos)
   640  		fn = w.mkcallstmt("memclrHasPointers", hp, hn)
   641  	} else {
   642  		// memclrNoHeapPointers(hp, hn)
   643  		fn = w.mkcallstmt("memclrNoHeapPointers", hp, hn)
   644  	}
   645  
   646  	n.Body.Append(fn)
   647  
   648  	// For array range clear, also set "i = len(a) - 1"
   649  	if nrange != nil {
   650  		idx := ir.NewAssignStmt(base.Pos, nrange.Key, typecheck.Conv(ir.NewBinaryExpr(base.Pos, ir.OSUB, ln, ir.NewInt(base.Pos, 1)), nrange.Key.Type()))
   651  		n.Body.Append(idx)
   652  	}
   653  
   654  	n.Cond = typecheck.Expr(n.Cond)
   655  	n.Cond = typecheck.DefaultLit(n.Cond, nil)
   656  	typecheck.Stmts(n.Body)
   657  	return w.walkStmt(n)
   658  }
   659
View as plain text