memcombine.go

Documentation: cmd/compile/internal/ssa

     1  // Copyright 2023 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 ssa
     6  
     7  import (
     8  	"cmd/compile/internal/base"
     9  	"cmd/compile/internal/types"
    10  	"cmd/internal/src"
    11  	"sort"
    12  )
    13  
    14  // memcombine combines smaller loads and stores into larger ones.
    15  // We ensure this generates good code for encoding/binary operations.
    16  // It may help other cases also.
    17  func memcombine(f *Func) {
    18  	// This optimization requires that the architecture has
    19  	// unaligned loads and unaligned stores.
    20  	if !f.Config.unalignedOK {
    21  		return
    22  	}
    23  
    24  	memcombineLoads(f)
    25  	memcombineStores(f)
    26  }
    27  
    28  func memcombineLoads(f *Func) {
    29  	// Find "OR trees" to start with.
    30  	mark := f.newSparseSet(f.NumValues())
    31  	defer f.retSparseSet(mark)
    32  	var order []*Value
    33  
    34  	// Mark all values that are the argument of an OR.
    35  	for _, b := range f.Blocks {
    36  		for _, v := range b.Values {
    37  			if v.Op == OpOr16 || v.Op == OpOr32 || v.Op == OpOr64 {
    38  				mark.add(v.Args[0].ID)
    39  				mark.add(v.Args[1].ID)
    40  			}
    41  		}
    42  	}
    43  	for _, b := range f.Blocks {
    44  		order = order[:0]
    45  		for _, v := range b.Values {
    46  			if v.Op != OpOr16 && v.Op != OpOr32 && v.Op != OpOr64 {
    47  				continue
    48  			}
    49  			if mark.contains(v.ID) {
    50  				// marked - means it is not the root of an OR tree
    51  				continue
    52  			}
    53  			// Add the OR tree rooted at v to the order.
    54  			// We use BFS here, but any walk that puts roots before leaves would work.
    55  			i := len(order)
    56  			order = append(order, v)
    57  			for ; i < len(order); i++ {
    58  				x := order[i]
    59  				for j := 0; j < 2; j++ {
    60  					a := x.Args[j]
    61  					if a.Op == OpOr16 || a.Op == OpOr32 || a.Op == OpOr64 {
    62  						order = append(order, a)
    63  					}
    64  				}
    65  			}
    66  		}
    67  		for _, v := range order {
    68  			max := f.Config.RegSize
    69  			switch v.Op {
    70  			case OpOr64:
    71  			case OpOr32:
    72  				max = 4
    73  			case OpOr16:
    74  				max = 2
    75  			default:
    76  				continue
    77  			}
    78  			for n := max; n > 1; n /= 2 {
    79  				if combineLoads(v, n) {
    80  					break
    81  				}
    82  			}
    83  		}
    84  	}
    85  }
    86  
    87  // A BaseAddress represents the address ptr+idx, where
    88  // ptr is a pointer type and idx is an integer type.
    89  // idx may be nil, in which case it is treated as 0.
    90  type BaseAddress struct {
    91  	ptr *Value
    92  	idx *Value
    93  }
    94  
    95  // splitPtr returns the base address of ptr and any
    96  // constant offset from that base.
    97  // BaseAddress{ptr,nil},0 is always a valid result, but splitPtr
    98  // tries to peel away as many constants into off as possible.
    99  func splitPtr(ptr *Value) (BaseAddress, int64) {
   100  	var idx *Value
   101  	var off int64
   102  	for {
   103  		if ptr.Op == OpOffPtr {
   104  			off += ptr.AuxInt
   105  			ptr = ptr.Args[0]
   106  		} else if ptr.Op == OpAddPtr {
   107  			if idx != nil {
   108  				// We have two or more indexing values.
   109  				// Pick the first one we found.
   110  				return BaseAddress{ptr: ptr, idx: idx}, off
   111  			}
   112  			idx = ptr.Args[1]
   113  			if idx.Op == OpAdd32 || idx.Op == OpAdd64 {
   114  				if idx.Args[0].Op == OpConst32 || idx.Args[0].Op == OpConst64 {
   115  					off += idx.Args[0].AuxInt
   116  					idx = idx.Args[1]
   117  				} else if idx.Args[1].Op == OpConst32 || idx.Args[1].Op == OpConst64 {
   118  					off += idx.Args[1].AuxInt
   119  					idx = idx.Args[0]
   120  				}
   121  			}
   122  			ptr = ptr.Args[0]
   123  		} else {
   124  			return BaseAddress{ptr: ptr, idx: idx}, off
   125  		}
   126  	}
   127  }
   128  
   129  func combineLoads(root *Value, n int64) bool {
   130  	orOp := root.Op
   131  	var shiftOp Op
   132  	switch orOp {
   133  	case OpOr64:
   134  		shiftOp = OpLsh64x64
   135  	case OpOr32:
   136  		shiftOp = OpLsh32x64
   137  	case OpOr16:
   138  		shiftOp = OpLsh16x64
   139  	default:
   140  		return false
   141  	}
   142  
   143  	// Find n values that are ORed together with the above op.
   144  	a := make([]*Value, 0, 8)
   145  	a = append(a, root)
   146  	for i := 0; i < len(a) && int64(len(a)) < n; i++ {
   147  		v := a[i]
   148  		if v.Uses != 1 && v != root {
   149  			// Something in this subtree is used somewhere else.
   150  			return false
   151  		}
   152  		if v.Op == orOp {
   153  			a[i] = v.Args[0]
   154  			a = append(a, v.Args[1])
   155  			i--
   156  		}
   157  	}
   158  	if int64(len(a)) != n {
   159  		return false
   160  	}
   161  
   162  	// Check that the first entry to see what ops we're looking for.
   163  	// All the entries should be of the form shift(extend(load)), maybe with no shift.
   164  	v := a[0]
   165  	if v.Op == shiftOp {
   166  		v = v.Args[0]
   167  	}
   168  	var extOp Op
   169  	if orOp == OpOr64 && (v.Op == OpZeroExt8to64 || v.Op == OpZeroExt16to64 || v.Op == OpZeroExt32to64) ||
   170  		orOp == OpOr32 && (v.Op == OpZeroExt8to32 || v.Op == OpZeroExt16to32) ||
   171  		orOp == OpOr16 && v.Op == OpZeroExt8to16 {
   172  		extOp = v.Op
   173  		v = v.Args[0]
   174  	} else {
   175  		return false
   176  	}
   177  	if v.Op != OpLoad {
   178  		return false
   179  	}
   180  	base, _ := splitPtr(v.Args[0])
   181  	mem := v.Args[1]
   182  	size := v.Type.Size()
   183  
   184  	if root.Block.Func.Config.arch == "S390X" {
   185  		// s390x can't handle unaligned accesses to global variables.
   186  		if base.ptr.Op == OpAddr {
   187  			return false
   188  		}
   189  	}
   190  
   191  	// Check all the entries, extract useful info.
   192  	type LoadRecord struct {
   193  		load   *Value
   194  		offset int64 // offset of load address from base
   195  		shift  int64
   196  	}
   197  	r := make([]LoadRecord, n, 8)
   198  	for i := int64(0); i < n; i++ {
   199  		v := a[i]
   200  		if v.Uses != 1 {
   201  			return false
   202  		}
   203  		shift := int64(0)
   204  		if v.Op == shiftOp {
   205  			if v.Args[1].Op != OpConst64 {
   206  				return false
   207  			}
   208  			shift = v.Args[1].AuxInt
   209  			v = v.Args[0]
   210  			if v.Uses != 1 {
   211  				return false
   212  			}
   213  		}
   214  		if v.Op != extOp {
   215  			return false
   216  		}
   217  		load := v.Args[0]
   218  		if load.Op != OpLoad {
   219  			return false
   220  		}
   221  		if load.Uses != 1 {
   222  			return false
   223  		}
   224  		if load.Args[1] != mem {
   225  			return false
   226  		}
   227  		p, off := splitPtr(load.Args[0])
   228  		if p != base {
   229  			return false
   230  		}
   231  		r[i] = LoadRecord{load: load, offset: off, shift: shift}
   232  	}
   233  
   234  	// Sort in memory address order.
   235  	sort.Slice(r, func(i, j int) bool {
   236  		return r[i].offset < r[j].offset
   237  	})
   238  
   239  	// Check that we have contiguous offsets.
   240  	for i := int64(0); i < n; i++ {
   241  		if r[i].offset != r[0].offset+i*size {
   242  			return false
   243  		}
   244  	}
   245  
   246  	// Check for reads in little-endian or big-endian order.
   247  	shift0 := r[0].shift
   248  	isLittleEndian := true
   249  	for i := int64(0); i < n; i++ {
   250  		if r[i].shift != shift0+i*size*8 {
   251  			isLittleEndian = false
   252  			break
   253  		}
   254  	}
   255  	isBigEndian := true
   256  	for i := int64(0); i < n; i++ {
   257  		if r[i].shift != shift0-i*size*8 {
   258  			isBigEndian = false
   259  			break
   260  		}
   261  	}
   262  	if !isLittleEndian && !isBigEndian {
   263  		return false
   264  	}
   265  
   266  	// Find a place to put the new load.
   267  	// This is tricky, because it has to be at a point where
   268  	// its memory argument is live. We can't just put it in root.Block.
   269  	// We use the block of the latest load.
   270  	loads := make([]*Value, n, 8)
   271  	for i := int64(0); i < n; i++ {
   272  		loads[i] = r[i].load
   273  	}
   274  	loadBlock := mergePoint(root.Block, loads...)
   275  	if loadBlock == nil {
   276  		return false
   277  	}
   278  	// Find a source position to use.
   279  	pos := src.NoXPos
   280  	for _, load := range loads {
   281  		if load.Block == loadBlock {
   282  			pos = load.Pos
   283  			break
   284  		}
   285  	}
   286  	if pos == src.NoXPos {
   287  		return false
   288  	}
   289  
   290  	// Check to see if we need byte swap before storing.
   291  	needSwap := isLittleEndian && root.Block.Func.Config.BigEndian ||
   292  		isBigEndian && !root.Block.Func.Config.BigEndian
   293  	if needSwap && (size != 1 || !root.Block.Func.Config.haveByteSwap(n)) {
   294  		return false
   295  	}
   296  
   297  	// This is the commit point.
   298  
   299  	// First, issue load at lowest address.
   300  	v = loadBlock.NewValue2(pos, OpLoad, sizeType(n*size), r[0].load.Args[0], mem)
   301  
   302  	// Byte swap if needed,
   303  	if needSwap {
   304  		v = byteSwap(loadBlock, pos, v)
   305  	}
   306  
   307  	// Extend if needed.
   308  	if n*size < root.Type.Size() {
   309  		v = zeroExtend(loadBlock, pos, v, n*size, root.Type.Size())
   310  	}
   311  
   312  	// Shift if needed.
   313  	if isLittleEndian && shift0 != 0 {
   314  		v = leftShift(loadBlock, pos, v, shift0)
   315  	}
   316  	if isBigEndian && shift0-(n-1)*size*8 != 0 {
   317  		v = leftShift(loadBlock, pos, v, shift0-(n-1)*size*8)
   318  	}
   319  
   320  	// Install with (Copy v).
   321  	root.reset(OpCopy)
   322  	root.AddArg(v)
   323  
   324  	// Clobber the loads, just to prevent additional work being done on
   325  	// subtrees (which are now unreachable).
   326  	for i := int64(0); i < n; i++ {
   327  		clobber(r[i].load)
   328  	}
   329  	return true
   330  }
   331  
   332  func memcombineStores(f *Func) {
   333  	mark := f.newSparseSet(f.NumValues())
   334  	defer f.retSparseSet(mark)
   335  	var order []*Value
   336  
   337  	for _, b := range f.Blocks {
   338  		// Mark all stores which are not last in a store sequence.
   339  		mark.clear()
   340  		for _, v := range b.Values {
   341  			if v.Op == OpStore {
   342  				mark.add(v.MemoryArg().ID)
   343  			}
   344  		}
   345  
   346  		// pick an order for visiting stores such that
   347  		// later stores come earlier in the ordering.
   348  		order = order[:0]
   349  		for _, v := range b.Values {
   350  			if v.Op != OpStore {
   351  				continue
   352  			}
   353  			if mark.contains(v.ID) {
   354  				continue // not last in a chain of stores
   355  			}
   356  			for {
   357  				order = append(order, v)
   358  				v = v.Args[2]
   359  				if v.Block != b || v.Op != OpStore {
   360  					break
   361  				}
   362  			}
   363  		}
   364  
   365  		// Look for combining opportunities at each store in queue order.
   366  		for _, v := range order {
   367  			if v.Op != OpStore { // already rewritten
   368  				continue
   369  			}
   370  
   371  			size := v.Aux.(*types.Type).Size()
   372  			if size >= f.Config.RegSize || size == 0 {
   373  				continue
   374  			}
   375  
   376  			for n := f.Config.RegSize / size; n > 1; n /= 2 {
   377  				if combineStores(v, n) {
   378  					continue
   379  				}
   380  			}
   381  		}
   382  	}
   383  }
   384  
   385  // Try to combine the n stores ending in root.
   386  // Returns true if successful.
   387  func combineStores(root *Value, n int64) bool {
   388  	// Helper functions.
   389  	type StoreRecord struct {
   390  		store  *Value
   391  		offset int64
   392  	}
   393  	getShiftBase := func(a []StoreRecord) *Value {
   394  		x := a[0].store.Args[1]
   395  		y := a[1].store.Args[1]
   396  		switch x.Op {
   397  		case OpTrunc64to8, OpTrunc64to16, OpTrunc64to32, OpTrunc32to8, OpTrunc32to16, OpTrunc16to8:
   398  			x = x.Args[0]
   399  		default:
   400  			return nil
   401  		}
   402  		switch y.Op {
   403  		case OpTrunc64to8, OpTrunc64to16, OpTrunc64to32, OpTrunc32to8, OpTrunc32to16, OpTrunc16to8:
   404  			y = y.Args[0]
   405  		default:
   406  			return nil
   407  		}
   408  		var x2 *Value
   409  		switch x.Op {
   410  		case OpRsh64Ux64, OpRsh32Ux64, OpRsh16Ux64:
   411  			x2 = x.Args[0]
   412  		default:
   413  		}
   414  		var y2 *Value
   415  		switch y.Op {
   416  		case OpRsh64Ux64, OpRsh32Ux64, OpRsh16Ux64:
   417  			y2 = y.Args[0]
   418  		default:
   419  		}
   420  		if y2 == x {
   421  			// a shift of x and x itself.
   422  			return x
   423  		}
   424  		if x2 == y {
   425  			// a shift of y and y itself.
   426  			return y
   427  		}
   428  		if x2 == y2 {
   429  			// 2 shifts both of the same argument.
   430  			return x2
   431  		}
   432  		return nil
   433  	}
   434  	isShiftBase := func(v, base *Value) bool {
   435  		val := v.Args[1]
   436  		switch val.Op {
   437  		case OpTrunc64to8, OpTrunc64to16, OpTrunc64to32, OpTrunc32to8, OpTrunc32to16, OpTrunc16to8:
   438  			val = val.Args[0]
   439  		default:
   440  			return false
   441  		}
   442  		if val == base {
   443  			return true
   444  		}
   445  		switch val.Op {
   446  		case OpRsh64Ux64, OpRsh32Ux64, OpRsh16Ux64:
   447  			val = val.Args[0]
   448  		default:
   449  			return false
   450  		}
   451  		return val == base
   452  	}
   453  	shift := func(v, base *Value) int64 {
   454  		val := v.Args[1]
   455  		switch val.Op {
   456  		case OpTrunc64to8, OpTrunc64to16, OpTrunc64to32, OpTrunc32to8, OpTrunc32to16, OpTrunc16to8:
   457  			val = val.Args[0]
   458  		default:
   459  			return -1
   460  		}
   461  		if val == base {
   462  			return 0
   463  		}
   464  		switch val.Op {
   465  		case OpRsh64Ux64, OpRsh32Ux64, OpRsh16Ux64:
   466  			val = val.Args[1]
   467  		default:
   468  			return -1
   469  		}
   470  		if val.Op != OpConst64 {
   471  			return -1
   472  		}
   473  		return val.AuxInt
   474  	}
   475  
   476  	// Element size of the individual stores.
   477  	size := root.Aux.(*types.Type).Size()
   478  	if size*n > root.Block.Func.Config.RegSize {
   479  		return false
   480  	}
   481  
   482  	// Gather n stores to look at. Check easy conditions we require.
   483  	a := make([]StoreRecord, 0, 8)
   484  	rbase, roff := splitPtr(root.Args[0])
   485  	if root.Block.Func.Config.arch == "S390X" {
   486  		// s390x can't handle unaligned accesses to global variables.
   487  		if rbase.ptr.Op == OpAddr {
   488  			return false
   489  		}
   490  	}
   491  	a = append(a, StoreRecord{root, roff})
   492  	for i, x := int64(1), root.Args[2]; i < n; i, x = i+1, x.Args[2] {
   493  		if x.Op != OpStore {
   494  			return false
   495  		}
   496  		if x.Block != root.Block {
   497  			return false
   498  		}
   499  		if x.Uses != 1 { // Note: root can have more than one use.
   500  			return false
   501  		}
   502  		if x.Aux.(*types.Type).Size() != size {
   503  			// TODO: the constant source and consecutive load source cases
   504  			// do not need all the stores to be the same size.
   505  			return false
   506  		}
   507  		base, off := splitPtr(x.Args[0])
   508  		if base != rbase {
   509  			return false
   510  		}
   511  		a = append(a, StoreRecord{x, off})
   512  	}
   513  	// Before we sort, grab the memory arg the result should have.
   514  	mem := a[n-1].store.Args[2]
   515  	// Also grab position of first store (last in array = first in memory order).
   516  	pos := a[n-1].store.Pos
   517  
   518  	// Sort stores in increasing address order.
   519  	sort.Slice(a, func(i, j int) bool {
   520  		return a[i].offset < a[j].offset
   521  	})
   522  
   523  	// Check that everything is written to sequential locations.
   524  	for i := int64(0); i < n; i++ {
   525  		if a[i].offset != a[0].offset+i*size {
   526  			return false
   527  		}
   528  	}
   529  
   530  	// Memory location we're going to write at (the lowest one).
   531  	ptr := a[0].store.Args[0]
   532  
   533  	// Check for constant stores
   534  	isConst := true
   535  	for i := int64(0); i < n; i++ {
   536  		switch a[i].store.Args[1].Op {
   537  		case OpConst32, OpConst16, OpConst8, OpConstBool:
   538  		default:
   539  			isConst = false
   540  			break
   541  		}
   542  	}
   543  	if isConst {
   544  		// Modify root to do all the stores.
   545  		var c int64
   546  		mask := int64(1)<<(8*size) - 1
   547  		for i := int64(0); i < n; i++ {
   548  			s := 8 * size * int64(i)
   549  			if root.Block.Func.Config.BigEndian {
   550  				s = 8*size*(n-1) - s
   551  			}
   552  			c |= (a[i].store.Args[1].AuxInt & mask) << s
   553  		}
   554  		var cv *Value
   555  		switch size * n {
   556  		case 2:
   557  			cv = root.Block.Func.ConstInt16(types.Types[types.TUINT16], int16(c))
   558  		case 4:
   559  			cv = root.Block.Func.ConstInt32(types.Types[types.TUINT32], int32(c))
   560  		case 8:
   561  			cv = root.Block.Func.ConstInt64(types.Types[types.TUINT64], c)
   562  		}
   563  
   564  		// Move all the stores to the root.
   565  		for i := int64(0); i < n; i++ {
   566  			v := a[i].store
   567  			if v == root {
   568  				v.Aux = cv.Type // widen store type
   569  				v.Pos = pos
   570  				v.SetArg(0, ptr)
   571  				v.SetArg(1, cv)
   572  				v.SetArg(2, mem)
   573  			} else {
   574  				clobber(v)
   575  				v.Type = types.Types[types.TBOOL] // erase memory type
   576  			}
   577  		}
   578  		return true
   579  	}
   580  
   581  	// Check for consecutive loads as the source of the stores.
   582  	var loadMem *Value
   583  	var loadBase BaseAddress
   584  	var loadIdx int64
   585  	for i := int64(0); i < n; i++ {
   586  		load := a[i].store.Args[1]
   587  		if load.Op != OpLoad {
   588  			loadMem = nil
   589  			break
   590  		}
   591  		if load.Uses != 1 {
   592  			loadMem = nil
   593  			break
   594  		}
   595  		if load.Type.IsPtr() {
   596  			// Don't combine stores containing a pointer, as we need
   597  			// a write barrier for those. This can't currently happen,
   598  			// but might in the future if we ever have another
   599  			// 8-byte-reg/4-byte-ptr architecture like amd64p32.
   600  			loadMem = nil
   601  			break
   602  		}
   603  		mem := load.Args[1]
   604  		base, idx := splitPtr(load.Args[0])
   605  		if loadMem == nil {
   606  			// First one we found
   607  			loadMem = mem
   608  			loadBase = base
   609  			loadIdx = idx
   610  			continue
   611  		}
   612  		if base != loadBase || mem != loadMem {
   613  			loadMem = nil
   614  			break
   615  		}
   616  		if idx != loadIdx+(a[i].offset-a[0].offset) {
   617  			loadMem = nil
   618  			break
   619  		}
   620  	}
   621  	if loadMem != nil {
   622  		// Modify the first load to do a larger load instead.
   623  		load := a[0].store.Args[1]
   624  		switch size * n {
   625  		case 2:
   626  			load.Type = types.Types[types.TUINT16]
   627  		case 4:
   628  			load.Type = types.Types[types.TUINT32]
   629  		case 8:
   630  			load.Type = types.Types[types.TUINT64]
   631  		}
   632  
   633  		// Modify root to do the store.
   634  		for i := int64(0); i < n; i++ {
   635  			v := a[i].store
   636  			if v == root {
   637  				v.Aux = load.Type // widen store type
   638  				v.Pos = pos
   639  				v.SetArg(0, ptr)
   640  				v.SetArg(1, load)
   641  				v.SetArg(2, mem)
   642  			} else {
   643  				clobber(v)
   644  				v.Type = types.Types[types.TBOOL] // erase memory type
   645  			}
   646  		}
   647  		return true
   648  	}
   649  
   650  	// Check that all the shift/trunc are of the same base value.
   651  	shiftBase := getShiftBase(a)
   652  	if shiftBase == nil {
   653  		return false
   654  	}
   655  	for i := int64(0); i < n; i++ {
   656  		if !isShiftBase(a[i].store, shiftBase) {
   657  			return false
   658  		}
   659  	}
   660  
   661  	// Check for writes in little-endian or big-endian order.
   662  	isLittleEndian := true
   663  	shift0 := shift(a[0].store, shiftBase)
   664  	for i := int64(1); i < n; i++ {
   665  		if shift(a[i].store, shiftBase) != shift0+i*size*8 {
   666  			isLittleEndian = false
   667  			break
   668  		}
   669  	}
   670  	isBigEndian := true
   671  	for i := int64(1); i < n; i++ {
   672  		if shift(a[i].store, shiftBase) != shift0-i*size*8 {
   673  			isBigEndian = false
   674  			break
   675  		}
   676  	}
   677  	if !isLittleEndian && !isBigEndian {
   678  		return false
   679  	}
   680  
   681  	// Check to see if we need byte swap before storing.
   682  	needSwap := isLittleEndian && root.Block.Func.Config.BigEndian ||
   683  		isBigEndian && !root.Block.Func.Config.BigEndian
   684  	if needSwap && (size != 1 || !root.Block.Func.Config.haveByteSwap(n)) {
   685  		return false
   686  	}
   687  
   688  	// This is the commit point.
   689  
   690  	// Modify root to do all the stores.
   691  	sv := shiftBase
   692  	if isLittleEndian && shift0 != 0 {
   693  		sv = rightShift(root.Block, root.Pos, sv, shift0)
   694  	}
   695  	if isBigEndian && shift0-(n-1)*size*8 != 0 {
   696  		sv = rightShift(root.Block, root.Pos, sv, shift0-(n-1)*size*8)
   697  	}
   698  	if sv.Type.Size() > size*n {
   699  		sv = truncate(root.Block, root.Pos, sv, sv.Type.Size(), size*n)
   700  	}
   701  	if needSwap {
   702  		sv = byteSwap(root.Block, root.Pos, sv)
   703  	}
   704  
   705  	// Move all the stores to the root.
   706  	for i := int64(0); i < n; i++ {
   707  		v := a[i].store
   708  		if v == root {
   709  			v.Aux = sv.Type // widen store type
   710  			v.Pos = pos
   711  			v.SetArg(0, ptr)
   712  			v.SetArg(1, sv)
   713  			v.SetArg(2, mem)
   714  		} else {
   715  			clobber(v)
   716  			v.Type = types.Types[types.TBOOL] // erase memory type
   717  		}
   718  	}
   719  	return true
   720  }
   721  
   722  func sizeType(size int64) *types.Type {
   723  	switch size {
   724  	case 8:
   725  		return types.Types[types.TUINT64]
   726  	case 4:
   727  		return types.Types[types.TUINT32]
   728  	case 2:
   729  		return types.Types[types.TUINT16]
   730  	default:
   731  		base.Fatalf("bad size %d\n", size)
   732  		return nil
   733  	}
   734  }
   735  
   736  func truncate(b *Block, pos src.XPos, v *Value, from, to int64) *Value {
   737  	switch from*10 + to {
   738  	case 82:
   739  		return b.NewValue1(pos, OpTrunc64to16, types.Types[types.TUINT16], v)
   740  	case 84:
   741  		return b.NewValue1(pos, OpTrunc64to32, types.Types[types.TUINT32], v)
   742  	case 42:
   743  		return b.NewValue1(pos, OpTrunc32to16, types.Types[types.TUINT16], v)
   744  	default:
   745  		base.Fatalf("bad sizes %d %d\n", from, to)
   746  		return nil
   747  	}
   748  }
   749  func zeroExtend(b *Block, pos src.XPos, v *Value, from, to int64) *Value {
   750  	switch from*10 + to {
   751  	case 24:
   752  		return b.NewValue1(pos, OpZeroExt16to32, types.Types[types.TUINT32], v)
   753  	case 28:
   754  		return b.NewValue1(pos, OpZeroExt16to64, types.Types[types.TUINT64], v)
   755  	case 48:
   756  		return b.NewValue1(pos, OpZeroExt32to64, types.Types[types.TUINT64], v)
   757  	default:
   758  		base.Fatalf("bad sizes %d %d\n", from, to)
   759  		return nil
   760  	}
   761  }
   762  
   763  func leftShift(b *Block, pos src.XPos, v *Value, shift int64) *Value {
   764  	s := b.Func.ConstInt64(types.Types[types.TUINT64], shift)
   765  	size := v.Type.Size()
   766  	switch size {
   767  	case 8:
   768  		return b.NewValue2(pos, OpLsh64x64, v.Type, v, s)
   769  	case 4:
   770  		return b.NewValue2(pos, OpLsh32x64, v.Type, v, s)
   771  	case 2:
   772  		return b.NewValue2(pos, OpLsh16x64, v.Type, v, s)
   773  	default:
   774  		base.Fatalf("bad size %d\n", size)
   775  		return nil
   776  	}
   777  }
   778  func rightShift(b *Block, pos src.XPos, v *Value, shift int64) *Value {
   779  	s := b.Func.ConstInt64(types.Types[types.TUINT64], shift)
   780  	size := v.Type.Size()
   781  	switch size {
   782  	case 8:
   783  		return b.NewValue2(pos, OpRsh64Ux64, v.Type, v, s)
   784  	case 4:
   785  		return b.NewValue2(pos, OpRsh32Ux64, v.Type, v, s)
   786  	case 2:
   787  		return b.NewValue2(pos, OpRsh16Ux64, v.Type, v, s)
   788  	default:
   789  		base.Fatalf("bad size %d\n", size)
   790  		return nil
   791  	}
   792  }
   793  func byteSwap(b *Block, pos src.XPos, v *Value) *Value {
   794  	switch v.Type.Size() {
   795  	case 8:
   796  		return b.NewValue1(pos, OpBswap64, v.Type, v)
   797  	case 4:
   798  		return b.NewValue1(pos, OpBswap32, v.Type, v)
   799  	case 2:
   800  		return b.NewValue1(pos, OpBswap16, v.Type, v)
   801  
   802  	default:
   803  		v.Fatalf("bad size %d\n", v.Type.Size())
   804  		return nil
   805  	}
   806  }
   807
View as plain text