github.com/goplus/gossa@v0.3.25/unop.go (about)

     1  package gossa
     2  
     3  import (
     4  	"reflect"
     5  
     6  	"github.com/goplus/gossa/internal/xtype"
     7  	"golang.org/x/tools/go/ssa"
     8  )
     9  
    10  func makeUnOpSUB(pfn *function, instr *ssa.UnOp) func(fr *frame) {
    11  	ir := pfn.regIndex(instr)
    12  	ix, kx, vx := pfn.regIndex3(instr.X)
    13  	typ := pfn.Interp.preToType(instr.Type())
    14  	if typ.PkgPath() == "" {
    15  		switch typ.Kind() {
    16  		case reflect.Int:
    17  			if kx == kindConst {
    18  				v := -vx.(int)
    19  				return func(fr *frame) { fr.setReg(ir, v) }
    20  			} else {
    21  				return func(fr *frame) {
    22  					v := -fr.reg(ix).(int)
    23  					fr.setReg(ir, v)
    24  				}
    25  			}
    26  		case reflect.Int8:
    27  			if kx == kindConst {
    28  				v := -vx.(int8)
    29  				return func(fr *frame) { fr.setReg(ir, v) }
    30  			} else {
    31  				return func(fr *frame) {
    32  					v := -fr.reg(ix).(int8)
    33  					fr.setReg(ir, v)
    34  				}
    35  			}
    36  		case reflect.Int16:
    37  			if kx == kindConst {
    38  				v := -vx.(int16)
    39  				return func(fr *frame) { fr.setReg(ir, v) }
    40  			} else {
    41  				return func(fr *frame) {
    42  					v := -fr.reg(ix).(int16)
    43  					fr.setReg(ir, v)
    44  				}
    45  			}
    46  		case reflect.Int32:
    47  			if kx == kindConst {
    48  				v := -vx.(int32)
    49  				return func(fr *frame) { fr.setReg(ir, v) }
    50  			} else {
    51  				return func(fr *frame) {
    52  					v := -fr.reg(ix).(int32)
    53  					fr.setReg(ir, v)
    54  				}
    55  			}
    56  		case reflect.Int64:
    57  			if kx == kindConst {
    58  				v := -vx.(int64)
    59  				return func(fr *frame) { fr.setReg(ir, v) }
    60  			} else {
    61  				return func(fr *frame) {
    62  					v := -fr.reg(ix).(int64)
    63  					fr.setReg(ir, v)
    64  				}
    65  			}
    66  		case reflect.Uint:
    67  			if kx == kindConst {
    68  				v := -vx.(uint)
    69  				return func(fr *frame) { fr.setReg(ir, v) }
    70  			} else {
    71  				return func(fr *frame) {
    72  					v := -fr.reg(ix).(uint)
    73  					fr.setReg(ir, v)
    74  				}
    75  			}
    76  		case reflect.Uint8:
    77  			if kx == kindConst {
    78  				v := -vx.(uint8)
    79  				return func(fr *frame) { fr.setReg(ir, v) }
    80  			} else {
    81  				return func(fr *frame) {
    82  					v := -fr.reg(ix).(uint8)
    83  					fr.setReg(ir, v)
    84  				}
    85  			}
    86  		case reflect.Uint16:
    87  			if kx == kindConst {
    88  				v := -vx.(uint16)
    89  				return func(fr *frame) { fr.setReg(ir, v) }
    90  			} else {
    91  				return func(fr *frame) {
    92  					v := -fr.reg(ix).(uint16)
    93  					fr.setReg(ir, v)
    94  				}
    95  			}
    96  		case reflect.Uint32:
    97  			if kx == kindConst {
    98  				v := -vx.(uint32)
    99  				return func(fr *frame) { fr.setReg(ir, v) }
   100  			} else {
   101  				return func(fr *frame) {
   102  					v := -fr.reg(ix).(uint32)
   103  					fr.setReg(ir, v)
   104  				}
   105  			}
   106  		case reflect.Uint64:
   107  			if kx == kindConst {
   108  				v := -vx.(uint64)
   109  				return func(fr *frame) { fr.setReg(ir, v) }
   110  			} else {
   111  				return func(fr *frame) {
   112  					v := -fr.reg(ix).(uint64)
   113  					fr.setReg(ir, v)
   114  				}
   115  			}
   116  		case reflect.Uintptr:
   117  			if kx == kindConst {
   118  				v := -vx.(uintptr)
   119  				return func(fr *frame) { fr.setReg(ir, v) }
   120  			} else {
   121  				return func(fr *frame) {
   122  					v := -fr.reg(ix).(uintptr)
   123  					fr.setReg(ir, v)
   124  				}
   125  			}
   126  		case reflect.Float32:
   127  			if kx == kindConst {
   128  				v := -vx.(float32)
   129  				return func(fr *frame) { fr.setReg(ir, v) }
   130  			} else {
   131  				return func(fr *frame) {
   132  					v := -fr.reg(ix).(float32)
   133  					fr.setReg(ir, v)
   134  				}
   135  			}
   136  		case reflect.Float64:
   137  			if kx == kindConst {
   138  				v := -vx.(float64)
   139  				return func(fr *frame) { fr.setReg(ir, v) }
   140  			} else {
   141  				return func(fr *frame) {
   142  					v := -fr.reg(ix).(float64)
   143  					fr.setReg(ir, v)
   144  				}
   145  			}
   146  		case reflect.Complex64:
   147  			if kx == kindConst {
   148  				v := -vx.(complex64)
   149  				return func(fr *frame) { fr.setReg(ir, v) }
   150  			} else {
   151  				return func(fr *frame) {
   152  					v := -fr.reg(ix).(complex64)
   153  					fr.setReg(ir, v)
   154  				}
   155  			}
   156  		case reflect.Complex128:
   157  			if kx == kindConst {
   158  				v := -vx.(complex128)
   159  				return func(fr *frame) { fr.setReg(ir, v) }
   160  			} else {
   161  				return func(fr *frame) {
   162  					v := -fr.reg(ix).(complex128)
   163  					fr.setReg(ir, v)
   164  				}
   165  			}
   166  		}
   167  	} else {
   168  		switch typ.Kind() {
   169  		case reflect.Int:
   170  			if kx == kindConst {
   171  				v := xtype.NegInt(vx)
   172  				return func(fr *frame) { fr.setReg(ir, v) }
   173  			} else {
   174  				return func(fr *frame) {
   175  					v := xtype.NegInt(fr.reg(ix))
   176  					fr.setReg(ir, v)
   177  				}
   178  			}
   179  		case reflect.Int8:
   180  			if kx == kindConst {
   181  				v := xtype.NegInt8(vx)
   182  				return func(fr *frame) { fr.setReg(ir, v) }
   183  			} else {
   184  				return func(fr *frame) {
   185  					v := xtype.NegInt8(fr.reg(ix))
   186  					fr.setReg(ir, v)
   187  				}
   188  			}
   189  		case reflect.Int16:
   190  			if kx == kindConst {
   191  				v := xtype.NegInt16(vx)
   192  				return func(fr *frame) { fr.setReg(ir, v) }
   193  			} else {
   194  				return func(fr *frame) {
   195  					v := xtype.NegInt16(fr.reg(ix))
   196  					fr.setReg(ir, v)
   197  				}
   198  			}
   199  		case reflect.Int32:
   200  			if kx == kindConst {
   201  				v := xtype.NegInt32(vx)
   202  				return func(fr *frame) { fr.setReg(ir, v) }
   203  			} else {
   204  				return func(fr *frame) {
   205  					v := xtype.NegInt32(fr.reg(ix))
   206  					fr.setReg(ir, v)
   207  				}
   208  			}
   209  		case reflect.Int64:
   210  			if kx == kindConst {
   211  				v := xtype.NegInt64(vx)
   212  				return func(fr *frame) { fr.setReg(ir, v) }
   213  			} else {
   214  				return func(fr *frame) {
   215  					v := xtype.NegInt64(fr.reg(ix))
   216  					fr.setReg(ir, v)
   217  				}
   218  			}
   219  		case reflect.Uint:
   220  			if kx == kindConst {
   221  				v := xtype.NegUint(vx)
   222  				return func(fr *frame) { fr.setReg(ir, v) }
   223  			} else {
   224  				return func(fr *frame) {
   225  					v := xtype.NegUint(fr.reg(ix))
   226  					fr.setReg(ir, v)
   227  				}
   228  			}
   229  		case reflect.Uint8:
   230  			if kx == kindConst {
   231  				v := xtype.NegUint8(vx)
   232  				return func(fr *frame) { fr.setReg(ir, v) }
   233  			} else {
   234  				return func(fr *frame) {
   235  					v := xtype.NegUint8(fr.reg(ix))
   236  					fr.setReg(ir, v)
   237  				}
   238  			}
   239  		case reflect.Uint16:
   240  			if kx == kindConst {
   241  				v := xtype.NegUint16(vx)
   242  				return func(fr *frame) { fr.setReg(ir, v) }
   243  			} else {
   244  				return func(fr *frame) {
   245  					v := xtype.NegUint16(fr.reg(ix))
   246  					fr.setReg(ir, v)
   247  				}
   248  			}
   249  		case reflect.Uint32:
   250  			if kx == kindConst {
   251  				v := xtype.NegUint32(vx)
   252  				return func(fr *frame) { fr.setReg(ir, v) }
   253  			} else {
   254  				return func(fr *frame) {
   255  					v := xtype.NegUint32(fr.reg(ix))
   256  					fr.setReg(ir, v)
   257  				}
   258  			}
   259  		case reflect.Uint64:
   260  			if kx == kindConst {
   261  				v := xtype.NegUint64(vx)
   262  				return func(fr *frame) { fr.setReg(ir, v) }
   263  			} else {
   264  				return func(fr *frame) {
   265  					v := xtype.NegUint64(fr.reg(ix))
   266  					fr.setReg(ir, v)
   267  				}
   268  			}
   269  		case reflect.Uintptr:
   270  			if kx == kindConst {
   271  				v := xtype.NegUintptr(vx)
   272  				return func(fr *frame) { fr.setReg(ir, v) }
   273  			} else {
   274  				return func(fr *frame) {
   275  					v := xtype.NegUintptr(fr.reg(ix))
   276  					fr.setReg(ir, v)
   277  				}
   278  			}
   279  		case reflect.Float32:
   280  			if kx == kindConst {
   281  				v := xtype.NegFloat32(vx)
   282  				return func(fr *frame) { fr.setReg(ir, v) }
   283  			} else {
   284  				return func(fr *frame) {
   285  					v := xtype.NegFloat32(fr.reg(ix))
   286  					fr.setReg(ir, v)
   287  				}
   288  			}
   289  		case reflect.Float64:
   290  			if kx == kindConst {
   291  				v := xtype.NegFloat64(vx)
   292  				return func(fr *frame) { fr.setReg(ir, v) }
   293  			} else {
   294  				return func(fr *frame) {
   295  					v := xtype.NegFloat64(fr.reg(ix))
   296  					fr.setReg(ir, v)
   297  				}
   298  			}
   299  		case reflect.Complex64:
   300  			if kx == kindConst {
   301  				v := xtype.NegComplex64(vx)
   302  				return func(fr *frame) { fr.setReg(ir, v) }
   303  			} else {
   304  				return func(fr *frame) {
   305  					v := xtype.NegComplex64(fr.reg(ix))
   306  					fr.setReg(ir, v)
   307  				}
   308  			}
   309  		case reflect.Complex128:
   310  			if kx == kindConst {
   311  				v := xtype.NegComplex128(vx)
   312  				return func(fr *frame) { fr.setReg(ir, v) }
   313  			} else {
   314  				return func(fr *frame) {
   315  					v := xtype.NegComplex128(fr.reg(ix))
   316  					fr.setReg(ir, v)
   317  				}
   318  			}
   319  		}
   320  	}
   321  	panic("unreachable")
   322  }
   323  func makeUnOpXOR(pfn *function, instr *ssa.UnOp) func(fr *frame) {
   324  	ir := pfn.regIndex(instr)
   325  	ix, kx, vx := pfn.regIndex3(instr.X)
   326  	typ := pfn.Interp.preToType(instr.Type())
   327  	if typ.PkgPath() == "" {
   328  		switch typ.Kind() {
   329  		case reflect.Int:
   330  			if kx == kindConst {
   331  				v := ^vx.(int)
   332  				return func(fr *frame) { fr.setReg(ir, v) }
   333  			} else {
   334  				return func(fr *frame) {
   335  					v := ^fr.reg(ix).(int)
   336  					fr.setReg(ir, v)
   337  				}
   338  			}
   339  		case reflect.Int8:
   340  			if kx == kindConst {
   341  				v := ^vx.(int8)
   342  				return func(fr *frame) { fr.setReg(ir, v) }
   343  			} else {
   344  				return func(fr *frame) {
   345  					v := ^fr.reg(ix).(int8)
   346  					fr.setReg(ir, v)
   347  				}
   348  			}
   349  		case reflect.Int16:
   350  			if kx == kindConst {
   351  				v := ^vx.(int16)
   352  				return func(fr *frame) { fr.setReg(ir, v) }
   353  			} else {
   354  				return func(fr *frame) {
   355  					v := ^fr.reg(ix).(int16)
   356  					fr.setReg(ir, v)
   357  				}
   358  			}
   359  		case reflect.Int32:
   360  			if kx == kindConst {
   361  				v := ^vx.(int32)
   362  				return func(fr *frame) { fr.setReg(ir, v) }
   363  			} else {
   364  				return func(fr *frame) {
   365  					v := ^fr.reg(ix).(int32)
   366  					fr.setReg(ir, v)
   367  				}
   368  			}
   369  		case reflect.Int64:
   370  			if kx == kindConst {
   371  				v := ^vx.(int64)
   372  				return func(fr *frame) { fr.setReg(ir, v) }
   373  			} else {
   374  				return func(fr *frame) {
   375  					v := ^fr.reg(ix).(int64)
   376  					fr.setReg(ir, v)
   377  				}
   378  			}
   379  		case reflect.Uint:
   380  			if kx == kindConst {
   381  				v := ^vx.(uint)
   382  				return func(fr *frame) { fr.setReg(ir, v) }
   383  			} else {
   384  				return func(fr *frame) {
   385  					v := ^fr.reg(ix).(uint)
   386  					fr.setReg(ir, v)
   387  				}
   388  			}
   389  		case reflect.Uint8:
   390  			if kx == kindConst {
   391  				v := ^vx.(uint8)
   392  				return func(fr *frame) { fr.setReg(ir, v) }
   393  			} else {
   394  				return func(fr *frame) {
   395  					v := ^fr.reg(ix).(uint8)
   396  					fr.setReg(ir, v)
   397  				}
   398  			}
   399  		case reflect.Uint16:
   400  			if kx == kindConst {
   401  				v := ^vx.(uint16)
   402  				return func(fr *frame) { fr.setReg(ir, v) }
   403  			} else {
   404  				return func(fr *frame) {
   405  					v := ^fr.reg(ix).(uint16)
   406  					fr.setReg(ir, v)
   407  				}
   408  			}
   409  		case reflect.Uint32:
   410  			if kx == kindConst {
   411  				v := ^vx.(uint32)
   412  				return func(fr *frame) { fr.setReg(ir, v) }
   413  			} else {
   414  				return func(fr *frame) {
   415  					v := ^fr.reg(ix).(uint32)
   416  					fr.setReg(ir, v)
   417  				}
   418  			}
   419  		case reflect.Uint64:
   420  			if kx == kindConst {
   421  				v := ^vx.(uint64)
   422  				return func(fr *frame) { fr.setReg(ir, v) }
   423  			} else {
   424  				return func(fr *frame) {
   425  					v := ^fr.reg(ix).(uint64)
   426  					fr.setReg(ir, v)
   427  				}
   428  			}
   429  		case reflect.Uintptr:
   430  			if kx == kindConst {
   431  				v := ^vx.(uintptr)
   432  				return func(fr *frame) { fr.setReg(ir, v) }
   433  			} else {
   434  				return func(fr *frame) {
   435  					v := ^fr.reg(ix).(uintptr)
   436  					fr.setReg(ir, v)
   437  				}
   438  			}
   439  		}
   440  	} else {
   441  		switch typ.Kind() {
   442  		case reflect.Int:
   443  			if kx == kindConst {
   444  				v := xtype.XorInt(vx)
   445  				return func(fr *frame) { fr.setReg(ir, v) }
   446  			} else {
   447  				return func(fr *frame) {
   448  					v := xtype.XorInt(fr.reg(ix))
   449  					fr.setReg(ir, v)
   450  				}
   451  			}
   452  		case reflect.Int8:
   453  			if kx == kindConst {
   454  				v := xtype.XorInt8(vx)
   455  				return func(fr *frame) { fr.setReg(ir, v) }
   456  			} else {
   457  				return func(fr *frame) {
   458  					v := xtype.XorInt8(fr.reg(ix))
   459  					fr.setReg(ir, v)
   460  				}
   461  			}
   462  		case reflect.Int16:
   463  			if kx == kindConst {
   464  				v := xtype.XorInt16(vx)
   465  				return func(fr *frame) { fr.setReg(ir, v) }
   466  			} else {
   467  				return func(fr *frame) {
   468  					v := xtype.XorInt16(fr.reg(ix))
   469  					fr.setReg(ir, v)
   470  				}
   471  			}
   472  		case reflect.Int32:
   473  			if kx == kindConst {
   474  				v := xtype.XorInt32(vx)
   475  				return func(fr *frame) { fr.setReg(ir, v) }
   476  			} else {
   477  				return func(fr *frame) {
   478  					v := xtype.XorInt32(fr.reg(ix))
   479  					fr.setReg(ir, v)
   480  				}
   481  			}
   482  		case reflect.Int64:
   483  			if kx == kindConst {
   484  				v := xtype.XorInt64(vx)
   485  				return func(fr *frame) { fr.setReg(ir, v) }
   486  			} else {
   487  				return func(fr *frame) {
   488  					v := xtype.XorInt64(fr.reg(ix))
   489  					fr.setReg(ir, v)
   490  				}
   491  			}
   492  		case reflect.Uint:
   493  			if kx == kindConst {
   494  				v := xtype.XorUint(vx)
   495  				return func(fr *frame) { fr.setReg(ir, v) }
   496  			} else {
   497  				return func(fr *frame) {
   498  					v := xtype.XorUint(fr.reg(ix))
   499  					fr.setReg(ir, v)
   500  				}
   501  			}
   502  		case reflect.Uint8:
   503  			if kx == kindConst {
   504  				v := xtype.XorUint8(vx)
   505  				return func(fr *frame) { fr.setReg(ir, v) }
   506  			} else {
   507  				return func(fr *frame) {
   508  					v := xtype.XorUint8(fr.reg(ix))
   509  					fr.setReg(ir, v)
   510  				}
   511  			}
   512  		case reflect.Uint16:
   513  			if kx == kindConst {
   514  				v := xtype.XorUint16(vx)
   515  				return func(fr *frame) { fr.setReg(ir, v) }
   516  			} else {
   517  				return func(fr *frame) {
   518  					v := xtype.XorUint16(fr.reg(ix))
   519  					fr.setReg(ir, v)
   520  				}
   521  			}
   522  		case reflect.Uint32:
   523  			if kx == kindConst {
   524  				v := xtype.XorUint32(vx)
   525  				return func(fr *frame) { fr.setReg(ir, v) }
   526  			} else {
   527  				return func(fr *frame) {
   528  					v := xtype.XorUint32(fr.reg(ix))
   529  					fr.setReg(ir, v)
   530  				}
   531  			}
   532  		case reflect.Uint64:
   533  			if kx == kindConst {
   534  				v := xtype.XorUint64(vx)
   535  				return func(fr *frame) { fr.setReg(ir, v) }
   536  			} else {
   537  				return func(fr *frame) {
   538  					v := xtype.XorUint64(fr.reg(ix))
   539  					fr.setReg(ir, v)
   540  				}
   541  			}
   542  		case reflect.Uintptr:
   543  			if kx == kindConst {
   544  				v := xtype.XorUintptr(vx)
   545  				return func(fr *frame) { fr.setReg(ir, v) }
   546  			} else {
   547  				return func(fr *frame) {
   548  					v := xtype.XorUintptr(fr.reg(ix))
   549  					fr.setReg(ir, v)
   550  				}
   551  			}
   552  		}
   553  	}
   554  	panic("unreachable")
   555  }