github.com/goplus/igop@v0.25.0/binop.go (about) 1 /* 2 * Copyright (c) 2022 The GoPlus Authors (goplus.org). All rights reserved. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package igop 18 19 import ( 20 "reflect" 21 22 "github.com/visualfc/xtype" 23 "golang.org/x/tools/go/ssa" 24 ) 25 26 func makeBinOpADD(pfn *function, instr *ssa.BinOp) func(fr *frame) { 27 ir := pfn.regIndex(instr) 28 ix, kx, vx := pfn.regIndex3(instr.X) 29 iy, ky, vy := pfn.regIndex3(instr.Y) 30 typ := pfn.Interp.preToType(instr.Type()) 31 if typ.PkgPath() == "" { 32 switch typ.Kind() { 33 case reflect.Int: 34 if kx == kindConst && ky == kindConst { 35 v := vx.(int) + vy.(int) 36 return func(fr *frame) { fr.setReg(ir, v) } 37 } else if kx == kindConst { 38 x := vx.(int) 39 return func(fr *frame) { fr.setReg(ir, x+fr.reg(iy).(int)) } 40 } else if ky == kindConst { 41 y := vy.(int) 42 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)+y) } 43 } else { 44 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)+fr.reg(iy).(int)) } 45 } 46 case reflect.Int8: 47 if kx == kindConst && ky == kindConst { 48 v := vx.(int8) + vy.(int8) 49 return func(fr *frame) { fr.setReg(ir, v) } 50 } else if kx == kindConst { 51 x := vx.(int8) 52 return func(fr *frame) { fr.setReg(ir, x+fr.reg(iy).(int8)) } 53 } else if ky == kindConst { 54 y := vy.(int8) 55 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)+y) } 56 } else { 57 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)+fr.reg(iy).(int8)) } 58 } 59 case reflect.Int16: 60 if kx == kindConst && ky == kindConst { 61 v := vx.(int16) + vy.(int16) 62 return func(fr *frame) { fr.setReg(ir, v) } 63 } else if kx == kindConst { 64 x := vx.(int16) 65 return func(fr *frame) { fr.setReg(ir, x+fr.reg(iy).(int16)) } 66 } else if ky == kindConst { 67 y := vy.(int16) 68 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)+y) } 69 } else { 70 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)+fr.reg(iy).(int16)) } 71 } 72 case reflect.Int32: 73 if kx == kindConst && ky == kindConst { 74 v := vx.(int32) + vy.(int32) 75 return func(fr *frame) { fr.setReg(ir, v) } 76 } else if kx == kindConst { 77 x := vx.(int32) 78 return func(fr *frame) { fr.setReg(ir, x+fr.reg(iy).(int32)) } 79 } else if ky == kindConst { 80 y := vy.(int32) 81 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)+y) } 82 } else { 83 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)+fr.reg(iy).(int32)) } 84 } 85 case reflect.Int64: 86 if kx == kindConst && ky == kindConst { 87 v := vx.(int64) + vy.(int64) 88 return func(fr *frame) { fr.setReg(ir, v) } 89 } else if kx == kindConst { 90 x := vx.(int64) 91 return func(fr *frame) { fr.setReg(ir, x+fr.reg(iy).(int64)) } 92 } else if ky == kindConst { 93 y := vy.(int64) 94 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)+y) } 95 } else { 96 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)+fr.reg(iy).(int64)) } 97 } 98 case reflect.Uint: 99 if kx == kindConst && ky == kindConst { 100 v := vx.(uint) + vy.(uint) 101 return func(fr *frame) { fr.setReg(ir, v) } 102 } else if kx == kindConst { 103 x := vx.(uint) 104 return func(fr *frame) { fr.setReg(ir, x+fr.reg(iy).(uint)) } 105 } else if ky == kindConst { 106 y := vy.(uint) 107 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)+y) } 108 } else { 109 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)+fr.reg(iy).(uint)) } 110 } 111 case reflect.Uint8: 112 if kx == kindConst && ky == kindConst { 113 v := vx.(uint8) + vy.(uint8) 114 return func(fr *frame) { fr.setReg(ir, v) } 115 } else if kx == kindConst { 116 x := vx.(uint8) 117 return func(fr *frame) { fr.setReg(ir, x+fr.reg(iy).(uint8)) } 118 } else if ky == kindConst { 119 y := vy.(uint8) 120 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)+y) } 121 } else { 122 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)+fr.reg(iy).(uint8)) } 123 } 124 case reflect.Uint16: 125 if kx == kindConst && ky == kindConst { 126 v := vx.(uint16) + vy.(uint16) 127 return func(fr *frame) { fr.setReg(ir, v) } 128 } else if kx == kindConst { 129 x := vx.(uint16) 130 return func(fr *frame) { fr.setReg(ir, x+fr.reg(iy).(uint16)) } 131 } else if ky == kindConst { 132 y := vy.(uint16) 133 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)+y) } 134 } else { 135 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)+fr.reg(iy).(uint16)) } 136 } 137 case reflect.Uint32: 138 if kx == kindConst && ky == kindConst { 139 v := vx.(uint32) + vy.(uint32) 140 return func(fr *frame) { fr.setReg(ir, v) } 141 } else if kx == kindConst { 142 x := vx.(uint32) 143 return func(fr *frame) { fr.setReg(ir, x+fr.reg(iy).(uint32)) } 144 } else if ky == kindConst { 145 y := vy.(uint32) 146 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)+y) } 147 } else { 148 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)+fr.reg(iy).(uint32)) } 149 } 150 case reflect.Uint64: 151 if kx == kindConst && ky == kindConst { 152 v := vx.(uint64) + vy.(uint64) 153 return func(fr *frame) { fr.setReg(ir, v) } 154 } else if kx == kindConst { 155 x := vx.(uint64) 156 return func(fr *frame) { fr.setReg(ir, x+fr.reg(iy).(uint64)) } 157 } else if ky == kindConst { 158 y := vy.(uint64) 159 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)+y) } 160 } else { 161 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)+fr.reg(iy).(uint64)) } 162 } 163 case reflect.Uintptr: 164 if kx == kindConst && ky == kindConst { 165 v := vx.(uintptr) + vy.(uintptr) 166 return func(fr *frame) { fr.setReg(ir, v) } 167 } else if kx == kindConst { 168 x := vx.(uintptr) 169 return func(fr *frame) { fr.setReg(ir, x+fr.reg(iy).(uintptr)) } 170 } else if ky == kindConst { 171 y := vy.(uintptr) 172 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)+y) } 173 } else { 174 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)+fr.reg(iy).(uintptr)) } 175 } 176 case reflect.Float32: 177 if kx == kindConst && ky == kindConst { 178 v := vx.(float32) + vy.(float32) 179 return func(fr *frame) { fr.setReg(ir, v) } 180 } else if kx == kindConst { 181 x := vx.(float32) 182 return func(fr *frame) { fr.setReg(ir, x+fr.reg(iy).(float32)) } 183 } else if ky == kindConst { 184 y := vy.(float32) 185 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float32)+y) } 186 } else { 187 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float32)+fr.reg(iy).(float32)) } 188 } 189 case reflect.Float64: 190 if kx == kindConst && ky == kindConst { 191 v := vx.(float64) + vy.(float64) 192 return func(fr *frame) { fr.setReg(ir, v) } 193 } else if kx == kindConst { 194 x := vx.(float64) 195 return func(fr *frame) { fr.setReg(ir, x+fr.reg(iy).(float64)) } 196 } else if ky == kindConst { 197 y := vy.(float64) 198 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float64)+y) } 199 } else { 200 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float64)+fr.reg(iy).(float64)) } 201 } 202 case reflect.Complex64: 203 if kx == kindConst && ky == kindConst { 204 v := vx.(complex64) + vy.(complex64) 205 return func(fr *frame) { fr.setReg(ir, v) } 206 } else if kx == kindConst { 207 x := vx.(complex64) 208 return func(fr *frame) { fr.setReg(ir, x+fr.reg(iy).(complex64)) } 209 } else if ky == kindConst { 210 y := vy.(complex64) 211 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(complex64)+y) } 212 } else { 213 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(complex64)+fr.reg(iy).(complex64)) } 214 } 215 case reflect.Complex128: 216 if kx == kindConst && ky == kindConst { 217 v := vx.(complex128) + vy.(complex128) 218 return func(fr *frame) { fr.setReg(ir, v) } 219 } else if kx == kindConst { 220 x := vx.(complex128) 221 return func(fr *frame) { fr.setReg(ir, x+fr.reg(iy).(complex128)) } 222 } else if ky == kindConst { 223 y := vy.(complex128) 224 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(complex128)+y) } 225 } else { 226 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(complex128)+fr.reg(iy).(complex128)) } 227 } 228 case reflect.String: 229 if kx == kindConst && ky == kindConst { 230 v := vx.(string) + vy.(string) 231 return func(fr *frame) { fr.setReg(ir, v) } 232 } else if kx == kindConst { 233 x := vx.(string) 234 return func(fr *frame) { fr.setReg(ir, x+fr.reg(iy).(string)) } 235 } else if ky == kindConst { 236 y := vy.(string) 237 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(string)+y) } 238 } else { 239 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(string)+fr.reg(iy).(string)) } 240 } 241 } 242 } else { 243 t := xtype.TypeOfType(typ) 244 switch typ.Kind() { 245 case reflect.Int: 246 if kx == kindConst && ky == kindConst { 247 v := xtype.Make(t, xtype.Int(vx)+xtype.Int(vy)) 248 return func(fr *frame) { fr.setReg(ir, v) } 249 } else if kx == kindConst { 250 x := xtype.Int(vx) 251 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x+fr.int(iy))) } 252 } else if ky == kindConst { 253 y := xtype.Int(vy) 254 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)+y)) } 255 } else { 256 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)+fr.int(iy))) } 257 } 258 case reflect.Int8: 259 if kx == kindConst && ky == kindConst { 260 v := xtype.Make(t, xtype.Int8(vx)+xtype.Int8(vy)) 261 return func(fr *frame) { fr.setReg(ir, v) } 262 } else if kx == kindConst { 263 x := xtype.Int8(vx) 264 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x+fr.int8(iy))) } 265 } else if ky == kindConst { 266 y := xtype.Int8(vy) 267 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)+y)) } 268 } else { 269 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)+fr.int8(iy))) } 270 } 271 case reflect.Int16: 272 if kx == kindConst && ky == kindConst { 273 v := xtype.Make(t, xtype.Int16(vx)+xtype.Int16(vy)) 274 return func(fr *frame) { fr.setReg(ir, v) } 275 } else if kx == kindConst { 276 x := xtype.Int16(vx) 277 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x+fr.int16(iy))) } 278 } else if ky == kindConst { 279 y := xtype.Int16(vy) 280 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)+y)) } 281 } else { 282 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)+fr.int16(iy))) } 283 } 284 case reflect.Int32: 285 if kx == kindConst && ky == kindConst { 286 v := xtype.Make(t, xtype.Int32(vx)+xtype.Int32(vy)) 287 return func(fr *frame) { fr.setReg(ir, v) } 288 } else if kx == kindConst { 289 x := xtype.Int32(vx) 290 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x+fr.int32(iy))) } 291 } else if ky == kindConst { 292 y := xtype.Int32(vy) 293 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)+y)) } 294 } else { 295 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)+fr.int32(iy))) } 296 } 297 case reflect.Int64: 298 if kx == kindConst && ky == kindConst { 299 v := xtype.Make(t, xtype.Int64(vx)+xtype.Int64(vy)) 300 return func(fr *frame) { fr.setReg(ir, v) } 301 } else if kx == kindConst { 302 x := xtype.Int64(vx) 303 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x+fr.int64(iy))) } 304 } else if ky == kindConst { 305 y := xtype.Int64(vy) 306 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)+y)) } 307 } else { 308 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)+fr.int64(iy))) } 309 } 310 case reflect.Uint: 311 if kx == kindConst && ky == kindConst { 312 v := xtype.Make(t, xtype.Uint(vx)+xtype.Uint(vy)) 313 return func(fr *frame) { fr.setReg(ir, v) } 314 } else if kx == kindConst { 315 x := xtype.Uint(vx) 316 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x+fr.uint(iy))) } 317 } else if ky == kindConst { 318 y := xtype.Uint(vy) 319 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)+y)) } 320 } else { 321 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)+fr.uint(iy))) } 322 } 323 case reflect.Uint8: 324 if kx == kindConst && ky == kindConst { 325 v := xtype.Make(t, xtype.Uint8(vx)+xtype.Uint8(vy)) 326 return func(fr *frame) { fr.setReg(ir, v) } 327 } else if kx == kindConst { 328 x := xtype.Uint8(vx) 329 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x+fr.uint8(iy))) } 330 } else if ky == kindConst { 331 y := xtype.Uint8(vy) 332 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)+y)) } 333 } else { 334 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)+fr.uint8(iy))) } 335 } 336 case reflect.Uint16: 337 if kx == kindConst && ky == kindConst { 338 v := xtype.Make(t, xtype.Uint16(vx)+xtype.Uint16(vy)) 339 return func(fr *frame) { fr.setReg(ir, v) } 340 } else if kx == kindConst { 341 x := xtype.Uint16(vx) 342 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x+fr.uint16(iy))) } 343 } else if ky == kindConst { 344 y := xtype.Uint16(vy) 345 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)+y)) } 346 } else { 347 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)+fr.uint16(iy))) } 348 } 349 case reflect.Uint32: 350 if kx == kindConst && ky == kindConst { 351 v := xtype.Make(t, xtype.Uint32(vx)+xtype.Uint32(vy)) 352 return func(fr *frame) { fr.setReg(ir, v) } 353 } else if kx == kindConst { 354 x := xtype.Uint32(vx) 355 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x+fr.uint32(iy))) } 356 } else if ky == kindConst { 357 y := xtype.Uint32(vy) 358 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)+y)) } 359 } else { 360 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)+fr.uint32(iy))) } 361 } 362 case reflect.Uint64: 363 if kx == kindConst && ky == kindConst { 364 v := xtype.Make(t, xtype.Uint64(vx)+xtype.Uint64(vy)) 365 return func(fr *frame) { fr.setReg(ir, v) } 366 } else if kx == kindConst { 367 x := xtype.Uint64(vx) 368 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x+fr.uint64(iy))) } 369 } else if ky == kindConst { 370 y := xtype.Uint64(vy) 371 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)+y)) } 372 } else { 373 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)+fr.uint64(iy))) } 374 } 375 case reflect.Uintptr: 376 if kx == kindConst && ky == kindConst { 377 v := xtype.Make(t, xtype.Uintptr(vx)+xtype.Uintptr(vy)) 378 return func(fr *frame) { fr.setReg(ir, v) } 379 } else if kx == kindConst { 380 x := xtype.Uintptr(vx) 381 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x+fr.uintptr(iy))) } 382 } else if ky == kindConst { 383 y := xtype.Uintptr(vy) 384 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)+y)) } 385 } else { 386 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)+fr.uintptr(iy))) } 387 } 388 case reflect.Float32: 389 if kx == kindConst && ky == kindConst { 390 v := xtype.Make(t, xtype.Float32(vx)+xtype.Float32(vy)) 391 return func(fr *frame) { fr.setReg(ir, v) } 392 } else if kx == kindConst { 393 x := xtype.Float32(vx) 394 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x+fr.float32(iy))) } 395 } else if ky == kindConst { 396 y := xtype.Float32(vy) 397 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.float32(ix)+y)) } 398 } else { 399 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.float32(ix)+fr.float32(iy))) } 400 } 401 case reflect.Float64: 402 if kx == kindConst && ky == kindConst { 403 v := xtype.Make(t, xtype.Float64(vx)+xtype.Float64(vy)) 404 return func(fr *frame) { fr.setReg(ir, v) } 405 } else if kx == kindConst { 406 x := xtype.Float64(vx) 407 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x+fr.float64(iy))) } 408 } else if ky == kindConst { 409 y := xtype.Float64(vy) 410 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.float64(ix)+y)) } 411 } else { 412 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.float64(ix)+fr.float64(iy))) } 413 } 414 case reflect.Complex64: 415 if kx == kindConst && ky == kindConst { 416 v := xtype.Make(t, xtype.Complex64(vx)+xtype.Complex64(vy)) 417 return func(fr *frame) { fr.setReg(ir, v) } 418 } else if kx == kindConst { 419 x := xtype.Complex64(vx) 420 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x+fr.complex64(iy))) } 421 } else if ky == kindConst { 422 y := xtype.Complex64(vy) 423 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.complex64(ix)+y)) } 424 } else { 425 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.complex64(ix)+fr.complex64(iy))) } 426 } 427 case reflect.Complex128: 428 if kx == kindConst && ky == kindConst { 429 v := xtype.Make(t, xtype.Complex128(vx)+xtype.Complex128(vy)) 430 return func(fr *frame) { fr.setReg(ir, v) } 431 } else if kx == kindConst { 432 x := xtype.Complex128(vx) 433 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x+fr.complex128(iy))) } 434 } else if ky == kindConst { 435 y := xtype.Complex128(vy) 436 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.complex128(ix)+y)) } 437 } else { 438 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.complex128(ix)+fr.complex128(iy))) } 439 } 440 case reflect.String: 441 if kx == kindConst && ky == kindConst { 442 v := xtype.Make(t, xtype.String(vx)+xtype.String(vy)) 443 return func(fr *frame) { fr.setReg(ir, v) } 444 } else if kx == kindConst { 445 x := xtype.String(vx) 446 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x+fr.string(iy))) } 447 } else if ky == kindConst { 448 y := xtype.String(vy) 449 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.string(ix)+y)) } 450 } else { 451 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.string(ix)+fr.string(iy))) } 452 } 453 } 454 } 455 panic("unreachable") 456 } 457 func makeBinOpSUB(pfn *function, instr *ssa.BinOp) func(fr *frame) { 458 ir := pfn.regIndex(instr) 459 ix, kx, vx := pfn.regIndex3(instr.X) 460 iy, ky, vy := pfn.regIndex3(instr.Y) 461 typ := pfn.Interp.preToType(instr.Type()) 462 if typ.PkgPath() == "" { 463 switch typ.Kind() { 464 case reflect.Int: 465 if kx == kindConst && ky == kindConst { 466 v := vx.(int) - vy.(int) 467 return func(fr *frame) { fr.setReg(ir, v) } 468 } else if kx == kindConst { 469 x := vx.(int) 470 return func(fr *frame) { fr.setReg(ir, x-fr.reg(iy).(int)) } 471 } else if ky == kindConst { 472 y := vy.(int) 473 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)-y) } 474 } else { 475 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)-fr.reg(iy).(int)) } 476 } 477 case reflect.Int8: 478 if kx == kindConst && ky == kindConst { 479 v := vx.(int8) - vy.(int8) 480 return func(fr *frame) { fr.setReg(ir, v) } 481 } else if kx == kindConst { 482 x := vx.(int8) 483 return func(fr *frame) { fr.setReg(ir, x-fr.reg(iy).(int8)) } 484 } else if ky == kindConst { 485 y := vy.(int8) 486 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)-y) } 487 } else { 488 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)-fr.reg(iy).(int8)) } 489 } 490 case reflect.Int16: 491 if kx == kindConst && ky == kindConst { 492 v := vx.(int16) - vy.(int16) 493 return func(fr *frame) { fr.setReg(ir, v) } 494 } else if kx == kindConst { 495 x := vx.(int16) 496 return func(fr *frame) { fr.setReg(ir, x-fr.reg(iy).(int16)) } 497 } else if ky == kindConst { 498 y := vy.(int16) 499 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)-y) } 500 } else { 501 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)-fr.reg(iy).(int16)) } 502 } 503 case reflect.Int32: 504 if kx == kindConst && ky == kindConst { 505 v := vx.(int32) - vy.(int32) 506 return func(fr *frame) { fr.setReg(ir, v) } 507 } else if kx == kindConst { 508 x := vx.(int32) 509 return func(fr *frame) { fr.setReg(ir, x-fr.reg(iy).(int32)) } 510 } else if ky == kindConst { 511 y := vy.(int32) 512 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)-y) } 513 } else { 514 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)-fr.reg(iy).(int32)) } 515 } 516 case reflect.Int64: 517 if kx == kindConst && ky == kindConst { 518 v := vx.(int64) - vy.(int64) 519 return func(fr *frame) { fr.setReg(ir, v) } 520 } else if kx == kindConst { 521 x := vx.(int64) 522 return func(fr *frame) { fr.setReg(ir, x-fr.reg(iy).(int64)) } 523 } else if ky == kindConst { 524 y := vy.(int64) 525 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)-y) } 526 } else { 527 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)-fr.reg(iy).(int64)) } 528 } 529 case reflect.Uint: 530 if kx == kindConst && ky == kindConst { 531 v := vx.(uint) - vy.(uint) 532 return func(fr *frame) { fr.setReg(ir, v) } 533 } else if kx == kindConst { 534 x := vx.(uint) 535 return func(fr *frame) { fr.setReg(ir, x-fr.reg(iy).(uint)) } 536 } else if ky == kindConst { 537 y := vy.(uint) 538 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)-y) } 539 } else { 540 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)-fr.reg(iy).(uint)) } 541 } 542 case reflect.Uint8: 543 if kx == kindConst && ky == kindConst { 544 v := vx.(uint8) - vy.(uint8) 545 return func(fr *frame) { fr.setReg(ir, v) } 546 } else if kx == kindConst { 547 x := vx.(uint8) 548 return func(fr *frame) { fr.setReg(ir, x-fr.reg(iy).(uint8)) } 549 } else if ky == kindConst { 550 y := vy.(uint8) 551 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)-y) } 552 } else { 553 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)-fr.reg(iy).(uint8)) } 554 } 555 case reflect.Uint16: 556 if kx == kindConst && ky == kindConst { 557 v := vx.(uint16) - vy.(uint16) 558 return func(fr *frame) { fr.setReg(ir, v) } 559 } else if kx == kindConst { 560 x := vx.(uint16) 561 return func(fr *frame) { fr.setReg(ir, x-fr.reg(iy).(uint16)) } 562 } else if ky == kindConst { 563 y := vy.(uint16) 564 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)-y) } 565 } else { 566 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)-fr.reg(iy).(uint16)) } 567 } 568 case reflect.Uint32: 569 if kx == kindConst && ky == kindConst { 570 v := vx.(uint32) - vy.(uint32) 571 return func(fr *frame) { fr.setReg(ir, v) } 572 } else if kx == kindConst { 573 x := vx.(uint32) 574 return func(fr *frame) { fr.setReg(ir, x-fr.reg(iy).(uint32)) } 575 } else if ky == kindConst { 576 y := vy.(uint32) 577 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)-y) } 578 } else { 579 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)-fr.reg(iy).(uint32)) } 580 } 581 case reflect.Uint64: 582 if kx == kindConst && ky == kindConst { 583 v := vx.(uint64) - vy.(uint64) 584 return func(fr *frame) { fr.setReg(ir, v) } 585 } else if kx == kindConst { 586 x := vx.(uint64) 587 return func(fr *frame) { fr.setReg(ir, x-fr.reg(iy).(uint64)) } 588 } else if ky == kindConst { 589 y := vy.(uint64) 590 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)-y) } 591 } else { 592 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)-fr.reg(iy).(uint64)) } 593 } 594 case reflect.Uintptr: 595 if kx == kindConst && ky == kindConst { 596 v := vx.(uintptr) - vy.(uintptr) 597 return func(fr *frame) { fr.setReg(ir, v) } 598 } else if kx == kindConst { 599 x := vx.(uintptr) 600 return func(fr *frame) { fr.setReg(ir, x-fr.reg(iy).(uintptr)) } 601 } else if ky == kindConst { 602 y := vy.(uintptr) 603 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)-y) } 604 } else { 605 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)-fr.reg(iy).(uintptr)) } 606 } 607 case reflect.Float32: 608 if kx == kindConst && ky == kindConst { 609 v := vx.(float32) - vy.(float32) 610 return func(fr *frame) { fr.setReg(ir, v) } 611 } else if kx == kindConst { 612 x := vx.(float32) 613 return func(fr *frame) { fr.setReg(ir, x-fr.reg(iy).(float32)) } 614 } else if ky == kindConst { 615 y := vy.(float32) 616 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float32)-y) } 617 } else { 618 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float32)-fr.reg(iy).(float32)) } 619 } 620 case reflect.Float64: 621 if kx == kindConst && ky == kindConst { 622 v := vx.(float64) - vy.(float64) 623 return func(fr *frame) { fr.setReg(ir, v) } 624 } else if kx == kindConst { 625 x := vx.(float64) 626 return func(fr *frame) { fr.setReg(ir, x-fr.reg(iy).(float64)) } 627 } else if ky == kindConst { 628 y := vy.(float64) 629 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float64)-y) } 630 } else { 631 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float64)-fr.reg(iy).(float64)) } 632 } 633 case reflect.Complex64: 634 if kx == kindConst && ky == kindConst { 635 v := vx.(complex64) - vy.(complex64) 636 return func(fr *frame) { fr.setReg(ir, v) } 637 } else if kx == kindConst { 638 x := vx.(complex64) 639 return func(fr *frame) { fr.setReg(ir, x-fr.reg(iy).(complex64)) } 640 } else if ky == kindConst { 641 y := vy.(complex64) 642 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(complex64)-y) } 643 } else { 644 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(complex64)-fr.reg(iy).(complex64)) } 645 } 646 case reflect.Complex128: 647 if kx == kindConst && ky == kindConst { 648 v := vx.(complex128) - vy.(complex128) 649 return func(fr *frame) { fr.setReg(ir, v) } 650 } else if kx == kindConst { 651 x := vx.(complex128) 652 return func(fr *frame) { fr.setReg(ir, x-fr.reg(iy).(complex128)) } 653 } else if ky == kindConst { 654 y := vy.(complex128) 655 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(complex128)-y) } 656 } else { 657 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(complex128)-fr.reg(iy).(complex128)) } 658 } 659 } 660 } else { 661 t := xtype.TypeOfType(typ) 662 switch typ.Kind() { 663 case reflect.Int: 664 if kx == kindConst && ky == kindConst { 665 v := xtype.Make(t, xtype.Int(vx)-xtype.Int(vy)) 666 return func(fr *frame) { fr.setReg(ir, v) } 667 } else if kx == kindConst { 668 x := xtype.Int(vx) 669 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x-fr.int(iy))) } 670 } else if ky == kindConst { 671 y := xtype.Int(vy) 672 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)-y)) } 673 } else { 674 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)-fr.int(iy))) } 675 } 676 case reflect.Int8: 677 if kx == kindConst && ky == kindConst { 678 v := xtype.Make(t, xtype.Int8(vx)-xtype.Int8(vy)) 679 return func(fr *frame) { fr.setReg(ir, v) } 680 } else if kx == kindConst { 681 x := xtype.Int8(vx) 682 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x-fr.int8(iy))) } 683 } else if ky == kindConst { 684 y := xtype.Int8(vy) 685 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)-y)) } 686 } else { 687 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)-fr.int8(iy))) } 688 } 689 case reflect.Int16: 690 if kx == kindConst && ky == kindConst { 691 v := xtype.Make(t, xtype.Int16(vx)-xtype.Int16(vy)) 692 return func(fr *frame) { fr.setReg(ir, v) } 693 } else if kx == kindConst { 694 x := xtype.Int16(vx) 695 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x-fr.int16(iy))) } 696 } else if ky == kindConst { 697 y := xtype.Int16(vy) 698 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)-y)) } 699 } else { 700 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)-fr.int16(iy))) } 701 } 702 case reflect.Int32: 703 if kx == kindConst && ky == kindConst { 704 v := xtype.Make(t, xtype.Int32(vx)-xtype.Int32(vy)) 705 return func(fr *frame) { fr.setReg(ir, v) } 706 } else if kx == kindConst { 707 x := xtype.Int32(vx) 708 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x-fr.int32(iy))) } 709 } else if ky == kindConst { 710 y := xtype.Int32(vy) 711 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)-y)) } 712 } else { 713 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)-fr.int32(iy))) } 714 } 715 case reflect.Int64: 716 if kx == kindConst && ky == kindConst { 717 v := xtype.Make(t, xtype.Int64(vx)-xtype.Int64(vy)) 718 return func(fr *frame) { fr.setReg(ir, v) } 719 } else if kx == kindConst { 720 x := xtype.Int64(vx) 721 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x-fr.int64(iy))) } 722 } else if ky == kindConst { 723 y := xtype.Int64(vy) 724 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)-y)) } 725 } else { 726 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)-fr.int64(iy))) } 727 } 728 case reflect.Uint: 729 if kx == kindConst && ky == kindConst { 730 v := xtype.Make(t, xtype.Uint(vx)-xtype.Uint(vy)) 731 return func(fr *frame) { fr.setReg(ir, v) } 732 } else if kx == kindConst { 733 x := xtype.Uint(vx) 734 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x-fr.uint(iy))) } 735 } else if ky == kindConst { 736 y := xtype.Uint(vy) 737 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)-y)) } 738 } else { 739 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)-fr.uint(iy))) } 740 } 741 case reflect.Uint8: 742 if kx == kindConst && ky == kindConst { 743 v := xtype.Make(t, xtype.Uint8(vx)-xtype.Uint8(vy)) 744 return func(fr *frame) { fr.setReg(ir, v) } 745 } else if kx == kindConst { 746 x := xtype.Uint8(vx) 747 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x-fr.uint8(iy))) } 748 } else if ky == kindConst { 749 y := xtype.Uint8(vy) 750 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)-y)) } 751 } else { 752 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)-fr.uint8(iy))) } 753 } 754 case reflect.Uint16: 755 if kx == kindConst && ky == kindConst { 756 v := xtype.Make(t, xtype.Uint16(vx)-xtype.Uint16(vy)) 757 return func(fr *frame) { fr.setReg(ir, v) } 758 } else if kx == kindConst { 759 x := xtype.Uint16(vx) 760 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x-fr.uint16(iy))) } 761 } else if ky == kindConst { 762 y := xtype.Uint16(vy) 763 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)-y)) } 764 } else { 765 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)-fr.uint16(iy))) } 766 } 767 case reflect.Uint32: 768 if kx == kindConst && ky == kindConst { 769 v := xtype.Make(t, xtype.Uint32(vx)-xtype.Uint32(vy)) 770 return func(fr *frame) { fr.setReg(ir, v) } 771 } else if kx == kindConst { 772 x := xtype.Uint32(vx) 773 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x-fr.uint32(iy))) } 774 } else if ky == kindConst { 775 y := xtype.Uint32(vy) 776 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)-y)) } 777 } else { 778 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)-fr.uint32(iy))) } 779 } 780 case reflect.Uint64: 781 if kx == kindConst && ky == kindConst { 782 v := xtype.Make(t, xtype.Uint64(vx)-xtype.Uint64(vy)) 783 return func(fr *frame) { fr.setReg(ir, v) } 784 } else if kx == kindConst { 785 x := xtype.Uint64(vx) 786 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x-fr.uint64(iy))) } 787 } else if ky == kindConst { 788 y := xtype.Uint64(vy) 789 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)-y)) } 790 } else { 791 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)-fr.uint64(iy))) } 792 } 793 case reflect.Uintptr: 794 if kx == kindConst && ky == kindConst { 795 v := xtype.Make(t, xtype.Uintptr(vx)-xtype.Uintptr(vy)) 796 return func(fr *frame) { fr.setReg(ir, v) } 797 } else if kx == kindConst { 798 x := xtype.Uintptr(vx) 799 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x-fr.uintptr(iy))) } 800 } else if ky == kindConst { 801 y := xtype.Uintptr(vy) 802 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)-y)) } 803 } else { 804 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)-fr.uintptr(iy))) } 805 } 806 case reflect.Float32: 807 if kx == kindConst && ky == kindConst { 808 v := xtype.Make(t, xtype.Float32(vx)-xtype.Float32(vy)) 809 return func(fr *frame) { fr.setReg(ir, v) } 810 } else if kx == kindConst { 811 x := xtype.Float32(vx) 812 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x-fr.float32(iy))) } 813 } else if ky == kindConst { 814 y := xtype.Float32(vy) 815 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.float32(ix)-y)) } 816 } else { 817 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.float32(ix)-fr.float32(iy))) } 818 } 819 case reflect.Float64: 820 if kx == kindConst && ky == kindConst { 821 v := xtype.Make(t, xtype.Float64(vx)-xtype.Float64(vy)) 822 return func(fr *frame) { fr.setReg(ir, v) } 823 } else if kx == kindConst { 824 x := xtype.Float64(vx) 825 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x-fr.float64(iy))) } 826 } else if ky == kindConst { 827 y := xtype.Float64(vy) 828 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.float64(ix)-y)) } 829 } else { 830 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.float64(ix)-fr.float64(iy))) } 831 } 832 case reflect.Complex64: 833 if kx == kindConst && ky == kindConst { 834 v := xtype.Make(t, xtype.Complex64(vx)-xtype.Complex64(vy)) 835 return func(fr *frame) { fr.setReg(ir, v) } 836 } else if kx == kindConst { 837 x := xtype.Complex64(vx) 838 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x-fr.complex64(iy))) } 839 } else if ky == kindConst { 840 y := xtype.Complex64(vy) 841 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.complex64(ix)-y)) } 842 } else { 843 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.complex64(ix)-fr.complex64(iy))) } 844 } 845 case reflect.Complex128: 846 if kx == kindConst && ky == kindConst { 847 v := xtype.Make(t, xtype.Complex128(vx)-xtype.Complex128(vy)) 848 return func(fr *frame) { fr.setReg(ir, v) } 849 } else if kx == kindConst { 850 x := xtype.Complex128(vx) 851 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x-fr.complex128(iy))) } 852 } else if ky == kindConst { 853 y := xtype.Complex128(vy) 854 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.complex128(ix)-y)) } 855 } else { 856 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.complex128(ix)-fr.complex128(iy))) } 857 } 858 } 859 } 860 panic("unreachable") 861 } 862 func makeBinOpMUL(pfn *function, instr *ssa.BinOp) func(fr *frame) { 863 ir := pfn.regIndex(instr) 864 ix, kx, vx := pfn.regIndex3(instr.X) 865 iy, ky, vy := pfn.regIndex3(instr.Y) 866 typ := pfn.Interp.preToType(instr.Type()) 867 if typ.PkgPath() == "" { 868 switch typ.Kind() { 869 case reflect.Int: 870 if kx == kindConst && ky == kindConst { 871 v := vx.(int) * vy.(int) 872 return func(fr *frame) { fr.setReg(ir, v) } 873 } else if kx == kindConst { 874 x := vx.(int) 875 return func(fr *frame) { fr.setReg(ir, x*fr.reg(iy).(int)) } 876 } else if ky == kindConst { 877 y := vy.(int) 878 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)*y) } 879 } else { 880 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)*fr.reg(iy).(int)) } 881 } 882 case reflect.Int8: 883 if kx == kindConst && ky == kindConst { 884 v := vx.(int8) * vy.(int8) 885 return func(fr *frame) { fr.setReg(ir, v) } 886 } else if kx == kindConst { 887 x := vx.(int8) 888 return func(fr *frame) { fr.setReg(ir, x*fr.reg(iy).(int8)) } 889 } else if ky == kindConst { 890 y := vy.(int8) 891 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)*y) } 892 } else { 893 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)*fr.reg(iy).(int8)) } 894 } 895 case reflect.Int16: 896 if kx == kindConst && ky == kindConst { 897 v := vx.(int16) * vy.(int16) 898 return func(fr *frame) { fr.setReg(ir, v) } 899 } else if kx == kindConst { 900 x := vx.(int16) 901 return func(fr *frame) { fr.setReg(ir, x*fr.reg(iy).(int16)) } 902 } else if ky == kindConst { 903 y := vy.(int16) 904 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)*y) } 905 } else { 906 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)*fr.reg(iy).(int16)) } 907 } 908 case reflect.Int32: 909 if kx == kindConst && ky == kindConst { 910 v := vx.(int32) * vy.(int32) 911 return func(fr *frame) { fr.setReg(ir, v) } 912 } else if kx == kindConst { 913 x := vx.(int32) 914 return func(fr *frame) { fr.setReg(ir, x*fr.reg(iy).(int32)) } 915 } else if ky == kindConst { 916 y := vy.(int32) 917 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)*y) } 918 } else { 919 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)*fr.reg(iy).(int32)) } 920 } 921 case reflect.Int64: 922 if kx == kindConst && ky == kindConst { 923 v := vx.(int64) * vy.(int64) 924 return func(fr *frame) { fr.setReg(ir, v) } 925 } else if kx == kindConst { 926 x := vx.(int64) 927 return func(fr *frame) { fr.setReg(ir, x*fr.reg(iy).(int64)) } 928 } else if ky == kindConst { 929 y := vy.(int64) 930 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)*y) } 931 } else { 932 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)*fr.reg(iy).(int64)) } 933 } 934 case reflect.Uint: 935 if kx == kindConst && ky == kindConst { 936 v := vx.(uint) * vy.(uint) 937 return func(fr *frame) { fr.setReg(ir, v) } 938 } else if kx == kindConst { 939 x := vx.(uint) 940 return func(fr *frame) { fr.setReg(ir, x*fr.reg(iy).(uint)) } 941 } else if ky == kindConst { 942 y := vy.(uint) 943 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)*y) } 944 } else { 945 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)*fr.reg(iy).(uint)) } 946 } 947 case reflect.Uint8: 948 if kx == kindConst && ky == kindConst { 949 v := vx.(uint8) * vy.(uint8) 950 return func(fr *frame) { fr.setReg(ir, v) } 951 } else if kx == kindConst { 952 x := vx.(uint8) 953 return func(fr *frame) { fr.setReg(ir, x*fr.reg(iy).(uint8)) } 954 } else if ky == kindConst { 955 y := vy.(uint8) 956 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)*y) } 957 } else { 958 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)*fr.reg(iy).(uint8)) } 959 } 960 case reflect.Uint16: 961 if kx == kindConst && ky == kindConst { 962 v := vx.(uint16) * vy.(uint16) 963 return func(fr *frame) { fr.setReg(ir, v) } 964 } else if kx == kindConst { 965 x := vx.(uint16) 966 return func(fr *frame) { fr.setReg(ir, x*fr.reg(iy).(uint16)) } 967 } else if ky == kindConst { 968 y := vy.(uint16) 969 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)*y) } 970 } else { 971 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)*fr.reg(iy).(uint16)) } 972 } 973 case reflect.Uint32: 974 if kx == kindConst && ky == kindConst { 975 v := vx.(uint32) * vy.(uint32) 976 return func(fr *frame) { fr.setReg(ir, v) } 977 } else if kx == kindConst { 978 x := vx.(uint32) 979 return func(fr *frame) { fr.setReg(ir, x*fr.reg(iy).(uint32)) } 980 } else if ky == kindConst { 981 y := vy.(uint32) 982 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)*y) } 983 } else { 984 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)*fr.reg(iy).(uint32)) } 985 } 986 case reflect.Uint64: 987 if kx == kindConst && ky == kindConst { 988 v := vx.(uint64) * vy.(uint64) 989 return func(fr *frame) { fr.setReg(ir, v) } 990 } else if kx == kindConst { 991 x := vx.(uint64) 992 return func(fr *frame) { fr.setReg(ir, x*fr.reg(iy).(uint64)) } 993 } else if ky == kindConst { 994 y := vy.(uint64) 995 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)*y) } 996 } else { 997 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)*fr.reg(iy).(uint64)) } 998 } 999 case reflect.Uintptr: 1000 if kx == kindConst && ky == kindConst { 1001 v := vx.(uintptr) * vy.(uintptr) 1002 return func(fr *frame) { fr.setReg(ir, v) } 1003 } else if kx == kindConst { 1004 x := vx.(uintptr) 1005 return func(fr *frame) { fr.setReg(ir, x*fr.reg(iy).(uintptr)) } 1006 } else if ky == kindConst { 1007 y := vy.(uintptr) 1008 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)*y) } 1009 } else { 1010 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)*fr.reg(iy).(uintptr)) } 1011 } 1012 case reflect.Float32: 1013 if kx == kindConst && ky == kindConst { 1014 v := vx.(float32) * vy.(float32) 1015 return func(fr *frame) { fr.setReg(ir, v) } 1016 } else if kx == kindConst { 1017 x := vx.(float32) 1018 return func(fr *frame) { fr.setReg(ir, x*fr.reg(iy).(float32)) } 1019 } else if ky == kindConst { 1020 y := vy.(float32) 1021 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float32)*y) } 1022 } else { 1023 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float32)*fr.reg(iy).(float32)) } 1024 } 1025 case reflect.Float64: 1026 if kx == kindConst && ky == kindConst { 1027 v := vx.(float64) * vy.(float64) 1028 return func(fr *frame) { fr.setReg(ir, v) } 1029 } else if kx == kindConst { 1030 x := vx.(float64) 1031 return func(fr *frame) { fr.setReg(ir, x*fr.reg(iy).(float64)) } 1032 } else if ky == kindConst { 1033 y := vy.(float64) 1034 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float64)*y) } 1035 } else { 1036 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float64)*fr.reg(iy).(float64)) } 1037 } 1038 case reflect.Complex64: 1039 if kx == kindConst && ky == kindConst { 1040 v := vx.(complex64) * vy.(complex64) 1041 return func(fr *frame) { fr.setReg(ir, v) } 1042 } else if kx == kindConst { 1043 x := vx.(complex64) 1044 return func(fr *frame) { fr.setReg(ir, x*fr.reg(iy).(complex64)) } 1045 } else if ky == kindConst { 1046 y := vy.(complex64) 1047 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(complex64)*y) } 1048 } else { 1049 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(complex64)*fr.reg(iy).(complex64)) } 1050 } 1051 case reflect.Complex128: 1052 if kx == kindConst && ky == kindConst { 1053 v := vx.(complex128) * vy.(complex128) 1054 return func(fr *frame) { fr.setReg(ir, v) } 1055 } else if kx == kindConst { 1056 x := vx.(complex128) 1057 return func(fr *frame) { fr.setReg(ir, x*fr.reg(iy).(complex128)) } 1058 } else if ky == kindConst { 1059 y := vy.(complex128) 1060 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(complex128)*y) } 1061 } else { 1062 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(complex128)*fr.reg(iy).(complex128)) } 1063 } 1064 } 1065 } else { 1066 t := xtype.TypeOfType(typ) 1067 switch typ.Kind() { 1068 case reflect.Int: 1069 if kx == kindConst && ky == kindConst { 1070 v := xtype.Make(t, xtype.Int(vx)*xtype.Int(vy)) 1071 return func(fr *frame) { fr.setReg(ir, v) } 1072 } else if kx == kindConst { 1073 x := xtype.Int(vx) 1074 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x*fr.int(iy))) } 1075 } else if ky == kindConst { 1076 y := xtype.Int(vy) 1077 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)*y)) } 1078 } else { 1079 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)*fr.int(iy))) } 1080 } 1081 case reflect.Int8: 1082 if kx == kindConst && ky == kindConst { 1083 v := xtype.Make(t, xtype.Int8(vx)*xtype.Int8(vy)) 1084 return func(fr *frame) { fr.setReg(ir, v) } 1085 } else if kx == kindConst { 1086 x := xtype.Int8(vx) 1087 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x*fr.int8(iy))) } 1088 } else if ky == kindConst { 1089 y := xtype.Int8(vy) 1090 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)*y)) } 1091 } else { 1092 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)*fr.int8(iy))) } 1093 } 1094 case reflect.Int16: 1095 if kx == kindConst && ky == kindConst { 1096 v := xtype.Make(t, xtype.Int16(vx)*xtype.Int16(vy)) 1097 return func(fr *frame) { fr.setReg(ir, v) } 1098 } else if kx == kindConst { 1099 x := xtype.Int16(vx) 1100 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x*fr.int16(iy))) } 1101 } else if ky == kindConst { 1102 y := xtype.Int16(vy) 1103 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)*y)) } 1104 } else { 1105 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)*fr.int16(iy))) } 1106 } 1107 case reflect.Int32: 1108 if kx == kindConst && ky == kindConst { 1109 v := xtype.Make(t, xtype.Int32(vx)*xtype.Int32(vy)) 1110 return func(fr *frame) { fr.setReg(ir, v) } 1111 } else if kx == kindConst { 1112 x := xtype.Int32(vx) 1113 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x*fr.int32(iy))) } 1114 } else if ky == kindConst { 1115 y := xtype.Int32(vy) 1116 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)*y)) } 1117 } else { 1118 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)*fr.int32(iy))) } 1119 } 1120 case reflect.Int64: 1121 if kx == kindConst && ky == kindConst { 1122 v := xtype.Make(t, xtype.Int64(vx)*xtype.Int64(vy)) 1123 return func(fr *frame) { fr.setReg(ir, v) } 1124 } else if kx == kindConst { 1125 x := xtype.Int64(vx) 1126 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x*fr.int64(iy))) } 1127 } else if ky == kindConst { 1128 y := xtype.Int64(vy) 1129 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)*y)) } 1130 } else { 1131 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)*fr.int64(iy))) } 1132 } 1133 case reflect.Uint: 1134 if kx == kindConst && ky == kindConst { 1135 v := xtype.Make(t, xtype.Uint(vx)*xtype.Uint(vy)) 1136 return func(fr *frame) { fr.setReg(ir, v) } 1137 } else if kx == kindConst { 1138 x := xtype.Uint(vx) 1139 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x*fr.uint(iy))) } 1140 } else if ky == kindConst { 1141 y := xtype.Uint(vy) 1142 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)*y)) } 1143 } else { 1144 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)*fr.uint(iy))) } 1145 } 1146 case reflect.Uint8: 1147 if kx == kindConst && ky == kindConst { 1148 v := xtype.Make(t, xtype.Uint8(vx)*xtype.Uint8(vy)) 1149 return func(fr *frame) { fr.setReg(ir, v) } 1150 } else if kx == kindConst { 1151 x := xtype.Uint8(vx) 1152 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x*fr.uint8(iy))) } 1153 } else if ky == kindConst { 1154 y := xtype.Uint8(vy) 1155 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)*y)) } 1156 } else { 1157 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)*fr.uint8(iy))) } 1158 } 1159 case reflect.Uint16: 1160 if kx == kindConst && ky == kindConst { 1161 v := xtype.Make(t, xtype.Uint16(vx)*xtype.Uint16(vy)) 1162 return func(fr *frame) { fr.setReg(ir, v) } 1163 } else if kx == kindConst { 1164 x := xtype.Uint16(vx) 1165 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x*fr.uint16(iy))) } 1166 } else if ky == kindConst { 1167 y := xtype.Uint16(vy) 1168 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)*y)) } 1169 } else { 1170 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)*fr.uint16(iy))) } 1171 } 1172 case reflect.Uint32: 1173 if kx == kindConst && ky == kindConst { 1174 v := xtype.Make(t, xtype.Uint32(vx)*xtype.Uint32(vy)) 1175 return func(fr *frame) { fr.setReg(ir, v) } 1176 } else if kx == kindConst { 1177 x := xtype.Uint32(vx) 1178 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x*fr.uint32(iy))) } 1179 } else if ky == kindConst { 1180 y := xtype.Uint32(vy) 1181 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)*y)) } 1182 } else { 1183 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)*fr.uint32(iy))) } 1184 } 1185 case reflect.Uint64: 1186 if kx == kindConst && ky == kindConst { 1187 v := xtype.Make(t, xtype.Uint64(vx)*xtype.Uint64(vy)) 1188 return func(fr *frame) { fr.setReg(ir, v) } 1189 } else if kx == kindConst { 1190 x := xtype.Uint64(vx) 1191 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x*fr.uint64(iy))) } 1192 } else if ky == kindConst { 1193 y := xtype.Uint64(vy) 1194 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)*y)) } 1195 } else { 1196 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)*fr.uint64(iy))) } 1197 } 1198 case reflect.Uintptr: 1199 if kx == kindConst && ky == kindConst { 1200 v := xtype.Make(t, xtype.Uintptr(vx)*xtype.Uintptr(vy)) 1201 return func(fr *frame) { fr.setReg(ir, v) } 1202 } else if kx == kindConst { 1203 x := xtype.Uintptr(vx) 1204 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x*fr.uintptr(iy))) } 1205 } else if ky == kindConst { 1206 y := xtype.Uintptr(vy) 1207 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)*y)) } 1208 } else { 1209 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)*fr.uintptr(iy))) } 1210 } 1211 case reflect.Float32: 1212 if kx == kindConst && ky == kindConst { 1213 v := xtype.Make(t, xtype.Float32(vx)*xtype.Float32(vy)) 1214 return func(fr *frame) { fr.setReg(ir, v) } 1215 } else if kx == kindConst { 1216 x := xtype.Float32(vx) 1217 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x*fr.float32(iy))) } 1218 } else if ky == kindConst { 1219 y := xtype.Float32(vy) 1220 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.float32(ix)*y)) } 1221 } else { 1222 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.float32(ix)*fr.float32(iy))) } 1223 } 1224 case reflect.Float64: 1225 if kx == kindConst && ky == kindConst { 1226 v := xtype.Make(t, xtype.Float64(vx)*xtype.Float64(vy)) 1227 return func(fr *frame) { fr.setReg(ir, v) } 1228 } else if kx == kindConst { 1229 x := xtype.Float64(vx) 1230 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x*fr.float64(iy))) } 1231 } else if ky == kindConst { 1232 y := xtype.Float64(vy) 1233 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.float64(ix)*y)) } 1234 } else { 1235 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.float64(ix)*fr.float64(iy))) } 1236 } 1237 case reflect.Complex64: 1238 if kx == kindConst && ky == kindConst { 1239 v := xtype.Make(t, xtype.Complex64(vx)*xtype.Complex64(vy)) 1240 return func(fr *frame) { fr.setReg(ir, v) } 1241 } else if kx == kindConst { 1242 x := xtype.Complex64(vx) 1243 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x*fr.complex64(iy))) } 1244 } else if ky == kindConst { 1245 y := xtype.Complex64(vy) 1246 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.complex64(ix)*y)) } 1247 } else { 1248 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.complex64(ix)*fr.complex64(iy))) } 1249 } 1250 case reflect.Complex128: 1251 if kx == kindConst && ky == kindConst { 1252 v := xtype.Make(t, xtype.Complex128(vx)*xtype.Complex128(vy)) 1253 return func(fr *frame) { fr.setReg(ir, v) } 1254 } else if kx == kindConst { 1255 x := xtype.Complex128(vx) 1256 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x*fr.complex128(iy))) } 1257 } else if ky == kindConst { 1258 y := xtype.Complex128(vy) 1259 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.complex128(ix)*y)) } 1260 } else { 1261 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.complex128(ix)*fr.complex128(iy))) } 1262 } 1263 } 1264 } 1265 panic("unreachable") 1266 } 1267 func makeBinOpQUO(pfn *function, instr *ssa.BinOp) func(fr *frame) { 1268 ir := pfn.regIndex(instr) 1269 ix, kx, vx := pfn.regIndex3(instr.X) 1270 iy, ky, vy := pfn.regIndex3(instr.Y) 1271 typ := pfn.Interp.preToType(instr.Type()) 1272 if typ.PkgPath() == "" { 1273 switch typ.Kind() { 1274 case reflect.Int: 1275 if kx == kindConst && ky == kindConst { 1276 x := vx.(int) 1277 y := vy.(int) 1278 if y == 0 { 1279 return func(fr *frame) { fr.setReg(ir, x/y) } 1280 } 1281 v := x / y 1282 return func(fr *frame) { fr.setReg(ir, v) } 1283 } else if kx == kindConst { 1284 x := vx.(int) 1285 return func(fr *frame) { fr.setReg(ir, x/fr.reg(iy).(int)) } 1286 } else if ky == kindConst { 1287 y := vy.(int) 1288 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)/y) } 1289 } else { 1290 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)/fr.reg(iy).(int)) } 1291 } 1292 case reflect.Int8: 1293 if kx == kindConst && ky == kindConst { 1294 x := vx.(int8) 1295 y := vy.(int8) 1296 if y == 0 { 1297 return func(fr *frame) { fr.setReg(ir, x/y) } 1298 } 1299 v := x / y 1300 return func(fr *frame) { fr.setReg(ir, v) } 1301 } else if kx == kindConst { 1302 x := vx.(int8) 1303 return func(fr *frame) { fr.setReg(ir, x/fr.reg(iy).(int8)) } 1304 } else if ky == kindConst { 1305 y := vy.(int8) 1306 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)/y) } 1307 } else { 1308 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)/fr.reg(iy).(int8)) } 1309 } 1310 case reflect.Int16: 1311 if kx == kindConst && ky == kindConst { 1312 x := vx.(int16) 1313 y := vy.(int16) 1314 if y == 0 { 1315 return func(fr *frame) { fr.setReg(ir, x/y) } 1316 } 1317 v := x / y 1318 return func(fr *frame) { fr.setReg(ir, v) } 1319 } else if kx == kindConst { 1320 x := vx.(int16) 1321 return func(fr *frame) { fr.setReg(ir, x/fr.reg(iy).(int16)) } 1322 } else if ky == kindConst { 1323 y := vy.(int16) 1324 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)/y) } 1325 } else { 1326 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)/fr.reg(iy).(int16)) } 1327 } 1328 case reflect.Int32: 1329 if kx == kindConst && ky == kindConst { 1330 x := vx.(int32) 1331 y := vy.(int32) 1332 if y == 0 { 1333 return func(fr *frame) { fr.setReg(ir, x/y) } 1334 } 1335 v := x / y 1336 return func(fr *frame) { fr.setReg(ir, v) } 1337 } else if kx == kindConst { 1338 x := vx.(int32) 1339 return func(fr *frame) { fr.setReg(ir, x/fr.reg(iy).(int32)) } 1340 } else if ky == kindConst { 1341 y := vy.(int32) 1342 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)/y) } 1343 } else { 1344 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)/fr.reg(iy).(int32)) } 1345 } 1346 case reflect.Int64: 1347 if kx == kindConst && ky == kindConst { 1348 x := vx.(int64) 1349 y := vy.(int64) 1350 if y == 0 { 1351 return func(fr *frame) { fr.setReg(ir, x/y) } 1352 } 1353 v := x / y 1354 return func(fr *frame) { fr.setReg(ir, v) } 1355 } else if kx == kindConst { 1356 x := vx.(int64) 1357 return func(fr *frame) { fr.setReg(ir, x/fr.reg(iy).(int64)) } 1358 } else if ky == kindConst { 1359 y := vy.(int64) 1360 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)/y) } 1361 } else { 1362 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)/fr.reg(iy).(int64)) } 1363 } 1364 case reflect.Uint: 1365 if kx == kindConst && ky == kindConst { 1366 x := vx.(uint) 1367 y := vy.(uint) 1368 if y == 0 { 1369 return func(fr *frame) { fr.setReg(ir, x/y) } 1370 } 1371 v := x / y 1372 return func(fr *frame) { fr.setReg(ir, v) } 1373 } else if kx == kindConst { 1374 x := vx.(uint) 1375 return func(fr *frame) { fr.setReg(ir, x/fr.reg(iy).(uint)) } 1376 } else if ky == kindConst { 1377 y := vy.(uint) 1378 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)/y) } 1379 } else { 1380 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)/fr.reg(iy).(uint)) } 1381 } 1382 case reflect.Uint8: 1383 if kx == kindConst && ky == kindConst { 1384 x := vx.(uint8) 1385 y := vy.(uint8) 1386 if y == 0 { 1387 return func(fr *frame) { fr.setReg(ir, x/y) } 1388 } 1389 v := x / y 1390 return func(fr *frame) { fr.setReg(ir, v) } 1391 } else if kx == kindConst { 1392 x := vx.(uint8) 1393 return func(fr *frame) { fr.setReg(ir, x/fr.reg(iy).(uint8)) } 1394 } else if ky == kindConst { 1395 y := vy.(uint8) 1396 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)/y) } 1397 } else { 1398 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)/fr.reg(iy).(uint8)) } 1399 } 1400 case reflect.Uint16: 1401 if kx == kindConst && ky == kindConst { 1402 x := vx.(uint16) 1403 y := vy.(uint16) 1404 if y == 0 { 1405 return func(fr *frame) { fr.setReg(ir, x/y) } 1406 } 1407 v := x / y 1408 return func(fr *frame) { fr.setReg(ir, v) } 1409 } else if kx == kindConst { 1410 x := vx.(uint16) 1411 return func(fr *frame) { fr.setReg(ir, x/fr.reg(iy).(uint16)) } 1412 } else if ky == kindConst { 1413 y := vy.(uint16) 1414 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)/y) } 1415 } else { 1416 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)/fr.reg(iy).(uint16)) } 1417 } 1418 case reflect.Uint32: 1419 if kx == kindConst && ky == kindConst { 1420 x := vx.(uint32) 1421 y := vy.(uint32) 1422 if y == 0 { 1423 return func(fr *frame) { fr.setReg(ir, x/y) } 1424 } 1425 v := x / y 1426 return func(fr *frame) { fr.setReg(ir, v) } 1427 } else if kx == kindConst { 1428 x := vx.(uint32) 1429 return func(fr *frame) { fr.setReg(ir, x/fr.reg(iy).(uint32)) } 1430 } else if ky == kindConst { 1431 y := vy.(uint32) 1432 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)/y) } 1433 } else { 1434 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)/fr.reg(iy).(uint32)) } 1435 } 1436 case reflect.Uint64: 1437 if kx == kindConst && ky == kindConst { 1438 x := vx.(uint64) 1439 y := vy.(uint64) 1440 if y == 0 { 1441 return func(fr *frame) { fr.setReg(ir, x/y) } 1442 } 1443 v := x / y 1444 return func(fr *frame) { fr.setReg(ir, v) } 1445 } else if kx == kindConst { 1446 x := vx.(uint64) 1447 return func(fr *frame) { fr.setReg(ir, x/fr.reg(iy).(uint64)) } 1448 } else if ky == kindConst { 1449 y := vy.(uint64) 1450 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)/y) } 1451 } else { 1452 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)/fr.reg(iy).(uint64)) } 1453 } 1454 case reflect.Uintptr: 1455 if kx == kindConst && ky == kindConst { 1456 x := vx.(uintptr) 1457 y := vy.(uintptr) 1458 if y == 0 { 1459 return func(fr *frame) { fr.setReg(ir, x/y) } 1460 } 1461 v := x / y 1462 return func(fr *frame) { fr.setReg(ir, v) } 1463 } else if kx == kindConst { 1464 x := vx.(uintptr) 1465 return func(fr *frame) { fr.setReg(ir, x/fr.reg(iy).(uintptr)) } 1466 } else if ky == kindConst { 1467 y := vy.(uintptr) 1468 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)/y) } 1469 } else { 1470 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)/fr.reg(iy).(uintptr)) } 1471 } 1472 case reflect.Float32: 1473 if kx == kindConst && ky == kindConst { 1474 v := vx.(float32) / vy.(float32) 1475 return func(fr *frame) { fr.setReg(ir, v) } 1476 } else if kx == kindConst { 1477 x := vx.(float32) 1478 return func(fr *frame) { fr.setReg(ir, x/fr.reg(iy).(float32)) } 1479 } else if ky == kindConst { 1480 y := vy.(float32) 1481 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float32)/y) } 1482 } else { 1483 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float32)/fr.reg(iy).(float32)) } 1484 } 1485 case reflect.Float64: 1486 if kx == kindConst && ky == kindConst { 1487 v := vx.(float64) / vy.(float64) 1488 return func(fr *frame) { fr.setReg(ir, v) } 1489 } else if kx == kindConst { 1490 x := vx.(float64) 1491 return func(fr *frame) { fr.setReg(ir, x/fr.reg(iy).(float64)) } 1492 } else if ky == kindConst { 1493 y := vy.(float64) 1494 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float64)/y) } 1495 } else { 1496 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float64)/fr.reg(iy).(float64)) } 1497 } 1498 case reflect.Complex64: 1499 if kx == kindConst && ky == kindConst { 1500 v := vx.(complex64) / vy.(complex64) 1501 return func(fr *frame) { fr.setReg(ir, v) } 1502 } else if kx == kindConst { 1503 x := vx.(complex64) 1504 return func(fr *frame) { fr.setReg(ir, x/fr.reg(iy).(complex64)) } 1505 } else if ky == kindConst { 1506 y := vy.(complex64) 1507 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(complex64)/y) } 1508 } else { 1509 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(complex64)/fr.reg(iy).(complex64)) } 1510 } 1511 case reflect.Complex128: 1512 if kx == kindConst && ky == kindConst { 1513 v := vx.(complex128) / vy.(complex128) 1514 return func(fr *frame) { fr.setReg(ir, v) } 1515 } else if kx == kindConst { 1516 x := vx.(complex128) 1517 return func(fr *frame) { fr.setReg(ir, x/fr.reg(iy).(complex128)) } 1518 } else if ky == kindConst { 1519 y := vy.(complex128) 1520 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(complex128)/y) } 1521 } else { 1522 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(complex128)/fr.reg(iy).(complex128)) } 1523 } 1524 } 1525 } else { 1526 t := xtype.TypeOfType(typ) 1527 switch typ.Kind() { 1528 case reflect.Int: 1529 if kx == kindConst && ky == kindConst { 1530 x := xtype.Int(vx) 1531 y := xtype.Int(vy) 1532 if y == 0 { 1533 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/y)) } 1534 } 1535 v := xtype.Make(t, x/y) 1536 return func(fr *frame) { fr.setReg(ir, v) } 1537 } else if kx == kindConst { 1538 x := xtype.Int(vx) 1539 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/fr.int(iy))) } 1540 } else if ky == kindConst { 1541 y := xtype.Int(vy) 1542 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)/y)) } 1543 } else { 1544 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)/fr.int(iy))) } 1545 } 1546 case reflect.Int8: 1547 if kx == kindConst && ky == kindConst { 1548 x := xtype.Int8(vx) 1549 y := xtype.Int8(vy) 1550 if y == 0 { 1551 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/y)) } 1552 } 1553 v := xtype.Make(t, x/y) 1554 return func(fr *frame) { fr.setReg(ir, v) } 1555 } else if kx == kindConst { 1556 x := xtype.Int8(vx) 1557 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/fr.int8(iy))) } 1558 } else if ky == kindConst { 1559 y := xtype.Int8(vy) 1560 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)/y)) } 1561 } else { 1562 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)/fr.int8(iy))) } 1563 } 1564 case reflect.Int16: 1565 if kx == kindConst && ky == kindConst { 1566 x := xtype.Int16(vx) 1567 y := xtype.Int16(vy) 1568 if y == 0 { 1569 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/y)) } 1570 } 1571 v := xtype.Make(t, x/y) 1572 return func(fr *frame) { fr.setReg(ir, v) } 1573 } else if kx == kindConst { 1574 x := xtype.Int16(vx) 1575 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/fr.int16(iy))) } 1576 } else if ky == kindConst { 1577 y := xtype.Int16(vy) 1578 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)/y)) } 1579 } else { 1580 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)/fr.int16(iy))) } 1581 } 1582 case reflect.Int32: 1583 if kx == kindConst && ky == kindConst { 1584 x := xtype.Int32(vx) 1585 y := xtype.Int32(vy) 1586 if y == 0 { 1587 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/y)) } 1588 } 1589 v := xtype.Make(t, x/y) 1590 return func(fr *frame) { fr.setReg(ir, v) } 1591 } else if kx == kindConst { 1592 x := xtype.Int32(vx) 1593 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/fr.int32(iy))) } 1594 } else if ky == kindConst { 1595 y := xtype.Int32(vy) 1596 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)/y)) } 1597 } else { 1598 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)/fr.int32(iy))) } 1599 } 1600 case reflect.Int64: 1601 if kx == kindConst && ky == kindConst { 1602 x := xtype.Int64(vx) 1603 y := xtype.Int64(vy) 1604 if y == 0 { 1605 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/y)) } 1606 } 1607 v := xtype.Make(t, x/y) 1608 return func(fr *frame) { fr.setReg(ir, v) } 1609 } else if kx == kindConst { 1610 x := xtype.Int64(vx) 1611 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/fr.int64(iy))) } 1612 } else if ky == kindConst { 1613 y := xtype.Int64(vy) 1614 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)/y)) } 1615 } else { 1616 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)/fr.int64(iy))) } 1617 } 1618 case reflect.Uint: 1619 if kx == kindConst && ky == kindConst { 1620 x := xtype.Uint(vx) 1621 y := xtype.Uint(vy) 1622 if y == 0 { 1623 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/y)) } 1624 } 1625 v := xtype.Make(t, x/y) 1626 return func(fr *frame) { fr.setReg(ir, v) } 1627 } else if kx == kindConst { 1628 x := xtype.Uint(vx) 1629 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/fr.uint(iy))) } 1630 } else if ky == kindConst { 1631 y := xtype.Uint(vy) 1632 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)/y)) } 1633 } else { 1634 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)/fr.uint(iy))) } 1635 } 1636 case reflect.Uint8: 1637 if kx == kindConst && ky == kindConst { 1638 x := xtype.Uint8(vx) 1639 y := xtype.Uint8(vy) 1640 if y == 0 { 1641 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/y)) } 1642 } 1643 v := xtype.Make(t, x/y) 1644 return func(fr *frame) { fr.setReg(ir, v) } 1645 } else if kx == kindConst { 1646 x := xtype.Uint8(vx) 1647 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/fr.uint8(iy))) } 1648 } else if ky == kindConst { 1649 y := xtype.Uint8(vy) 1650 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)/y)) } 1651 } else { 1652 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)/fr.uint8(iy))) } 1653 } 1654 case reflect.Uint16: 1655 if kx == kindConst && ky == kindConst { 1656 x := xtype.Uint16(vx) 1657 y := xtype.Uint16(vy) 1658 if y == 0 { 1659 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/y)) } 1660 } 1661 v := xtype.Make(t, x/y) 1662 return func(fr *frame) { fr.setReg(ir, v) } 1663 } else if kx == kindConst { 1664 x := xtype.Uint16(vx) 1665 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/fr.uint16(iy))) } 1666 } else if ky == kindConst { 1667 y := xtype.Uint16(vy) 1668 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)/y)) } 1669 } else { 1670 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)/fr.uint16(iy))) } 1671 } 1672 case reflect.Uint32: 1673 if kx == kindConst && ky == kindConst { 1674 x := xtype.Uint32(vx) 1675 y := xtype.Uint32(vy) 1676 if y == 0 { 1677 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/y)) } 1678 } 1679 v := xtype.Make(t, x/y) 1680 return func(fr *frame) { fr.setReg(ir, v) } 1681 } else if kx == kindConst { 1682 x := xtype.Uint32(vx) 1683 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/fr.uint32(iy))) } 1684 } else if ky == kindConst { 1685 y := xtype.Uint32(vy) 1686 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)/y)) } 1687 } else { 1688 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)/fr.uint32(iy))) } 1689 } 1690 case reflect.Uint64: 1691 if kx == kindConst && ky == kindConst { 1692 x := xtype.Uint64(vx) 1693 y := xtype.Uint64(vy) 1694 if y == 0 { 1695 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/y)) } 1696 } 1697 v := xtype.Make(t, x/y) 1698 return func(fr *frame) { fr.setReg(ir, v) } 1699 } else if kx == kindConst { 1700 x := xtype.Uint64(vx) 1701 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/fr.uint64(iy))) } 1702 } else if ky == kindConst { 1703 y := xtype.Uint64(vy) 1704 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)/y)) } 1705 } else { 1706 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)/fr.uint64(iy))) } 1707 } 1708 case reflect.Uintptr: 1709 if kx == kindConst && ky == kindConst { 1710 x := xtype.Uintptr(vx) 1711 y := xtype.Uintptr(vy) 1712 if y == 0 { 1713 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/y)) } 1714 } 1715 v := xtype.Make(t, x/y) 1716 return func(fr *frame) { fr.setReg(ir, v) } 1717 } else if kx == kindConst { 1718 x := xtype.Uintptr(vx) 1719 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/fr.uintptr(iy))) } 1720 } else if ky == kindConst { 1721 y := xtype.Uintptr(vy) 1722 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)/y)) } 1723 } else { 1724 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)/fr.uintptr(iy))) } 1725 } 1726 case reflect.Float32: 1727 if kx == kindConst && ky == kindConst { 1728 v := xtype.Make(t, xtype.Float32(vx)/xtype.Float32(vy)) 1729 return func(fr *frame) { fr.setReg(ir, v) } 1730 } else if kx == kindConst { 1731 x := xtype.Float32(vx) 1732 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/fr.float32(iy))) } 1733 } else if ky == kindConst { 1734 y := xtype.Float32(vy) 1735 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.float32(ix)/y)) } 1736 } else { 1737 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.float32(ix)/fr.float32(iy))) } 1738 } 1739 case reflect.Float64: 1740 if kx == kindConst && ky == kindConst { 1741 v := xtype.Make(t, xtype.Float64(vx)/xtype.Float64(vy)) 1742 return func(fr *frame) { fr.setReg(ir, v) } 1743 } else if kx == kindConst { 1744 x := xtype.Float64(vx) 1745 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/fr.float64(iy))) } 1746 } else if ky == kindConst { 1747 y := xtype.Float64(vy) 1748 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.float64(ix)/y)) } 1749 } else { 1750 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.float64(ix)/fr.float64(iy))) } 1751 } 1752 case reflect.Complex64: 1753 if kx == kindConst && ky == kindConst { 1754 v := xtype.Make(t, xtype.Complex64(vx)/xtype.Complex64(vy)) 1755 return func(fr *frame) { fr.setReg(ir, v) } 1756 } else if kx == kindConst { 1757 x := xtype.Complex64(vx) 1758 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/fr.complex64(iy))) } 1759 } else if ky == kindConst { 1760 y := xtype.Complex64(vy) 1761 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.complex64(ix)/y)) } 1762 } else { 1763 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.complex64(ix)/fr.complex64(iy))) } 1764 } 1765 case reflect.Complex128: 1766 if kx == kindConst && ky == kindConst { 1767 v := xtype.Make(t, xtype.Complex128(vx)/xtype.Complex128(vy)) 1768 return func(fr *frame) { fr.setReg(ir, v) } 1769 } else if kx == kindConst { 1770 x := xtype.Complex128(vx) 1771 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x/fr.complex128(iy))) } 1772 } else if ky == kindConst { 1773 y := xtype.Complex128(vy) 1774 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.complex128(ix)/y)) } 1775 } else { 1776 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.complex128(ix)/fr.complex128(iy))) } 1777 } 1778 } 1779 } 1780 panic("unreachable") 1781 } 1782 func makeBinOpREM(pfn *function, instr *ssa.BinOp) func(fr *frame) { 1783 ir := pfn.regIndex(instr) 1784 ix, kx, vx := pfn.regIndex3(instr.X) 1785 iy, ky, vy := pfn.regIndex3(instr.Y) 1786 typ := pfn.Interp.preToType(instr.Type()) 1787 if typ.PkgPath() == "" { 1788 switch typ.Kind() { 1789 case reflect.Int: 1790 if kx == kindConst && ky == kindConst { 1791 v := vx.(int) % vy.(int) 1792 return func(fr *frame) { fr.setReg(ir, v) } 1793 } else if kx == kindConst { 1794 x := vx.(int) 1795 return func(fr *frame) { fr.setReg(ir, x%fr.reg(iy).(int)) } 1796 } else if ky == kindConst { 1797 y := vy.(int) 1798 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)%y) } 1799 } else { 1800 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)%fr.reg(iy).(int)) } 1801 } 1802 case reflect.Int8: 1803 if kx == kindConst && ky == kindConst { 1804 v := vx.(int8) % vy.(int8) 1805 return func(fr *frame) { fr.setReg(ir, v) } 1806 } else if kx == kindConst { 1807 x := vx.(int8) 1808 return func(fr *frame) { fr.setReg(ir, x%fr.reg(iy).(int8)) } 1809 } else if ky == kindConst { 1810 y := vy.(int8) 1811 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)%y) } 1812 } else { 1813 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)%fr.reg(iy).(int8)) } 1814 } 1815 case reflect.Int16: 1816 if kx == kindConst && ky == kindConst { 1817 v := vx.(int16) % vy.(int16) 1818 return func(fr *frame) { fr.setReg(ir, v) } 1819 } else if kx == kindConst { 1820 x := vx.(int16) 1821 return func(fr *frame) { fr.setReg(ir, x%fr.reg(iy).(int16)) } 1822 } else if ky == kindConst { 1823 y := vy.(int16) 1824 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)%y) } 1825 } else { 1826 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)%fr.reg(iy).(int16)) } 1827 } 1828 case reflect.Int32: 1829 if kx == kindConst && ky == kindConst { 1830 v := vx.(int32) % vy.(int32) 1831 return func(fr *frame) { fr.setReg(ir, v) } 1832 } else if kx == kindConst { 1833 x := vx.(int32) 1834 return func(fr *frame) { fr.setReg(ir, x%fr.reg(iy).(int32)) } 1835 } else if ky == kindConst { 1836 y := vy.(int32) 1837 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)%y) } 1838 } else { 1839 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)%fr.reg(iy).(int32)) } 1840 } 1841 case reflect.Int64: 1842 if kx == kindConst && ky == kindConst { 1843 v := vx.(int64) % vy.(int64) 1844 return func(fr *frame) { fr.setReg(ir, v) } 1845 } else if kx == kindConst { 1846 x := vx.(int64) 1847 return func(fr *frame) { fr.setReg(ir, x%fr.reg(iy).(int64)) } 1848 } else if ky == kindConst { 1849 y := vy.(int64) 1850 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)%y) } 1851 } else { 1852 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)%fr.reg(iy).(int64)) } 1853 } 1854 case reflect.Uint: 1855 if kx == kindConst && ky == kindConst { 1856 v := vx.(uint) % vy.(uint) 1857 return func(fr *frame) { fr.setReg(ir, v) } 1858 } else if kx == kindConst { 1859 x := vx.(uint) 1860 return func(fr *frame) { fr.setReg(ir, x%fr.reg(iy).(uint)) } 1861 } else if ky == kindConst { 1862 y := vy.(uint) 1863 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)%y) } 1864 } else { 1865 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)%fr.reg(iy).(uint)) } 1866 } 1867 case reflect.Uint8: 1868 if kx == kindConst && ky == kindConst { 1869 v := vx.(uint8) % vy.(uint8) 1870 return func(fr *frame) { fr.setReg(ir, v) } 1871 } else if kx == kindConst { 1872 x := vx.(uint8) 1873 return func(fr *frame) { fr.setReg(ir, x%fr.reg(iy).(uint8)) } 1874 } else if ky == kindConst { 1875 y := vy.(uint8) 1876 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)%y) } 1877 } else { 1878 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)%fr.reg(iy).(uint8)) } 1879 } 1880 case reflect.Uint16: 1881 if kx == kindConst && ky == kindConst { 1882 v := vx.(uint16) % vy.(uint16) 1883 return func(fr *frame) { fr.setReg(ir, v) } 1884 } else if kx == kindConst { 1885 x := vx.(uint16) 1886 return func(fr *frame) { fr.setReg(ir, x%fr.reg(iy).(uint16)) } 1887 } else if ky == kindConst { 1888 y := vy.(uint16) 1889 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)%y) } 1890 } else { 1891 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)%fr.reg(iy).(uint16)) } 1892 } 1893 case reflect.Uint32: 1894 if kx == kindConst && ky == kindConst { 1895 v := vx.(uint32) % vy.(uint32) 1896 return func(fr *frame) { fr.setReg(ir, v) } 1897 } else if kx == kindConst { 1898 x := vx.(uint32) 1899 return func(fr *frame) { fr.setReg(ir, x%fr.reg(iy).(uint32)) } 1900 } else if ky == kindConst { 1901 y := vy.(uint32) 1902 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)%y) } 1903 } else { 1904 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)%fr.reg(iy).(uint32)) } 1905 } 1906 case reflect.Uint64: 1907 if kx == kindConst && ky == kindConst { 1908 v := vx.(uint64) % vy.(uint64) 1909 return func(fr *frame) { fr.setReg(ir, v) } 1910 } else if kx == kindConst { 1911 x := vx.(uint64) 1912 return func(fr *frame) { fr.setReg(ir, x%fr.reg(iy).(uint64)) } 1913 } else if ky == kindConst { 1914 y := vy.(uint64) 1915 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)%y) } 1916 } else { 1917 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)%fr.reg(iy).(uint64)) } 1918 } 1919 case reflect.Uintptr: 1920 if kx == kindConst && ky == kindConst { 1921 v := vx.(uintptr) % vy.(uintptr) 1922 return func(fr *frame) { fr.setReg(ir, v) } 1923 } else if kx == kindConst { 1924 x := vx.(uintptr) 1925 return func(fr *frame) { fr.setReg(ir, x%fr.reg(iy).(uintptr)) } 1926 } else if ky == kindConst { 1927 y := vy.(uintptr) 1928 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)%y) } 1929 } else { 1930 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)%fr.reg(iy).(uintptr)) } 1931 } 1932 } 1933 } else { 1934 t := xtype.TypeOfType(typ) 1935 switch typ.Kind() { 1936 case reflect.Int: 1937 if kx == kindConst && ky == kindConst { 1938 v := xtype.Make(t, xtype.Int(vx)%xtype.Int(vy)) 1939 return func(fr *frame) { fr.setReg(ir, v) } 1940 } else if kx == kindConst { 1941 x := xtype.Int(vx) 1942 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x%fr.int(iy))) } 1943 } else if ky == kindConst { 1944 y := xtype.Int(vy) 1945 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)%y)) } 1946 } else { 1947 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)%fr.int(iy))) } 1948 } 1949 case reflect.Int8: 1950 if kx == kindConst && ky == kindConst { 1951 v := xtype.Make(t, xtype.Int8(vx)%xtype.Int8(vy)) 1952 return func(fr *frame) { fr.setReg(ir, v) } 1953 } else if kx == kindConst { 1954 x := xtype.Int8(vx) 1955 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x%fr.int8(iy))) } 1956 } else if ky == kindConst { 1957 y := xtype.Int8(vy) 1958 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)%y)) } 1959 } else { 1960 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)%fr.int8(iy))) } 1961 } 1962 case reflect.Int16: 1963 if kx == kindConst && ky == kindConst { 1964 v := xtype.Make(t, xtype.Int16(vx)%xtype.Int16(vy)) 1965 return func(fr *frame) { fr.setReg(ir, v) } 1966 } else if kx == kindConst { 1967 x := xtype.Int16(vx) 1968 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x%fr.int16(iy))) } 1969 } else if ky == kindConst { 1970 y := xtype.Int16(vy) 1971 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)%y)) } 1972 } else { 1973 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)%fr.int16(iy))) } 1974 } 1975 case reflect.Int32: 1976 if kx == kindConst && ky == kindConst { 1977 v := xtype.Make(t, xtype.Int32(vx)%xtype.Int32(vy)) 1978 return func(fr *frame) { fr.setReg(ir, v) } 1979 } else if kx == kindConst { 1980 x := xtype.Int32(vx) 1981 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x%fr.int32(iy))) } 1982 } else if ky == kindConst { 1983 y := xtype.Int32(vy) 1984 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)%y)) } 1985 } else { 1986 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)%fr.int32(iy))) } 1987 } 1988 case reflect.Int64: 1989 if kx == kindConst && ky == kindConst { 1990 v := xtype.Make(t, xtype.Int64(vx)%xtype.Int64(vy)) 1991 return func(fr *frame) { fr.setReg(ir, v) } 1992 } else if kx == kindConst { 1993 x := xtype.Int64(vx) 1994 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x%fr.int64(iy))) } 1995 } else if ky == kindConst { 1996 y := xtype.Int64(vy) 1997 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)%y)) } 1998 } else { 1999 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)%fr.int64(iy))) } 2000 } 2001 case reflect.Uint: 2002 if kx == kindConst && ky == kindConst { 2003 v := xtype.Make(t, xtype.Uint(vx)%xtype.Uint(vy)) 2004 return func(fr *frame) { fr.setReg(ir, v) } 2005 } else if kx == kindConst { 2006 x := xtype.Uint(vx) 2007 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x%fr.uint(iy))) } 2008 } else if ky == kindConst { 2009 y := xtype.Uint(vy) 2010 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)%y)) } 2011 } else { 2012 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)%fr.uint(iy))) } 2013 } 2014 case reflect.Uint8: 2015 if kx == kindConst && ky == kindConst { 2016 v := xtype.Make(t, xtype.Uint8(vx)%xtype.Uint8(vy)) 2017 return func(fr *frame) { fr.setReg(ir, v) } 2018 } else if kx == kindConst { 2019 x := xtype.Uint8(vx) 2020 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x%fr.uint8(iy))) } 2021 } else if ky == kindConst { 2022 y := xtype.Uint8(vy) 2023 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)%y)) } 2024 } else { 2025 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)%fr.uint8(iy))) } 2026 } 2027 case reflect.Uint16: 2028 if kx == kindConst && ky == kindConst { 2029 v := xtype.Make(t, xtype.Uint16(vx)%xtype.Uint16(vy)) 2030 return func(fr *frame) { fr.setReg(ir, v) } 2031 } else if kx == kindConst { 2032 x := xtype.Uint16(vx) 2033 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x%fr.uint16(iy))) } 2034 } else if ky == kindConst { 2035 y := xtype.Uint16(vy) 2036 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)%y)) } 2037 } else { 2038 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)%fr.uint16(iy))) } 2039 } 2040 case reflect.Uint32: 2041 if kx == kindConst && ky == kindConst { 2042 v := xtype.Make(t, xtype.Uint32(vx)%xtype.Uint32(vy)) 2043 return func(fr *frame) { fr.setReg(ir, v) } 2044 } else if kx == kindConst { 2045 x := xtype.Uint32(vx) 2046 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x%fr.uint32(iy))) } 2047 } else if ky == kindConst { 2048 y := xtype.Uint32(vy) 2049 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)%y)) } 2050 } else { 2051 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)%fr.uint32(iy))) } 2052 } 2053 case reflect.Uint64: 2054 if kx == kindConst && ky == kindConst { 2055 v := xtype.Make(t, xtype.Uint64(vx)%xtype.Uint64(vy)) 2056 return func(fr *frame) { fr.setReg(ir, v) } 2057 } else if kx == kindConst { 2058 x := xtype.Uint64(vx) 2059 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x%fr.uint64(iy))) } 2060 } else if ky == kindConst { 2061 y := xtype.Uint64(vy) 2062 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)%y)) } 2063 } else { 2064 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)%fr.uint64(iy))) } 2065 } 2066 case reflect.Uintptr: 2067 if kx == kindConst && ky == kindConst { 2068 v := xtype.Make(t, xtype.Uintptr(vx)%xtype.Uintptr(vy)) 2069 return func(fr *frame) { fr.setReg(ir, v) } 2070 } else if kx == kindConst { 2071 x := xtype.Uintptr(vx) 2072 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x%fr.uintptr(iy))) } 2073 } else if ky == kindConst { 2074 y := xtype.Uintptr(vy) 2075 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)%y)) } 2076 } else { 2077 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)%fr.uintptr(iy))) } 2078 } 2079 } 2080 } 2081 panic("unreachable") 2082 } 2083 func makeBinOpAND(pfn *function, instr *ssa.BinOp) func(fr *frame) { 2084 ir := pfn.regIndex(instr) 2085 ix, kx, vx := pfn.regIndex3(instr.X) 2086 iy, ky, vy := pfn.regIndex3(instr.Y) 2087 typ := pfn.Interp.preToType(instr.Type()) 2088 if typ.PkgPath() == "" { 2089 switch typ.Kind() { 2090 case reflect.Int: 2091 if kx == kindConst && ky == kindConst { 2092 v := vx.(int) & vy.(int) 2093 return func(fr *frame) { fr.setReg(ir, v) } 2094 } else if kx == kindConst { 2095 x := vx.(int) 2096 return func(fr *frame) { fr.setReg(ir, x&fr.reg(iy).(int)) } 2097 } else if ky == kindConst { 2098 y := vy.(int) 2099 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)&y) } 2100 } else { 2101 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)&fr.reg(iy).(int)) } 2102 } 2103 case reflect.Int8: 2104 if kx == kindConst && ky == kindConst { 2105 v := vx.(int8) & vy.(int8) 2106 return func(fr *frame) { fr.setReg(ir, v) } 2107 } else if kx == kindConst { 2108 x := vx.(int8) 2109 return func(fr *frame) { fr.setReg(ir, x&fr.reg(iy).(int8)) } 2110 } else if ky == kindConst { 2111 y := vy.(int8) 2112 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)&y) } 2113 } else { 2114 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)&fr.reg(iy).(int8)) } 2115 } 2116 case reflect.Int16: 2117 if kx == kindConst && ky == kindConst { 2118 v := vx.(int16) & vy.(int16) 2119 return func(fr *frame) { fr.setReg(ir, v) } 2120 } else if kx == kindConst { 2121 x := vx.(int16) 2122 return func(fr *frame) { fr.setReg(ir, x&fr.reg(iy).(int16)) } 2123 } else if ky == kindConst { 2124 y := vy.(int16) 2125 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)&y) } 2126 } else { 2127 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)&fr.reg(iy).(int16)) } 2128 } 2129 case reflect.Int32: 2130 if kx == kindConst && ky == kindConst { 2131 v := vx.(int32) & vy.(int32) 2132 return func(fr *frame) { fr.setReg(ir, v) } 2133 } else if kx == kindConst { 2134 x := vx.(int32) 2135 return func(fr *frame) { fr.setReg(ir, x&fr.reg(iy).(int32)) } 2136 } else if ky == kindConst { 2137 y := vy.(int32) 2138 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)&y) } 2139 } else { 2140 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)&fr.reg(iy).(int32)) } 2141 } 2142 case reflect.Int64: 2143 if kx == kindConst && ky == kindConst { 2144 v := vx.(int64) & vy.(int64) 2145 return func(fr *frame) { fr.setReg(ir, v) } 2146 } else if kx == kindConst { 2147 x := vx.(int64) 2148 return func(fr *frame) { fr.setReg(ir, x&fr.reg(iy).(int64)) } 2149 } else if ky == kindConst { 2150 y := vy.(int64) 2151 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)&y) } 2152 } else { 2153 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)&fr.reg(iy).(int64)) } 2154 } 2155 case reflect.Uint: 2156 if kx == kindConst && ky == kindConst { 2157 v := vx.(uint) & vy.(uint) 2158 return func(fr *frame) { fr.setReg(ir, v) } 2159 } else if kx == kindConst { 2160 x := vx.(uint) 2161 return func(fr *frame) { fr.setReg(ir, x&fr.reg(iy).(uint)) } 2162 } else if ky == kindConst { 2163 y := vy.(uint) 2164 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)&y) } 2165 } else { 2166 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)&fr.reg(iy).(uint)) } 2167 } 2168 case reflect.Uint8: 2169 if kx == kindConst && ky == kindConst { 2170 v := vx.(uint8) & vy.(uint8) 2171 return func(fr *frame) { fr.setReg(ir, v) } 2172 } else if kx == kindConst { 2173 x := vx.(uint8) 2174 return func(fr *frame) { fr.setReg(ir, x&fr.reg(iy).(uint8)) } 2175 } else if ky == kindConst { 2176 y := vy.(uint8) 2177 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)&y) } 2178 } else { 2179 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)&fr.reg(iy).(uint8)) } 2180 } 2181 case reflect.Uint16: 2182 if kx == kindConst && ky == kindConst { 2183 v := vx.(uint16) & vy.(uint16) 2184 return func(fr *frame) { fr.setReg(ir, v) } 2185 } else if kx == kindConst { 2186 x := vx.(uint16) 2187 return func(fr *frame) { fr.setReg(ir, x&fr.reg(iy).(uint16)) } 2188 } else if ky == kindConst { 2189 y := vy.(uint16) 2190 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)&y) } 2191 } else { 2192 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)&fr.reg(iy).(uint16)) } 2193 } 2194 case reflect.Uint32: 2195 if kx == kindConst && ky == kindConst { 2196 v := vx.(uint32) & vy.(uint32) 2197 return func(fr *frame) { fr.setReg(ir, v) } 2198 } else if kx == kindConst { 2199 x := vx.(uint32) 2200 return func(fr *frame) { fr.setReg(ir, x&fr.reg(iy).(uint32)) } 2201 } else if ky == kindConst { 2202 y := vy.(uint32) 2203 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)&y) } 2204 } else { 2205 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)&fr.reg(iy).(uint32)) } 2206 } 2207 case reflect.Uint64: 2208 if kx == kindConst && ky == kindConst { 2209 v := vx.(uint64) & vy.(uint64) 2210 return func(fr *frame) { fr.setReg(ir, v) } 2211 } else if kx == kindConst { 2212 x := vx.(uint64) 2213 return func(fr *frame) { fr.setReg(ir, x&fr.reg(iy).(uint64)) } 2214 } else if ky == kindConst { 2215 y := vy.(uint64) 2216 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)&y) } 2217 } else { 2218 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)&fr.reg(iy).(uint64)) } 2219 } 2220 case reflect.Uintptr: 2221 if kx == kindConst && ky == kindConst { 2222 v := vx.(uintptr) & vy.(uintptr) 2223 return func(fr *frame) { fr.setReg(ir, v) } 2224 } else if kx == kindConst { 2225 x := vx.(uintptr) 2226 return func(fr *frame) { fr.setReg(ir, x&fr.reg(iy).(uintptr)) } 2227 } else if ky == kindConst { 2228 y := vy.(uintptr) 2229 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)&y) } 2230 } else { 2231 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)&fr.reg(iy).(uintptr)) } 2232 } 2233 } 2234 } else { 2235 t := xtype.TypeOfType(typ) 2236 switch typ.Kind() { 2237 case reflect.Int: 2238 if kx == kindConst && ky == kindConst { 2239 v := xtype.Make(t, xtype.Int(vx)&xtype.Int(vy)) 2240 return func(fr *frame) { fr.setReg(ir, v) } 2241 } else if kx == kindConst { 2242 x := xtype.Int(vx) 2243 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&fr.int(iy))) } 2244 } else if ky == kindConst { 2245 y := xtype.Int(vy) 2246 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)&y)) } 2247 } else { 2248 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)&fr.int(iy))) } 2249 } 2250 case reflect.Int8: 2251 if kx == kindConst && ky == kindConst { 2252 v := xtype.Make(t, xtype.Int8(vx)&xtype.Int8(vy)) 2253 return func(fr *frame) { fr.setReg(ir, v) } 2254 } else if kx == kindConst { 2255 x := xtype.Int8(vx) 2256 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&fr.int8(iy))) } 2257 } else if ky == kindConst { 2258 y := xtype.Int8(vy) 2259 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)&y)) } 2260 } else { 2261 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)&fr.int8(iy))) } 2262 } 2263 case reflect.Int16: 2264 if kx == kindConst && ky == kindConst { 2265 v := xtype.Make(t, xtype.Int16(vx)&xtype.Int16(vy)) 2266 return func(fr *frame) { fr.setReg(ir, v) } 2267 } else if kx == kindConst { 2268 x := xtype.Int16(vx) 2269 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&fr.int16(iy))) } 2270 } else if ky == kindConst { 2271 y := xtype.Int16(vy) 2272 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)&y)) } 2273 } else { 2274 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)&fr.int16(iy))) } 2275 } 2276 case reflect.Int32: 2277 if kx == kindConst && ky == kindConst { 2278 v := xtype.Make(t, xtype.Int32(vx)&xtype.Int32(vy)) 2279 return func(fr *frame) { fr.setReg(ir, v) } 2280 } else if kx == kindConst { 2281 x := xtype.Int32(vx) 2282 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&fr.int32(iy))) } 2283 } else if ky == kindConst { 2284 y := xtype.Int32(vy) 2285 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)&y)) } 2286 } else { 2287 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)&fr.int32(iy))) } 2288 } 2289 case reflect.Int64: 2290 if kx == kindConst && ky == kindConst { 2291 v := xtype.Make(t, xtype.Int64(vx)&xtype.Int64(vy)) 2292 return func(fr *frame) { fr.setReg(ir, v) } 2293 } else if kx == kindConst { 2294 x := xtype.Int64(vx) 2295 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&fr.int64(iy))) } 2296 } else if ky == kindConst { 2297 y := xtype.Int64(vy) 2298 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)&y)) } 2299 } else { 2300 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)&fr.int64(iy))) } 2301 } 2302 case reflect.Uint: 2303 if kx == kindConst && ky == kindConst { 2304 v := xtype.Make(t, xtype.Uint(vx)&xtype.Uint(vy)) 2305 return func(fr *frame) { fr.setReg(ir, v) } 2306 } else if kx == kindConst { 2307 x := xtype.Uint(vx) 2308 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&fr.uint(iy))) } 2309 } else if ky == kindConst { 2310 y := xtype.Uint(vy) 2311 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)&y)) } 2312 } else { 2313 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)&fr.uint(iy))) } 2314 } 2315 case reflect.Uint8: 2316 if kx == kindConst && ky == kindConst { 2317 v := xtype.Make(t, xtype.Uint8(vx)&xtype.Uint8(vy)) 2318 return func(fr *frame) { fr.setReg(ir, v) } 2319 } else if kx == kindConst { 2320 x := xtype.Uint8(vx) 2321 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&fr.uint8(iy))) } 2322 } else if ky == kindConst { 2323 y := xtype.Uint8(vy) 2324 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)&y)) } 2325 } else { 2326 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)&fr.uint8(iy))) } 2327 } 2328 case reflect.Uint16: 2329 if kx == kindConst && ky == kindConst { 2330 v := xtype.Make(t, xtype.Uint16(vx)&xtype.Uint16(vy)) 2331 return func(fr *frame) { fr.setReg(ir, v) } 2332 } else if kx == kindConst { 2333 x := xtype.Uint16(vx) 2334 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&fr.uint16(iy))) } 2335 } else if ky == kindConst { 2336 y := xtype.Uint16(vy) 2337 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)&y)) } 2338 } else { 2339 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)&fr.uint16(iy))) } 2340 } 2341 case reflect.Uint32: 2342 if kx == kindConst && ky == kindConst { 2343 v := xtype.Make(t, xtype.Uint32(vx)&xtype.Uint32(vy)) 2344 return func(fr *frame) { fr.setReg(ir, v) } 2345 } else if kx == kindConst { 2346 x := xtype.Uint32(vx) 2347 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&fr.uint32(iy))) } 2348 } else if ky == kindConst { 2349 y := xtype.Uint32(vy) 2350 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)&y)) } 2351 } else { 2352 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)&fr.uint32(iy))) } 2353 } 2354 case reflect.Uint64: 2355 if kx == kindConst && ky == kindConst { 2356 v := xtype.Make(t, xtype.Uint64(vx)&xtype.Uint64(vy)) 2357 return func(fr *frame) { fr.setReg(ir, v) } 2358 } else if kx == kindConst { 2359 x := xtype.Uint64(vx) 2360 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&fr.uint64(iy))) } 2361 } else if ky == kindConst { 2362 y := xtype.Uint64(vy) 2363 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)&y)) } 2364 } else { 2365 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)&fr.uint64(iy))) } 2366 } 2367 case reflect.Uintptr: 2368 if kx == kindConst && ky == kindConst { 2369 v := xtype.Make(t, xtype.Uintptr(vx)&xtype.Uintptr(vy)) 2370 return func(fr *frame) { fr.setReg(ir, v) } 2371 } else if kx == kindConst { 2372 x := xtype.Uintptr(vx) 2373 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&fr.uintptr(iy))) } 2374 } else if ky == kindConst { 2375 y := xtype.Uintptr(vy) 2376 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)&y)) } 2377 } else { 2378 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)&fr.uintptr(iy))) } 2379 } 2380 } 2381 } 2382 panic("unreachable") 2383 } 2384 func makeBinOpOR(pfn *function, instr *ssa.BinOp) func(fr *frame) { 2385 ir := pfn.regIndex(instr) 2386 ix, kx, vx := pfn.regIndex3(instr.X) 2387 iy, ky, vy := pfn.regIndex3(instr.Y) 2388 typ := pfn.Interp.preToType(instr.Type()) 2389 if typ.PkgPath() == "" { 2390 switch typ.Kind() { 2391 case reflect.Int: 2392 if kx == kindConst && ky == kindConst { 2393 v := vx.(int) | vy.(int) 2394 return func(fr *frame) { fr.setReg(ir, v) } 2395 } else if kx == kindConst { 2396 x := vx.(int) 2397 return func(fr *frame) { fr.setReg(ir, x|fr.reg(iy).(int)) } 2398 } else if ky == kindConst { 2399 y := vy.(int) 2400 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)|y) } 2401 } else { 2402 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)|fr.reg(iy).(int)) } 2403 } 2404 case reflect.Int8: 2405 if kx == kindConst && ky == kindConst { 2406 v := vx.(int8) | vy.(int8) 2407 return func(fr *frame) { fr.setReg(ir, v) } 2408 } else if kx == kindConst { 2409 x := vx.(int8) 2410 return func(fr *frame) { fr.setReg(ir, x|fr.reg(iy).(int8)) } 2411 } else if ky == kindConst { 2412 y := vy.(int8) 2413 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)|y) } 2414 } else { 2415 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)|fr.reg(iy).(int8)) } 2416 } 2417 case reflect.Int16: 2418 if kx == kindConst && ky == kindConst { 2419 v := vx.(int16) | vy.(int16) 2420 return func(fr *frame) { fr.setReg(ir, v) } 2421 } else if kx == kindConst { 2422 x := vx.(int16) 2423 return func(fr *frame) { fr.setReg(ir, x|fr.reg(iy).(int16)) } 2424 } else if ky == kindConst { 2425 y := vy.(int16) 2426 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)|y) } 2427 } else { 2428 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)|fr.reg(iy).(int16)) } 2429 } 2430 case reflect.Int32: 2431 if kx == kindConst && ky == kindConst { 2432 v := vx.(int32) | vy.(int32) 2433 return func(fr *frame) { fr.setReg(ir, v) } 2434 } else if kx == kindConst { 2435 x := vx.(int32) 2436 return func(fr *frame) { fr.setReg(ir, x|fr.reg(iy).(int32)) } 2437 } else if ky == kindConst { 2438 y := vy.(int32) 2439 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)|y) } 2440 } else { 2441 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)|fr.reg(iy).(int32)) } 2442 } 2443 case reflect.Int64: 2444 if kx == kindConst && ky == kindConst { 2445 v := vx.(int64) | vy.(int64) 2446 return func(fr *frame) { fr.setReg(ir, v) } 2447 } else if kx == kindConst { 2448 x := vx.(int64) 2449 return func(fr *frame) { fr.setReg(ir, x|fr.reg(iy).(int64)) } 2450 } else if ky == kindConst { 2451 y := vy.(int64) 2452 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)|y) } 2453 } else { 2454 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)|fr.reg(iy).(int64)) } 2455 } 2456 case reflect.Uint: 2457 if kx == kindConst && ky == kindConst { 2458 v := vx.(uint) | vy.(uint) 2459 return func(fr *frame) { fr.setReg(ir, v) } 2460 } else if kx == kindConst { 2461 x := vx.(uint) 2462 return func(fr *frame) { fr.setReg(ir, x|fr.reg(iy).(uint)) } 2463 } else if ky == kindConst { 2464 y := vy.(uint) 2465 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)|y) } 2466 } else { 2467 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)|fr.reg(iy).(uint)) } 2468 } 2469 case reflect.Uint8: 2470 if kx == kindConst && ky == kindConst { 2471 v := vx.(uint8) | vy.(uint8) 2472 return func(fr *frame) { fr.setReg(ir, v) } 2473 } else if kx == kindConst { 2474 x := vx.(uint8) 2475 return func(fr *frame) { fr.setReg(ir, x|fr.reg(iy).(uint8)) } 2476 } else if ky == kindConst { 2477 y := vy.(uint8) 2478 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)|y) } 2479 } else { 2480 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)|fr.reg(iy).(uint8)) } 2481 } 2482 case reflect.Uint16: 2483 if kx == kindConst && ky == kindConst { 2484 v := vx.(uint16) | vy.(uint16) 2485 return func(fr *frame) { fr.setReg(ir, v) } 2486 } else if kx == kindConst { 2487 x := vx.(uint16) 2488 return func(fr *frame) { fr.setReg(ir, x|fr.reg(iy).(uint16)) } 2489 } else if ky == kindConst { 2490 y := vy.(uint16) 2491 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)|y) } 2492 } else { 2493 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)|fr.reg(iy).(uint16)) } 2494 } 2495 case reflect.Uint32: 2496 if kx == kindConst && ky == kindConst { 2497 v := vx.(uint32) | vy.(uint32) 2498 return func(fr *frame) { fr.setReg(ir, v) } 2499 } else if kx == kindConst { 2500 x := vx.(uint32) 2501 return func(fr *frame) { fr.setReg(ir, x|fr.reg(iy).(uint32)) } 2502 } else if ky == kindConst { 2503 y := vy.(uint32) 2504 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)|y) } 2505 } else { 2506 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)|fr.reg(iy).(uint32)) } 2507 } 2508 case reflect.Uint64: 2509 if kx == kindConst && ky == kindConst { 2510 v := vx.(uint64) | vy.(uint64) 2511 return func(fr *frame) { fr.setReg(ir, v) } 2512 } else if kx == kindConst { 2513 x := vx.(uint64) 2514 return func(fr *frame) { fr.setReg(ir, x|fr.reg(iy).(uint64)) } 2515 } else if ky == kindConst { 2516 y := vy.(uint64) 2517 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)|y) } 2518 } else { 2519 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)|fr.reg(iy).(uint64)) } 2520 } 2521 case reflect.Uintptr: 2522 if kx == kindConst && ky == kindConst { 2523 v := vx.(uintptr) | vy.(uintptr) 2524 return func(fr *frame) { fr.setReg(ir, v) } 2525 } else if kx == kindConst { 2526 x := vx.(uintptr) 2527 return func(fr *frame) { fr.setReg(ir, x|fr.reg(iy).(uintptr)) } 2528 } else if ky == kindConst { 2529 y := vy.(uintptr) 2530 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)|y) } 2531 } else { 2532 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)|fr.reg(iy).(uintptr)) } 2533 } 2534 } 2535 } else { 2536 t := xtype.TypeOfType(typ) 2537 switch typ.Kind() { 2538 case reflect.Int: 2539 if kx == kindConst && ky == kindConst { 2540 v := xtype.Make(t, xtype.Int(vx)|xtype.Int(vy)) 2541 return func(fr *frame) { fr.setReg(ir, v) } 2542 } else if kx == kindConst { 2543 x := xtype.Int(vx) 2544 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x|fr.int(iy))) } 2545 } else if ky == kindConst { 2546 y := xtype.Int(vy) 2547 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)|y)) } 2548 } else { 2549 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)|fr.int(iy))) } 2550 } 2551 case reflect.Int8: 2552 if kx == kindConst && ky == kindConst { 2553 v := xtype.Make(t, xtype.Int8(vx)|xtype.Int8(vy)) 2554 return func(fr *frame) { fr.setReg(ir, v) } 2555 } else if kx == kindConst { 2556 x := xtype.Int8(vx) 2557 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x|fr.int8(iy))) } 2558 } else if ky == kindConst { 2559 y := xtype.Int8(vy) 2560 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)|y)) } 2561 } else { 2562 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)|fr.int8(iy))) } 2563 } 2564 case reflect.Int16: 2565 if kx == kindConst && ky == kindConst { 2566 v := xtype.Make(t, xtype.Int16(vx)|xtype.Int16(vy)) 2567 return func(fr *frame) { fr.setReg(ir, v) } 2568 } else if kx == kindConst { 2569 x := xtype.Int16(vx) 2570 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x|fr.int16(iy))) } 2571 } else if ky == kindConst { 2572 y := xtype.Int16(vy) 2573 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)|y)) } 2574 } else { 2575 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)|fr.int16(iy))) } 2576 } 2577 case reflect.Int32: 2578 if kx == kindConst && ky == kindConst { 2579 v := xtype.Make(t, xtype.Int32(vx)|xtype.Int32(vy)) 2580 return func(fr *frame) { fr.setReg(ir, v) } 2581 } else if kx == kindConst { 2582 x := xtype.Int32(vx) 2583 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x|fr.int32(iy))) } 2584 } else if ky == kindConst { 2585 y := xtype.Int32(vy) 2586 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)|y)) } 2587 } else { 2588 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)|fr.int32(iy))) } 2589 } 2590 case reflect.Int64: 2591 if kx == kindConst && ky == kindConst { 2592 v := xtype.Make(t, xtype.Int64(vx)|xtype.Int64(vy)) 2593 return func(fr *frame) { fr.setReg(ir, v) } 2594 } else if kx == kindConst { 2595 x := xtype.Int64(vx) 2596 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x|fr.int64(iy))) } 2597 } else if ky == kindConst { 2598 y := xtype.Int64(vy) 2599 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)|y)) } 2600 } else { 2601 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)|fr.int64(iy))) } 2602 } 2603 case reflect.Uint: 2604 if kx == kindConst && ky == kindConst { 2605 v := xtype.Make(t, xtype.Uint(vx)|xtype.Uint(vy)) 2606 return func(fr *frame) { fr.setReg(ir, v) } 2607 } else if kx == kindConst { 2608 x := xtype.Uint(vx) 2609 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x|fr.uint(iy))) } 2610 } else if ky == kindConst { 2611 y := xtype.Uint(vy) 2612 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)|y)) } 2613 } else { 2614 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)|fr.uint(iy))) } 2615 } 2616 case reflect.Uint8: 2617 if kx == kindConst && ky == kindConst { 2618 v := xtype.Make(t, xtype.Uint8(vx)|xtype.Uint8(vy)) 2619 return func(fr *frame) { fr.setReg(ir, v) } 2620 } else if kx == kindConst { 2621 x := xtype.Uint8(vx) 2622 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x|fr.uint8(iy))) } 2623 } else if ky == kindConst { 2624 y := xtype.Uint8(vy) 2625 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)|y)) } 2626 } else { 2627 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)|fr.uint8(iy))) } 2628 } 2629 case reflect.Uint16: 2630 if kx == kindConst && ky == kindConst { 2631 v := xtype.Make(t, xtype.Uint16(vx)|xtype.Uint16(vy)) 2632 return func(fr *frame) { fr.setReg(ir, v) } 2633 } else if kx == kindConst { 2634 x := xtype.Uint16(vx) 2635 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x|fr.uint16(iy))) } 2636 } else if ky == kindConst { 2637 y := xtype.Uint16(vy) 2638 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)|y)) } 2639 } else { 2640 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)|fr.uint16(iy))) } 2641 } 2642 case reflect.Uint32: 2643 if kx == kindConst && ky == kindConst { 2644 v := xtype.Make(t, xtype.Uint32(vx)|xtype.Uint32(vy)) 2645 return func(fr *frame) { fr.setReg(ir, v) } 2646 } else if kx == kindConst { 2647 x := xtype.Uint32(vx) 2648 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x|fr.uint32(iy))) } 2649 } else if ky == kindConst { 2650 y := xtype.Uint32(vy) 2651 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)|y)) } 2652 } else { 2653 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)|fr.uint32(iy))) } 2654 } 2655 case reflect.Uint64: 2656 if kx == kindConst && ky == kindConst { 2657 v := xtype.Make(t, xtype.Uint64(vx)|xtype.Uint64(vy)) 2658 return func(fr *frame) { fr.setReg(ir, v) } 2659 } else if kx == kindConst { 2660 x := xtype.Uint64(vx) 2661 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x|fr.uint64(iy))) } 2662 } else if ky == kindConst { 2663 y := xtype.Uint64(vy) 2664 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)|y)) } 2665 } else { 2666 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)|fr.uint64(iy))) } 2667 } 2668 case reflect.Uintptr: 2669 if kx == kindConst && ky == kindConst { 2670 v := xtype.Make(t, xtype.Uintptr(vx)|xtype.Uintptr(vy)) 2671 return func(fr *frame) { fr.setReg(ir, v) } 2672 } else if kx == kindConst { 2673 x := xtype.Uintptr(vx) 2674 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x|fr.uintptr(iy))) } 2675 } else if ky == kindConst { 2676 y := xtype.Uintptr(vy) 2677 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)|y)) } 2678 } else { 2679 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)|fr.uintptr(iy))) } 2680 } 2681 } 2682 } 2683 panic("unreachable") 2684 } 2685 func makeBinOpXOR(pfn *function, instr *ssa.BinOp) func(fr *frame) { 2686 ir := pfn.regIndex(instr) 2687 ix, kx, vx := pfn.regIndex3(instr.X) 2688 iy, ky, vy := pfn.regIndex3(instr.Y) 2689 typ := pfn.Interp.preToType(instr.Type()) 2690 if typ.PkgPath() == "" { 2691 switch typ.Kind() { 2692 case reflect.Int: 2693 if kx == kindConst && ky == kindConst { 2694 v := vx.(int) ^ vy.(int) 2695 return func(fr *frame) { fr.setReg(ir, v) } 2696 } else if kx == kindConst { 2697 x := vx.(int) 2698 return func(fr *frame) { fr.setReg(ir, x^fr.reg(iy).(int)) } 2699 } else if ky == kindConst { 2700 y := vy.(int) 2701 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)^y) } 2702 } else { 2703 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)^fr.reg(iy).(int)) } 2704 } 2705 case reflect.Int8: 2706 if kx == kindConst && ky == kindConst { 2707 v := vx.(int8) ^ vy.(int8) 2708 return func(fr *frame) { fr.setReg(ir, v) } 2709 } else if kx == kindConst { 2710 x := vx.(int8) 2711 return func(fr *frame) { fr.setReg(ir, x^fr.reg(iy).(int8)) } 2712 } else if ky == kindConst { 2713 y := vy.(int8) 2714 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)^y) } 2715 } else { 2716 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)^fr.reg(iy).(int8)) } 2717 } 2718 case reflect.Int16: 2719 if kx == kindConst && ky == kindConst { 2720 v := vx.(int16) ^ vy.(int16) 2721 return func(fr *frame) { fr.setReg(ir, v) } 2722 } else if kx == kindConst { 2723 x := vx.(int16) 2724 return func(fr *frame) { fr.setReg(ir, x^fr.reg(iy).(int16)) } 2725 } else if ky == kindConst { 2726 y := vy.(int16) 2727 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)^y) } 2728 } else { 2729 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)^fr.reg(iy).(int16)) } 2730 } 2731 case reflect.Int32: 2732 if kx == kindConst && ky == kindConst { 2733 v := vx.(int32) ^ vy.(int32) 2734 return func(fr *frame) { fr.setReg(ir, v) } 2735 } else if kx == kindConst { 2736 x := vx.(int32) 2737 return func(fr *frame) { fr.setReg(ir, x^fr.reg(iy).(int32)) } 2738 } else if ky == kindConst { 2739 y := vy.(int32) 2740 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)^y) } 2741 } else { 2742 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)^fr.reg(iy).(int32)) } 2743 } 2744 case reflect.Int64: 2745 if kx == kindConst && ky == kindConst { 2746 v := vx.(int64) ^ vy.(int64) 2747 return func(fr *frame) { fr.setReg(ir, v) } 2748 } else if kx == kindConst { 2749 x := vx.(int64) 2750 return func(fr *frame) { fr.setReg(ir, x^fr.reg(iy).(int64)) } 2751 } else if ky == kindConst { 2752 y := vy.(int64) 2753 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)^y) } 2754 } else { 2755 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)^fr.reg(iy).(int64)) } 2756 } 2757 case reflect.Uint: 2758 if kx == kindConst && ky == kindConst { 2759 v := vx.(uint) ^ vy.(uint) 2760 return func(fr *frame) { fr.setReg(ir, v) } 2761 } else if kx == kindConst { 2762 x := vx.(uint) 2763 return func(fr *frame) { fr.setReg(ir, x^fr.reg(iy).(uint)) } 2764 } else if ky == kindConst { 2765 y := vy.(uint) 2766 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)^y) } 2767 } else { 2768 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)^fr.reg(iy).(uint)) } 2769 } 2770 case reflect.Uint8: 2771 if kx == kindConst && ky == kindConst { 2772 v := vx.(uint8) ^ vy.(uint8) 2773 return func(fr *frame) { fr.setReg(ir, v) } 2774 } else if kx == kindConst { 2775 x := vx.(uint8) 2776 return func(fr *frame) { fr.setReg(ir, x^fr.reg(iy).(uint8)) } 2777 } else if ky == kindConst { 2778 y := vy.(uint8) 2779 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)^y) } 2780 } else { 2781 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)^fr.reg(iy).(uint8)) } 2782 } 2783 case reflect.Uint16: 2784 if kx == kindConst && ky == kindConst { 2785 v := vx.(uint16) ^ vy.(uint16) 2786 return func(fr *frame) { fr.setReg(ir, v) } 2787 } else if kx == kindConst { 2788 x := vx.(uint16) 2789 return func(fr *frame) { fr.setReg(ir, x^fr.reg(iy).(uint16)) } 2790 } else if ky == kindConst { 2791 y := vy.(uint16) 2792 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)^y) } 2793 } else { 2794 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)^fr.reg(iy).(uint16)) } 2795 } 2796 case reflect.Uint32: 2797 if kx == kindConst && ky == kindConst { 2798 v := vx.(uint32) ^ vy.(uint32) 2799 return func(fr *frame) { fr.setReg(ir, v) } 2800 } else if kx == kindConst { 2801 x := vx.(uint32) 2802 return func(fr *frame) { fr.setReg(ir, x^fr.reg(iy).(uint32)) } 2803 } else if ky == kindConst { 2804 y := vy.(uint32) 2805 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)^y) } 2806 } else { 2807 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)^fr.reg(iy).(uint32)) } 2808 } 2809 case reflect.Uint64: 2810 if kx == kindConst && ky == kindConst { 2811 v := vx.(uint64) ^ vy.(uint64) 2812 return func(fr *frame) { fr.setReg(ir, v) } 2813 } else if kx == kindConst { 2814 x := vx.(uint64) 2815 return func(fr *frame) { fr.setReg(ir, x^fr.reg(iy).(uint64)) } 2816 } else if ky == kindConst { 2817 y := vy.(uint64) 2818 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)^y) } 2819 } else { 2820 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)^fr.reg(iy).(uint64)) } 2821 } 2822 case reflect.Uintptr: 2823 if kx == kindConst && ky == kindConst { 2824 v := vx.(uintptr) ^ vy.(uintptr) 2825 return func(fr *frame) { fr.setReg(ir, v) } 2826 } else if kx == kindConst { 2827 x := vx.(uintptr) 2828 return func(fr *frame) { fr.setReg(ir, x^fr.reg(iy).(uintptr)) } 2829 } else if ky == kindConst { 2830 y := vy.(uintptr) 2831 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)^y) } 2832 } else { 2833 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)^fr.reg(iy).(uintptr)) } 2834 } 2835 } 2836 } else { 2837 t := xtype.TypeOfType(typ) 2838 switch typ.Kind() { 2839 case reflect.Int: 2840 if kx == kindConst && ky == kindConst { 2841 v := xtype.Make(t, xtype.Int(vx)^xtype.Int(vy)) 2842 return func(fr *frame) { fr.setReg(ir, v) } 2843 } else if kx == kindConst { 2844 x := xtype.Int(vx) 2845 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x^fr.int(iy))) } 2846 } else if ky == kindConst { 2847 y := xtype.Int(vy) 2848 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)^y)) } 2849 } else { 2850 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)^fr.int(iy))) } 2851 } 2852 case reflect.Int8: 2853 if kx == kindConst && ky == kindConst { 2854 v := xtype.Make(t, xtype.Int8(vx)^xtype.Int8(vy)) 2855 return func(fr *frame) { fr.setReg(ir, v) } 2856 } else if kx == kindConst { 2857 x := xtype.Int8(vx) 2858 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x^fr.int8(iy))) } 2859 } else if ky == kindConst { 2860 y := xtype.Int8(vy) 2861 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)^y)) } 2862 } else { 2863 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)^fr.int8(iy))) } 2864 } 2865 case reflect.Int16: 2866 if kx == kindConst && ky == kindConst { 2867 v := xtype.Make(t, xtype.Int16(vx)^xtype.Int16(vy)) 2868 return func(fr *frame) { fr.setReg(ir, v) } 2869 } else if kx == kindConst { 2870 x := xtype.Int16(vx) 2871 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x^fr.int16(iy))) } 2872 } else if ky == kindConst { 2873 y := xtype.Int16(vy) 2874 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)^y)) } 2875 } else { 2876 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)^fr.int16(iy))) } 2877 } 2878 case reflect.Int32: 2879 if kx == kindConst && ky == kindConst { 2880 v := xtype.Make(t, xtype.Int32(vx)^xtype.Int32(vy)) 2881 return func(fr *frame) { fr.setReg(ir, v) } 2882 } else if kx == kindConst { 2883 x := xtype.Int32(vx) 2884 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x^fr.int32(iy))) } 2885 } else if ky == kindConst { 2886 y := xtype.Int32(vy) 2887 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)^y)) } 2888 } else { 2889 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)^fr.int32(iy))) } 2890 } 2891 case reflect.Int64: 2892 if kx == kindConst && ky == kindConst { 2893 v := xtype.Make(t, xtype.Int64(vx)^xtype.Int64(vy)) 2894 return func(fr *frame) { fr.setReg(ir, v) } 2895 } else if kx == kindConst { 2896 x := xtype.Int64(vx) 2897 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x^fr.int64(iy))) } 2898 } else if ky == kindConst { 2899 y := xtype.Int64(vy) 2900 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)^y)) } 2901 } else { 2902 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)^fr.int64(iy))) } 2903 } 2904 case reflect.Uint: 2905 if kx == kindConst && ky == kindConst { 2906 v := xtype.Make(t, xtype.Uint(vx)^xtype.Uint(vy)) 2907 return func(fr *frame) { fr.setReg(ir, v) } 2908 } else if kx == kindConst { 2909 x := xtype.Uint(vx) 2910 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x^fr.uint(iy))) } 2911 } else if ky == kindConst { 2912 y := xtype.Uint(vy) 2913 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)^y)) } 2914 } else { 2915 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)^fr.uint(iy))) } 2916 } 2917 case reflect.Uint8: 2918 if kx == kindConst && ky == kindConst { 2919 v := xtype.Make(t, xtype.Uint8(vx)^xtype.Uint8(vy)) 2920 return func(fr *frame) { fr.setReg(ir, v) } 2921 } else if kx == kindConst { 2922 x := xtype.Uint8(vx) 2923 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x^fr.uint8(iy))) } 2924 } else if ky == kindConst { 2925 y := xtype.Uint8(vy) 2926 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)^y)) } 2927 } else { 2928 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)^fr.uint8(iy))) } 2929 } 2930 case reflect.Uint16: 2931 if kx == kindConst && ky == kindConst { 2932 v := xtype.Make(t, xtype.Uint16(vx)^xtype.Uint16(vy)) 2933 return func(fr *frame) { fr.setReg(ir, v) } 2934 } else if kx == kindConst { 2935 x := xtype.Uint16(vx) 2936 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x^fr.uint16(iy))) } 2937 } else if ky == kindConst { 2938 y := xtype.Uint16(vy) 2939 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)^y)) } 2940 } else { 2941 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)^fr.uint16(iy))) } 2942 } 2943 case reflect.Uint32: 2944 if kx == kindConst && ky == kindConst { 2945 v := xtype.Make(t, xtype.Uint32(vx)^xtype.Uint32(vy)) 2946 return func(fr *frame) { fr.setReg(ir, v) } 2947 } else if kx == kindConst { 2948 x := xtype.Uint32(vx) 2949 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x^fr.uint32(iy))) } 2950 } else if ky == kindConst { 2951 y := xtype.Uint32(vy) 2952 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)^y)) } 2953 } else { 2954 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)^fr.uint32(iy))) } 2955 } 2956 case reflect.Uint64: 2957 if kx == kindConst && ky == kindConst { 2958 v := xtype.Make(t, xtype.Uint64(vx)^xtype.Uint64(vy)) 2959 return func(fr *frame) { fr.setReg(ir, v) } 2960 } else if kx == kindConst { 2961 x := xtype.Uint64(vx) 2962 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x^fr.uint64(iy))) } 2963 } else if ky == kindConst { 2964 y := xtype.Uint64(vy) 2965 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)^y)) } 2966 } else { 2967 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)^fr.uint64(iy))) } 2968 } 2969 case reflect.Uintptr: 2970 if kx == kindConst && ky == kindConst { 2971 v := xtype.Make(t, xtype.Uintptr(vx)^xtype.Uintptr(vy)) 2972 return func(fr *frame) { fr.setReg(ir, v) } 2973 } else if kx == kindConst { 2974 x := xtype.Uintptr(vx) 2975 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x^fr.uintptr(iy))) } 2976 } else if ky == kindConst { 2977 y := xtype.Uintptr(vy) 2978 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)^y)) } 2979 } else { 2980 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)^fr.uintptr(iy))) } 2981 } 2982 } 2983 } 2984 panic("unreachable") 2985 } 2986 func makeBinOpANDNOT(pfn *function, instr *ssa.BinOp) func(fr *frame) { 2987 ir := pfn.regIndex(instr) 2988 ix, kx, vx := pfn.regIndex3(instr.X) 2989 iy, ky, vy := pfn.regIndex3(instr.Y) 2990 typ := pfn.Interp.preToType(instr.Type()) 2991 if typ.PkgPath() == "" { 2992 switch typ.Kind() { 2993 case reflect.Int: 2994 if kx == kindConst && ky == kindConst { 2995 v := vx.(int) &^ vy.(int) 2996 return func(fr *frame) { fr.setReg(ir, v) } 2997 } else if kx == kindConst { 2998 x := vx.(int) 2999 return func(fr *frame) { fr.setReg(ir, x&^fr.reg(iy).(int)) } 3000 } else if ky == kindConst { 3001 y := vy.(int) 3002 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)&^y) } 3003 } else { 3004 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int)&^fr.reg(iy).(int)) } 3005 } 3006 case reflect.Int8: 3007 if kx == kindConst && ky == kindConst { 3008 v := vx.(int8) &^ vy.(int8) 3009 return func(fr *frame) { fr.setReg(ir, v) } 3010 } else if kx == kindConst { 3011 x := vx.(int8) 3012 return func(fr *frame) { fr.setReg(ir, x&^fr.reg(iy).(int8)) } 3013 } else if ky == kindConst { 3014 y := vy.(int8) 3015 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)&^y) } 3016 } else { 3017 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8)&^fr.reg(iy).(int8)) } 3018 } 3019 case reflect.Int16: 3020 if kx == kindConst && ky == kindConst { 3021 v := vx.(int16) &^ vy.(int16) 3022 return func(fr *frame) { fr.setReg(ir, v) } 3023 } else if kx == kindConst { 3024 x := vx.(int16) 3025 return func(fr *frame) { fr.setReg(ir, x&^fr.reg(iy).(int16)) } 3026 } else if ky == kindConst { 3027 y := vy.(int16) 3028 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)&^y) } 3029 } else { 3030 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16)&^fr.reg(iy).(int16)) } 3031 } 3032 case reflect.Int32: 3033 if kx == kindConst && ky == kindConst { 3034 v := vx.(int32) &^ vy.(int32) 3035 return func(fr *frame) { fr.setReg(ir, v) } 3036 } else if kx == kindConst { 3037 x := vx.(int32) 3038 return func(fr *frame) { fr.setReg(ir, x&^fr.reg(iy).(int32)) } 3039 } else if ky == kindConst { 3040 y := vy.(int32) 3041 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)&^y) } 3042 } else { 3043 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32)&^fr.reg(iy).(int32)) } 3044 } 3045 case reflect.Int64: 3046 if kx == kindConst && ky == kindConst { 3047 v := vx.(int64) &^ vy.(int64) 3048 return func(fr *frame) { fr.setReg(ir, v) } 3049 } else if kx == kindConst { 3050 x := vx.(int64) 3051 return func(fr *frame) { fr.setReg(ir, x&^fr.reg(iy).(int64)) } 3052 } else if ky == kindConst { 3053 y := vy.(int64) 3054 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)&^y) } 3055 } else { 3056 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64)&^fr.reg(iy).(int64)) } 3057 } 3058 case reflect.Uint: 3059 if kx == kindConst && ky == kindConst { 3060 v := vx.(uint) &^ vy.(uint) 3061 return func(fr *frame) { fr.setReg(ir, v) } 3062 } else if kx == kindConst { 3063 x := vx.(uint) 3064 return func(fr *frame) { fr.setReg(ir, x&^fr.reg(iy).(uint)) } 3065 } else if ky == kindConst { 3066 y := vy.(uint) 3067 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)&^y) } 3068 } else { 3069 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint)&^fr.reg(iy).(uint)) } 3070 } 3071 case reflect.Uint8: 3072 if kx == kindConst && ky == kindConst { 3073 v := vx.(uint8) &^ vy.(uint8) 3074 return func(fr *frame) { fr.setReg(ir, v) } 3075 } else if kx == kindConst { 3076 x := vx.(uint8) 3077 return func(fr *frame) { fr.setReg(ir, x&^fr.reg(iy).(uint8)) } 3078 } else if ky == kindConst { 3079 y := vy.(uint8) 3080 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)&^y) } 3081 } else { 3082 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8)&^fr.reg(iy).(uint8)) } 3083 } 3084 case reflect.Uint16: 3085 if kx == kindConst && ky == kindConst { 3086 v := vx.(uint16) &^ vy.(uint16) 3087 return func(fr *frame) { fr.setReg(ir, v) } 3088 } else if kx == kindConst { 3089 x := vx.(uint16) 3090 return func(fr *frame) { fr.setReg(ir, x&^fr.reg(iy).(uint16)) } 3091 } else if ky == kindConst { 3092 y := vy.(uint16) 3093 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)&^y) } 3094 } else { 3095 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16)&^fr.reg(iy).(uint16)) } 3096 } 3097 case reflect.Uint32: 3098 if kx == kindConst && ky == kindConst { 3099 v := vx.(uint32) &^ vy.(uint32) 3100 return func(fr *frame) { fr.setReg(ir, v) } 3101 } else if kx == kindConst { 3102 x := vx.(uint32) 3103 return func(fr *frame) { fr.setReg(ir, x&^fr.reg(iy).(uint32)) } 3104 } else if ky == kindConst { 3105 y := vy.(uint32) 3106 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)&^y) } 3107 } else { 3108 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32)&^fr.reg(iy).(uint32)) } 3109 } 3110 case reflect.Uint64: 3111 if kx == kindConst && ky == kindConst { 3112 v := vx.(uint64) &^ vy.(uint64) 3113 return func(fr *frame) { fr.setReg(ir, v) } 3114 } else if kx == kindConst { 3115 x := vx.(uint64) 3116 return func(fr *frame) { fr.setReg(ir, x&^fr.reg(iy).(uint64)) } 3117 } else if ky == kindConst { 3118 y := vy.(uint64) 3119 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)&^y) } 3120 } else { 3121 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64)&^fr.reg(iy).(uint64)) } 3122 } 3123 case reflect.Uintptr: 3124 if kx == kindConst && ky == kindConst { 3125 v := vx.(uintptr) &^ vy.(uintptr) 3126 return func(fr *frame) { fr.setReg(ir, v) } 3127 } else if kx == kindConst { 3128 x := vx.(uintptr) 3129 return func(fr *frame) { fr.setReg(ir, x&^fr.reg(iy).(uintptr)) } 3130 } else if ky == kindConst { 3131 y := vy.(uintptr) 3132 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)&^y) } 3133 } else { 3134 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr)&^fr.reg(iy).(uintptr)) } 3135 } 3136 } 3137 } else { 3138 t := xtype.TypeOfType(typ) 3139 switch typ.Kind() { 3140 case reflect.Int: 3141 if kx == kindConst && ky == kindConst { 3142 v := xtype.Make(t, xtype.Int(vx)&^xtype.Int(vy)) 3143 return func(fr *frame) { fr.setReg(ir, v) } 3144 } else if kx == kindConst { 3145 x := xtype.Int(vx) 3146 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&^fr.int(iy))) } 3147 } else if ky == kindConst { 3148 y := xtype.Int(vy) 3149 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)&^y)) } 3150 } else { 3151 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int(ix)&^fr.int(iy))) } 3152 } 3153 case reflect.Int8: 3154 if kx == kindConst && ky == kindConst { 3155 v := xtype.Make(t, xtype.Int8(vx)&^xtype.Int8(vy)) 3156 return func(fr *frame) { fr.setReg(ir, v) } 3157 } else if kx == kindConst { 3158 x := xtype.Int8(vx) 3159 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&^fr.int8(iy))) } 3160 } else if ky == kindConst { 3161 y := xtype.Int8(vy) 3162 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)&^y)) } 3163 } else { 3164 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int8(ix)&^fr.int8(iy))) } 3165 } 3166 case reflect.Int16: 3167 if kx == kindConst && ky == kindConst { 3168 v := xtype.Make(t, xtype.Int16(vx)&^xtype.Int16(vy)) 3169 return func(fr *frame) { fr.setReg(ir, v) } 3170 } else if kx == kindConst { 3171 x := xtype.Int16(vx) 3172 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&^fr.int16(iy))) } 3173 } else if ky == kindConst { 3174 y := xtype.Int16(vy) 3175 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)&^y)) } 3176 } else { 3177 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int16(ix)&^fr.int16(iy))) } 3178 } 3179 case reflect.Int32: 3180 if kx == kindConst && ky == kindConst { 3181 v := xtype.Make(t, xtype.Int32(vx)&^xtype.Int32(vy)) 3182 return func(fr *frame) { fr.setReg(ir, v) } 3183 } else if kx == kindConst { 3184 x := xtype.Int32(vx) 3185 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&^fr.int32(iy))) } 3186 } else if ky == kindConst { 3187 y := xtype.Int32(vy) 3188 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)&^y)) } 3189 } else { 3190 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int32(ix)&^fr.int32(iy))) } 3191 } 3192 case reflect.Int64: 3193 if kx == kindConst && ky == kindConst { 3194 v := xtype.Make(t, xtype.Int64(vx)&^xtype.Int64(vy)) 3195 return func(fr *frame) { fr.setReg(ir, v) } 3196 } else if kx == kindConst { 3197 x := xtype.Int64(vx) 3198 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&^fr.int64(iy))) } 3199 } else if ky == kindConst { 3200 y := xtype.Int64(vy) 3201 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)&^y)) } 3202 } else { 3203 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.int64(ix)&^fr.int64(iy))) } 3204 } 3205 case reflect.Uint: 3206 if kx == kindConst && ky == kindConst { 3207 v := xtype.Make(t, xtype.Uint(vx)&^xtype.Uint(vy)) 3208 return func(fr *frame) { fr.setReg(ir, v) } 3209 } else if kx == kindConst { 3210 x := xtype.Uint(vx) 3211 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&^fr.uint(iy))) } 3212 } else if ky == kindConst { 3213 y := xtype.Uint(vy) 3214 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)&^y)) } 3215 } else { 3216 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint(ix)&^fr.uint(iy))) } 3217 } 3218 case reflect.Uint8: 3219 if kx == kindConst && ky == kindConst { 3220 v := xtype.Make(t, xtype.Uint8(vx)&^xtype.Uint8(vy)) 3221 return func(fr *frame) { fr.setReg(ir, v) } 3222 } else if kx == kindConst { 3223 x := xtype.Uint8(vx) 3224 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&^fr.uint8(iy))) } 3225 } else if ky == kindConst { 3226 y := xtype.Uint8(vy) 3227 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)&^y)) } 3228 } else { 3229 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint8(ix)&^fr.uint8(iy))) } 3230 } 3231 case reflect.Uint16: 3232 if kx == kindConst && ky == kindConst { 3233 v := xtype.Make(t, xtype.Uint16(vx)&^xtype.Uint16(vy)) 3234 return func(fr *frame) { fr.setReg(ir, v) } 3235 } else if kx == kindConst { 3236 x := xtype.Uint16(vx) 3237 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&^fr.uint16(iy))) } 3238 } else if ky == kindConst { 3239 y := xtype.Uint16(vy) 3240 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)&^y)) } 3241 } else { 3242 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint16(ix)&^fr.uint16(iy))) } 3243 } 3244 case reflect.Uint32: 3245 if kx == kindConst && ky == kindConst { 3246 v := xtype.Make(t, xtype.Uint32(vx)&^xtype.Uint32(vy)) 3247 return func(fr *frame) { fr.setReg(ir, v) } 3248 } else if kx == kindConst { 3249 x := xtype.Uint32(vx) 3250 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&^fr.uint32(iy))) } 3251 } else if ky == kindConst { 3252 y := xtype.Uint32(vy) 3253 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)&^y)) } 3254 } else { 3255 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint32(ix)&^fr.uint32(iy))) } 3256 } 3257 case reflect.Uint64: 3258 if kx == kindConst && ky == kindConst { 3259 v := xtype.Make(t, xtype.Uint64(vx)&^xtype.Uint64(vy)) 3260 return func(fr *frame) { fr.setReg(ir, v) } 3261 } else if kx == kindConst { 3262 x := xtype.Uint64(vx) 3263 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&^fr.uint64(iy))) } 3264 } else if ky == kindConst { 3265 y := xtype.Uint64(vy) 3266 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)&^y)) } 3267 } else { 3268 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uint64(ix)&^fr.uint64(iy))) } 3269 } 3270 case reflect.Uintptr: 3271 if kx == kindConst && ky == kindConst { 3272 v := xtype.Make(t, xtype.Uintptr(vx)&^xtype.Uintptr(vy)) 3273 return func(fr *frame) { fr.setReg(ir, v) } 3274 } else if kx == kindConst { 3275 x := xtype.Uintptr(vx) 3276 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, x&^fr.uintptr(iy))) } 3277 } else if ky == kindConst { 3278 y := xtype.Uintptr(vy) 3279 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)&^y)) } 3280 } else { 3281 return func(fr *frame) { fr.setReg(ir, xtype.Make(t, fr.uintptr(ix)&^fr.uintptr(iy))) } 3282 } 3283 } 3284 } 3285 panic("unreachable") 3286 } 3287 func makeBinOpLSS(pfn *function, instr *ssa.BinOp) func(fr *frame) { 3288 ir := pfn.regIndex(instr) 3289 ix, kx, vx := pfn.regIndex3(instr.X) 3290 iy, ky, vy := pfn.regIndex3(instr.Y) 3291 typ := pfn.Interp.preToType(instr.X.Type()) 3292 if typ.PkgPath() == "" { 3293 switch typ.Kind() { 3294 case reflect.Int: 3295 if kx == kindConst && ky == kindConst { 3296 v := vx.(int) < vy.(int) 3297 return func(fr *frame) { fr.setReg(ir, v) } 3298 } else if kx == kindConst { 3299 x := vx.(int) 3300 return func(fr *frame) { fr.setReg(ir, x < fr.reg(iy).(int)) } 3301 } else if ky == kindConst { 3302 y := vy.(int) 3303 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int) < y) } 3304 } else { 3305 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int) < fr.reg(iy).(int)) } 3306 } 3307 case reflect.Int8: 3308 if kx == kindConst && ky == kindConst { 3309 v := vx.(int8) < vy.(int8) 3310 return func(fr *frame) { fr.setReg(ir, v) } 3311 } else if kx == kindConst { 3312 x := vx.(int8) 3313 return func(fr *frame) { fr.setReg(ir, x < fr.reg(iy).(int8)) } 3314 } else if ky == kindConst { 3315 y := vy.(int8) 3316 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8) < y) } 3317 } else { 3318 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8) < fr.reg(iy).(int8)) } 3319 } 3320 case reflect.Int16: 3321 if kx == kindConst && ky == kindConst { 3322 v := vx.(int16) < vy.(int16) 3323 return func(fr *frame) { fr.setReg(ir, v) } 3324 } else if kx == kindConst { 3325 x := vx.(int16) 3326 return func(fr *frame) { fr.setReg(ir, x < fr.reg(iy).(int16)) } 3327 } else if ky == kindConst { 3328 y := vy.(int16) 3329 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16) < y) } 3330 } else { 3331 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16) < fr.reg(iy).(int16)) } 3332 } 3333 case reflect.Int32: 3334 if kx == kindConst && ky == kindConst { 3335 v := vx.(int32) < vy.(int32) 3336 return func(fr *frame) { fr.setReg(ir, v) } 3337 } else if kx == kindConst { 3338 x := vx.(int32) 3339 return func(fr *frame) { fr.setReg(ir, x < fr.reg(iy).(int32)) } 3340 } else if ky == kindConst { 3341 y := vy.(int32) 3342 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32) < y) } 3343 } else { 3344 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32) < fr.reg(iy).(int32)) } 3345 } 3346 case reflect.Int64: 3347 if kx == kindConst && ky == kindConst { 3348 v := vx.(int64) < vy.(int64) 3349 return func(fr *frame) { fr.setReg(ir, v) } 3350 } else if kx == kindConst { 3351 x := vx.(int64) 3352 return func(fr *frame) { fr.setReg(ir, x < fr.reg(iy).(int64)) } 3353 } else if ky == kindConst { 3354 y := vy.(int64) 3355 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64) < y) } 3356 } else { 3357 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64) < fr.reg(iy).(int64)) } 3358 } 3359 case reflect.Uint: 3360 if kx == kindConst && ky == kindConst { 3361 v := vx.(uint) < vy.(uint) 3362 return func(fr *frame) { fr.setReg(ir, v) } 3363 } else if kx == kindConst { 3364 x := vx.(uint) 3365 return func(fr *frame) { fr.setReg(ir, x < fr.reg(iy).(uint)) } 3366 } else if ky == kindConst { 3367 y := vy.(uint) 3368 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint) < y) } 3369 } else { 3370 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint) < fr.reg(iy).(uint)) } 3371 } 3372 case reflect.Uint8: 3373 if kx == kindConst && ky == kindConst { 3374 v := vx.(uint8) < vy.(uint8) 3375 return func(fr *frame) { fr.setReg(ir, v) } 3376 } else if kx == kindConst { 3377 x := vx.(uint8) 3378 return func(fr *frame) { fr.setReg(ir, x < fr.reg(iy).(uint8)) } 3379 } else if ky == kindConst { 3380 y := vy.(uint8) 3381 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8) < y) } 3382 } else { 3383 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8) < fr.reg(iy).(uint8)) } 3384 } 3385 case reflect.Uint16: 3386 if kx == kindConst && ky == kindConst { 3387 v := vx.(uint16) < vy.(uint16) 3388 return func(fr *frame) { fr.setReg(ir, v) } 3389 } else if kx == kindConst { 3390 x := vx.(uint16) 3391 return func(fr *frame) { fr.setReg(ir, x < fr.reg(iy).(uint16)) } 3392 } else if ky == kindConst { 3393 y := vy.(uint16) 3394 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16) < y) } 3395 } else { 3396 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16) < fr.reg(iy).(uint16)) } 3397 } 3398 case reflect.Uint32: 3399 if kx == kindConst && ky == kindConst { 3400 v := vx.(uint32) < vy.(uint32) 3401 return func(fr *frame) { fr.setReg(ir, v) } 3402 } else if kx == kindConst { 3403 x := vx.(uint32) 3404 return func(fr *frame) { fr.setReg(ir, x < fr.reg(iy).(uint32)) } 3405 } else if ky == kindConst { 3406 y := vy.(uint32) 3407 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32) < y) } 3408 } else { 3409 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32) < fr.reg(iy).(uint32)) } 3410 } 3411 case reflect.Uint64: 3412 if kx == kindConst && ky == kindConst { 3413 v := vx.(uint64) < vy.(uint64) 3414 return func(fr *frame) { fr.setReg(ir, v) } 3415 } else if kx == kindConst { 3416 x := vx.(uint64) 3417 return func(fr *frame) { fr.setReg(ir, x < fr.reg(iy).(uint64)) } 3418 } else if ky == kindConst { 3419 y := vy.(uint64) 3420 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64) < y) } 3421 } else { 3422 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64) < fr.reg(iy).(uint64)) } 3423 } 3424 case reflect.Uintptr: 3425 if kx == kindConst && ky == kindConst { 3426 v := vx.(uintptr) < vy.(uintptr) 3427 return func(fr *frame) { fr.setReg(ir, v) } 3428 } else if kx == kindConst { 3429 x := vx.(uintptr) 3430 return func(fr *frame) { fr.setReg(ir, x < fr.reg(iy).(uintptr)) } 3431 } else if ky == kindConst { 3432 y := vy.(uintptr) 3433 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr) < y) } 3434 } else { 3435 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr) < fr.reg(iy).(uintptr)) } 3436 } 3437 case reflect.Float32: 3438 if kx == kindConst && ky == kindConst { 3439 v := vx.(float32) < vy.(float32) 3440 return func(fr *frame) { fr.setReg(ir, v) } 3441 } else if kx == kindConst { 3442 x := vx.(float32) 3443 return func(fr *frame) { fr.setReg(ir, x < fr.reg(iy).(float32)) } 3444 } else if ky == kindConst { 3445 y := vy.(float32) 3446 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float32) < y) } 3447 } else { 3448 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float32) < fr.reg(iy).(float32)) } 3449 } 3450 case reflect.Float64: 3451 if kx == kindConst && ky == kindConst { 3452 v := vx.(float64) < vy.(float64) 3453 return func(fr *frame) { fr.setReg(ir, v) } 3454 } else if kx == kindConst { 3455 x := vx.(float64) 3456 return func(fr *frame) { fr.setReg(ir, x < fr.reg(iy).(float64)) } 3457 } else if ky == kindConst { 3458 y := vy.(float64) 3459 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float64) < y) } 3460 } else { 3461 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float64) < fr.reg(iy).(float64)) } 3462 } 3463 case reflect.String: 3464 if kx == kindConst && ky == kindConst { 3465 v := vx.(string) < vy.(string) 3466 return func(fr *frame) { fr.setReg(ir, v) } 3467 } else if kx == kindConst { 3468 x := vx.(string) 3469 return func(fr *frame) { fr.setReg(ir, x < fr.reg(iy).(string)) } 3470 } else if ky == kindConst { 3471 y := vy.(string) 3472 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(string) < y) } 3473 } else { 3474 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(string) < fr.reg(iy).(string)) } 3475 } 3476 } 3477 } else { 3478 switch typ.Kind() { 3479 case reflect.Int: 3480 if kx == kindConst && ky == kindConst { 3481 v := xtype.Int(vx) < xtype.Int(vy) 3482 return func(fr *frame) { fr.setReg(ir, v) } 3483 } else if kx == kindConst { 3484 x := xtype.Int(vx) 3485 return func(fr *frame) { fr.setReg(ir, x < fr.int(iy)) } 3486 } else if ky == kindConst { 3487 y := xtype.Int(vy) 3488 return func(fr *frame) { fr.setReg(ir, fr.int(ix) < y) } 3489 } else { 3490 return func(fr *frame) { fr.setReg(ir, fr.int(ix) < fr.int(iy)) } 3491 } 3492 case reflect.Int8: 3493 if kx == kindConst && ky == kindConst { 3494 v := xtype.Int8(vx) < xtype.Int8(vy) 3495 return func(fr *frame) { fr.setReg(ir, v) } 3496 } else if kx == kindConst { 3497 x := xtype.Int8(vx) 3498 return func(fr *frame) { fr.setReg(ir, x < fr.int8(iy)) } 3499 } else if ky == kindConst { 3500 y := xtype.Int8(vy) 3501 return func(fr *frame) { fr.setReg(ir, fr.int8(ix) < y) } 3502 } else { 3503 return func(fr *frame) { fr.setReg(ir, fr.int8(ix) < fr.int8(iy)) } 3504 } 3505 case reflect.Int16: 3506 if kx == kindConst && ky == kindConst { 3507 v := xtype.Int16(vx) < xtype.Int16(vy) 3508 return func(fr *frame) { fr.setReg(ir, v) } 3509 } else if kx == kindConst { 3510 x := xtype.Int16(vx) 3511 return func(fr *frame) { fr.setReg(ir, x < fr.int16(iy)) } 3512 } else if ky == kindConst { 3513 y := xtype.Int16(vy) 3514 return func(fr *frame) { fr.setReg(ir, fr.int16(ix) < y) } 3515 } else { 3516 return func(fr *frame) { fr.setReg(ir, fr.int16(ix) < fr.int16(iy)) } 3517 } 3518 case reflect.Int32: 3519 if kx == kindConst && ky == kindConst { 3520 v := xtype.Int32(vx) < xtype.Int32(vy) 3521 return func(fr *frame) { fr.setReg(ir, v) } 3522 } else if kx == kindConst { 3523 x := xtype.Int32(vx) 3524 return func(fr *frame) { fr.setReg(ir, x < fr.int32(iy)) } 3525 } else if ky == kindConst { 3526 y := xtype.Int32(vy) 3527 return func(fr *frame) { fr.setReg(ir, fr.int32(ix) < y) } 3528 } else { 3529 return func(fr *frame) { fr.setReg(ir, fr.int32(ix) < fr.int32(iy)) } 3530 } 3531 case reflect.Int64: 3532 if kx == kindConst && ky == kindConst { 3533 v := xtype.Int64(vx) < xtype.Int64(vy) 3534 return func(fr *frame) { fr.setReg(ir, v) } 3535 } else if kx == kindConst { 3536 x := xtype.Int64(vx) 3537 return func(fr *frame) { fr.setReg(ir, x < fr.int64(iy)) } 3538 } else if ky == kindConst { 3539 y := xtype.Int64(vy) 3540 return func(fr *frame) { fr.setReg(ir, fr.int64(ix) < y) } 3541 } else { 3542 return func(fr *frame) { fr.setReg(ir, fr.int64(ix) < fr.int64(iy)) } 3543 } 3544 case reflect.Uint: 3545 if kx == kindConst && ky == kindConst { 3546 v := xtype.Uint(vx) < xtype.Uint(vy) 3547 return func(fr *frame) { fr.setReg(ir, v) } 3548 } else if kx == kindConst { 3549 x := xtype.Uint(vx) 3550 return func(fr *frame) { fr.setReg(ir, x < fr.uint(iy)) } 3551 } else if ky == kindConst { 3552 y := xtype.Uint(vy) 3553 return func(fr *frame) { fr.setReg(ir, fr.uint(ix) < y) } 3554 } else { 3555 return func(fr *frame) { fr.setReg(ir, fr.uint(ix) < fr.uint(iy)) } 3556 } 3557 case reflect.Uint8: 3558 if kx == kindConst && ky == kindConst { 3559 v := xtype.Uint8(vx) < xtype.Uint8(vy) 3560 return func(fr *frame) { fr.setReg(ir, v) } 3561 } else if kx == kindConst { 3562 x := xtype.Uint8(vx) 3563 return func(fr *frame) { fr.setReg(ir, x < fr.uint8(iy)) } 3564 } else if ky == kindConst { 3565 y := xtype.Uint8(vy) 3566 return func(fr *frame) { fr.setReg(ir, fr.uint8(ix) < y) } 3567 } else { 3568 return func(fr *frame) { fr.setReg(ir, fr.uint8(ix) < fr.uint8(iy)) } 3569 } 3570 case reflect.Uint16: 3571 if kx == kindConst && ky == kindConst { 3572 v := xtype.Uint16(vx) < xtype.Uint16(vy) 3573 return func(fr *frame) { fr.setReg(ir, v) } 3574 } else if kx == kindConst { 3575 x := xtype.Uint16(vx) 3576 return func(fr *frame) { fr.setReg(ir, x < fr.uint16(iy)) } 3577 } else if ky == kindConst { 3578 y := xtype.Uint16(vy) 3579 return func(fr *frame) { fr.setReg(ir, fr.uint16(ix) < y) } 3580 } else { 3581 return func(fr *frame) { fr.setReg(ir, fr.uint16(ix) < fr.uint16(iy)) } 3582 } 3583 case reflect.Uint32: 3584 if kx == kindConst && ky == kindConst { 3585 v := xtype.Uint32(vx) < xtype.Uint32(vy) 3586 return func(fr *frame) { fr.setReg(ir, v) } 3587 } else if kx == kindConst { 3588 x := xtype.Uint32(vx) 3589 return func(fr *frame) { fr.setReg(ir, x < fr.uint32(iy)) } 3590 } else if ky == kindConst { 3591 y := xtype.Uint32(vy) 3592 return func(fr *frame) { fr.setReg(ir, fr.uint32(ix) < y) } 3593 } else { 3594 return func(fr *frame) { fr.setReg(ir, fr.uint32(ix) < fr.uint32(iy)) } 3595 } 3596 case reflect.Uint64: 3597 if kx == kindConst && ky == kindConst { 3598 v := xtype.Uint64(vx) < xtype.Uint64(vy) 3599 return func(fr *frame) { fr.setReg(ir, v) } 3600 } else if kx == kindConst { 3601 x := xtype.Uint64(vx) 3602 return func(fr *frame) { fr.setReg(ir, x < fr.uint64(iy)) } 3603 } else if ky == kindConst { 3604 y := xtype.Uint64(vy) 3605 return func(fr *frame) { fr.setReg(ir, fr.uint64(ix) < y) } 3606 } else { 3607 return func(fr *frame) { fr.setReg(ir, fr.uint64(ix) < fr.uint64(iy)) } 3608 } 3609 case reflect.Uintptr: 3610 if kx == kindConst && ky == kindConst { 3611 v := xtype.Uintptr(vx) < xtype.Uintptr(vy) 3612 return func(fr *frame) { fr.setReg(ir, v) } 3613 } else if kx == kindConst { 3614 x := xtype.Uintptr(vx) 3615 return func(fr *frame) { fr.setReg(ir, x < fr.uintptr(iy)) } 3616 } else if ky == kindConst { 3617 y := xtype.Uintptr(vy) 3618 return func(fr *frame) { fr.setReg(ir, fr.uintptr(ix) < y) } 3619 } else { 3620 return func(fr *frame) { fr.setReg(ir, fr.uintptr(ix) < fr.uintptr(iy)) } 3621 } 3622 case reflect.Float32: 3623 if kx == kindConst && ky == kindConst { 3624 v := xtype.Float32(vx) < xtype.Float32(vy) 3625 return func(fr *frame) { fr.setReg(ir, v) } 3626 } else if kx == kindConst { 3627 x := xtype.Float32(vx) 3628 return func(fr *frame) { fr.setReg(ir, x < fr.float32(iy)) } 3629 } else if ky == kindConst { 3630 y := xtype.Float32(vy) 3631 return func(fr *frame) { fr.setReg(ir, fr.float32(ix) < y) } 3632 } else { 3633 return func(fr *frame) { fr.setReg(ir, fr.float32(ix) < fr.float32(iy)) } 3634 } 3635 case reflect.Float64: 3636 if kx == kindConst && ky == kindConst { 3637 v := xtype.Float64(vx) < xtype.Float64(vy) 3638 return func(fr *frame) { fr.setReg(ir, v) } 3639 } else if kx == kindConst { 3640 x := xtype.Float64(vx) 3641 return func(fr *frame) { fr.setReg(ir, x < fr.float64(iy)) } 3642 } else if ky == kindConst { 3643 y := xtype.Float64(vy) 3644 return func(fr *frame) { fr.setReg(ir, fr.float64(ix) < y) } 3645 } else { 3646 return func(fr *frame) { fr.setReg(ir, fr.float64(ix) < fr.float64(iy)) } 3647 } 3648 case reflect.String: 3649 if kx == kindConst && ky == kindConst { 3650 v := xtype.String(vx) < xtype.String(vy) 3651 return func(fr *frame) { fr.setReg(ir, v) } 3652 } else if kx == kindConst { 3653 x := xtype.String(vx) 3654 return func(fr *frame) { fr.setReg(ir, x < fr.string(iy)) } 3655 } else if ky == kindConst { 3656 y := xtype.String(vy) 3657 return func(fr *frame) { fr.setReg(ir, fr.string(ix) < y) } 3658 } else { 3659 return func(fr *frame) { fr.setReg(ir, fr.string(ix) < fr.string(iy)) } 3660 } 3661 } 3662 } 3663 panic("unreachable") 3664 } 3665 func makeBinOpLEQ(pfn *function, instr *ssa.BinOp) func(fr *frame) { 3666 ir := pfn.regIndex(instr) 3667 ix, kx, vx := pfn.regIndex3(instr.X) 3668 iy, ky, vy := pfn.regIndex3(instr.Y) 3669 typ := pfn.Interp.preToType(instr.X.Type()) 3670 if typ.PkgPath() == "" { 3671 switch typ.Kind() { 3672 case reflect.Int: 3673 if kx == kindConst && ky == kindConst { 3674 v := vx.(int) <= vy.(int) 3675 return func(fr *frame) { fr.setReg(ir, v) } 3676 } else if kx == kindConst { 3677 x := vx.(int) 3678 return func(fr *frame) { fr.setReg(ir, x <= fr.reg(iy).(int)) } 3679 } else if ky == kindConst { 3680 y := vy.(int) 3681 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int) <= y) } 3682 } else { 3683 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int) <= fr.reg(iy).(int)) } 3684 } 3685 case reflect.Int8: 3686 if kx == kindConst && ky == kindConst { 3687 v := vx.(int8) <= vy.(int8) 3688 return func(fr *frame) { fr.setReg(ir, v) } 3689 } else if kx == kindConst { 3690 x := vx.(int8) 3691 return func(fr *frame) { fr.setReg(ir, x <= fr.reg(iy).(int8)) } 3692 } else if ky == kindConst { 3693 y := vy.(int8) 3694 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8) <= y) } 3695 } else { 3696 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8) <= fr.reg(iy).(int8)) } 3697 } 3698 case reflect.Int16: 3699 if kx == kindConst && ky == kindConst { 3700 v := vx.(int16) <= vy.(int16) 3701 return func(fr *frame) { fr.setReg(ir, v) } 3702 } else if kx == kindConst { 3703 x := vx.(int16) 3704 return func(fr *frame) { fr.setReg(ir, x <= fr.reg(iy).(int16)) } 3705 } else if ky == kindConst { 3706 y := vy.(int16) 3707 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16) <= y) } 3708 } else { 3709 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16) <= fr.reg(iy).(int16)) } 3710 } 3711 case reflect.Int32: 3712 if kx == kindConst && ky == kindConst { 3713 v := vx.(int32) <= vy.(int32) 3714 return func(fr *frame) { fr.setReg(ir, v) } 3715 } else if kx == kindConst { 3716 x := vx.(int32) 3717 return func(fr *frame) { fr.setReg(ir, x <= fr.reg(iy).(int32)) } 3718 } else if ky == kindConst { 3719 y := vy.(int32) 3720 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32) <= y) } 3721 } else { 3722 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32) <= fr.reg(iy).(int32)) } 3723 } 3724 case reflect.Int64: 3725 if kx == kindConst && ky == kindConst { 3726 v := vx.(int64) <= vy.(int64) 3727 return func(fr *frame) { fr.setReg(ir, v) } 3728 } else if kx == kindConst { 3729 x := vx.(int64) 3730 return func(fr *frame) { fr.setReg(ir, x <= fr.reg(iy).(int64)) } 3731 } else if ky == kindConst { 3732 y := vy.(int64) 3733 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64) <= y) } 3734 } else { 3735 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64) <= fr.reg(iy).(int64)) } 3736 } 3737 case reflect.Uint: 3738 if kx == kindConst && ky == kindConst { 3739 v := vx.(uint) <= vy.(uint) 3740 return func(fr *frame) { fr.setReg(ir, v) } 3741 } else if kx == kindConst { 3742 x := vx.(uint) 3743 return func(fr *frame) { fr.setReg(ir, x <= fr.reg(iy).(uint)) } 3744 } else if ky == kindConst { 3745 y := vy.(uint) 3746 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint) <= y) } 3747 } else { 3748 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint) <= fr.reg(iy).(uint)) } 3749 } 3750 case reflect.Uint8: 3751 if kx == kindConst && ky == kindConst { 3752 v := vx.(uint8) <= vy.(uint8) 3753 return func(fr *frame) { fr.setReg(ir, v) } 3754 } else if kx == kindConst { 3755 x := vx.(uint8) 3756 return func(fr *frame) { fr.setReg(ir, x <= fr.reg(iy).(uint8)) } 3757 } else if ky == kindConst { 3758 y := vy.(uint8) 3759 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8) <= y) } 3760 } else { 3761 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8) <= fr.reg(iy).(uint8)) } 3762 } 3763 case reflect.Uint16: 3764 if kx == kindConst && ky == kindConst { 3765 v := vx.(uint16) <= vy.(uint16) 3766 return func(fr *frame) { fr.setReg(ir, v) } 3767 } else if kx == kindConst { 3768 x := vx.(uint16) 3769 return func(fr *frame) { fr.setReg(ir, x <= fr.reg(iy).(uint16)) } 3770 } else if ky == kindConst { 3771 y := vy.(uint16) 3772 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16) <= y) } 3773 } else { 3774 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16) <= fr.reg(iy).(uint16)) } 3775 } 3776 case reflect.Uint32: 3777 if kx == kindConst && ky == kindConst { 3778 v := vx.(uint32) <= vy.(uint32) 3779 return func(fr *frame) { fr.setReg(ir, v) } 3780 } else if kx == kindConst { 3781 x := vx.(uint32) 3782 return func(fr *frame) { fr.setReg(ir, x <= fr.reg(iy).(uint32)) } 3783 } else if ky == kindConst { 3784 y := vy.(uint32) 3785 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32) <= y) } 3786 } else { 3787 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32) <= fr.reg(iy).(uint32)) } 3788 } 3789 case reflect.Uint64: 3790 if kx == kindConst && ky == kindConst { 3791 v := vx.(uint64) <= vy.(uint64) 3792 return func(fr *frame) { fr.setReg(ir, v) } 3793 } else if kx == kindConst { 3794 x := vx.(uint64) 3795 return func(fr *frame) { fr.setReg(ir, x <= fr.reg(iy).(uint64)) } 3796 } else if ky == kindConst { 3797 y := vy.(uint64) 3798 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64) <= y) } 3799 } else { 3800 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64) <= fr.reg(iy).(uint64)) } 3801 } 3802 case reflect.Uintptr: 3803 if kx == kindConst && ky == kindConst { 3804 v := vx.(uintptr) <= vy.(uintptr) 3805 return func(fr *frame) { fr.setReg(ir, v) } 3806 } else if kx == kindConst { 3807 x := vx.(uintptr) 3808 return func(fr *frame) { fr.setReg(ir, x <= fr.reg(iy).(uintptr)) } 3809 } else if ky == kindConst { 3810 y := vy.(uintptr) 3811 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr) <= y) } 3812 } else { 3813 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr) <= fr.reg(iy).(uintptr)) } 3814 } 3815 case reflect.Float32: 3816 if kx == kindConst && ky == kindConst { 3817 v := vx.(float32) <= vy.(float32) 3818 return func(fr *frame) { fr.setReg(ir, v) } 3819 } else if kx == kindConst { 3820 x := vx.(float32) 3821 return func(fr *frame) { fr.setReg(ir, x <= fr.reg(iy).(float32)) } 3822 } else if ky == kindConst { 3823 y := vy.(float32) 3824 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float32) <= y) } 3825 } else { 3826 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float32) <= fr.reg(iy).(float32)) } 3827 } 3828 case reflect.Float64: 3829 if kx == kindConst && ky == kindConst { 3830 v := vx.(float64) <= vy.(float64) 3831 return func(fr *frame) { fr.setReg(ir, v) } 3832 } else if kx == kindConst { 3833 x := vx.(float64) 3834 return func(fr *frame) { fr.setReg(ir, x <= fr.reg(iy).(float64)) } 3835 } else if ky == kindConst { 3836 y := vy.(float64) 3837 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float64) <= y) } 3838 } else { 3839 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float64) <= fr.reg(iy).(float64)) } 3840 } 3841 case reflect.String: 3842 if kx == kindConst && ky == kindConst { 3843 v := vx.(string) <= vy.(string) 3844 return func(fr *frame) { fr.setReg(ir, v) } 3845 } else if kx == kindConst { 3846 x := vx.(string) 3847 return func(fr *frame) { fr.setReg(ir, x <= fr.reg(iy).(string)) } 3848 } else if ky == kindConst { 3849 y := vy.(string) 3850 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(string) <= y) } 3851 } else { 3852 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(string) <= fr.reg(iy).(string)) } 3853 } 3854 } 3855 } else { 3856 switch typ.Kind() { 3857 case reflect.Int: 3858 if kx == kindConst && ky == kindConst { 3859 v := xtype.Int(vx) <= xtype.Int(vy) 3860 return func(fr *frame) { fr.setReg(ir, v) } 3861 } else if kx == kindConst { 3862 x := xtype.Int(vx) 3863 return func(fr *frame) { fr.setReg(ir, x <= fr.int(iy)) } 3864 } else if ky == kindConst { 3865 y := xtype.Int(vy) 3866 return func(fr *frame) { fr.setReg(ir, fr.int(ix) <= y) } 3867 } else { 3868 return func(fr *frame) { fr.setReg(ir, fr.int(ix) <= fr.int(iy)) } 3869 } 3870 case reflect.Int8: 3871 if kx == kindConst && ky == kindConst { 3872 v := xtype.Int8(vx) <= xtype.Int8(vy) 3873 return func(fr *frame) { fr.setReg(ir, v) } 3874 } else if kx == kindConst { 3875 x := xtype.Int8(vx) 3876 return func(fr *frame) { fr.setReg(ir, x <= fr.int8(iy)) } 3877 } else if ky == kindConst { 3878 y := xtype.Int8(vy) 3879 return func(fr *frame) { fr.setReg(ir, fr.int8(ix) <= y) } 3880 } else { 3881 return func(fr *frame) { fr.setReg(ir, fr.int8(ix) <= fr.int8(iy)) } 3882 } 3883 case reflect.Int16: 3884 if kx == kindConst && ky == kindConst { 3885 v := xtype.Int16(vx) <= xtype.Int16(vy) 3886 return func(fr *frame) { fr.setReg(ir, v) } 3887 } else if kx == kindConst { 3888 x := xtype.Int16(vx) 3889 return func(fr *frame) { fr.setReg(ir, x <= fr.int16(iy)) } 3890 } else if ky == kindConst { 3891 y := xtype.Int16(vy) 3892 return func(fr *frame) { fr.setReg(ir, fr.int16(ix) <= y) } 3893 } else { 3894 return func(fr *frame) { fr.setReg(ir, fr.int16(ix) <= fr.int16(iy)) } 3895 } 3896 case reflect.Int32: 3897 if kx == kindConst && ky == kindConst { 3898 v := xtype.Int32(vx) <= xtype.Int32(vy) 3899 return func(fr *frame) { fr.setReg(ir, v) } 3900 } else if kx == kindConst { 3901 x := xtype.Int32(vx) 3902 return func(fr *frame) { fr.setReg(ir, x <= fr.int32(iy)) } 3903 } else if ky == kindConst { 3904 y := xtype.Int32(vy) 3905 return func(fr *frame) { fr.setReg(ir, fr.int32(ix) <= y) } 3906 } else { 3907 return func(fr *frame) { fr.setReg(ir, fr.int32(ix) <= fr.int32(iy)) } 3908 } 3909 case reflect.Int64: 3910 if kx == kindConst && ky == kindConst { 3911 v := xtype.Int64(vx) <= xtype.Int64(vy) 3912 return func(fr *frame) { fr.setReg(ir, v) } 3913 } else if kx == kindConst { 3914 x := xtype.Int64(vx) 3915 return func(fr *frame) { fr.setReg(ir, x <= fr.int64(iy)) } 3916 } else if ky == kindConst { 3917 y := xtype.Int64(vy) 3918 return func(fr *frame) { fr.setReg(ir, fr.int64(ix) <= y) } 3919 } else { 3920 return func(fr *frame) { fr.setReg(ir, fr.int64(ix) <= fr.int64(iy)) } 3921 } 3922 case reflect.Uint: 3923 if kx == kindConst && ky == kindConst { 3924 v := xtype.Uint(vx) <= xtype.Uint(vy) 3925 return func(fr *frame) { fr.setReg(ir, v) } 3926 } else if kx == kindConst { 3927 x := xtype.Uint(vx) 3928 return func(fr *frame) { fr.setReg(ir, x <= fr.uint(iy)) } 3929 } else if ky == kindConst { 3930 y := xtype.Uint(vy) 3931 return func(fr *frame) { fr.setReg(ir, fr.uint(ix) <= y) } 3932 } else { 3933 return func(fr *frame) { fr.setReg(ir, fr.uint(ix) <= fr.uint(iy)) } 3934 } 3935 case reflect.Uint8: 3936 if kx == kindConst && ky == kindConst { 3937 v := xtype.Uint8(vx) <= xtype.Uint8(vy) 3938 return func(fr *frame) { fr.setReg(ir, v) } 3939 } else if kx == kindConst { 3940 x := xtype.Uint8(vx) 3941 return func(fr *frame) { fr.setReg(ir, x <= fr.uint8(iy)) } 3942 } else if ky == kindConst { 3943 y := xtype.Uint8(vy) 3944 return func(fr *frame) { fr.setReg(ir, fr.uint8(ix) <= y) } 3945 } else { 3946 return func(fr *frame) { fr.setReg(ir, fr.uint8(ix) <= fr.uint8(iy)) } 3947 } 3948 case reflect.Uint16: 3949 if kx == kindConst && ky == kindConst { 3950 v := xtype.Uint16(vx) <= xtype.Uint16(vy) 3951 return func(fr *frame) { fr.setReg(ir, v) } 3952 } else if kx == kindConst { 3953 x := xtype.Uint16(vx) 3954 return func(fr *frame) { fr.setReg(ir, x <= fr.uint16(iy)) } 3955 } else if ky == kindConst { 3956 y := xtype.Uint16(vy) 3957 return func(fr *frame) { fr.setReg(ir, fr.uint16(ix) <= y) } 3958 } else { 3959 return func(fr *frame) { fr.setReg(ir, fr.uint16(ix) <= fr.uint16(iy)) } 3960 } 3961 case reflect.Uint32: 3962 if kx == kindConst && ky == kindConst { 3963 v := xtype.Uint32(vx) <= xtype.Uint32(vy) 3964 return func(fr *frame) { fr.setReg(ir, v) } 3965 } else if kx == kindConst { 3966 x := xtype.Uint32(vx) 3967 return func(fr *frame) { fr.setReg(ir, x <= fr.uint32(iy)) } 3968 } else if ky == kindConst { 3969 y := xtype.Uint32(vy) 3970 return func(fr *frame) { fr.setReg(ir, fr.uint32(ix) <= y) } 3971 } else { 3972 return func(fr *frame) { fr.setReg(ir, fr.uint32(ix) <= fr.uint32(iy)) } 3973 } 3974 case reflect.Uint64: 3975 if kx == kindConst && ky == kindConst { 3976 v := xtype.Uint64(vx) <= xtype.Uint64(vy) 3977 return func(fr *frame) { fr.setReg(ir, v) } 3978 } else if kx == kindConst { 3979 x := xtype.Uint64(vx) 3980 return func(fr *frame) { fr.setReg(ir, x <= fr.uint64(iy)) } 3981 } else if ky == kindConst { 3982 y := xtype.Uint64(vy) 3983 return func(fr *frame) { fr.setReg(ir, fr.uint64(ix) <= y) } 3984 } else { 3985 return func(fr *frame) { fr.setReg(ir, fr.uint64(ix) <= fr.uint64(iy)) } 3986 } 3987 case reflect.Uintptr: 3988 if kx == kindConst && ky == kindConst { 3989 v := xtype.Uintptr(vx) <= xtype.Uintptr(vy) 3990 return func(fr *frame) { fr.setReg(ir, v) } 3991 } else if kx == kindConst { 3992 x := xtype.Uintptr(vx) 3993 return func(fr *frame) { fr.setReg(ir, x <= fr.uintptr(iy)) } 3994 } else if ky == kindConst { 3995 y := xtype.Uintptr(vy) 3996 return func(fr *frame) { fr.setReg(ir, fr.uintptr(ix) <= y) } 3997 } else { 3998 return func(fr *frame) { fr.setReg(ir, fr.uintptr(ix) <= fr.uintptr(iy)) } 3999 } 4000 case reflect.Float32: 4001 if kx == kindConst && ky == kindConst { 4002 v := xtype.Float32(vx) <= xtype.Float32(vy) 4003 return func(fr *frame) { fr.setReg(ir, v) } 4004 } else if kx == kindConst { 4005 x := xtype.Float32(vx) 4006 return func(fr *frame) { fr.setReg(ir, x <= fr.float32(iy)) } 4007 } else if ky == kindConst { 4008 y := xtype.Float32(vy) 4009 return func(fr *frame) { fr.setReg(ir, fr.float32(ix) <= y) } 4010 } else { 4011 return func(fr *frame) { fr.setReg(ir, fr.float32(ix) <= fr.float32(iy)) } 4012 } 4013 case reflect.Float64: 4014 if kx == kindConst && ky == kindConst { 4015 v := xtype.Float64(vx) <= xtype.Float64(vy) 4016 return func(fr *frame) { fr.setReg(ir, v) } 4017 } else if kx == kindConst { 4018 x := xtype.Float64(vx) 4019 return func(fr *frame) { fr.setReg(ir, x <= fr.float64(iy)) } 4020 } else if ky == kindConst { 4021 y := xtype.Float64(vy) 4022 return func(fr *frame) { fr.setReg(ir, fr.float64(ix) <= y) } 4023 } else { 4024 return func(fr *frame) { fr.setReg(ir, fr.float64(ix) <= fr.float64(iy)) } 4025 } 4026 case reflect.String: 4027 if kx == kindConst && ky == kindConst { 4028 v := xtype.String(vx) <= xtype.String(vy) 4029 return func(fr *frame) { fr.setReg(ir, v) } 4030 } else if kx == kindConst { 4031 x := xtype.String(vx) 4032 return func(fr *frame) { fr.setReg(ir, x <= fr.string(iy)) } 4033 } else if ky == kindConst { 4034 y := xtype.String(vy) 4035 return func(fr *frame) { fr.setReg(ir, fr.string(ix) <= y) } 4036 } else { 4037 return func(fr *frame) { fr.setReg(ir, fr.string(ix) <= fr.string(iy)) } 4038 } 4039 } 4040 } 4041 panic("unreachable") 4042 } 4043 func makeBinOpGTR(pfn *function, instr *ssa.BinOp) func(fr *frame) { 4044 ir := pfn.regIndex(instr) 4045 ix, kx, vx := pfn.regIndex3(instr.X) 4046 iy, ky, vy := pfn.regIndex3(instr.Y) 4047 typ := pfn.Interp.preToType(instr.X.Type()) 4048 if typ.PkgPath() == "" { 4049 switch typ.Kind() { 4050 case reflect.Int: 4051 if kx == kindConst && ky == kindConst { 4052 v := vx.(int) > vy.(int) 4053 return func(fr *frame) { fr.setReg(ir, v) } 4054 } else if kx == kindConst { 4055 x := vx.(int) 4056 return func(fr *frame) { fr.setReg(ir, x > fr.reg(iy).(int)) } 4057 } else if ky == kindConst { 4058 y := vy.(int) 4059 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int) > y) } 4060 } else { 4061 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int) > fr.reg(iy).(int)) } 4062 } 4063 case reflect.Int8: 4064 if kx == kindConst && ky == kindConst { 4065 v := vx.(int8) > vy.(int8) 4066 return func(fr *frame) { fr.setReg(ir, v) } 4067 } else if kx == kindConst { 4068 x := vx.(int8) 4069 return func(fr *frame) { fr.setReg(ir, x > fr.reg(iy).(int8)) } 4070 } else if ky == kindConst { 4071 y := vy.(int8) 4072 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8) > y) } 4073 } else { 4074 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8) > fr.reg(iy).(int8)) } 4075 } 4076 case reflect.Int16: 4077 if kx == kindConst && ky == kindConst { 4078 v := vx.(int16) > vy.(int16) 4079 return func(fr *frame) { fr.setReg(ir, v) } 4080 } else if kx == kindConst { 4081 x := vx.(int16) 4082 return func(fr *frame) { fr.setReg(ir, x > fr.reg(iy).(int16)) } 4083 } else if ky == kindConst { 4084 y := vy.(int16) 4085 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16) > y) } 4086 } else { 4087 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16) > fr.reg(iy).(int16)) } 4088 } 4089 case reflect.Int32: 4090 if kx == kindConst && ky == kindConst { 4091 v := vx.(int32) > vy.(int32) 4092 return func(fr *frame) { fr.setReg(ir, v) } 4093 } else if kx == kindConst { 4094 x := vx.(int32) 4095 return func(fr *frame) { fr.setReg(ir, x > fr.reg(iy).(int32)) } 4096 } else if ky == kindConst { 4097 y := vy.(int32) 4098 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32) > y) } 4099 } else { 4100 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32) > fr.reg(iy).(int32)) } 4101 } 4102 case reflect.Int64: 4103 if kx == kindConst && ky == kindConst { 4104 v := vx.(int64) > vy.(int64) 4105 return func(fr *frame) { fr.setReg(ir, v) } 4106 } else if kx == kindConst { 4107 x := vx.(int64) 4108 return func(fr *frame) { fr.setReg(ir, x > fr.reg(iy).(int64)) } 4109 } else if ky == kindConst { 4110 y := vy.(int64) 4111 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64) > y) } 4112 } else { 4113 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64) > fr.reg(iy).(int64)) } 4114 } 4115 case reflect.Uint: 4116 if kx == kindConst && ky == kindConst { 4117 v := vx.(uint) > vy.(uint) 4118 return func(fr *frame) { fr.setReg(ir, v) } 4119 } else if kx == kindConst { 4120 x := vx.(uint) 4121 return func(fr *frame) { fr.setReg(ir, x > fr.reg(iy).(uint)) } 4122 } else if ky == kindConst { 4123 y := vy.(uint) 4124 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint) > y) } 4125 } else { 4126 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint) > fr.reg(iy).(uint)) } 4127 } 4128 case reflect.Uint8: 4129 if kx == kindConst && ky == kindConst { 4130 v := vx.(uint8) > vy.(uint8) 4131 return func(fr *frame) { fr.setReg(ir, v) } 4132 } else if kx == kindConst { 4133 x := vx.(uint8) 4134 return func(fr *frame) { fr.setReg(ir, x > fr.reg(iy).(uint8)) } 4135 } else if ky == kindConst { 4136 y := vy.(uint8) 4137 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8) > y) } 4138 } else { 4139 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8) > fr.reg(iy).(uint8)) } 4140 } 4141 case reflect.Uint16: 4142 if kx == kindConst && ky == kindConst { 4143 v := vx.(uint16) > vy.(uint16) 4144 return func(fr *frame) { fr.setReg(ir, v) } 4145 } else if kx == kindConst { 4146 x := vx.(uint16) 4147 return func(fr *frame) { fr.setReg(ir, x > fr.reg(iy).(uint16)) } 4148 } else if ky == kindConst { 4149 y := vy.(uint16) 4150 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16) > y) } 4151 } else { 4152 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16) > fr.reg(iy).(uint16)) } 4153 } 4154 case reflect.Uint32: 4155 if kx == kindConst && ky == kindConst { 4156 v := vx.(uint32) > vy.(uint32) 4157 return func(fr *frame) { fr.setReg(ir, v) } 4158 } else if kx == kindConst { 4159 x := vx.(uint32) 4160 return func(fr *frame) { fr.setReg(ir, x > fr.reg(iy).(uint32)) } 4161 } else if ky == kindConst { 4162 y := vy.(uint32) 4163 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32) > y) } 4164 } else { 4165 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32) > fr.reg(iy).(uint32)) } 4166 } 4167 case reflect.Uint64: 4168 if kx == kindConst && ky == kindConst { 4169 v := vx.(uint64) > vy.(uint64) 4170 return func(fr *frame) { fr.setReg(ir, v) } 4171 } else if kx == kindConst { 4172 x := vx.(uint64) 4173 return func(fr *frame) { fr.setReg(ir, x > fr.reg(iy).(uint64)) } 4174 } else if ky == kindConst { 4175 y := vy.(uint64) 4176 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64) > y) } 4177 } else { 4178 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64) > fr.reg(iy).(uint64)) } 4179 } 4180 case reflect.Uintptr: 4181 if kx == kindConst && ky == kindConst { 4182 v := vx.(uintptr) > vy.(uintptr) 4183 return func(fr *frame) { fr.setReg(ir, v) } 4184 } else if kx == kindConst { 4185 x := vx.(uintptr) 4186 return func(fr *frame) { fr.setReg(ir, x > fr.reg(iy).(uintptr)) } 4187 } else if ky == kindConst { 4188 y := vy.(uintptr) 4189 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr) > y) } 4190 } else { 4191 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr) > fr.reg(iy).(uintptr)) } 4192 } 4193 case reflect.Float32: 4194 if kx == kindConst && ky == kindConst { 4195 v := vx.(float32) > vy.(float32) 4196 return func(fr *frame) { fr.setReg(ir, v) } 4197 } else if kx == kindConst { 4198 x := vx.(float32) 4199 return func(fr *frame) { fr.setReg(ir, x > fr.reg(iy).(float32)) } 4200 } else if ky == kindConst { 4201 y := vy.(float32) 4202 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float32) > y) } 4203 } else { 4204 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float32) > fr.reg(iy).(float32)) } 4205 } 4206 case reflect.Float64: 4207 if kx == kindConst && ky == kindConst { 4208 v := vx.(float64) > vy.(float64) 4209 return func(fr *frame) { fr.setReg(ir, v) } 4210 } else if kx == kindConst { 4211 x := vx.(float64) 4212 return func(fr *frame) { fr.setReg(ir, x > fr.reg(iy).(float64)) } 4213 } else if ky == kindConst { 4214 y := vy.(float64) 4215 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float64) > y) } 4216 } else { 4217 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float64) > fr.reg(iy).(float64)) } 4218 } 4219 case reflect.String: 4220 if kx == kindConst && ky == kindConst { 4221 v := vx.(string) > vy.(string) 4222 return func(fr *frame) { fr.setReg(ir, v) } 4223 } else if kx == kindConst { 4224 x := vx.(string) 4225 return func(fr *frame) { fr.setReg(ir, x > fr.reg(iy).(string)) } 4226 } else if ky == kindConst { 4227 y := vy.(string) 4228 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(string) > y) } 4229 } else { 4230 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(string) > fr.reg(iy).(string)) } 4231 } 4232 } 4233 } else { 4234 switch typ.Kind() { 4235 case reflect.Int: 4236 if kx == kindConst && ky == kindConst { 4237 v := xtype.Int(vx) > xtype.Int(vy) 4238 return func(fr *frame) { fr.setReg(ir, v) } 4239 } else if kx == kindConst { 4240 x := xtype.Int(vx) 4241 return func(fr *frame) { fr.setReg(ir, x > fr.int(iy)) } 4242 } else if ky == kindConst { 4243 y := xtype.Int(vy) 4244 return func(fr *frame) { fr.setReg(ir, fr.int(ix) > y) } 4245 } else { 4246 return func(fr *frame) { fr.setReg(ir, fr.int(ix) > fr.int(iy)) } 4247 } 4248 case reflect.Int8: 4249 if kx == kindConst && ky == kindConst { 4250 v := xtype.Int8(vx) > xtype.Int8(vy) 4251 return func(fr *frame) { fr.setReg(ir, v) } 4252 } else if kx == kindConst { 4253 x := xtype.Int8(vx) 4254 return func(fr *frame) { fr.setReg(ir, x > fr.int8(iy)) } 4255 } else if ky == kindConst { 4256 y := xtype.Int8(vy) 4257 return func(fr *frame) { fr.setReg(ir, fr.int8(ix) > y) } 4258 } else { 4259 return func(fr *frame) { fr.setReg(ir, fr.int8(ix) > fr.int8(iy)) } 4260 } 4261 case reflect.Int16: 4262 if kx == kindConst && ky == kindConst { 4263 v := xtype.Int16(vx) > xtype.Int16(vy) 4264 return func(fr *frame) { fr.setReg(ir, v) } 4265 } else if kx == kindConst { 4266 x := xtype.Int16(vx) 4267 return func(fr *frame) { fr.setReg(ir, x > fr.int16(iy)) } 4268 } else if ky == kindConst { 4269 y := xtype.Int16(vy) 4270 return func(fr *frame) { fr.setReg(ir, fr.int16(ix) > y) } 4271 } else { 4272 return func(fr *frame) { fr.setReg(ir, fr.int16(ix) > fr.int16(iy)) } 4273 } 4274 case reflect.Int32: 4275 if kx == kindConst && ky == kindConst { 4276 v := xtype.Int32(vx) > xtype.Int32(vy) 4277 return func(fr *frame) { fr.setReg(ir, v) } 4278 } else if kx == kindConst { 4279 x := xtype.Int32(vx) 4280 return func(fr *frame) { fr.setReg(ir, x > fr.int32(iy)) } 4281 } else if ky == kindConst { 4282 y := xtype.Int32(vy) 4283 return func(fr *frame) { fr.setReg(ir, fr.int32(ix) > y) } 4284 } else { 4285 return func(fr *frame) { fr.setReg(ir, fr.int32(ix) > fr.int32(iy)) } 4286 } 4287 case reflect.Int64: 4288 if kx == kindConst && ky == kindConst { 4289 v := xtype.Int64(vx) > xtype.Int64(vy) 4290 return func(fr *frame) { fr.setReg(ir, v) } 4291 } else if kx == kindConst { 4292 x := xtype.Int64(vx) 4293 return func(fr *frame) { fr.setReg(ir, x > fr.int64(iy)) } 4294 } else if ky == kindConst { 4295 y := xtype.Int64(vy) 4296 return func(fr *frame) { fr.setReg(ir, fr.int64(ix) > y) } 4297 } else { 4298 return func(fr *frame) { fr.setReg(ir, fr.int64(ix) > fr.int64(iy)) } 4299 } 4300 case reflect.Uint: 4301 if kx == kindConst && ky == kindConst { 4302 v := xtype.Uint(vx) > xtype.Uint(vy) 4303 return func(fr *frame) { fr.setReg(ir, v) } 4304 } else if kx == kindConst { 4305 x := xtype.Uint(vx) 4306 return func(fr *frame) { fr.setReg(ir, x > fr.uint(iy)) } 4307 } else if ky == kindConst { 4308 y := xtype.Uint(vy) 4309 return func(fr *frame) { fr.setReg(ir, fr.uint(ix) > y) } 4310 } else { 4311 return func(fr *frame) { fr.setReg(ir, fr.uint(ix) > fr.uint(iy)) } 4312 } 4313 case reflect.Uint8: 4314 if kx == kindConst && ky == kindConst { 4315 v := xtype.Uint8(vx) > xtype.Uint8(vy) 4316 return func(fr *frame) { fr.setReg(ir, v) } 4317 } else if kx == kindConst { 4318 x := xtype.Uint8(vx) 4319 return func(fr *frame) { fr.setReg(ir, x > fr.uint8(iy)) } 4320 } else if ky == kindConst { 4321 y := xtype.Uint8(vy) 4322 return func(fr *frame) { fr.setReg(ir, fr.uint8(ix) > y) } 4323 } else { 4324 return func(fr *frame) { fr.setReg(ir, fr.uint8(ix) > fr.uint8(iy)) } 4325 } 4326 case reflect.Uint16: 4327 if kx == kindConst && ky == kindConst { 4328 v := xtype.Uint16(vx) > xtype.Uint16(vy) 4329 return func(fr *frame) { fr.setReg(ir, v) } 4330 } else if kx == kindConst { 4331 x := xtype.Uint16(vx) 4332 return func(fr *frame) { fr.setReg(ir, x > fr.uint16(iy)) } 4333 } else if ky == kindConst { 4334 y := xtype.Uint16(vy) 4335 return func(fr *frame) { fr.setReg(ir, fr.uint16(ix) > y) } 4336 } else { 4337 return func(fr *frame) { fr.setReg(ir, fr.uint16(ix) > fr.uint16(iy)) } 4338 } 4339 case reflect.Uint32: 4340 if kx == kindConst && ky == kindConst { 4341 v := xtype.Uint32(vx) > xtype.Uint32(vy) 4342 return func(fr *frame) { fr.setReg(ir, v) } 4343 } else if kx == kindConst { 4344 x := xtype.Uint32(vx) 4345 return func(fr *frame) { fr.setReg(ir, x > fr.uint32(iy)) } 4346 } else if ky == kindConst { 4347 y := xtype.Uint32(vy) 4348 return func(fr *frame) { fr.setReg(ir, fr.uint32(ix) > y) } 4349 } else { 4350 return func(fr *frame) { fr.setReg(ir, fr.uint32(ix) > fr.uint32(iy)) } 4351 } 4352 case reflect.Uint64: 4353 if kx == kindConst && ky == kindConst { 4354 v := xtype.Uint64(vx) > xtype.Uint64(vy) 4355 return func(fr *frame) { fr.setReg(ir, v) } 4356 } else if kx == kindConst { 4357 x := xtype.Uint64(vx) 4358 return func(fr *frame) { fr.setReg(ir, x > fr.uint64(iy)) } 4359 } else if ky == kindConst { 4360 y := xtype.Uint64(vy) 4361 return func(fr *frame) { fr.setReg(ir, fr.uint64(ix) > y) } 4362 } else { 4363 return func(fr *frame) { fr.setReg(ir, fr.uint64(ix) > fr.uint64(iy)) } 4364 } 4365 case reflect.Uintptr: 4366 if kx == kindConst && ky == kindConst { 4367 v := xtype.Uintptr(vx) > xtype.Uintptr(vy) 4368 return func(fr *frame) { fr.setReg(ir, v) } 4369 } else if kx == kindConst { 4370 x := xtype.Uintptr(vx) 4371 return func(fr *frame) { fr.setReg(ir, x > fr.uintptr(iy)) } 4372 } else if ky == kindConst { 4373 y := xtype.Uintptr(vy) 4374 return func(fr *frame) { fr.setReg(ir, fr.uintptr(ix) > y) } 4375 } else { 4376 return func(fr *frame) { fr.setReg(ir, fr.uintptr(ix) > fr.uintptr(iy)) } 4377 } 4378 case reflect.Float32: 4379 if kx == kindConst && ky == kindConst { 4380 v := xtype.Float32(vx) > xtype.Float32(vy) 4381 return func(fr *frame) { fr.setReg(ir, v) } 4382 } else if kx == kindConst { 4383 x := xtype.Float32(vx) 4384 return func(fr *frame) { fr.setReg(ir, x > fr.float32(iy)) } 4385 } else if ky == kindConst { 4386 y := xtype.Float32(vy) 4387 return func(fr *frame) { fr.setReg(ir, fr.float32(ix) > y) } 4388 } else { 4389 return func(fr *frame) { fr.setReg(ir, fr.float32(ix) > fr.float32(iy)) } 4390 } 4391 case reflect.Float64: 4392 if kx == kindConst && ky == kindConst { 4393 v := xtype.Float64(vx) > xtype.Float64(vy) 4394 return func(fr *frame) { fr.setReg(ir, v) } 4395 } else if kx == kindConst { 4396 x := xtype.Float64(vx) 4397 return func(fr *frame) { fr.setReg(ir, x > fr.float64(iy)) } 4398 } else if ky == kindConst { 4399 y := xtype.Float64(vy) 4400 return func(fr *frame) { fr.setReg(ir, fr.float64(ix) > y) } 4401 } else { 4402 return func(fr *frame) { fr.setReg(ir, fr.float64(ix) > fr.float64(iy)) } 4403 } 4404 case reflect.String: 4405 if kx == kindConst && ky == kindConst { 4406 v := xtype.String(vx) > xtype.String(vy) 4407 return func(fr *frame) { fr.setReg(ir, v) } 4408 } else if kx == kindConst { 4409 x := xtype.String(vx) 4410 return func(fr *frame) { fr.setReg(ir, x > fr.string(iy)) } 4411 } else if ky == kindConst { 4412 y := xtype.String(vy) 4413 return func(fr *frame) { fr.setReg(ir, fr.string(ix) > y) } 4414 } else { 4415 return func(fr *frame) { fr.setReg(ir, fr.string(ix) > fr.string(iy)) } 4416 } 4417 } 4418 } 4419 panic("unreachable") 4420 } 4421 func makeBinOpGEQ(pfn *function, instr *ssa.BinOp) func(fr *frame) { 4422 ir := pfn.regIndex(instr) 4423 ix, kx, vx := pfn.regIndex3(instr.X) 4424 iy, ky, vy := pfn.regIndex3(instr.Y) 4425 typ := pfn.Interp.preToType(instr.X.Type()) 4426 if typ.PkgPath() == "" { 4427 switch typ.Kind() { 4428 case reflect.Int: 4429 if kx == kindConst && ky == kindConst { 4430 v := vx.(int) >= vy.(int) 4431 return func(fr *frame) { fr.setReg(ir, v) } 4432 } else if kx == kindConst { 4433 x := vx.(int) 4434 return func(fr *frame) { fr.setReg(ir, x >= fr.reg(iy).(int)) } 4435 } else if ky == kindConst { 4436 y := vy.(int) 4437 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int) >= y) } 4438 } else { 4439 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int) >= fr.reg(iy).(int)) } 4440 } 4441 case reflect.Int8: 4442 if kx == kindConst && ky == kindConst { 4443 v := vx.(int8) >= vy.(int8) 4444 return func(fr *frame) { fr.setReg(ir, v) } 4445 } else if kx == kindConst { 4446 x := vx.(int8) 4447 return func(fr *frame) { fr.setReg(ir, x >= fr.reg(iy).(int8)) } 4448 } else if ky == kindConst { 4449 y := vy.(int8) 4450 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8) >= y) } 4451 } else { 4452 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int8) >= fr.reg(iy).(int8)) } 4453 } 4454 case reflect.Int16: 4455 if kx == kindConst && ky == kindConst { 4456 v := vx.(int16) >= vy.(int16) 4457 return func(fr *frame) { fr.setReg(ir, v) } 4458 } else if kx == kindConst { 4459 x := vx.(int16) 4460 return func(fr *frame) { fr.setReg(ir, x >= fr.reg(iy).(int16)) } 4461 } else if ky == kindConst { 4462 y := vy.(int16) 4463 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16) >= y) } 4464 } else { 4465 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int16) >= fr.reg(iy).(int16)) } 4466 } 4467 case reflect.Int32: 4468 if kx == kindConst && ky == kindConst { 4469 v := vx.(int32) >= vy.(int32) 4470 return func(fr *frame) { fr.setReg(ir, v) } 4471 } else if kx == kindConst { 4472 x := vx.(int32) 4473 return func(fr *frame) { fr.setReg(ir, x >= fr.reg(iy).(int32)) } 4474 } else if ky == kindConst { 4475 y := vy.(int32) 4476 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32) >= y) } 4477 } else { 4478 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int32) >= fr.reg(iy).(int32)) } 4479 } 4480 case reflect.Int64: 4481 if kx == kindConst && ky == kindConst { 4482 v := vx.(int64) >= vy.(int64) 4483 return func(fr *frame) { fr.setReg(ir, v) } 4484 } else if kx == kindConst { 4485 x := vx.(int64) 4486 return func(fr *frame) { fr.setReg(ir, x >= fr.reg(iy).(int64)) } 4487 } else if ky == kindConst { 4488 y := vy.(int64) 4489 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64) >= y) } 4490 } else { 4491 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(int64) >= fr.reg(iy).(int64)) } 4492 } 4493 case reflect.Uint: 4494 if kx == kindConst && ky == kindConst { 4495 v := vx.(uint) >= vy.(uint) 4496 return func(fr *frame) { fr.setReg(ir, v) } 4497 } else if kx == kindConst { 4498 x := vx.(uint) 4499 return func(fr *frame) { fr.setReg(ir, x >= fr.reg(iy).(uint)) } 4500 } else if ky == kindConst { 4501 y := vy.(uint) 4502 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint) >= y) } 4503 } else { 4504 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint) >= fr.reg(iy).(uint)) } 4505 } 4506 case reflect.Uint8: 4507 if kx == kindConst && ky == kindConst { 4508 v := vx.(uint8) >= vy.(uint8) 4509 return func(fr *frame) { fr.setReg(ir, v) } 4510 } else if kx == kindConst { 4511 x := vx.(uint8) 4512 return func(fr *frame) { fr.setReg(ir, x >= fr.reg(iy).(uint8)) } 4513 } else if ky == kindConst { 4514 y := vy.(uint8) 4515 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8) >= y) } 4516 } else { 4517 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint8) >= fr.reg(iy).(uint8)) } 4518 } 4519 case reflect.Uint16: 4520 if kx == kindConst && ky == kindConst { 4521 v := vx.(uint16) >= vy.(uint16) 4522 return func(fr *frame) { fr.setReg(ir, v) } 4523 } else if kx == kindConst { 4524 x := vx.(uint16) 4525 return func(fr *frame) { fr.setReg(ir, x >= fr.reg(iy).(uint16)) } 4526 } else if ky == kindConst { 4527 y := vy.(uint16) 4528 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16) >= y) } 4529 } else { 4530 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint16) >= fr.reg(iy).(uint16)) } 4531 } 4532 case reflect.Uint32: 4533 if kx == kindConst && ky == kindConst { 4534 v := vx.(uint32) >= vy.(uint32) 4535 return func(fr *frame) { fr.setReg(ir, v) } 4536 } else if kx == kindConst { 4537 x := vx.(uint32) 4538 return func(fr *frame) { fr.setReg(ir, x >= fr.reg(iy).(uint32)) } 4539 } else if ky == kindConst { 4540 y := vy.(uint32) 4541 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32) >= y) } 4542 } else { 4543 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint32) >= fr.reg(iy).(uint32)) } 4544 } 4545 case reflect.Uint64: 4546 if kx == kindConst && ky == kindConst { 4547 v := vx.(uint64) >= vy.(uint64) 4548 return func(fr *frame) { fr.setReg(ir, v) } 4549 } else if kx == kindConst { 4550 x := vx.(uint64) 4551 return func(fr *frame) { fr.setReg(ir, x >= fr.reg(iy).(uint64)) } 4552 } else if ky == kindConst { 4553 y := vy.(uint64) 4554 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64) >= y) } 4555 } else { 4556 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uint64) >= fr.reg(iy).(uint64)) } 4557 } 4558 case reflect.Uintptr: 4559 if kx == kindConst && ky == kindConst { 4560 v := vx.(uintptr) >= vy.(uintptr) 4561 return func(fr *frame) { fr.setReg(ir, v) } 4562 } else if kx == kindConst { 4563 x := vx.(uintptr) 4564 return func(fr *frame) { fr.setReg(ir, x >= fr.reg(iy).(uintptr)) } 4565 } else if ky == kindConst { 4566 y := vy.(uintptr) 4567 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr) >= y) } 4568 } else { 4569 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(uintptr) >= fr.reg(iy).(uintptr)) } 4570 } 4571 case reflect.Float32: 4572 if kx == kindConst && ky == kindConst { 4573 v := vx.(float32) >= vy.(float32) 4574 return func(fr *frame) { fr.setReg(ir, v) } 4575 } else if kx == kindConst { 4576 x := vx.(float32) 4577 return func(fr *frame) { fr.setReg(ir, x >= fr.reg(iy).(float32)) } 4578 } else if ky == kindConst { 4579 y := vy.(float32) 4580 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float32) >= y) } 4581 } else { 4582 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float32) >= fr.reg(iy).(float32)) } 4583 } 4584 case reflect.Float64: 4585 if kx == kindConst && ky == kindConst { 4586 v := vx.(float64) >= vy.(float64) 4587 return func(fr *frame) { fr.setReg(ir, v) } 4588 } else if kx == kindConst { 4589 x := vx.(float64) 4590 return func(fr *frame) { fr.setReg(ir, x >= fr.reg(iy).(float64)) } 4591 } else if ky == kindConst { 4592 y := vy.(float64) 4593 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float64) >= y) } 4594 } else { 4595 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(float64) >= fr.reg(iy).(float64)) } 4596 } 4597 case reflect.String: 4598 if kx == kindConst && ky == kindConst { 4599 v := vx.(string) >= vy.(string) 4600 return func(fr *frame) { fr.setReg(ir, v) } 4601 } else if kx == kindConst { 4602 x := vx.(string) 4603 return func(fr *frame) { fr.setReg(ir, x >= fr.reg(iy).(string)) } 4604 } else if ky == kindConst { 4605 y := vy.(string) 4606 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(string) >= y) } 4607 } else { 4608 return func(fr *frame) { fr.setReg(ir, fr.reg(ix).(string) >= fr.reg(iy).(string)) } 4609 } 4610 } 4611 } else { 4612 switch typ.Kind() { 4613 case reflect.Int: 4614 if kx == kindConst && ky == kindConst { 4615 v := xtype.Int(vx) >= xtype.Int(vy) 4616 return func(fr *frame) { fr.setReg(ir, v) } 4617 } else if kx == kindConst { 4618 x := xtype.Int(vx) 4619 return func(fr *frame) { fr.setReg(ir, x >= fr.int(iy)) } 4620 } else if ky == kindConst { 4621 y := xtype.Int(vy) 4622 return func(fr *frame) { fr.setReg(ir, fr.int(ix) >= y) } 4623 } else { 4624 return func(fr *frame) { fr.setReg(ir, fr.int(ix) >= fr.int(iy)) } 4625 } 4626 case reflect.Int8: 4627 if kx == kindConst && ky == kindConst { 4628 v := xtype.Int8(vx) >= xtype.Int8(vy) 4629 return func(fr *frame) { fr.setReg(ir, v) } 4630 } else if kx == kindConst { 4631 x := xtype.Int8(vx) 4632 return func(fr *frame) { fr.setReg(ir, x >= fr.int8(iy)) } 4633 } else if ky == kindConst { 4634 y := xtype.Int8(vy) 4635 return func(fr *frame) { fr.setReg(ir, fr.int8(ix) >= y) } 4636 } else { 4637 return func(fr *frame) { fr.setReg(ir, fr.int8(ix) >= fr.int8(iy)) } 4638 } 4639 case reflect.Int16: 4640 if kx == kindConst && ky == kindConst { 4641 v := xtype.Int16(vx) >= xtype.Int16(vy) 4642 return func(fr *frame) { fr.setReg(ir, v) } 4643 } else if kx == kindConst { 4644 x := xtype.Int16(vx) 4645 return func(fr *frame) { fr.setReg(ir, x >= fr.int16(iy)) } 4646 } else if ky == kindConst { 4647 y := xtype.Int16(vy) 4648 return func(fr *frame) { fr.setReg(ir, fr.int16(ix) >= y) } 4649 } else { 4650 return func(fr *frame) { fr.setReg(ir, fr.int16(ix) >= fr.int16(iy)) } 4651 } 4652 case reflect.Int32: 4653 if kx == kindConst && ky == kindConst { 4654 v := xtype.Int32(vx) >= xtype.Int32(vy) 4655 return func(fr *frame) { fr.setReg(ir, v) } 4656 } else if kx == kindConst { 4657 x := xtype.Int32(vx) 4658 return func(fr *frame) { fr.setReg(ir, x >= fr.int32(iy)) } 4659 } else if ky == kindConst { 4660 y := xtype.Int32(vy) 4661 return func(fr *frame) { fr.setReg(ir, fr.int32(ix) >= y) } 4662 } else { 4663 return func(fr *frame) { fr.setReg(ir, fr.int32(ix) >= fr.int32(iy)) } 4664 } 4665 case reflect.Int64: 4666 if kx == kindConst && ky == kindConst { 4667 v := xtype.Int64(vx) >= xtype.Int64(vy) 4668 return func(fr *frame) { fr.setReg(ir, v) } 4669 } else if kx == kindConst { 4670 x := xtype.Int64(vx) 4671 return func(fr *frame) { fr.setReg(ir, x >= fr.int64(iy)) } 4672 } else if ky == kindConst { 4673 y := xtype.Int64(vy) 4674 return func(fr *frame) { fr.setReg(ir, fr.int64(ix) >= y) } 4675 } else { 4676 return func(fr *frame) { fr.setReg(ir, fr.int64(ix) >= fr.int64(iy)) } 4677 } 4678 case reflect.Uint: 4679 if kx == kindConst && ky == kindConst { 4680 v := xtype.Uint(vx) >= xtype.Uint(vy) 4681 return func(fr *frame) { fr.setReg(ir, v) } 4682 } else if kx == kindConst { 4683 x := xtype.Uint(vx) 4684 return func(fr *frame) { fr.setReg(ir, x >= fr.uint(iy)) } 4685 } else if ky == kindConst { 4686 y := xtype.Uint(vy) 4687 return func(fr *frame) { fr.setReg(ir, fr.uint(ix) >= y) } 4688 } else { 4689 return func(fr *frame) { fr.setReg(ir, fr.uint(ix) >= fr.uint(iy)) } 4690 } 4691 case reflect.Uint8: 4692 if kx == kindConst && ky == kindConst { 4693 v := xtype.Uint8(vx) >= xtype.Uint8(vy) 4694 return func(fr *frame) { fr.setReg(ir, v) } 4695 } else if kx == kindConst { 4696 x := xtype.Uint8(vx) 4697 return func(fr *frame) { fr.setReg(ir, x >= fr.uint8(iy)) } 4698 } else if ky == kindConst { 4699 y := xtype.Uint8(vy) 4700 return func(fr *frame) { fr.setReg(ir, fr.uint8(ix) >= y) } 4701 } else { 4702 return func(fr *frame) { fr.setReg(ir, fr.uint8(ix) >= fr.uint8(iy)) } 4703 } 4704 case reflect.Uint16: 4705 if kx == kindConst && ky == kindConst { 4706 v := xtype.Uint16(vx) >= xtype.Uint16(vy) 4707 return func(fr *frame) { fr.setReg(ir, v) } 4708 } else if kx == kindConst { 4709 x := xtype.Uint16(vx) 4710 return func(fr *frame) { fr.setReg(ir, x >= fr.uint16(iy)) } 4711 } else if ky == kindConst { 4712 y := xtype.Uint16(vy) 4713 return func(fr *frame) { fr.setReg(ir, fr.uint16(ix) >= y) } 4714 } else { 4715 return func(fr *frame) { fr.setReg(ir, fr.uint16(ix) >= fr.uint16(iy)) } 4716 } 4717 case reflect.Uint32: 4718 if kx == kindConst && ky == kindConst { 4719 v := xtype.Uint32(vx) >= xtype.Uint32(vy) 4720 return func(fr *frame) { fr.setReg(ir, v) } 4721 } else if kx == kindConst { 4722 x := xtype.Uint32(vx) 4723 return func(fr *frame) { fr.setReg(ir, x >= fr.uint32(iy)) } 4724 } else if ky == kindConst { 4725 y := xtype.Uint32(vy) 4726 return func(fr *frame) { fr.setReg(ir, fr.uint32(ix) >= y) } 4727 } else { 4728 return func(fr *frame) { fr.setReg(ir, fr.uint32(ix) >= fr.uint32(iy)) } 4729 } 4730 case reflect.Uint64: 4731 if kx == kindConst && ky == kindConst { 4732 v := xtype.Uint64(vx) >= xtype.Uint64(vy) 4733 return func(fr *frame) { fr.setReg(ir, v) } 4734 } else if kx == kindConst { 4735 x := xtype.Uint64(vx) 4736 return func(fr *frame) { fr.setReg(ir, x >= fr.uint64(iy)) } 4737 } else if ky == kindConst { 4738 y := xtype.Uint64(vy) 4739 return func(fr *frame) { fr.setReg(ir, fr.uint64(ix) >= y) } 4740 } else { 4741 return func(fr *frame) { fr.setReg(ir, fr.uint64(ix) >= fr.uint64(iy)) } 4742 } 4743 case reflect.Uintptr: 4744 if kx == kindConst && ky == kindConst { 4745 v := xtype.Uintptr(vx) >= xtype.Uintptr(vy) 4746 return func(fr *frame) { fr.setReg(ir, v) } 4747 } else if kx == kindConst { 4748 x := xtype.Uintptr(vx) 4749 return func(fr *frame) { fr.setReg(ir, x >= fr.uintptr(iy)) } 4750 } else if ky == kindConst { 4751 y := xtype.Uintptr(vy) 4752 return func(fr *frame) { fr.setReg(ir, fr.uintptr(ix) >= y) } 4753 } else { 4754 return func(fr *frame) { fr.setReg(ir, fr.uintptr(ix) >= fr.uintptr(iy)) } 4755 } 4756 case reflect.Float32: 4757 if kx == kindConst && ky == kindConst { 4758 v := xtype.Float32(vx) >= xtype.Float32(vy) 4759 return func(fr *frame) { fr.setReg(ir, v) } 4760 } else if kx == kindConst { 4761 x := xtype.Float32(vx) 4762 return func(fr *frame) { fr.setReg(ir, x >= fr.float32(iy)) } 4763 } else if ky == kindConst { 4764 y := xtype.Float32(vy) 4765 return func(fr *frame) { fr.setReg(ir, fr.float32(ix) >= y) } 4766 } else { 4767 return func(fr *frame) { fr.setReg(ir, fr.float32(ix) >= fr.float32(iy)) } 4768 } 4769 case reflect.Float64: 4770 if kx == kindConst && ky == kindConst { 4771 v := xtype.Float64(vx) >= xtype.Float64(vy) 4772 return func(fr *frame) { fr.setReg(ir, v) } 4773 } else if kx == kindConst { 4774 x := xtype.Float64(vx) 4775 return func(fr *frame) { fr.setReg(ir, x >= fr.float64(iy)) } 4776 } else if ky == kindConst { 4777 y := xtype.Float64(vy) 4778 return func(fr *frame) { fr.setReg(ir, fr.float64(ix) >= y) } 4779 } else { 4780 return func(fr *frame) { fr.setReg(ir, fr.float64(ix) >= fr.float64(iy)) } 4781 } 4782 case reflect.String: 4783 if kx == kindConst && ky == kindConst { 4784 v := xtype.String(vx) >= xtype.String(vy) 4785 return func(fr *frame) { fr.setReg(ir, v) } 4786 } else if kx == kindConst { 4787 x := xtype.String(vx) 4788 return func(fr *frame) { fr.setReg(ir, x >= fr.string(iy)) } 4789 } else if ky == kindConst { 4790 y := xtype.String(vy) 4791 return func(fr *frame) { fr.setReg(ir, fr.string(ix) >= y) } 4792 } else { 4793 return func(fr *frame) { fr.setReg(ir, fr.string(ix) >= fr.string(iy)) } 4794 } 4795 } 4796 } 4797 panic("unreachable") 4798 }