Source file test/codegen/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 bitcheck64_constleft(a uint64) (n int) {
    16  	// amd64:"BTQ\t[$]63"
    17  	if a&(1<<63) != 0 {
    18  		return 1
    19  	}
    20  	// amd64:"BTQ\t[$]60"
    21  	if a&(1<<60) != 0 {
    22  		return 1
    23  	}
    24  	// amd64:"BTL\t[$]0"
    25  	if a&(1<<0) != 0 {
    26  		return 1
    27  	}
    28  	return 0
    29  }
    30  
    31  func bitcheck64_constright(a [8]uint64) (n int) {
    32  	// amd64:"BTQ\t[$]63"
    33  	if (a[0]>>63)&1 != 0 {
    34  		return 1
    35  	}
    36  	// amd64:"BTQ\t[$]63"
    37  	if a[1]>>63 != 0 {
    38  		return 1
    39  	}
    40  	// amd64:"BTQ\t[$]63"
    41  	if a[2]>>63 == 0 {
    42  		return 1
    43  	}
    44  	// amd64:"BTQ\t[$]60"
    45  	if (a[3]>>60)&1 == 0 {
    46  		return 1
    47  	}
    48  	// amd64:"BTL\t[$]1"
    49  	if (a[4]>>1)&1 == 0 {
    50  		return 1
    51  	}
    52  	// amd64:"BTL\t[$]0"
    53  	if (a[5]>>0)&1 == 0 {
    54  		return 1
    55  	}
    56  	// amd64:"BTL\t[$]7"
    57  	if (a[6]>>5)&4 == 0 {
    58  		return 1
    59  	}
    60  	return 0
    61  }
    62  
    63  func bitcheck64_var(a, b uint64) (n int) {
    64  	// amd64:"BTQ"
    65  	if a&(1<<(b&63)) != 0 {
    66  		return 1
    67  	}
    68  	// amd64:"BTQ",-"BT.\t[$]0"
    69  	if (b>>(a&63))&1 != 0 {
    70  		return 1
    71  	}
    72  	return 0
    73  }
    74  
    75  func bitcheck64_mask(a uint64) (n int) {
    76  	// amd64:"BTQ\t[$]63"
    77  	if a&0x8000000000000000 != 0 {
    78  		return 1
    79  	}
    80  	// amd64:"BTQ\t[$]59"
    81  	if a&0x800000000000000 != 0 {
    82  		return 1
    83  	}
    84  	// amd64:"BTL\t[$]0"
    85  	if a&0x1 != 0 {
    86  		return 1
    87  	}
    88  	return 0
    89  }
    90  
    91  func biton64(a, b uint64) (n uint64) {
    92  	// amd64:"BTSQ"
    93  	n += b | (1 << (a & 63))
    94  
    95  	// amd64:"BTSQ\t[$]63"
    96  	n += a | (1 << 63)
    97  
    98  	// amd64:"BTSQ\t[$]60"
    99  	n += a | (1 << 60)
   100  
   101  	// amd64:"ORQ\t[$]1"
   102  	n += a | (1 << 0)
   103  
   104  	return n
   105  }
   106  
   107  func bitoff64(a, b uint64) (n uint64) {
   108  	// amd64:"BTRQ"
   109  	n += b &^ (1 << (a & 63))
   110  
   111  	// amd64:"BTRQ\t[$]63"
   112  	n += a &^ (1 << 63)
   113  
   114  	// amd64:"BTRQ\t[$]60"
   115  	n += a &^ (1 << 60)
   116  
   117  	// amd64:"ANDQ\t[$]-2"
   118  	n += a &^ (1 << 0)
   119  
   120  	return n
   121  }
   122  
   123  func clearLastBit(x int64, y int32) (int64, int32) {
   124  	// amd64:"ANDQ\t[$]-2"
   125  	a := (x >> 1) << 1
   126  
   127  	// amd64:"ANDL\t[$]-2"
   128  	b := (y >> 1) << 1
   129  
   130  	return a, b
   131  }
   132  
   133  func bitcompl64(a, b uint64) (n uint64) {
   134  	// amd64:"BTCQ"
   135  	n += b ^ (1 << (a & 63))
   136  
   137  	// amd64:"BTCQ\t[$]63"
   138  	n += a ^ (1 << 63)
   139  
   140  	// amd64:"BTCQ\t[$]60"
   141  	n += a ^ (1 << 60)
   142  
   143  	// amd64:"XORQ\t[$]1"
   144  	n += a ^ (1 << 0)
   145  
   146  	return n
   147  }
   148  
   149  /************************************
   150   * 32-bit instructions
   151   ************************************/
   152  
   153  func bitcheck32_constleft(a uint32) (n int) {
   154  	// amd64:"BTL\t[$]31"
   155  	if a&(1<<31) != 0 {
   156  		return 1
   157  	}
   158  	// amd64:"BTL\t[$]28"
   159  	if a&(1<<28) != 0 {
   160  		return 1
   161  	}
   162  	// amd64:"BTL\t[$]0"
   163  	if a&(1<<0) != 0 {
   164  		return 1
   165  	}
   166  	return 0
   167  }
   168  
   169  func bitcheck32_constright(a [8]uint32) (n int) {
   170  	// amd64:"BTL\t[$]31"
   171  	if (a[0]>>31)&1 != 0 {
   172  		return 1
   173  	}
   174  	// amd64:"BTL\t[$]31"
   175  	if a[1]>>31 != 0 {
   176  		return 1
   177  	}
   178  	// amd64:"BTL\t[$]31"
   179  	if a[2]>>31 == 0 {
   180  		return 1
   181  	}
   182  	// amd64:"BTL\t[$]28"
   183  	if (a[3]>>28)&1 == 0 {
   184  		return 1
   185  	}
   186  	// amd64:"BTL\t[$]1"
   187  	if (a[4]>>1)&1 == 0 {
   188  		return 1
   189  	}
   190  	// amd64:"BTL\t[$]0"
   191  	if (a[5]>>0)&1 == 0 {
   192  		return 1
   193  	}
   194  	// amd64:"BTL\t[$]7"
   195  	if (a[6]>>5)&4 == 0 {
   196  		return 1
   197  	}
   198  	return 0
   199  }
   200  
   201  func bitcheck32_var(a, b uint32) (n int) {
   202  	// amd64:"BTL"
   203  	if a&(1<<(b&31)) != 0 {
   204  		return 1
   205  	}
   206  	// amd64:"BTL",-"BT.\t[$]0"
   207  	if (b>>(a&31))&1 != 0 {
   208  		return 1
   209  	}
   210  	return 0
   211  }
   212  
   213  func bitcheck32_mask(a uint32) (n int) {
   214  	// amd64:"BTL\t[$]31"
   215  	if a&0x80000000 != 0 {
   216  		return 1
   217  	}
   218  	// amd64:"BTL\t[$]27"
   219  	if a&0x8000000 != 0 {
   220  		return 1
   221  	}
   222  	// amd64:"BTL\t[$]0"
   223  	if a&0x1 != 0 {
   224  		return 1
   225  	}
   226  	return 0
   227  }
   228  
   229  func biton32(a, b uint32) (n uint32) {
   230  	// amd64:"BTSL"
   231  	n += b | (1 << (a & 31))
   232  
   233  	// amd64:"ORL\t[$]-2147483648"
   234  	n += a | (1 << 31)
   235  
   236  	// amd64:"ORL\t[$]268435456"
   237  	n += a | (1 << 28)
   238  
   239  	// amd64:"ORL\t[$]1"
   240  	n += a | (1 << 0)
   241  
   242  	return n
   243  }
   244  
   245  func bitoff32(a, b uint32) (n uint32) {
   246  	// amd64:"BTRL"
   247  	n += b &^ (1 << (a & 31))
   248  
   249  	// amd64:"ANDL\t[$]2147483647"
   250  	n += a &^ (1 << 31)
   251  
   252  	// amd64:"ANDL\t[$]-268435457"
   253  	n += a &^ (1 << 28)
   254  
   255  	// amd64:"ANDL\t[$]-2"
   256  	n += a &^ (1 << 0)
   257  
   258  	return n
   259  }
   260  
   261  func bitcompl32(a, b uint32) (n uint32) {
   262  	// amd64:"BTCL"
   263  	n += b ^ (1 << (a & 31))
   264  
   265  	// amd64:"XORL\t[$]-2147483648"
   266  	n += a ^ (1 << 31)
   267  
   268  	// amd64:"XORL\t[$]268435456"
   269  	n += a ^ (1 << 28)
   270  
   271  	// amd64:"XORL\t[$]1"
   272  	n += a ^ (1 << 0)
   273  
   274  	return n
   275  }
   276  
   277  // check direct operation on memory with constant and shifted constant sources
   278  func bitOpOnMem(a []uint32, b, c, d uint32) {
   279  	// amd64:`ANDL\s[$]200,\s\([A-Z][A-Z0-9]+\)`
   280  	a[0] &= 200
   281  	// amd64:`ORL\s[$]220,\s4\([A-Z][A-Z0-9]+\)`
   282  	a[1] |= 220
   283  	// amd64:`XORL\s[$]240,\s8\([A-Z][A-Z0-9]+\)`
   284  	a[2] ^= 240
   285  }
   286  
   287  func bitcheckMostNegative(b uint8) bool {
   288  	// amd64:"TESTB"
   289  	return b&0x80 == 0x80
   290  }
   291  
   292  // Check AND masking on arm64 (Issue #19857)
   293  
   294  func and_mask_1(a uint64) uint64 {
   295  	// arm64:`AND\t`
   296  	return a & ((1 << 63) - 1)
   297  }
   298  
   299  func and_mask_2(a uint64) uint64 {
   300  	// arm64:`AND\t`
   301  	return a & (1 << 63)
   302  }
   303  
   304  func and_mask_3(a, b uint32) (uint32, uint32) {
   305  	// arm/7:`BIC`,-`AND`
   306  	a &= 0xffffaaaa
   307  	// arm/7:`BFC`,-`AND`,-`BIC`
   308  	b &= 0xffc003ff
   309  	return a, b
   310  }
   311  
   312  // Check generation of arm64 BIC/EON/ORN instructions
   313  
   314  func op_bic(x, y uint32) uint32 {
   315  	// arm64:`BIC\t`,-`AND`
   316  	return x &^ y
   317  }
   318  
   319  func op_eon(x, y, z uint32, a []uint32, n, m uint64) uint64 {
   320  	// arm64:`EON\t`,-`EOR`,-`MVN`
   321  	a[0] = x ^ (y ^ 0xffffffff)
   322  
   323  	// arm64:`EON\t`,-`EOR`,-`MVN`
   324  	a[1] = ^(y ^ z)
   325  
   326  	// arm64:`EON\t`,-`XOR`
   327  	a[2] = x ^ ^z
   328  
   329  	// arm64:`EON\t`,-`EOR`,-`MVN`
   330  	return n ^ (m ^ 0xffffffffffffffff)
   331  }
   332  
   333  func op_orn(x, y uint32) uint32 {
   334  	// arm64:`ORN\t`,-`ORR`
   335  	// loong64:"ORN"\t,-"OR\t"
   336  	return x | ^y
   337  }
   338  
   339  func op_nor(x int64, a []int64) {
   340  	// loong64: "MOVV\t[$]0","NOR\tR"
   341  	a[0] = ^(0x1234 | x)
   342  	// loong64:"NOR",-"XOR"
   343  	a[1] = (-1) ^ x
   344  	// loong64: "MOVV\t[$]-55",-"OR",-"NOR"
   345  	a[2] = ^(0x12 | 0x34)
   346  }
   347  
   348  func op_andn(x, y uint32) uint32 {
   349  	// loong64:"ANDN\t",-"AND\t"
   350  	return x &^ y
   351  }
   352  
   353  // check bitsets
   354  func bitSetPowerOf2Test(x int) bool {
   355  	// amd64:"BTL\t[$]3"
   356  	return x&8 == 8
   357  }
   358  
   359  func bitSetTest(x int) bool {
   360  	// amd64:"ANDL\t[$]9, AX"
   361  	// amd64:"CMPQ\tAX, [$]9"
   362  	return x&9 == 9
   363  }
   364  
   365  // mask contiguous one bits
   366  func cont1Mask64U(x uint64) uint64 {
   367  	// s390x:"RISBGZ\t[$]16, [$]47, [$]0,"
   368  	return x & 0x0000ffffffff0000
   369  }
   370  
   371  // mask contiguous zero bits
   372  func cont0Mask64U(x uint64) uint64 {
   373  	// s390x:"RISBGZ\t[$]48, [$]15, [$]0,"
   374  	return x & 0xffff00000000ffff
   375  }
   376  
   377  func issue44228a(a []int64, i int) bool {
   378  	// amd64: "BTQ", -"SHL"
   379  	return a[i>>6]&(1<<(i&63)) != 0
   380  }
   381  func issue44228b(a []int32, i int) bool {
   382  	// amd64: "BTL", -"SHL"
   383  	return a[i>>5]&(1<<(i&31)) != 0
   384  }
   385  
   386  func issue48467(x, y uint64) uint64 {
   387  	// arm64: -"NEG"
   388  	d, borrow := bits.Sub64(x, y, 0)
   389  	return x - d&(-borrow)
   390  }
   391  
   392  func foldConst(x, y uint64) uint64 {
   393  	// arm64: "ADDS\t[$]7",-"MOVD\t[$]7"
   394  	// ppc64x: "ADDC\t[$]7,"
   395  	d, b := bits.Add64(x, 7, 0)
   396  	return b & d
   397  }
   398  
   399  func foldConstOutOfRange(a uint64) uint64 {
   400  	// arm64: "MOVD\t[$]19088744",-"ADD\t[$]19088744"
   401  	return a + 0x1234568
   402  }
   403  
   404  // Verify sign-extended values are not zero-extended under a bit mask (#61297)
   405  func signextendAndMask8to64(a int8) (s, z uint64) {
   406  	// ppc64x: "MOVB", "ANDCC\t[$]1015,"
   407  	s = uint64(a) & 0x3F7
   408  	// ppc64x: -"MOVB", "ANDCC\t[$]247,"
   409  	z = uint64(uint8(a)) & 0x3F7
   410  	return
   411  }
   412  
   413  // Verify zero-extended values are not sign-extended under a bit mask (#61297)
   414  func zeroextendAndMask8to64(a int8, b int16) (x, y uint64) {
   415  	// ppc64x: -"MOVB\t", -"ANDCC", "MOVBZ"
   416  	x = uint64(a) & 0xFF
   417  	// ppc64x: -"MOVH\t", -"ANDCC", "MOVHZ"
   418  	y = uint64(b) & 0xFFFF
   419  	return
   420  }
   421  
   422  // Verify rotate and mask instructions, and further simplified instructions for small types
   423  func bitRotateAndMask(io64 [8]uint64, io32 [4]uint32, io16 [4]uint16, io8 [4]uint8) {
   424  	// ppc64x: "RLDICR\t[$]0, R[0-9]*, [$]47, R"
   425  	io64[0] = io64[0] & 0xFFFFFFFFFFFF0000
   426  	// ppc64x: "RLDICL\t[$]0, R[0-9]*, [$]16, R"
   427  	io64[1] = io64[1] & 0x0000FFFFFFFFFFFF
   428  	// ppc64x: -"SRD", -"AND", "RLDICL\t[$]60, R[0-9]*, [$]16, R"
   429  	io64[2] = (io64[2] >> 4) & 0x0000FFFFFFFFFFFF
   430  	// ppc64x: -"SRD", -"AND", "RLDICL\t[$]36, R[0-9]*, [$]28, R"
   431  	io64[3] = (io64[3] >> 28) & 0x0000FFFFFFFFFFFF
   432  
   433  	// ppc64x: "MOVWZ", "RLWNM\t[$]1, R[0-9]*, [$]28, [$]3, R"
   434  	io64[4] = uint64(bits.RotateLeft32(io32[0], 1) & 0xF000000F)
   435  
   436  	// ppc64x: "RLWNM\t[$]0, R[0-9]*, [$]4, [$]19, R"
   437  	io32[0] = io32[0] & 0x0FFFF000
   438  	// ppc64x: "RLWNM\t[$]0, R[0-9]*, [$]20, [$]3, R"
   439  	io32[1] = io32[1] & 0xF0000FFF
   440  	// ppc64x: -"RLWNM", MOVD, AND
   441  	io32[2] = io32[2] & 0xFFFF0002
   442  
   443  	var bigc uint32 = 0x12345678
   444  	// ppc64x: "ANDCC\t[$]22136"
   445  	io16[0] = io16[0] & uint16(bigc)
   446  
   447  	// ppc64x: "ANDCC\t[$]120"
   448  	io8[0] = io8[0] & uint8(bigc)
   449  }
   450  

View as plain text