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