shift.go

     1  // asmcheck
     2  
     3  // Copyright 2018 The Go Authors. All rights reserved.
     4  // Use of this source code is governed by a BSD-style
     5  // license that can be found in the LICENSE file.
     6  
     7  package codegen
     8  
     9  // ------------------ //
    10  //   constant shifts  //
    11  // ------------------ //
    12  
    13  func lshConst64x64(v int64) int64 {
    14  	// loong64:"SLLV"
    15  	// ppc64x:"SLD"
    16  	// riscv64:"SLLI",-"AND",-"SLTIU"
    17  	return v << uint64(33)
    18  }
    19  
    20  func rshConst64Ux64(v uint64) uint64 {
    21  	// loong64:"SRLV"
    22  	// ppc64x:"SRD"
    23  	// riscv64:"SRLI\t",-"AND",-"SLTIU"
    24  	return v >> uint64(33)
    25  }
    26  
    27  func rshConst64Ux64Overflow32(v uint32) uint64 {
    28  	// loong64:"MOVV\t\\$0,",-"SRL\t"
    29  	// riscv64:"MOV\t\\$0,",-"SRL"
    30  	return uint64(v) >> 32
    31  }
    32  
    33  func rshConst64Ux64Overflow16(v uint16) uint64 {
    34  	// loong64:"MOVV\t\\$0,",-"SRLV"
    35  	// riscv64:"MOV\t\\$0,",-"SRL"
    36  	return uint64(v) >> 16
    37  }
    38  
    39  func rshConst64Ux64Overflow8(v uint8) uint64 {
    40  	// loong64:"MOVV\t\\$0,",-"SRLV"
    41  	// riscv64:"MOV\t\\$0,",-"SRL"
    42  	return uint64(v) >> 8
    43  }
    44  
    45  func rshConst64x64(v int64) int64 {
    46  	// loong64:"SRAV"
    47  	// ppc64x:"SRAD"
    48  	// riscv64:"SRAI\t",-"OR",-"SLTIU"
    49  	return v >> uint64(33)
    50  }
    51  
    52  func rshConst64x64Overflow32(v int32) int64 {
    53  	// loong64:"SRA\t\\$31"
    54  	// riscv64:"SRAIW",-"SLLI",-"SRAI\t"
    55  	return int64(v) >> 32
    56  }
    57  
    58  func rshConst64x64Overflow16(v int16) int64 {
    59  	// loong64:"SLLV\t\\$48","SRAV\t\\$63"
    60  	// riscv64:"SLLI","SRAI",-"SRAIW"
    61  	return int64(v) >> 16
    62  }
    63  
    64  func rshConst64x64Overflow8(v int8) int64 {
    65  	// loong64:"SLLV\t\\$56","SRAV\t\\$63"
    66  	// riscv64:"SLLI","SRAI",-"SRAIW"
    67  	return int64(v) >> 8
    68  }
    69  
    70  func lshConst32x1(v int32) int32 {
    71  	// amd64:"ADDL", -"SHLL"
    72  	return v << 1
    73  }
    74  
    75  func lshConst64x1(v int64) int64 {
    76  	// amd64:"ADDQ", -"SHLQ"
    77  	return v << 1
    78  }
    79  
    80  func lshConst32x64(v int32) int32 {
    81  	// loong64:"SLL\t"
    82  	// ppc64x:"SLW"
    83  	// riscv64:"SLLI",-"AND",-"SLTIU", -"MOVW"
    84  	return v << uint64(29)
    85  }
    86  
    87  func rshConst32Ux64(v uint32) uint32 {
    88  	// loong64:"SRL\t"
    89  	// ppc64x:"SRW"
    90  	// riscv64:"SRLIW",-"AND",-"SLTIU", -"MOVW"
    91  	return v >> uint64(29)
    92  }
    93  
    94  func rshConst32x64(v int32) int32 {
    95  	// loong64:"SRA\t"
    96  	// ppc64x:"SRAW"
    97  	// riscv64:"SRAIW",-"OR",-"SLTIU", -"MOVW"
    98  	return v >> uint64(29)
    99  }
   100  
   101  func lshConst64x32(v int64) int64 {
   102  	// loong64:"SLLV"
   103  	// ppc64x:"SLD"
   104  	// riscv64:"SLLI",-"AND",-"SLTIU"
   105  	return v << uint32(33)
   106  }
   107  
   108  func rshConst64Ux32(v uint64) uint64 {
   109  	// loong64:"SRLV"
   110  	// ppc64x:"SRD"
   111  	// riscv64:"SRLI\t",-"AND",-"SLTIU"
   112  	return v >> uint32(33)
   113  }
   114  
   115  func rshConst64x32(v int64) int64 {
   116  	// loong64:"SRAV"
   117  	// ppc64x:"SRAD"
   118  	// riscv64:"SRAI\t",-"OR",-"SLTIU"
   119  	return v >> uint32(33)
   120  }
   121  
   122  func lshConst32x1Add(x int32) int32 {
   123  	// amd64:"SHLL\t[$]2"
   124  	return (x + x) << 1
   125  }
   126  
   127  func lshConst64x1Add(x int64) int64 {
   128  	// amd64:"SHLQ\t[$]2"
   129  	return (x + x) << 1
   130  }
   131  
   132  func lshConst32x2Add(x int32) int32 {
   133  	// amd64:"SHLL\t[$]3"
   134  	return (x + x) << 2
   135  }
   136  
   137  func lshConst64x2Add(x int64) int64 {
   138  	// amd64:"SHLQ\t[$]3"
   139  	return (x + x) << 2
   140  }
   141  
   142  // ------------------ //
   143  //   masked shifts    //
   144  // ------------------ //
   145  
   146  func lshMask64x64(v int64, s uint64) int64 {
   147  	// arm64:"LSL",-"AND"
   148  	// loong64:"SLLV",-"AND"
   149  	// ppc64x:"RLDICL",-"ORN",-"ISEL"
   150  	// riscv64:"SLL",-"AND\t",-"SLTIU"
   151  	// s390x:-"RISBGZ",-"AND",-"LOCGR"
   152  	return v << (s & 63)
   153  }
   154  
   155  func rshMask64Ux64(v uint64, s uint64) uint64 {
   156  	// arm64:"LSR",-"AND",-"CSEL"
   157  	// loong64:"SRLV",-"AND"
   158  	// ppc64x:"RLDICL",-"ORN",-"ISEL"
   159  	// riscv64:"SRL\t",-"AND\t",-"SLTIU"
   160  	// s390x:-"RISBGZ",-"AND",-"LOCGR"
   161  	return v >> (s & 63)
   162  }
   163  
   164  func rshMask64x64(v int64, s uint64) int64 {
   165  	// arm64:"ASR",-"AND",-"CSEL"
   166  	// loong64:"SRAV",-"AND"
   167  	// ppc64x:"RLDICL",-"ORN",-"ISEL"
   168  	// riscv64:"SRA\t",-"OR",-"SLTIU"
   169  	// s390x:-"RISBGZ",-"AND",-"LOCGR"
   170  	return v >> (s & 63)
   171  }
   172  
   173  func lshMask32x64(v int32, s uint64) int32 {
   174  	// arm64:"LSL",-"AND"
   175  	// loong64:"SLL\t","AND","SGTU","MASKEQZ"
   176  	// ppc64x:"ISEL",-"ORN"
   177  	// riscv64:"SLL",-"AND\t",-"SLTIU"
   178  	// s390x:-"RISBGZ",-"AND",-"LOCGR"
   179  	return v << (s & 63)
   180  }
   181  
   182  func lsh5Mask32x64(v int32, s uint64) int32 {
   183  	// loong64:"SLL\t",-"AND"
   184  	return v << (s & 31)
   185  }
   186  
   187  func rshMask32Ux64(v uint32, s uint64) uint32 {
   188  	// arm64:"LSR",-"AND"
   189  	// loong64:"SRL\t","AND","SGTU","MASKEQZ"
   190  	// ppc64x:"ISEL",-"ORN"
   191  	// riscv64:"SRLW","SLTIU","NEG","AND\t",-"SRL\t"
   192  	// s390x:-"RISBGZ",-"AND",-"LOCGR"
   193  	return v >> (s & 63)
   194  }
   195  
   196  func rsh5Mask32Ux64(v uint32, s uint64) uint32 {
   197  	// loong64:"SRL\t",-"AND"
   198  	// riscv64:"SRLW",-"AND\t",-"SLTIU",-"SRL\t"
   199  	return v >> (s & 31)
   200  }
   201  
   202  func rshMask32x64(v int32, s uint64) int32 {
   203  	// arm64:"ASR",-"AND"
   204  	// loong64:"SRA\t","AND","SGTU","SUBVU","OR"
   205  	// ppc64x:"ISEL",-"ORN"
   206  	// riscv64:"SRAW","OR","SLTIU"
   207  	// s390x:-"RISBGZ",-"AND",-"LOCGR"
   208  	return v >> (s & 63)
   209  }
   210  
   211  func rsh5Mask32x64(v int32, s uint64) int32 {
   212  	// loong64:"SRA\t",-"AND"
   213  	// riscv64:"SRAW",-"OR",-"SLTIU"
   214  	return v >> (s & 31)
   215  }
   216  
   217  func lshMask64x32(v int64, s uint32) int64 {
   218  	// arm64:"LSL",-"AND"
   219  	// loong64:"SLLV",-"AND"
   220  	// ppc64x:"RLDICL",-"ORN"
   221  	// riscv64:"SLL",-"AND\t",-"SLTIU"
   222  	// s390x:-"RISBGZ",-"AND",-"LOCGR"
   223  	return v << (s & 63)
   224  }
   225  
   226  func rshMask64Ux32(v uint64, s uint32) uint64 {
   227  	// arm64:"LSR",-"AND",-"CSEL"
   228  	// loong64:"SRLV",-"AND"
   229  	// ppc64x:"RLDICL",-"ORN"
   230  	// riscv64:"SRL\t",-"AND\t",-"SLTIU"
   231  	// s390x:-"RISBGZ",-"AND",-"LOCGR"
   232  	return v >> (s & 63)
   233  }
   234  
   235  func rshMask64x32(v int64, s uint32) int64 {
   236  	// arm64:"ASR",-"AND",-"CSEL"
   237  	// loong64:"SRAV",-"AND"
   238  	// ppc64x:"RLDICL",-"ORN",-"ISEL"
   239  	// riscv64:"SRA\t",-"OR",-"SLTIU"
   240  	// s390x:-"RISBGZ",-"AND",-"LOCGR"
   241  	return v >> (s & 63)
   242  }
   243  
   244  func lshMask64x32Ext(v int64, s int32) int64 {
   245  	// ppc64x:"RLDICL",-"ORN",-"ISEL"
   246  	// riscv64:"SLL",-"AND\t",-"SLTIU"
   247  	// s390x:-"RISBGZ",-"AND",-"LOCGR"
   248  	return v << uint(s&63)
   249  }
   250  
   251  func rshMask64Ux32Ext(v uint64, s int32) uint64 {
   252  	// ppc64x:"RLDICL",-"ORN",-"ISEL"
   253  	// riscv64:"SRL\t",-"AND\t",-"SLTIU"
   254  	// s390x:-"RISBGZ",-"AND",-"LOCGR"
   255  	return v >> uint(s&63)
   256  }
   257  
   258  func rshMask64x32Ext(v int64, s int32) int64 {
   259  	// ppc64x:"RLDICL",-"ORN",-"ISEL"
   260  	// riscv64:"SRA\t",-"OR",-"SLTIU"
   261  	// s390x:-"RISBGZ",-"AND",-"LOCGR"
   262  	return v >> uint(s&63)
   263  }
   264  
   265  // --------------- //
   266  //  signed shifts  //
   267  // --------------- //
   268  
   269  // We do want to generate a test + panicshift for these cases.
   270  func lshSigned(v8 int8, v16 int16, v32 int32, v64 int64, x int) {
   271  	// amd64:"TESTB"
   272  	_ = x << v8
   273  	// amd64:"TESTW"
   274  	_ = x << v16
   275  	// amd64:"TESTL"
   276  	_ = x << v32
   277  	// amd64:"TESTQ"
   278  	_ = x << v64
   279  }
   280  
   281  // We want to avoid generating a test + panicshift for these cases.
   282  func lshSignedMasked(v8 int8, v16 int16, v32 int32, v64 int64, x int) {
   283  	// amd64:-"TESTB"
   284  	_ = x << (v8 & 7)
   285  	// amd64:-"TESTW"
   286  	_ = x << (v16 & 15)
   287  	// amd64:-"TESTL"
   288  	_ = x << (v32 & 31)
   289  	// amd64:-"TESTQ"
   290  	_ = x << (v64 & 63)
   291  }
   292  
   293  // ------------------ //
   294  //   bounded shifts   //
   295  // ------------------ //
   296  
   297  func lshGuarded64(v int64, s uint) int64 {
   298  	if s < 64 {
   299  		// riscv64:"SLL",-"AND",-"SLTIU"
   300  		// s390x:-"RISBGZ",-"AND",-"LOCGR"
   301  		// wasm:-"Select",-".*LtU"
   302  		// arm64:"LSL",-"CSEL"
   303  		return v << s
   304  	}
   305  	panic("shift too large")
   306  }
   307  
   308  func rshGuarded64U(v uint64, s uint) uint64 {
   309  	if s < 64 {
   310  		// riscv64:"SRL\t",-"AND",-"SLTIU"
   311  		// s390x:-"RISBGZ",-"AND",-"LOCGR"
   312  		// wasm:-"Select",-".*LtU"
   313  		// arm64:"LSR",-"CSEL"
   314  		return v >> s
   315  	}
   316  	panic("shift too large")
   317  }
   318  
   319  func rshGuarded64(v int64, s uint) int64 {
   320  	if s < 64 {
   321  		// riscv64:"SRA\t",-"OR",-"SLTIU"
   322  		// s390x:-"RISBGZ",-"AND",-"LOCGR"
   323  		// wasm:-"Select",-".*LtU"
   324  		// arm64:"ASR",-"CSEL"
   325  		return v >> s
   326  	}
   327  	panic("shift too large")
   328  }
   329  
   330  func provedUnsignedShiftLeft(val64 uint64, val32 uint32, val16 uint16, val8 uint8, shift int) (r1 uint64, r2 uint32, r3 uint16, r4 uint8) {
   331  	if shift >= 0 && shift < 64 {
   332  		// arm64:"LSL",-"CSEL"
   333  		r1 = val64 << shift
   334  	}
   335  	if shift >= 0 && shift < 32 {
   336  		// arm64:"LSL",-"CSEL"
   337  		r2 = val32 << shift
   338  	}
   339  	if shift >= 0 && shift < 16 {
   340  		// arm64:"LSL",-"CSEL"
   341  		r3 = val16 << shift
   342  	}
   343  	if shift >= 0 && shift < 8 {
   344  		// arm64:"LSL",-"CSEL"
   345  		r4 = val8 << shift
   346  	}
   347  	return r1, r2, r3, r4
   348  }
   349  
   350  func provedSignedShiftLeft(val64 int64, val32 int32, val16 int16, val8 int8, shift int) (r1 int64, r2 int32, r3 int16, r4 int8) {
   351  	if shift >= 0 && shift < 64 {
   352  		// arm64:"LSL",-"CSEL"
   353  		r1 = val64 << shift
   354  	}
   355  	if shift >= 0 && shift < 32 {
   356  		// arm64:"LSL",-"CSEL"
   357  		r2 = val32 << shift
   358  	}
   359  	if shift >= 0 && shift < 16 {
   360  		// arm64:"LSL",-"CSEL"
   361  		r3 = val16 << shift
   362  	}
   363  	if shift >= 0 && shift < 8 {
   364  		// arm64:"LSL",-"CSEL"
   365  		r4 = val8 << shift
   366  	}
   367  	return r1, r2, r3, r4
   368  }
   369  
   370  func provedUnsignedShiftRight(val64 uint64, val32 uint32, val16 uint16, val8 uint8, shift int) (r1 uint64, r2 uint32, r3 uint16, r4 uint8) {
   371  	if shift >= 0 && shift < 64 {
   372  		// arm64:"LSR",-"CSEL"
   373  		r1 = val64 >> shift
   374  	}
   375  	if shift >= 0 && shift < 32 {
   376  		// arm64:"LSR",-"CSEL"
   377  		r2 = val32 >> shift
   378  	}
   379  	if shift >= 0 && shift < 16 {
   380  		// arm64:"LSR",-"CSEL"
   381  		r3 = val16 >> shift
   382  	}
   383  	if shift >= 0 && shift < 8 {
   384  		// arm64:"LSR",-"CSEL"
   385  		r4 = val8 >> shift
   386  	}
   387  	return r1, r2, r3, r4
   388  }
   389  
   390  func provedSignedShiftRight(val64 int64, val32 int32, val16 int16, val8 int8, shift int) (r1 int64, r2 int32, r3 int16, r4 int8) {
   391  	if shift >= 0 && shift < 64 {
   392  		// arm64:"ASR",-"CSEL"
   393  		r1 = val64 >> shift
   394  	}
   395  	if shift >= 0 && shift < 32 {
   396  		// arm64:"ASR",-"CSEL"
   397  		r2 = val32 >> shift
   398  	}
   399  	if shift >= 0 && shift < 16 {
   400  		// arm64:"ASR",-"CSEL"
   401  		r3 = val16 >> shift
   402  	}
   403  	if shift >= 0 && shift < 8 {
   404  		// arm64:"ASR",-"CSEL"
   405  		r4 = val8 >> shift
   406  	}
   407  	return r1, r2, r3, r4
   408  }
   409  
   410  func checkUnneededTrunc(tab *[100000]uint32, d uint64, v uint32, h uint16, b byte) (uint32, uint64) {
   411  
   412  	// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
   413  	f := tab[byte(v)^b]
   414  	// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
   415  	f += tab[byte(v)&b]
   416  	// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
   417  	f += tab[byte(v)|b]
   418  	// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
   419  	f += tab[uint16(v)&h]
   420  	// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
   421  	f += tab[uint16(v)^h]
   422  	// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
   423  	f += tab[uint16(v)|h]
   424  	// ppc64x:-".*AND",-"RLDICR",".*CLRLSLDI"
   425  	f += tab[v&0xff]
   426  	// ppc64x:-".*AND",".*CLRLSLWI"
   427  	f += 2 * uint32(uint16(d))
   428  	// ppc64x:-".*AND",-"RLDICR",".*CLRLSLDI"
   429  	g := 2 * uint64(uint32(d))
   430  	return f, g
   431  }
   432  
   433  func checkCombinedShifts(v8 uint8, v16 uint16, v32 uint32, x32 int32, v64 uint64) (uint8, uint16, uint32, uint64, int64) {
   434  
   435  	// ppc64x:-"AND","CLRLSLWI"
   436  	f := (v8 & 0xF) << 2
   437  	// ppc64x:"CLRLSLWI"
   438  	f += byte(v16) << 3
   439  	// ppc64x:-"AND","CLRLSLWI"
   440  	g := (v16 & 0xFF) << 3
   441  	// ppc64x:-"AND","CLRLSLWI"
   442  	h := (v32 & 0xFFFFF) << 2
   443  	// ppc64x:"CLRLSLDI"
   444  	i := (v64 & 0xFFFFFFFF) << 5
   445  	// ppc64x:-"CLRLSLDI"
   446  	i += (v64 & 0xFFFFFFF) << 38
   447  	// ppc64x/power9:-"CLRLSLDI"
   448  	i += (v64 & 0xFFFF00) << 10
   449  	// ppc64x/power9:-"SLD","EXTSWSLI"
   450  	j := int64(x32+32) * 8
   451  	return f, g, h, i, j
   452  }
   453  
   454  func checkWidenAfterShift(v int64, u uint64) (int64, uint64) {
   455  
   456  	// ppc64x:-".*MOVW"
   457  	f := int32(v >> 32)
   458  	// ppc64x:".*MOVW"
   459  	f += int32(v >> 31)
   460  	// ppc64x:-".*MOVH"
   461  	g := int16(v >> 48)
   462  	// ppc64x:".*MOVH"
   463  	g += int16(v >> 30)
   464  	// ppc64x:-".*MOVH"
   465  	g += int16(f >> 16)
   466  	// ppc64x:-".*MOVB"
   467  	h := int8(v >> 56)
   468  	// ppc64x:".*MOVB"
   469  	h += int8(v >> 28)
   470  	// ppc64x:-".*MOVB"
   471  	h += int8(f >> 24)
   472  	// ppc64x:".*MOVB"
   473  	h += int8(f >> 16)
   474  	return int64(h), uint64(g)
   475  }
   476  
   477  func checkShiftAndMask32(v []uint32) {
   478  	i := 0
   479  
   480  	// ppc64x: "RLWNM\t[$]24, R[0-9]+, [$]12, [$]19, R[0-9]+"
   481  	v[i] = (v[i] & 0xFF00000) >> 8
   482  	i++
   483  	// ppc64x: "RLWNM\t[$]26, R[0-9]+, [$]22, [$]29, R[0-9]+"
   484  	v[i] = (v[i] & 0xFF00) >> 6
   485  	i++
   486  	// ppc64x: "MOVW\tR0"
   487  	v[i] = (v[i] & 0xFF) >> 8
   488  	i++
   489  	// ppc64x: "MOVW\tR0"
   490  	v[i] = (v[i] & 0xF000000) >> 28
   491  	i++
   492  	// ppc64x: "RLWNM\t[$]26, R[0-9]+, [$]24, [$]31, R[0-9]+"
   493  	v[i] = (v[i] >> 6) & 0xFF
   494  	i++
   495  	// ppc64x: "RLWNM\t[$]26, R[0-9]+, [$]12, [$]19, R[0-9]+"
   496  	v[i] = (v[i] >> 6) & 0xFF000
   497  	i++
   498  	// ppc64x: "MOVW\tR0"
   499  	v[i] = (v[i] >> 20) & 0xFF000
   500  	i++
   501  	// ppc64x: "MOVW\tR0"
   502  	v[i] = (v[i] >> 24) & 0xFF00
   503  	i++
   504  }
   505  
   506  func checkMergedShifts32(a [256]uint32, b [256]uint64, u uint32, v uint32) {
   507  	// ppc64x: -"CLRLSLDI", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]29, R[0-9]+"
   508  	a[0] = a[uint8(v>>24)]
   509  	// ppc64x: -"CLRLSLDI", "RLWNM\t[$]11, R[0-9]+, [$]21, [$]28, R[0-9]+"
   510  	b[0] = b[uint8(v>>24)]
   511  	// ppc64x: -"CLRLSLDI", "RLWNM\t[$]15, R[0-9]+, [$]21, [$]28, R[0-9]+"
   512  	b[1] = b[(v>>20)&0xFF]
   513  	// ppc64x: -"SLD", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]28, R[0-9]+"
   514  	b[2] = b[v>>25]
   515  }
   516  
   517  func checkMergedShifts64(a [256]uint32, b [256]uint64, c [256]byte, v uint64) {
   518  	// ppc64x: -"CLRLSLDI", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]29, R[0-9]+"
   519  	a[0] = a[uint8(v>>24)]
   520  	// ppc64x: "SRD", "CLRLSLDI", -"RLWNM"
   521  	a[1] = a[uint8(v>>25)]
   522  	// ppc64x: -"CLRLSLDI", "RLWNM\t[$]9, R[0-9]+, [$]23, [$]29, R[0-9]+"
   523  	a[2] = a[v>>25&0x7F]
   524  	// ppc64x: -"CLRLSLDI", "RLWNM\t[$]3, R[0-9]+, [$]29, [$]29, R[0-9]+"
   525  	a[3] = a[(v>>31)&0x01]
   526  	// ppc64x: -"CLRLSLDI", "RLWNM\t[$]12, R[0-9]+, [$]21, [$]28, R[0-9]+"
   527  	b[0] = b[uint8(v>>23)]
   528  	// ppc64x: -"CLRLSLDI", "RLWNM\t[$]15, R[0-9]+, [$]21, [$]28, R[0-9]+"
   529  	b[1] = b[(v>>20)&0xFF]
   530  	// ppc64x: "RLWNM", -"SLD"
   531  	b[2] = b[((uint64((uint32(v) >> 21)) & 0x3f) << 4)]
   532  	// ppc64x: -"RLWNM"
   533  	b[3] = (b[3] << 24) & 0xFFFFFF000000
   534  	// ppc64x: "RLWNM\t[$]24, R[0-9]+, [$]0, [$]7,"
   535  	b[4] = (b[4] << 24) & 0xFF000000
   536  	// ppc64x: "RLWNM\t[$]24, R[0-9]+, [$]0, [$]7,"
   537  	b[5] = (b[5] << 24) & 0xFF00000F
   538  	// ppc64x: -"RLWNM"
   539  	b[6] = (b[6] << 0) & 0xFF00000F
   540  	// ppc64x: "RLWNM\t[$]4, R[0-9]+, [$]28, [$]31,"
   541  	b[7] = (b[7] >> 28) & 0xF
   542  	// ppc64x: "RLWNM\t[$]11, R[0-9]+, [$]10, [$]15"
   543  	c[0] = c[((v>>5)&0x3F)<<16]
   544  	// ppc64x: "ANDCC\t[$]8064,"
   545  	c[1] = c[((v>>7)&0x3F)<<7]
   546  }
   547  
   548  func checkShiftMask(a uint32, b uint64, z []uint32, y []uint64) {
   549  	_ = y[128]
   550  	_ = z[128]
   551  	// ppc64x: -"MOVBZ", -"SRW", "RLWNM"
   552  	z[0] = uint32(uint8(a >> 5))
   553  	// ppc64x: -"MOVBZ", -"SRW", "RLWNM"
   554  	z[1] = uint32(uint8((a >> 4) & 0x7e))
   555  	// ppc64x: "RLWNM\t[$]25, R[0-9]+, [$]27, [$]29, R[0-9]+"
   556  	z[2] = uint32(uint8(a>>7)) & 0x1c
   557  	// ppc64x: -"MOVWZ"
   558  	y[0] = uint64((a >> 6) & 0x1c)
   559  	// ppc64x: -"MOVWZ"
   560  	y[1] = uint64(uint32(b)<<6) + 1
   561  	// ppc64x: -"MOVHZ", -"MOVWZ"
   562  	y[2] = uint64((uint16(a) >> 9) & 0x1F)
   563  	// ppc64x: -"MOVHZ", -"MOVWZ", -"ANDCC"
   564  	y[3] = uint64(((uint16(a) & 0xFF0) >> 9) & 0x1F)
   565  }
   566  
   567  // 128 bit shifts
   568  
   569  func check128bitShifts(x, y uint64, bits uint) (uint64, uint64) {
   570  	s := bits & 63
   571  	ŝ := (64 - bits) & 63
   572  	// check that the shift operation has two commas (three operands)
   573  	// amd64:"SHRQ.*,.*,"
   574  	shr := x>>s | y<<ŝ
   575  	// amd64:"SHLQ.*,.*,"
   576  	shl := x<<s | y>>ŝ
   577  	return shr, shl
   578  }
   579  
   580  func checkShiftToMask(u []uint64, s []int64) {
   581  	// amd64:-"SHR",-"SHL","ANDQ"
   582  	u[0] = u[0] >> 5 << 5
   583  	// amd64:-"SAR",-"SHL","ANDQ"
   584  	s[0] = s[0] >> 5 << 5
   585  	// amd64:-"SHR",-"SHL","ANDQ"
   586  	u[1] = u[1] << 5 >> 5
   587  }
   588  
   589  //
   590  // Left shift with addition.
   591  //
   592  
   593  func checkLeftShiftWithAddition(a int64, b int64) int64 {
   594  	// riscv64/rva20u64: "SLLI","ADD"
   595  	// riscv64/rva22u64,riscv64/rva23u64: "SH1ADD"
   596  	a = a + b<<1
   597  	// riscv64/rva20u64: "SLLI","ADD"
   598  	// riscv64/rva22u64,riscv64/rva23u64: "SH2ADD"
   599  	a = a + b<<2
   600  	// riscv64/rva20u64: "SLLI","ADD"
   601  	// riscv64/rva22u64,riscv64/rva23u64: "SH3ADD"
   602  	a = a + b<<3
   603  	return a
   604  }
   605  
   606  //
   607  // Convert and shift.
   608  //
   609  
   610  func rsh64Uto32U(v uint64) uint32 {
   611  	x := uint32(v)
   612  	// riscv64:"MOVWU"
   613  	if x > 8 {
   614  		// riscv64:"SRLIW",-"MOVWU",-"SLLI"
   615  		x >>= 2
   616  	}
   617  	return x
   618  }
   619  
   620  func rsh64Uto16U(v uint64) uint16 {
   621  	x := uint16(v)
   622  	// riscv64:"MOVHU"
   623  	if x > 8 {
   624  		// riscv64:"SLLI","SRLI"
   625  		x >>= 2
   626  	}
   627  	return x
   628  }
   629  
   630  func rsh64Uto8U(v uint64) uint8 {
   631  	x := uint8(v)
   632  	// riscv64:"MOVBU"
   633  	if x > 8 {
   634  		// riscv64:"SLLI","SRLI"
   635  		x >>= 2
   636  	}
   637  	return x
   638  }
   639  
   640  func rsh64to32(v int64) int32 {
   641  	x := int32(v)
   642  	// riscv64:"MOVW"
   643  	if x > 8 {
   644  		// riscv64:"SRAIW",-"MOVW",-"SLLI"
   645  		x >>= 2
   646  	}
   647  	return x
   648  }
   649  
   650  func rsh64to16(v int64) int16 {
   651  	x := int16(v)
   652  	// riscv64:"MOVH"
   653  	if x > 8 {
   654  		// riscv64:"SLLI","SRAI"
   655  		x >>= 2
   656  	}
   657  	return x
   658  }
   659  
   660  func rsh64to8(v int64) int8 {
   661  	x := int8(v)
   662  	// riscv64:"MOVB"
   663  	if x > 8 {
   664  		// riscv64:"SLLI","SRAI"
   665  		x >>= 2
   666  	}
   667  	return x
   668  }
   669  
   670  // We don't need to worry about shifting
   671  // more than the type size.
   672  // (There is still a negative shift test, but
   673  // no shift-too-big test.)
   674  func signedModShift(i int) int64 {
   675  	// arm64:-"CMP",-"CSEL"
   676  	return 1 << (i % 64)
   677  }
   678
View as plain text