bits.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  import "math/bits"
    10  
    11  //
    12  // 64 bit instructions
    13  //
    14  
    15  func bitsCheckConstLeftShiftU64(a uint64) (n int) {
    16  	// amd64:"BTQ [$]63,"
    17  	// arm64:"TBNZ [$]63,"
    18  	// loong64:"MOVV [$]" "AND" "BNE"
    19  	// riscv64:"MOV [$]-9223372036854775808," "AND " "BNEZ"
    20  	if a&(1<<63) != 0 {
    21  		return 1
    22  	}
    23  	// amd64:"BTQ [$]60,"
    24  	// arm64:"TBNZ [$]60,"
    25  	// loong64:"MOVV [$]" "AND" "BNE"
    26  	// riscv64:"MOV [$]1152921504606846976," "AND " "BNEZ"
    27  	if a&(1<<60) != 0 {
    28  		return 1
    29  	}
    30  	// amd64:"BTL [$]0,"
    31  	// arm64:"TBZ [$]0,"
    32  	// loong64:"AND [$]1," "BEQ"
    33  	// riscv64:"ANDI [$]1," "BEQZ"
    34  	if a&(1<<0) != 0 {
    35  		return 1
    36  	}
    37  	return 0
    38  }
    39  
    40  func bitsCheckConstRightShiftU64(a [8]uint64) (n int) {
    41  	// amd64:"BTQ [$]63,"
    42  	// arm64:"TBNZ [$]63," -"LSR"
    43  	// loong64:"SRLV [$]63," "BNE"
    44  	// riscv64:"SRLI [$]63," "BNEZ"
    45  	if (a[0]>>63)&1 != 0 {
    46  		return 1
    47  	}
    48  	// amd64:"BTQ [$]63,"
    49  	// arm64:"TBNZ [$]63," -"LSR"
    50  	// loong64:"SRLV [$]63," "BNE"
    51  	// riscv64:"SRLI [$]63," "BNEZ"
    52  	if a[1]>>63 != 0 {
    53  		return 1
    54  	}
    55  	// amd64:"BTQ [$]63,"
    56  	// arm64:"TBZ [$]63," -"LSR"
    57  	// loong64:"SRLV [$]63," "BEQ"
    58  	// riscv64:"SRLI [$]63," "BEQZ"
    59  	if a[2]>>63 == 0 {
    60  		return 1
    61  	}
    62  	// amd64:"BTQ [$]60,"
    63  	// arm64:"TBZ [$]60," -"LSR"
    64  	// loong64:"SRLV [$]60," "AND [$]1," "BEQ"
    65  	// riscv64:"SRLI [$]60," "ANDI [$]1," "BEQZ"
    66  	if (a[3]>>60)&1 == 0 {
    67  		return 1
    68  	}
    69  	// amd64:"BTL [$]1,"
    70  	// arm64:"TBZ [$]1," -"LSR"
    71  	// loong64:"SRLV [$]1," "AND [$]1," "BEQ"
    72  	// riscv64:"SRLI [$]1," "ANDI [$]1," "BEQZ"
    73  	if (a[4]>>1)&1 == 0 {
    74  		return 1
    75  	}
    76  	// amd64:"BTL [$]0,"
    77  	// arm64:"TBZ [$]0," -"LSR"
    78  	// loong64:"AND [$]1," "BEQ" -"SRLV"
    79  	// riscv64:"ANDI [$]1," "BEQZ" -"SRLI"
    80  	if (a[5]>>0)&1 == 0 {
    81  		return 1
    82  	}
    83  	// amd64:"BTL [$]7,"
    84  	// arm64:"TBNZ [$]7," -"LSR"
    85  	// loong64:"SRLV [$]5," "AND [$]4," "BNE"
    86  	// riscv64:"SRLI [$]5," "ANDI [$]4," "BNEZ"
    87  	if (a[6]>>5)&4 == 0 {
    88  		return 1
    89  	}
    90  	return 0
    91  }
    92  
    93  func bitsCheckVarU64(a, b uint64) (n int) {
    94  	// amd64:"BTQ"
    95  	// arm64:"MOVD [$]1," "LSL" "TST"
    96  	// loong64:"MOVV [$]1," "SLLV R" "AND" "BNE"
    97  	// riscv64:"ANDI [$]63," "MOV [$]1," "SLL " "AND "
    98  	if a&(1<<(b&63)) != 0 {
    99  		return 1
   100  	}
   101  	// amd64:"BTQ" -"BT. [$]0,"
   102  	// arm64:"LSR" "TBZ [$]0,"
   103  	// loong64:"SRLV" "AND [$]1," "BEQ"
   104  	// riscv64:"ANDI [$]63," "SRL " "ANDI [$]1,"
   105  	if (b>>(a&63))&1 != 0 {
   106  		return 1
   107  	}
   108  	return 0
   109  }
   110  
   111  func bitsCheckMaskU64(a uint64) (n int) {
   112  	// amd64:"BTQ [$]63,"
   113  	// arm64:"TBNZ [$]63,"
   114  	// loong64:"MOVV [$]" "AND" "BNE"
   115  	// riscv64:"MOV [$]-9223372036854775808" "AND " "BNEZ"
   116  	if a&0x8000000000000000 != 0 {
   117  		return 1
   118  	}
   119  	// amd64:"BTQ [$]59,"
   120  	// arm64:"TBNZ [$]59,"
   121  	// loong64:"MOVV [$]" "AND" "BNE"
   122  	// riscv64:"MOV [$]576460752303423488" "AND " "BNEZ"
   123  	if a&0x800000000000000 != 0 {
   124  		return 1
   125  	}
   126  	// amd64:"BTL [$]0,"
   127  	// arm64:"TBZ [$]0,"
   128  	// loong64:"AND [$]1," "BEQ"
   129  	// riscv64:"ANDI [$]1," "BEQZ"
   130  	if a&0x1 != 0 {
   131  		return 1
   132  	}
   133  	return 0
   134  }
   135  
   136  func bitsSetU64(a, b uint64) (n uint64) {
   137  	// amd64:"BTSQ"
   138  	// arm64:"MOVD [$]1," "LSL" "ORR"
   139  	// loong64:"MOVV [$]1," "SLLV" "OR"
   140  	// riscv64:"ANDI [$]63," "MOV [$]1," "SLL " "OR "
   141  	n += b | (1 << (a & 63))
   142  
   143  	// amd64:"BTSQ [$]63,"
   144  	// arm64:"ORR [$]-9223372036854775808,"
   145  	// loong64:"MOVV [$]" "OR"
   146  	// riscv64:"MOV [$]-9223372036854775808," "OR "
   147  	n += a | (1 << 63)
   148  
   149  	// amd64:"BTSQ [$]60,"
   150  	// arm64:"ORR [$]1152921504606846976,"
   151  	// loong64:"MOVV [$]" "OR"
   152  	// riscv64:"MOV [$]1152921504606846976," "OR "
   153  	n += a | (1 << 60)
   154  
   155  	// amd64:"ORQ [$]1,"
   156  	// arm64:"ORR [$]1,"
   157  	// loong64:"OR [$]1,"
   158  	// riscv64:"ORI [$]1,"
   159  	n += a | (1 << 0)
   160  
   161  	return n
   162  }
   163  
   164  func bitsClearU64(a, b uint64) (n uint64) {
   165  	// amd64:"BTRQ"
   166  	// arm64:"MOVD [$]1," "LSL" "BIC"
   167  	// loong64:"MOVV [$]1," "SLLV" "ANDN"
   168  	// riscv64:"ANDI [$]63," "MOV [$]1," "SLL " "ANDN"
   169  	n += b &^ (1 << (a & 63))
   170  
   171  	// amd64:"BTRQ [$]63,"
   172  	// arm64:"AND [$]9223372036854775807,"
   173  	// loong64:"MOVV [$]" "AND "
   174  	// riscv64:"MOV [$]9223372036854775807," "AND "
   175  	n += a &^ (1 << 63)
   176  
   177  	// amd64:"BTRQ [$]60,"
   178  	// arm64:"AND [$]-1152921504606846977,"
   179  	// loong64:"MOVV [$]" "AND "
   180  	// riscv64:"MOV [$]i64.efffffffffffffff" "AND "
   181  	n += a &^ (1 << 60)
   182  
   183  	// amd64:"ANDQ [$]-2"
   184  	// arm64:"AND [$]-2"
   185  	// loong64:"AND [$]-2"
   186  	// riscv64:"ANDI [$]-2,"
   187  	n += a &^ (1 << 0)
   188  
   189  	return n
   190  }
   191  
   192  func bitsClearLowest(x int64, y int32) (int64, int32) {
   193  	// amd64:"ANDQ [$]-2,"
   194  	// arm64:"AND [$]-2,"
   195  	// loong64:"AND [$]-2,"
   196  	// riscv64:"ANDI [$]-2,"
   197  	a := (x >> 1) << 1
   198  
   199  	// amd64:"ANDL [$]-2,"
   200  	// arm64:"AND [$]-2,"
   201  	// loong64:"AND [$]-2,"
   202  	// riscv64:"ANDI [$]-2,"
   203  	b := (y >> 1) << 1
   204  
   205  	return a, b
   206  }
   207  
   208  func bitsFlipU64(a, b uint64) (n uint64) {
   209  	// amd64:"BTCQ"
   210  	// arm64:"MOVD [$]1," "LSL" "EOR"
   211  	// loong64:"MOVV [$]1," "SLLV" "XOR"
   212  	// riscv64:"ANDI [$]63," "MOV [$]1," "SLL " "XOR "
   213  	n += b ^ (1 << (a & 63))
   214  
   215  	// amd64:"BTCQ [$]63,"
   216  	// arm64:"EOR [$]-9223372036854775808,"
   217  	// loong64:"MOVV [$]" "XOR"
   218  	// riscv64:"MOV [$]-9223372036854775808," "XOR "
   219  	n += a ^ (1 << 63)
   220  
   221  	// amd64:"BTCQ [$]60,"
   222  	// arm64:"EOR [$]1152921504606846976,"
   223  	// loong64:"MOVV [$]" "XOR"
   224  	// riscv64:"MOV [$]1152921504606846976," "XOR "
   225  	n += a ^ (1 << 60)
   226  
   227  	// amd64:"XORQ [$]1,"
   228  	// arm64:"EOR [$]1,"
   229  	// loong64:"XOR [$]1,"
   230  	// riscv64:"XORI [$]1,"
   231  	n += a ^ (1 << 0)
   232  
   233  	return n
   234  }
   235  
   236  //
   237  // 32 bit instructions
   238  //
   239  
   240  func bitsCheckConstShiftLeftU32(a uint32) (n int) {
   241  	// amd64:"BTL [$]31,"
   242  	// arm64:"TBNZ [$]31,"
   243  	// loong64:"AND [$]" "MOVWU" "BNE"
   244  	// riscv64:"MOV [$]2147483648," "AND " "BNEZ"
   245  	if a&(1<<31) != 0 {
   246  		return 1
   247  	}
   248  	// amd64:"BTL [$]28,"
   249  	// arm64:"TBNZ [$]28,"
   250  	// loong64:"AND [$]" "BNE"
   251  	// riscv64:"ANDI [$]268435456," "BNEZ"
   252  	if a&(1<<28) != 0 {
   253  		return 1
   254  	}
   255  	// amd64:"BTL [$]0,"
   256  	// arm64:"TBZ [$]0,"
   257  	// loong64:"AND [$]" "BEQ"
   258  	// riscv64:"ANDI [$]1," "BEQZ"
   259  	if a&(1<<0) != 0 {
   260  		return 1
   261  	}
   262  	return 0
   263  }
   264  
   265  func bitsCheckConstRightShiftU32(a [8]uint32) (n int) {
   266  	// amd64:"BTL [$]31,"
   267  	// arm64:"UBFX [$]31," "CBNZW"
   268  	// loong64:"SRL [$]31," "BNE"
   269  	// riscv64:"SRLIW [$]31," "BNEZ"
   270  	if (a[0]>>31)&1 != 0 {
   271  		return 1
   272  	}
   273  	// amd64:"BTL [$]31,"
   274  	// arm64:"UBFX [$]31," "CBNZW"
   275  	// loong64:"SRL [$]31," "MOVWU" "BNE"
   276  	// riscv64:"SRLIW [$]31," "BNEZ" -"ANDI"
   277  	if a[1]>>31 != 0 {
   278  		return 1
   279  	}
   280  	// amd64:"BTL [$]31,"
   281  	// arm64:"UBFX [$]31," "CBZW"
   282  	// loong64:"SRL [$]31," "MOVWU" "BEQ"
   283  	// riscv64:"SRLIW [$]31," "BEQZ" -"ANDI"
   284  	if a[2]>>31 == 0 {
   285  		return 1
   286  	}
   287  	// amd64:"BTL [$]28,"
   288  	// arm64:"UBFX [$]28," "TBZ"
   289  	// loong64:"SRL [$]28," "AND [$]1," "BEQ"
   290  	// riscv64:"SRLIW [$]28," "ANDI [$]1," "BEQZ"
   291  	if (a[3]>>28)&1 == 0 {
   292  		return 1
   293  	}
   294  	// amd64:"BTL [$]1,"
   295  	// arm64:"UBFX [$]1," "TBZ"
   296  	// loong64:"SRL [$]1," "AND [$]1," "BEQ"
   297  	// riscv64:"SRLIW [$]1," "ANDI [$]1," "BEQZ"
   298  	if (a[4]>>1)&1 == 0 {
   299  		return 1
   300  	}
   301  	// amd64:"BTL [$]0,"
   302  	// arm64:"TBZ" -"UBFX" -"SRL"
   303  	// loong64:"AND [$]1," "BEQ" -"SRL [$]"
   304  	// riscv64:"ANDI [$]1," "BEQZ" -"SRLI "
   305  	if (a[5]>>0)&1 == 0 {
   306  		return 1
   307  	}
   308  	// amd64:"BTL [$]7,"
   309  	// arm64:"UBFX [$]5," "TBNZ"
   310  	// loong64:"SRL [$]5," "AND [$]4," "BNE"
   311  	// riscv64:"SRLIW [$]5," "ANDI [$]4," "BNEZ"
   312  	if (a[6]>>5)&4 == 0 {
   313  		return 1
   314  	}
   315  	return 0
   316  }
   317  
   318  func bitsCheckVarU32(a, b uint32) (n int) {
   319  	// amd64:"BTL"
   320  	// arm64:"AND [$]31," "MOVD [$]1," "LSL" "TSTW"
   321  	// loong64:"MOVV [$]1," "SLL R" "AND R" "MOVWU" "BNE"
   322  	// riscv64:"ANDI [$]31," "MOV [$]1," "SLL " "AND "
   323  	if a&(1<<(b&31)) != 0 {
   324  		return 1
   325  	}
   326  	// amd64:"BTL" -"BT. [$]0"
   327  	// arm64:"AND [$]31," "LSR" "TBZ"
   328  	// loong64:"SRL R" "AND [$]1," "BEQ"
   329  	// riscv64:"ANDI [$]31," "SRLW " "ANDI [$]1,"
   330  	if (b>>(a&31))&1 != 0 {
   331  		return 1
   332  	}
   333  	return 0
   334  }
   335  
   336  func bitsCheckMaskU32(a uint32) (n int) {
   337  	// amd64:"BTL [$]31,"
   338  	// arm64:"TBNZ [$]31,"
   339  	// loong64:"AND [$]" "MOVWU" "BNE"
   340  	// riscv64:"MOV [$]2147483648," "AND " "BNEZ"
   341  	if a&0x80000000 != 0 {
   342  		return 1
   343  	}
   344  	// amd64:"BTL [$]27,"
   345  	// arm64:"TBNZ [$]27,"
   346  	// loong64:"AND [$]" "BNE"
   347  	// riscv64:"ANDI [$]134217728," "BNEZ"
   348  	if a&0x8000000 != 0 {
   349  		return 1
   350  	}
   351  	// amd64:"BTL [$]0,"
   352  	// arm64:"TBZ [$]0,"
   353  	// loong64:"AND [$]1," "BEQ"
   354  	// riscv64:"ANDI [$]1," "BEQZ"
   355  	if a&0x1 != 0 {
   356  		return 1
   357  	}
   358  	return 0
   359  }
   360  
   361  func bitsSetU32(a, b uint32) (n uint32) {
   362  	// amd64:"BTSL"
   363  	// arm64:"AND [$]31," "MOVD [$]1," "LSL" "ORR"
   364  	// loong64:"MOVV [$]1," "SLL " "OR "
   365  	// riscv64:"ANDI [$]31," "MOV [$]1," "SLL " "OR "
   366  	n += b | (1 << (a & 31))
   367  
   368  	// amd64:"ORL [$]-2147483648,"
   369  	// arm64:"ORR [$]-2147483648,"
   370  	// loong64:"OR [$]-2147483648,"
   371  	// riscv64:"ORI [$]-2147483648,"
   372  	n += a | (1 << 31)
   373  
   374  	// amd64:"ORL [$]268435456,"
   375  	// arm64:"ORR [$]268435456,"
   376  	// loong64:"OR [$]268435456,"
   377  	// riscv64:"ORI [$]268435456,"
   378  	n += a | (1 << 28)
   379  
   380  	// amd64:"ORL [$]1,"
   381  	// arm64:"ORR [$]1,"
   382  	// loong64:"OR [$]1,"
   383  	// riscv64:"ORI [$]1,"
   384  	n += a | (1 << 0)
   385  
   386  	return n
   387  }
   388  
   389  func bitsClearU32(a, b uint32) (n uint32) {
   390  	// amd64:"BTRL"
   391  	// arm64:"AND [$]31," "MOVD [$]1," "LSL" "BIC"
   392  	// loong64:"MOVV [$]1," "SLL R" "ANDN"
   393  	// riscv64:"ANDI [$]31," "MOV [$]1," "SLL " "ANDN"
   394  	n += b &^ (1 << (a & 31))
   395  
   396  	// amd64:"ANDL [$]2147483647,"
   397  	// arm64:"AND [$]2147483647,"
   398  	// loong64:"AND [$]2147483647,"
   399  	// riscv64:"ANDI [$]2147483647,"
   400  	n += a &^ (1 << 31)
   401  
   402  	// amd64:"ANDL [$]-268435457,"
   403  	// arm64:"AND [$]-268435457,"
   404  	// loong64:"AND [$]-268435457,"
   405  	// riscv64:"ANDI [$]-268435457,"
   406  	n += a &^ (1 << 28)
   407  
   408  	// amd64:"ANDL [$]-2,"
   409  	// arm64:"AND [$]-2,"
   410  	// loong64:"AND [$]-2,"
   411  	// riscv64:"ANDI [$]-2,"
   412  	n += a &^ (1 << 0)
   413  
   414  	return n
   415  }
   416  
   417  func bitsFlipU32(a, b uint32) (n uint32) {
   418  	// amd64:"BTCL"
   419  	// arm64:"AND [$]31," "MOVD [$]1," "LSL" "EOR"
   420  	// loong64:"MOVV [$]1," "SLL R" "XOR"
   421  	// riscv64:"ANDI [$]31," "MOV [$]1," "SLL " "XOR "
   422  	n += b ^ (1 << (a & 31))
   423  
   424  	// amd64:"XORL [$]-2147483648,"
   425  	// arm64:"EOR [$]-2147483648,"
   426  	// loong64:"XOR [$]-2147483648,"
   427  	// riscv64:"XORI [$]-2147483648,"
   428  	n += a ^ (1 << 31)
   429  
   430  	// amd64:"XORL [$]268435456,"
   431  	// arm64:"EOR [$]268435456,"
   432  	// loong64:"XOR [$]268435456,"
   433  	// riscv64:"XORI [$]268435456,"
   434  	n += a ^ (1 << 28)
   435  
   436  	// amd64:"XORL [$]1,"
   437  	// arm64:"EOR [$]1,"
   438  	// loong64:"XOR [$]1,"
   439  	// riscv64:"XORI [$]1,"
   440  	n += a ^ (1 << 0)
   441  
   442  	return n
   443  }
   444  
   445  func bitsOpOnMem(a []uint32, b, c, d uint32) {
   446  	// check direct operation on memory with constant
   447  
   448  	// amd64:`ANDL [$]200, \([A-Z][A-Z0-9]+\)`
   449  	a[0] &= 200
   450  	// amd64:`ORL [$]220, 4\([A-Z][A-Z0-9]+\)`
   451  	a[1] |= 220
   452  	// amd64:`XORL [$]240, 8\([A-Z][A-Z0-9]+\)`
   453  	a[2] ^= 240
   454  }
   455  
   456  func bitsCheckMostNegative(b uint8) bool {
   457  	// amd64:"TESTB"
   458  	// arm64:"TSTW" "CSET"
   459  	// loong64:"AND [$]128," "SGTU"
   460  	// riscv64:"ANDI [$]128," "SNEZ" -"ADDI"
   461  	return b&0x80 == 0x80
   462  }
   463  
   464  func bitsIssue19857a(a uint64) uint64 {
   465  	// arm64:`AND `
   466  	return a & ((1 << 63) - 1)
   467  }
   468  
   469  func bitsIssue19857b(a uint64) uint64 {
   470  	// arm64:`AND `
   471  	return a & (1 << 63)
   472  }
   473  
   474  func bitsIssue19857c(a, b uint32) (uint32, uint32) {
   475  	// arm/7:`BIC` -`AND`
   476  	a &= 0xffffaaaa
   477  	// arm/7:`BFC` -`AND` -`BIC`
   478  	b &= 0xffc003ff
   479  	return a, b
   480  }
   481  
   482  func bitsAndNot(x, y uint32) uint32 {
   483  	// arm64:`BIC ` -`AND`
   484  	// loong64:"ANDN " -"AND "
   485  	// riscv64:"ANDN" -"AND "
   486  	return x &^ y
   487  }
   488  
   489  func bitsXorNot(x, y, z uint32, a []uint32, n, m uint64) uint64 {
   490  	// arm64:`EON ` -`EOR` -`MVN`
   491  	// loong64:"NOR" "XOR"
   492  	// riscv64:"XNOR " -"MOV [$]" -"XOR "
   493  	a[0] = x ^ (y ^ 0xffffffff)
   494  
   495  	// arm64:`EON ` -`EOR` -`MVN`
   496  	// loong64:"XOR" "NOR"
   497  	// riscv64:"XNOR" -"XOR "
   498  	a[1] = ^(y ^ z)
   499  
   500  	// arm64:`EON ` -`XOR`
   501  	// loong64:"NOR" "XOR"
   502  	// riscv64:"XNOR" -"XOR " -"NOT"
   503  	a[2] = x ^ ^z
   504  
   505  	// arm64:`EON ` -`EOR` -`MVN`
   506  	// loong64:"NOR" "XOR"
   507  	// riscv64:"XNOR" -"MOV [$]" -"XOR "
   508  	return n ^ (m ^ 0xffffffffffffffff)
   509  }
   510  
   511  func bitsOrNot(x, y uint32) uint32 {
   512  	// arm64:"ORN " -"ORR"
   513  	// loong64:"ORN" -"OR "
   514  	// riscv64:"ORN" -"OR "
   515  	return x | ^y
   516  }
   517  
   518  func bitsNotOr(x int64, a []int64) {
   519  	// loong64: "MOVV [$]0" "NOR R"
   520  	a[0] = ^(0x1234 | x)
   521  	// loong64:"NOR" -"XOR"
   522  	a[1] = (-1) ^ x
   523  	// loong64: "MOVV [$]-55" -"OR" -"NOR"
   524  	a[2] = ^(0x12 | 0x34)
   525  }
   526  
   527  func bitsSetPowerOf2Test(x int) bool {
   528  	// amd64:"BTL [$]3"
   529  	// loong64:"AND [$]8," "SGTU"
   530  	// riscv64:"ANDI [$]8," "SNEZ" -"ADDI"
   531  	return x&8 == 8
   532  }
   533  
   534  func bitsSetTest(x int) bool {
   535  	// amd64:"ANDL [$]9, AX"
   536  	// amd64:"CMPQ AX, [$]9"
   537  	// loong64:"AND [$]9," "XOR" "SGTU"
   538  	// riscv64:"ANDI [$]9," "ADDI [$]-9," "SEQZ"
   539  	return x&9 == 9
   540  }
   541  
   542  func bitsMaskContiguousOnes64U(x uint64) uint64 {
   543  	// s390x:"RISBGZ [$]16, [$]47, [$]0,"
   544  	return x & 0x0000ffffffff0000
   545  }
   546  
   547  func bitsMaskContiguousZeroes64U(x uint64) uint64 {
   548  	// s390x:"RISBGZ [$]48, [$]15, [$]0,"
   549  	return x & 0xffff00000000ffff
   550  }
   551  
   552  func bitsIssue44228a(a []int64, i int) bool {
   553  	// amd64: "BTQ" -"SHL"
   554  	return a[i>>6]&(1<<(i&63)) != 0
   555  }
   556  
   557  func bitsIssue44228b(a []int32, i int) bool {
   558  	// amd64: "BTL" -"SHL"
   559  	return a[i>>5]&(1<<(i&31)) != 0
   560  }
   561  
   562  func bitsIssue48467(x, y uint64) uint64 {
   563  	// arm64: -"NEG"
   564  	d, borrow := bits.Sub64(x, y, 0)
   565  	return x - d&(-borrow)
   566  }
   567  
   568  func bitsFoldConst(x, y uint64) uint64 {
   569  	// arm64: "ADDS [$]7" -"MOVD [$]7"
   570  	// ppc64x: "ADDC [$]7,"
   571  	d, b := bits.Add64(x, 7, 0)
   572  	return b & d
   573  }
   574  
   575  func bitsFoldConstOutOfRange(a uint64) uint64 {
   576  	// arm64: "MOVD [$]19088744" -"ADD [$]19088744"
   577  	return a + 0x1234568
   578  }
   579  
   580  func bitsSignExtendAndMask8to64U(a int8) (s, z uint64) {
   581  	// Verify sign-extended values are not zero-extended under a bit mask (#61297)
   582  
   583  	// ppc64x: "MOVB" "ANDCC [$]1015,"
   584  	s = uint64(a) & 0x3F7
   585  	// ppc64x: -"MOVB" "ANDCC [$]247,"
   586  	z = uint64(uint8(a)) & 0x3F7
   587  	return
   588  }
   589  
   590  func bitsZeroExtendAndMask8toU64(a int8, b int16) (x, y uint64) {
   591  	// Verify zero-extended values are not sign-extended under a bit mask (#61297)
   592  
   593  	// ppc64x: -"MOVB " -"ANDCC" "MOVBZ"
   594  	x = uint64(a) & 0xFF
   595  	// ppc64x: -"MOVH " -"ANDCC" "MOVHZ"
   596  	y = uint64(b) & 0xFFFF
   597  	return
   598  }
   599  
   600  func bitsRotateAndMask(io64 [8]uint64, io32 [4]uint32, io16 [4]uint16, io8 [4]uint8) {
   601  	// Verify rotate and mask instructions, and further simplified instructions for small types
   602  
   603  	// ppc64x: "RLDICR [$]0, R[0-9]*, [$]47, R"
   604  	io64[0] = io64[0] & 0xFFFFFFFFFFFF0000
   605  	// ppc64x: "RLDICL [$]0, R[0-9]*, [$]16, R"
   606  	io64[1] = io64[1] & 0x0000FFFFFFFFFFFF
   607  	// ppc64x: -"SRD" -"AND" "RLDICL [$]60, R[0-9]*, [$]16, R"
   608  	io64[2] = (io64[2] >> 4) & 0x0000FFFFFFFFFFFF
   609  	// ppc64x: -"SRD" -"AND" "RLDICL [$]36, R[0-9]*, [$]29, R"
   610  	io64[3] = (io64[3] >> 28) & 0x00000007FFFFFFFF
   611  
   612  	// ppc64x: "MOVWZ" "RLWNM [$]1, R[0-9]*, [$]28, [$]3, R"
   613  	io64[4] = uint64(bits.RotateLeft32(io32[0], 1) & 0xF000000F)
   614  
   615  	// ppc64x: "RLWNM [$]0, R[0-9]*, [$]4, [$]19, R"
   616  	io32[0] = io32[0] & 0x0FFFF000
   617  	// ppc64x: "RLWNM [$]0, R[0-9]*, [$]20, [$]3, R"
   618  	io32[1] = io32[1] & 0xF0000FFF
   619  	// ppc64x: -"RLWNM" "MOVD" "AND"
   620  	io32[2] = io32[2] & 0xFFFF0002
   621  
   622  	var bigc uint32 = 0x12345678
   623  	// ppc64x: "ANDCC [$]22136"
   624  	io16[0] = io16[0] & uint16(bigc)
   625  
   626  	// ppc64x: "ANDCC [$]120"
   627  	io8[0] = io8[0] & uint8(bigc)
   628  }
   629  
   630  func bitsOpXor1(x, y uint32) uint32 {
   631  	// arm64: "ORR" "AND" "BIC"
   632  	// loong64: "OR " "AND " "ANDN"
   633  	return (x | y) &^ (x & y)
   634  }
   635  
   636  func bitsOpXor2(x, y uint32) uint32 {
   637  	// arm64: "BIC" "ORR"
   638  	// loong64: "ANDN" "OR "
   639  	return (x &^ y) | (^x & y)
   640  }
   641  
   642  // Absorption: x & (x | y) => x, x | (x & y) => x
   643  func absorptionAnd64(x, y uint64) uint64 {
   644  	// amd64:-"ORQ" -"ANDQ"
   645  	return x & (x | y)
   646  }
   647  
   648  func absorptionOr64(x, y uint64) uint64 {
   649  	// amd64:-"ORQ" -"ANDQ"
   650  	return x | (x & y)
   651  }
   652  
   653  func absorptionAnd32(x, y uint32) uint32 {
   654  	// amd64:-"ORL" -"ANDL"
   655  	return x & (x | y)
   656  }
   657  
   658  func absorptionOr32(x, y uint32) uint32 {
   659  	// amd64:-"ORL" -"ANDL"
   660  	return x | (x & y)
   661  }
   662  
   663  // Absorption with commuted arguments
   664  func absorptionAndCommuted64(x, y uint64) uint64 {
   665  	// amd64:-"ORQ" -"ANDQ"
   666  	return (x | y) & x
   667  }
   668  
   669  func absorptionOrCommuted64(x, y uint64) uint64 {
   670  	// amd64:-"ORQ" -"ANDQ"
   671  	return (x & y) | x
   672  }
   673
View as plain text