multiply.go

     1  // asmcheck
     2  
     3  // Copyright 2024 The Go Authors. All rights reserved.
     4  // Use of this source code is governed by a BSD-style
     5  // license that can be found in the LICENSE file.
     6  
     7  package codegen
     8  
     9  // This file contains codegen tests related to strength
    10  // reduction of integer multiply.
    11  
    12  func m0(x int64) int64 {
    13  	// amd64: "XORL"
    14  	// arm64: "MOVD ZR"
    15  	// loong64: "MOVV R0"
    16  	return x * 0
    17  }
    18  func m2(x int64) int64 {
    19  	// amd64: "ADDQ"
    20  	// arm64: "ADD"
    21  	// loong64: "ADDVU"
    22  	return x * 2
    23  }
    24  func m3(x int64) int64 {
    25  	// amd64: "LEAQ .*[*]2"
    26  	// arm64: "ADD R[0-9]+<<1,"
    27  	// loong64: "ALSLV [$]1,"
    28  	return x * 3
    29  }
    30  func m4(x int64) int64 {
    31  	// amd64: "SHLQ [$]2,"
    32  	// arm64: "LSL [$]2,"
    33  	// loong64: "SLLV [$]2,"
    34  	return x * 4
    35  }
    36  func m5(x int64) int64 {
    37  	// amd64: "LEAQ .*[*]4"
    38  	// arm64: "ADD R[0-9]+<<2,"
    39  	// loong64: "ALSLV [$]2,"
    40  	return x * 5
    41  }
    42  func m6(x int64) int64 {
    43  	// amd64: "LEAQ .*[*]1", "LEAQ .*[*]2"
    44  	// arm64: "ADD R[0-9]+,", "ADD R[0-9]+<<1,"
    45  	// loong64: "ADDVU", "ADDVU", "ADDVU"
    46  	return x * 6
    47  }
    48  func m7(x int64) int64 {
    49  	// amd64: "LEAQ .*[*]2"
    50  	// arm64: "LSL [$]3,", "SUB R[0-9]+,"
    51  	// loong64: "ALSLV [$]1,", "ALSLV [$]1,"
    52  	return x * 7
    53  }
    54  func m8(x int64) int64 {
    55  	// amd64: "SHLQ [$]3,"
    56  	// arm64: "LSL [$]3,"
    57  	// loong64: "SLLV [$]3,"
    58  	return x * 8
    59  }
    60  func m9(x int64) int64 {
    61  	// amd64: "LEAQ .*[*]8"
    62  	// arm64: "ADD R[0-9]+<<3,"
    63  	// loong64: "ALSLV [$]3,"
    64  	return x * 9
    65  }
    66  func m10(x int64) int64 {
    67  	// amd64: "LEAQ .*[*]1", "LEAQ .*[*]4"
    68  	// arm64: "ADD R[0-9]+,", "ADD R[0-9]+<<2,"
    69  	// loong64: "ADDVU", "ALSLV [$]2,"
    70  	return x * 10
    71  }
    72  func m11(x int64) int64 {
    73  	// amd64: "LEAQ .*[*]4", "LEAQ .*[*]2"
    74  	// arm64: "MOVD [$]11,", "MUL"
    75  	// loong64: "ALSLV [$]2,", "ALSLV [$]1,"
    76  	return x * 11
    77  }
    78  func m12(x int64) int64 {
    79  	// amd64: "LEAQ .*[*]2", "SHLQ [$]2,"
    80  	// arm64: "LSL [$]2,", "ADD R[0-9]+<<1,"
    81  	// loong64: "SLLV", "ALSLV [$]1,"
    82  	return x * 12
    83  }
    84  func m13(x int64) int64 {
    85  	// amd64: "LEAQ .*[*]2", "LEAQ .*[*]4"
    86  	// arm64: "MOVD [$]13,", "MUL"
    87  	// loong64: "ALSLV [$]1,", "ALSLV [$]2,"
    88  	return x * 13
    89  }
    90  func m14(x int64) int64 {
    91  	// amd64: "IMUL3Q [$]14,"
    92  	// arm64: "LSL [$]4,", "SUB R[0-9]+<<1,"
    93  	// loong64: "ADDVU", "ALSLV [$]1", "ALSLV [$]2"
    94  	return x * 14
    95  }
    96  func m15(x int64) int64 {
    97  	// amd64: "LEAQ .*[*]2", "LEAQ .*[*]4"
    98  	// arm64: "LSL [$]4,", "SUB R[0-9]+,"
    99  	// loong64: "ALSLV [$]1,", "ALSLV [$]2,"
   100  	return x * 15
   101  }
   102  func m16(x int64) int64 {
   103  	// amd64: "SHLQ [$]4,"
   104  	// arm64: "LSL [$]4,"
   105  	// loong64: "SLLV [$]4,"
   106  	return x * 16
   107  }
   108  func m17(x int64) int64 {
   109  	// amd64: "LEAQ .*[*]1", "LEAQ .*[*]8"
   110  	// arm64: "ADD R[0-9]+<<4,"
   111  	// loong64: "ALSLV [$]"
   112  	return x * 17
   113  }
   114  func m18(x int64) int64 {
   115  	// amd64: "LEAQ .*[*]1", "LEAQ .*[*]8"
   116  	// arm64: "ADD R[0-9]+,", "ADD R[0-9]+<<3,"
   117  	// loong64: "ADDVU", "ALSLV [$]3,"
   118  	return x * 18
   119  }
   120  func m19(x int64) int64 {
   121  	// amd64: "LEAQ .*[*]8", "LEAQ .*[*]2"
   122  	// arm64: "MOVD [$]19,", "MUL"
   123  	// loong64: "ALSLV [$]3,", "ALSLV [$]1,"
   124  	return x * 19
   125  }
   126  func m20(x int64) int64 {
   127  	// amd64: "LEAQ .*[*]4", "SHLQ [$]2,"
   128  	// arm64: "LSL [$]2,", "ADD R[0-9]+<<2,"
   129  	// loong64: "SLLV [$]2,", "ALSLV [$]2," 
   130  	return x * 20
   131  }
   132  func m21(x int64) int64 {
   133  	// amd64: "LEAQ .*[*]4", "LEAQ .*[*]4"
   134  	// arm64: "MOVD [$]21,", "MUL"
   135  	// loong64: "ALSLV [$]2,", "ALSLV [$]2,"
   136  	return x * 21
   137  }
   138  func m22(x int64) int64 {
   139  	// amd64: "IMUL3Q [$]22,"
   140  	// arm64: "MOVD [$]22,", "MUL"
   141  	// loong64: "ADDVU", "ALSLV [$]2,", "ALSLV [$]2,"
   142  	return x * 22
   143  }
   144  func m23(x int64) int64 {
   145  	// amd64: "IMUL3Q [$]23,"
   146  	// arm64: "MOVD [$]23,", "MUL"
   147  	// loong64: "ALSLV [$]1,", "SUBVU", "ALSLV [$]3,"
   148  	return x * 23
   149  }
   150  func m24(x int64) int64 {
   151  	// amd64: "LEAQ .*[*]2", "SHLQ [$]3,"
   152  	// arm64: "LSL [$]3,", "ADD R[0-9]+<<1,"
   153  	// loong64: "SLLV [$]3", "ALSLV [$]1,"
   154  	return x * 24
   155  }
   156  func m25(x int64) int64 {
   157  	// amd64: "LEAQ .*[*]4", "LEAQ .*[*]4"
   158  	// arm64: "MOVD [$]25,", "MUL"
   159  	// loong64: "ALSLV [$]2,", "ALSLV [$]2,"
   160  	return x * 25
   161  }
   162  func m26(x int64) int64 {
   163  	// amd64: "IMUL3Q [$]26,"
   164  	// arm64: "MOVD [$]26,", "MUL"
   165  	// loong64: "ADDVU", "ALSLV [$]1,", "ALSLV [$]3,"
   166  	return x * 26
   167  }
   168  func m27(x int64) int64 {
   169  	// amd64: "LEAQ .*[*]2", "LEAQ .*[*]8"
   170  	// arm64: "MOVD [$]27,", "MUL"
   171  	// loong64: "ALSLV [$]1,", "ALSLV [$]3,"
   172  	return x * 27
   173  }
   174  func m28(x int64) int64 {
   175  	// amd64: "IMUL3Q [$]28,"
   176  	// arm64: "LSL [$]5, "SUB R[0-9]+<<2,"
   177  	// loong64: "ALSLV [$]1," "SLLV [$]2," "ALSLV [$]3,"
   178  	return x * 28
   179  }
   180  func m29(x int64) int64 {
   181  	// amd64: "IMUL3Q [$]29,"
   182  	// arm64: "MOVD [$]29,", "MUL"
   183  	// loong64: "ALSLV [$]1," "SLLV [$]5," "SUBVU"
   184  	return x * 29
   185  }
   186  func m30(x int64) int64 {
   187  	// amd64: "IMUL3Q [$]30,"
   188  	// arm64: "LSL [$]5,", "SUB R[0-9]+<<1,"
   189  	// loong64: "ADDVU" "SLLV [$]5," "SUBVU"
   190  	return x * 30
   191  }
   192  func m31(x int64) int64 {
   193  	// amd64: "SHLQ [$]5,", "SUBQ"
   194  	// arm64: "LSL [$]5,", "SUB R[0-9]+,"
   195  	// loong64: "SLLV [$]5," "SUBVU"
   196  	return x * 31
   197  }
   198  func m32(x int64) int64 {
   199  	// amd64: "SHLQ [$]5,"
   200  	// arm64: "LSL [$]5,"
   201  	// loong64: "SLLV [$]5,"
   202  	return x * 32
   203  }
   204  func m33(x int64) int64 {
   205  	// amd64: "SHLQ [$]2,", "LEAQ .*[*]8"
   206  	// arm64: "ADD R[0-9]+<<5,"
   207  	// loong64: "ADDVU", "ALSLV [$]4,"
   208  	return x * 33
   209  }
   210  func m34(x int64) int64 {
   211  	// amd64: "SHLQ [$]5,", "LEAQ .*[*]2"
   212  	// arm64: "ADD R[0-9]+,", "ADD R[0-9]+<<4,"
   213  	// loong64: "ADDVU", "ALSLV [$]4,"
   214  	return x * 34
   215  }
   216  func m35(x int64) int64 {
   217  	// amd64: "IMUL3Q [$]35,"
   218  	// arm64: "MOVD [$]35,", "MUL"
   219  	// loong64: "ALSLV [$]4,", "ALSLV [$]1,"
   220  	return x * 35
   221  }
   222  func m36(x int64) int64 {
   223  	// amd64: "LEAQ .*[*]8", "SHLQ [$]2,"
   224  	// arm64: "LSL [$]2,", "ADD R[0-9]+<<3,"
   225  	// loong64: "SLLV [$]2,", "ALSLV [$]3,"
   226  	return x * 36
   227  }
   228  func m37(x int64) int64 {
   229  	// amd64: "LEAQ .*[*]8", "LEAQ .*[*]4"
   230  	// arm64: "MOVD [$]37,", "MUL"
   231  	// loong64: "ALSLV [$]3,", "ALSLV [$]2,"
   232  	return x * 37
   233  }
   234  func m38(x int64) int64 {
   235  	// amd64: "IMUL3Q [$]38,"
   236  	// arm64: "MOVD [$]38,", "MUL"
   237  	// loong64: "ALSLV [$]3,", "ALSLV [$]2,"
   238  	return x * 38
   239  }
   240  func m39(x int64) int64 {
   241  	// amd64: "IMUL3Q [$]39,"
   242  	// arm64: "MOVD [$]39,", "MUL"
   243  	// loong64: "ALSLV [$]2,", "SUBVU", "ALSLV [$]3,"
   244  	return x * 39
   245  }
   246  func m40(x int64) int64 {
   247  	// amd64: "LEAQ .*[*]4", "SHLQ [$]3,"
   248  	// arm64: "LSL [$]3,", "ADD R[0-9]+<<2,"
   249  	// loong64: "SLLV [$]3,", "ALSLV [$]2,"
   250  	return x * 40
   251  }
   252  
   253  func mn1(x int64) int64 {
   254  	// amd64: "NEGQ "
   255  	// arm64: "NEG R[0-9]+,"
   256  	// loong64: "SUBVU R[0-9], R0,"
   257  	return x * -1
   258  }
   259  func mn2(x int64) int64 {
   260  	// amd64: "NEGQ", "ADDQ"
   261  	// arm64: "NEG R[0-9]+<<1,"
   262  	// loong64: "ADDVU" "SUBVU R[0-9], R0,"
   263  	return x * -2
   264  }
   265  func mn3(x int64) int64 {
   266  	// amd64: "NEGQ", "LEAQ .*[*]2"
   267  	// arm64: "SUB R[0-9]+<<2,"
   268  	// loong64: "SUBVU", "ALSLV [$]1,"
   269  	return x * -3
   270  }
   271  func mn4(x int64) int64 {
   272  	// amd64: "NEGQ", "SHLQ [$]2,"
   273  	// arm64: "NEG R[0-9]+<<2,"
   274  	// loong64: "SLLV [$]2," "SUBVU R[0-9], R0,"
   275  	return x * -4
   276  }
   277  func mn5(x int64) int64 {
   278  	// amd64: "NEGQ", "LEAQ .*[*]4"
   279  	// arm64: "NEG R[0-9]+,", "ADD R[0-9]+<<2,"
   280  	// loong64: "SUBVU", "ALSLV [$]2,"
   281  	return x * -5
   282  }
   283  func mn6(x int64) int64 {
   284  	// amd64: "IMUL3Q [$]-6,"
   285  	// arm64: "ADD R[0-9]+,", "SUB R[0-9]+<<2,"
   286  	// loong64: "ADDVU", "SUBVU", "ALSLV [$]3,"
   287  	return x * -6
   288  }
   289  func mn7(x int64) int64 {
   290  	// amd64: "NEGQ", "LEAQ .*[*]8"
   291  	// arm64: "SUB R[0-9]+<<3,"
   292  	// loong64: "SUBVU", "ALSLV [$]3,"
   293  	return x * -7
   294  }
   295  func mn8(x int64) int64 {
   296  	// amd64: "NEGQ", "SHLQ [$]3,"
   297  	// arm64: "NEG R[0-9]+<<3,"
   298  	// loong64: "SLLV [$]3" "SUBVU R[0-9], R0,"
   299  	return x * -8
   300  }
   301  func mn9(x int64) int64 {
   302  	// amd64: "NEGQ", "LEAQ .*[*]8"
   303  	// arm64: "NEG R[0-9]+,", "ADD R[0-9]+<<3,"
   304  	// loong64: "SUBVU", "ALSLV [$]3,"
   305  	return x * -9
   306  }
   307  func mn10(x int64) int64 {
   308  	// amd64: "IMUL3Q [$]-10,"
   309  	// arm64: "MOVD [$]-10,", "MUL"
   310  	// loong64: "ADDVU", "ALSLV [$]3", "SUBVU"
   311  	return x * -10
   312  }
   313  func mn11(x int64) int64 {
   314  	// amd64: "IMUL3Q [$]-11,"
   315  	// arm64: "MOVD [$]-11,", "MUL"
   316  	// loong64: "ALSLV [$]2,", "SUBVU", "ALSLV [$]4,"
   317  	return x * -11
   318  }
   319  func mn12(x int64) int64 {
   320  	// amd64: "IMUL3Q [$]-12,"
   321  	// arm64: "LSL [$]2,", "SUB R[0-9]+<<2,"
   322  	// loong64: "SUBVU", "SLLV [$]2,", "ALSLV [$]4,"
   323  	return x * -12
   324  }
   325  func mn13(x int64) int64 {
   326  	// amd64: "IMUL3Q [$]-13,"
   327  	// arm64: "MOVD [$]-13,", "MUL"
   328  	// loong64: "ALSLV [$]4,", "SLLV [$]2, ", "SUBVU"
   329  	return x * -13
   330  }
   331  func mn14(x int64) int64 {
   332  	// amd64: "IMUL3Q [$]-14,"
   333  	// arm64: "ADD R[0-9]+,", "SUB R[0-9]+<<3,"
   334  	// loong64: "ADDVU", "SUBVU", "ALSLV [$]4,"
   335  	return x * -14
   336  }
   337  func mn15(x int64) int64 {
   338  	// amd64: "SHLQ [$]4,", "SUBQ"
   339  	// arm64: "SUB R[0-9]+<<4,"
   340  	// loong64: "SUBVU", "ALSLV [$]4,"
   341  	return x * -15
   342  }
   343  func mn16(x int64) int64 {
   344  	// amd64: "NEGQ", "SHLQ [$]4,"
   345  	// arm64: "NEG R[0-9]+<<4,"
   346  	// loong64: "SLLV [$]4," "SUBVU R[0-9], R0,"
   347  	return x * -16
   348  }
   349  func mn17(x int64) int64 {
   350  	// amd64: "IMUL3Q [$]-17,"
   351  	// arm64: "NEG R[0-9]+,", "ADD R[0-9]+<<4,"
   352  	// loong64: "SUBVU", "ALSLV [$]4,"
   353  	return x * -17
   354  }
   355  func mn18(x int64) int64 {
   356  	// amd64: "IMUL3Q [$]-18,"
   357  	// arm64: "MOVD [$]-18,", "MUL"
   358  	// loong64: "ADDVU", "ALSLV [$]4,", "SUBVU"
   359  	return x * -18
   360  }
   361  func mn19(x int64) int64 {
   362  	// amd64: "IMUL3Q [$]-19,"
   363  	// arm64: "MOVD [$]-19,", "MUL"
   364  	// loong64: "ALSLV [$]1,", "ALSLV [$]4,", "SUBVU"
   365  	return x * -19
   366  }
   367  func mn20(x int64) int64 {
   368  	// amd64: "IMUL3Q [$]-20,"
   369  	// arm64: "MOVD [$]-20,", "MUL"
   370  	// loong64: "SLLV [$]2,", "ALSLV [$]4,", "SUBVU"
   371  	return x * -20
   372  }
   373
View as plain text