github.com/hikaru7719/go@v0.0.0-20181025140707-c8b2ac68906a/test/codegen/bits.go (about) 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 * 64-bit instructions 11 ************************************/ 12 13 func bitcheck64_constleft(a uint64) (n int) { 14 // amd64:"BTQ\t[$]63" 15 if a&(1<<63) != 0 { 16 return 1 17 } 18 // amd64:"BTQ\t[$]60" 19 if a&(1<<60) != 0 { 20 return 1 21 } 22 // amd64:"BTL\t[$]0" 23 if a&(1<<0) != 0 { 24 return 1 25 } 26 return 0 27 } 28 29 func bitcheck64_constright(a [8]uint64) (n int) { 30 // amd64:"BTQ\t[$]63" 31 if (a[0]>>63)&1 != 0 { 32 return 1 33 } 34 // amd64:"BTQ\t[$]63" 35 if a[1]>>63 != 0 { 36 return 1 37 } 38 // amd64:"BTQ\t[$]63" 39 if a[2]>>63 == 0 { 40 return 1 41 } 42 // amd64:"BTQ\t[$]60" 43 if (a[3]>>60)&1 == 0 { 44 return 1 45 } 46 // amd64:"BTL\t[$]1" 47 if (a[4]>>1)&1 == 0 { 48 return 1 49 } 50 // amd64:"BTL\t[$]0" 51 if (a[5]>>0)&1 == 0 { 52 return 1 53 } 54 // amd64:"BTL\t[$]7" 55 if (a[6]>>5)&4 == 0 { 56 return 1 57 } 58 return 0 59 } 60 61 func bitcheck64_var(a, b uint64) (n int) { 62 // amd64:"BTQ" 63 if a&(1<<(b&63)) != 0 { 64 return 1 65 } 66 // amd64:"BTQ",-"BT.\t[$]0" 67 if (b>>(a&63))&1 != 0 { 68 return 1 69 } 70 return 0 71 } 72 73 func bitcheck64_mask(a uint64) (n int) { 74 // amd64:"BTQ\t[$]63" 75 if a&0x8000000000000000 != 0 { 76 return 1 77 } 78 // amd64:"BTQ\t[$]59" 79 if a&0x800000000000000 != 0 { 80 return 1 81 } 82 // amd64:"BTL\t[$]0" 83 if a&0x1 != 0 { 84 return 1 85 } 86 return 0 87 } 88 89 func biton64(a, b uint64) (n uint64) { 90 // amd64:"BTSQ" 91 n += b | (1 << (a & 63)) 92 93 // amd64:"BTSQ\t[$]63" 94 n += a | (1 << 63) 95 96 // amd64:"BTSQ\t[$]60" 97 n += a | (1 << 60) 98 99 // amd64:"ORQ\t[$]1" 100 n += a | (1 << 0) 101 102 return n 103 } 104 105 func bitoff64(a, b uint64) (n uint64) { 106 // amd64:"BTRQ" 107 n += b &^ (1 << (a & 63)) 108 109 // amd64:"BTRQ\t[$]63" 110 n += a &^ (1 << 63) 111 112 // amd64:"BTRQ\t[$]60" 113 n += a &^ (1 << 60) 114 115 // amd64:"ANDQ\t[$]-2" 116 n += a &^ (1 << 0) 117 118 return n 119 } 120 121 func bitcompl64(a, b uint64) (n uint64) { 122 // amd64:"BTCQ" 123 n += b ^ (1 << (a & 63)) 124 125 // amd64:"BTCQ\t[$]63" 126 n += a ^ (1 << 63) 127 128 // amd64:"BTCQ\t[$]60" 129 n += a ^ (1 << 60) 130 131 // amd64:"XORQ\t[$]1" 132 n += a ^ (1 << 0) 133 134 return n 135 } 136 137 /************************************ 138 * 32-bit instructions 139 ************************************/ 140 141 func bitcheck32_constleft(a uint32) (n int) { 142 // amd64:"BTL\t[$]31" 143 if a&(1<<31) != 0 { 144 return 1 145 } 146 // amd64:"BTL\t[$]28" 147 if a&(1<<28) != 0 { 148 return 1 149 } 150 // amd64:"BTL\t[$]0" 151 if a&(1<<0) != 0 { 152 return 1 153 } 154 return 0 155 } 156 157 func bitcheck32_constright(a [8]uint32) (n int) { 158 // amd64:"BTL\t[$]31" 159 if (a[0]>>31)&1 != 0 { 160 return 1 161 } 162 // amd64:"BTL\t[$]31" 163 if a[1]>>31 != 0 { 164 return 1 165 } 166 // amd64:"BTL\t[$]31" 167 if a[2]>>31 == 0 { 168 return 1 169 } 170 // amd64:"BTL\t[$]28" 171 if (a[3]>>28)&1 == 0 { 172 return 1 173 } 174 // amd64:"BTL\t[$]1" 175 if (a[4]>>1)&1 == 0 { 176 return 1 177 } 178 // amd64:"BTL\t[$]0" 179 if (a[5]>>0)&1 == 0 { 180 return 1 181 } 182 // amd64:"BTL\t[$]7" 183 if (a[6]>>5)&4 == 0 { 184 return 1 185 } 186 return 0 187 } 188 189 func bitcheck32_var(a, b uint32) (n int) { 190 // amd64:"BTL" 191 if a&(1<<(b&31)) != 0 { 192 return 1 193 } 194 // amd64:"BTL",-"BT.\t[$]0" 195 if (b>>(a&31))&1 != 0 { 196 return 1 197 } 198 return 0 199 } 200 201 func bitcheck32_mask(a uint32) (n int) { 202 // amd64:"BTL\t[$]31" 203 if a&0x80000000 != 0 { 204 return 1 205 } 206 // amd64:"BTL\t[$]27" 207 if a&0x8000000 != 0 { 208 return 1 209 } 210 // amd64:"BTL\t[$]0" 211 if a&0x1 != 0 { 212 return 1 213 } 214 return 0 215 } 216 217 func biton32(a, b uint32) (n uint32) { 218 // amd64:"BTSL" 219 n += b | (1 << (a & 31)) 220 221 // amd64:"BTSL\t[$]31" 222 n += a | (1 << 31) 223 224 // amd64:"BTSL\t[$]28" 225 n += a | (1 << 28) 226 227 // amd64:"ORL\t[$]1" 228 n += a | (1 << 0) 229 230 return n 231 } 232 233 func bitoff32(a, b uint32) (n uint32) { 234 // amd64:"BTRL" 235 n += b &^ (1 << (a & 31)) 236 237 // amd64:"BTRL\t[$]31" 238 n += a &^ (1 << 31) 239 240 // amd64:"BTRL\t[$]28" 241 n += a &^ (1 << 28) 242 243 // amd64:"ANDL\t[$]-2" 244 n += a &^ (1 << 0) 245 246 return n 247 } 248 249 func bitcompl32(a, b uint32) (n uint32) { 250 // amd64:"BTCL" 251 n += b ^ (1 << (a & 31)) 252 253 // amd64:"BTCL\t[$]31" 254 n += a ^ (1 << 31) 255 256 // amd64:"BTCL\t[$]28" 257 n += a ^ (1 << 28) 258 259 // amd64:"XORL\t[$]1" 260 n += a ^ (1 << 0) 261 262 return n 263 } 264 265 // check direct operation on memory with constant source 266 func bitOpOnMem(a []uint32) { 267 // amd64:`ANDL\s[$]200,\s\([A-Z]+\)` 268 a[0] &= 200 269 // amd64:`ORL\s[$]220,\s4\([A-Z]+\)` 270 a[1] |= 220 271 // amd64:`XORL\s[$]240,\s8\([A-Z]+\)` 272 a[2] ^= 240 273 // amd64:`BTRL\s[$]15,\s12\([A-Z]+\)`,-`ANDL` 274 a[3] &= 0xffff7fff 275 // amd64:`BTSL\s[$]14,\s16\([A-Z]+\)`,-`ORL` 276 a[4] |= 0x4000 277 // amd64:`BTCL\s[$]13,\s20\([A-Z]+\)`,-`XORL` 278 a[5] ^= 0x2000 279 } 280 281 // Check AND masking on arm64 (Issue #19857) 282 283 func and_mask_1(a uint64) uint64 { 284 // arm64:`AND\t` 285 return a & ((1 << 63) - 1) 286 } 287 288 func and_mask_2(a uint64) uint64 { 289 // arm64:`AND\t` 290 return a & (1 << 63) 291 } 292 293 func and_mask_3(a, b uint32) (uint32, uint32) { 294 // arm/7:`BIC`,-`AND` 295 a &= 0xffffaaaa 296 // arm/7:`BFC`,-`AND`,-`BIC` 297 b &= 0xffc003ff 298 return a, b 299 } 300 301 // Check generation of arm64 BIC/EON/ORN instructions 302 303 func op_bic(x, y uint32) uint32 { 304 // arm64:`BIC\t`,-`AND` 305 return x &^ y 306 } 307 308 func op_eon(x, y uint32) uint32 { 309 // arm64:`EON\t`,-`XOR` 310 return x ^ ^y 311 } 312 313 func op_orn(x, y uint32) uint32 { 314 // arm64:`ORN\t`,-`ORR` 315 return x | ^y 316 }