mapaccess.go

     1  // asmcheck
     2  
     3  // Copyright 2018 The Go Authors. All rights reserved.
     4  // Use of this source code is governed by a BSD-style
     5  // license that can be found in the LICENSE file.
     6  
     7  package codegen
     8  
     9  // These tests check that mapaccess calls are not used.
    10  // Issues #23661 and #24364.
    11  
    12  func mapCompoundAssignmentInt8() {
    13  	m := make(map[int8]int8, 0)
    14  	var k int8 = 0
    15  
    16  	// 386:-".*mapaccess"
    17  	// amd64:-".*mapaccess"
    18  	// arm:-".*mapaccess"
    19  	// arm64:-".*mapaccess"
    20  	m[k] += 67
    21  
    22  	// 386:-".*mapaccess"
    23  	// amd64:-".*mapaccess"
    24  	// arm:-".*mapaccess"
    25  	// arm64:-".*mapaccess"
    26  	m[k] -= 123
    27  
    28  	// 386:-".*mapaccess"
    29  	// amd64:-".*mapaccess"
    30  	// arm:-".*mapaccess"
    31  	// arm64:-".*mapaccess"
    32  	m[k] *= 45
    33  
    34  	// 386:-".*mapaccess"
    35  	// amd64:-".*mapaccess"
    36  	// arm:-".*mapaccess"
    37  	// arm64:-".*mapaccess"
    38  	m[k] |= 78
    39  
    40  	// 386:-".*mapaccess"
    41  	// amd64:-".*mapaccess"
    42  	// arm:-".*mapaccess"
    43  	// arm64:-".*mapaccess"
    44  	m[k] ^= 89
    45  
    46  	// 386:-".*mapaccess"
    47  	// amd64:-".*mapaccess"
    48  	// arm:-".*mapaccess"
    49  	// arm64:-".*mapaccess"
    50  	m[k] <<= 9
    51  
    52  	// 386:-".*mapaccess"
    53  	// amd64:-".*mapaccess"
    54  	// arm:-".*mapaccess"
    55  	// arm64:-".*mapaccess"
    56  	m[k] >>= 10
    57  
    58  	// 386:-".*mapaccess"
    59  	// amd64:-".*mapaccess"
    60  	// arm:-".*mapaccess"
    61  	// arm64:-".*mapaccess"
    62  	m[k]++
    63  
    64  	// 386:-".*mapaccess"
    65  	// amd64:-".*mapaccess"
    66  	// arm:-".*mapaccess"
    67  	// arm64:-".*mapaccess"
    68  	m[k]--
    69  }
    70  
    71  func mapCompoundAssignmentInt32() {
    72  	m := make(map[int32]int32, 0)
    73  	var k int32 = 0
    74  
    75  	// 386:-".*mapaccess"
    76  	// amd64:-".*mapaccess"
    77  	// arm:-".*mapaccess"
    78  	// arm64:-".*mapaccess"
    79  	m[k] += 67890
    80  
    81  	// 386:-".*mapaccess"
    82  	// amd64:-".*mapaccess"
    83  	// arm:-".*mapaccess"
    84  	// arm64:-".*mapaccess"
    85  	m[k] -= 123
    86  
    87  	// 386:-".*mapaccess"
    88  	// amd64:-".*mapaccess"
    89  	// arm:-".*mapaccess"
    90  	// arm64:-".*mapaccess"
    91  	m[k] *= 456
    92  
    93  	// 386:-".*mapaccess"
    94  	// amd64:-".*mapaccess"
    95  	// arm:-".*mapaccess"
    96  	// arm64:-".*mapaccess"
    97  	m[k] |= 78
    98  
    99  	// 386:-".*mapaccess"
   100  	// amd64:-".*mapaccess"
   101  	// arm:-".*mapaccess"
   102  	// arm64:-".*mapaccess"
   103  	m[k] ^= 89
   104  
   105  	// 386:-".*mapaccess"
   106  	// amd64:-".*mapaccess"
   107  	// arm:-".*mapaccess"
   108  	// arm64:-".*mapaccess"
   109  	m[k] <<= 9
   110  
   111  	// 386:-".*mapaccess"
   112  	// amd64:-".*mapaccess"
   113  	// arm:-".*mapaccess"
   114  	// arm64:-".*mapaccess"
   115  	m[k] >>= 10
   116  
   117  	// 386:-".*mapaccess"
   118  	// amd64:-".*mapaccess"
   119  	// arm:-".*mapaccess"
   120  	// arm64:-".*mapaccess"
   121  	m[k]++
   122  
   123  	// 386:-".*mapaccess"
   124  	// amd64:-".*mapaccess"
   125  	// arm:-".*mapaccess"
   126  	// arm64:-".*mapaccess"
   127  	m[k]--
   128  }
   129  
   130  func mapCompoundAssignmentInt64() {
   131  	m := make(map[int64]int64, 0)
   132  	var k int64 = 0
   133  
   134  	// 386:-".*mapaccess"
   135  	// amd64:-".*mapaccess"
   136  	// arm:-".*mapaccess"
   137  	// arm64:-".*mapaccess"
   138  	m[k] += 67890
   139  
   140  	// 386:-".*mapaccess"
   141  	// amd64:-".*mapaccess"
   142  	// arm:-".*mapaccess"
   143  	// arm64:-".*mapaccess"
   144  	m[k] -= 123
   145  
   146  	// 386:-".*mapaccess"
   147  	// amd64:-".*mapaccess"
   148  	// arm:-".*mapaccess"
   149  	// arm64:-".*mapaccess"
   150  	m[k] *= 456
   151  
   152  	// 386:-".*mapaccess"
   153  	// amd64:-".*mapaccess"
   154  	// arm:-".*mapaccess"
   155  	// arm64:-".*mapaccess"
   156  	m[k] |= 78
   157  
   158  	// 386:-".*mapaccess"
   159  	// amd64:-".*mapaccess"
   160  	// arm:-".*mapaccess"
   161  	// arm64:-".*mapaccess"
   162  	m[k] ^= 89
   163  
   164  	// 386:-".*mapaccess"
   165  	// amd64:-".*mapaccess"
   166  	// arm:-".*mapaccess"
   167  	// arm64:-".*mapaccess"
   168  	m[k] <<= 9
   169  
   170  	// 386:-".*mapaccess"
   171  	// amd64:-".*mapaccess"
   172  	// arm:-".*mapaccess"
   173  	// arm64:-".*mapaccess"
   174  	m[k] >>= 10
   175  
   176  	// 386:-".*mapaccess"
   177  	// amd64:-".*mapaccess"
   178  	// arm:-".*mapaccess"
   179  	// arm64:-".*mapaccess"
   180  	m[k]++
   181  
   182  	// 386:-".*mapaccess"
   183  	// amd64:-".*mapaccess"
   184  	// arm:-".*mapaccess"
   185  	// arm64:-".*mapaccess"
   186  	m[k]--
   187  }
   188  
   189  func mapCompoundAssignmentComplex128() {
   190  	m := make(map[complex128]complex128, 0)
   191  	var k complex128 = 0
   192  
   193  	// 386:-".*mapaccess"
   194  	// amd64:-".*mapaccess"
   195  	// arm:-".*mapaccess"
   196  	// arm64:-".*mapaccess"
   197  	m[k] += 67890
   198  
   199  	// 386:-".*mapaccess"
   200  	// amd64:-".*mapaccess"
   201  	// arm:-".*mapaccess"
   202  	// arm64:-".*mapaccess"
   203  	m[k] -= 123
   204  
   205  	// 386:-".*mapaccess"
   206  	// amd64:-".*mapaccess"
   207  	// arm:-".*mapaccess"
   208  	// arm64:-".*mapaccess"
   209  	m[k] *= 456
   210  
   211  	// 386:-".*mapaccess"
   212  	// amd64:-".*mapaccess"
   213  	// arm:-".*mapaccess"
   214  	// arm64:-".*mapaccess"
   215  	m[k]++
   216  
   217  	// 386:-".*mapaccess"
   218  	// amd64:-".*mapaccess"
   219  	// arm:-".*mapaccess"
   220  	// arm64:-".*mapaccess"
   221  	m[k]--
   222  }
   223  
   224  func mapCompoundAssignmentString() {
   225  	m := make(map[string]string, 0)
   226  	var k string = "key"
   227  
   228  	// 386:-".*mapaccess"
   229  	// amd64:-".*mapaccess"
   230  	// arm:-".*mapaccess"
   231  	// arm64:-".*mapaccess"
   232  	m[k] += "value"
   233  }
   234  
   235  var sinkAppend bool
   236  
   237  func mapAppendAssignmentInt8() {
   238  	m := make(map[int8][]int8, 0)
   239  	var k int8 = 0
   240  
   241  	// 386:-".*mapaccess"
   242  	// amd64:-".*mapaccess"
   243  	// arm:-".*mapaccess"
   244  	// arm64:-".*mapaccess"
   245  	m[k] = append(m[k], 1)
   246  
   247  	// 386:-".*mapaccess"
   248  	// amd64:-".*mapaccess"
   249  	// arm:-".*mapaccess"
   250  	// arm64:-".*mapaccess"
   251  	m[k] = append(m[k], 1, 2, 3)
   252  
   253  	a := []int8{7, 8, 9, 0}
   254  
   255  	// 386:-".*mapaccess"
   256  	// amd64:-".*mapaccess"
   257  	// arm:-".*mapaccess"
   258  	// arm64:-".*mapaccess"
   259  	m[k] = append(m[k], a...)
   260  
   261  	// Exceptions
   262  
   263  	// 386:".*mapaccess"
   264  	// amd64:".*mapaccess"
   265  	// arm:".*mapaccess"
   266  	// arm64:".*mapaccess"
   267  	m[k] = append(a, m[k]...)
   268  
   269  	// 386:".*mapaccess"
   270  	// amd64:".*mapaccess"
   271  	// arm:".*mapaccess"
   272  	// arm64:".*mapaccess"
   273  	sinkAppend, m[k] = !sinkAppend, append(m[k], 99)
   274  
   275  	// 386:".*mapaccess"
   276  	// amd64:".*mapaccess"
   277  	// arm:".*mapaccess"
   278  	// arm64:".*mapaccess"
   279  	m[k] = append(m[k+1], 100)
   280  }
   281  
   282  func mapAppendAssignmentInt32() {
   283  	m := make(map[int32][]int32, 0)
   284  	var k int32 = 0
   285  
   286  	// 386:-".*mapaccess"
   287  	// amd64:-".*mapaccess"
   288  	// arm:-".*mapaccess"
   289  	// arm64:-".*mapaccess"
   290  	m[k] = append(m[k], 1)
   291  
   292  	// 386:-".*mapaccess"
   293  	// amd64:-".*mapaccess"
   294  	// arm:-".*mapaccess"
   295  	// arm64:-".*mapaccess"
   296  	m[k] = append(m[k], 1, 2, 3)
   297  
   298  	a := []int32{7, 8, 9, 0}
   299  
   300  	// 386:-".*mapaccess"
   301  	// amd64:-".*mapaccess"
   302  	// arm:-".*mapaccess"
   303  	// arm64:-".*mapaccess"
   304  	m[k] = append(m[k], a...)
   305  
   306  	// 386:-".*mapaccess"
   307  	// amd64:-".*mapaccess"
   308  	// arm:-".*mapaccess"
   309  	// arm64:-".*mapaccess"
   310  	m[k+1] = append(m[k+1], a...)
   311  
   312  	// 386:-".*mapaccess"
   313  	// amd64:-".*mapaccess"
   314  	// arm:-".*mapaccess"
   315  	// arm64:-".*mapaccess"
   316  	m[-k] = append(m[-k], a...)
   317  
   318  	// Exceptions
   319  
   320  	// 386:".*mapaccess"
   321  	// amd64:".*mapaccess"
   322  	// arm:".*mapaccess"
   323  	// arm64:".*mapaccess"
   324  	m[k] = append(a, m[k]...)
   325  
   326  	// 386:".*mapaccess"
   327  	// amd64:".*mapaccess"
   328  	// arm:".*mapaccess"
   329  	// arm64:".*mapaccess"
   330  	sinkAppend, m[k] = !sinkAppend, append(m[k], 99)
   331  
   332  	// 386:".*mapaccess"
   333  	// amd64:".*mapaccess"
   334  	// arm:".*mapaccess"
   335  	// arm64:".*mapaccess"
   336  	m[k] = append(m[k+1], 100)
   337  }
   338  
   339  func mapAppendAssignmentInt64() {
   340  	m := make(map[int64][]int64, 0)
   341  	var k int64 = 0
   342  
   343  	// 386:-".*mapaccess"
   344  	// amd64:-".*mapaccess"
   345  	// arm:-".*mapaccess"
   346  	// arm64:-".*mapaccess"
   347  	m[k] = append(m[k], 1)
   348  
   349  	// 386:-".*mapaccess"
   350  	// amd64:-".*mapaccess"
   351  	// arm:-".*mapaccess"
   352  	// arm64:-".*mapaccess"
   353  	m[k] = append(m[k], 1, 2, 3)
   354  
   355  	a := []int64{7, 8, 9, 0}
   356  
   357  	// 386:-".*mapaccess"
   358  	// amd64:-".*mapaccess"
   359  	// arm:-".*mapaccess"
   360  	// arm64:-".*mapaccess"
   361  	m[k] = append(m[k], a...)
   362  
   363  	// 386:-".*mapaccess"
   364  	// amd64:-".*mapaccess"
   365  	// arm:-".*mapaccess"
   366  	// arm64:-".*mapaccess"
   367  	m[k+1] = append(m[k+1], a...)
   368  
   369  	// 386:-".*mapaccess"
   370  	// amd64:-".*mapaccess"
   371  	// arm:-".*mapaccess"
   372  	// arm64:-".*mapaccess"
   373  	m[-k] = append(m[-k], a...)
   374  
   375  	// Exceptions
   376  
   377  	// 386:".*mapaccess"
   378  	// amd64:".*mapaccess"
   379  	// arm:".*mapaccess"
   380  	// arm64:".*mapaccess"
   381  	m[k] = append(a, m[k]...)
   382  
   383  	// 386:".*mapaccess"
   384  	// amd64:".*mapaccess"
   385  	// arm:".*mapaccess"
   386  	// arm64:".*mapaccess"
   387  	sinkAppend, m[k] = !sinkAppend, append(m[k], 99)
   388  
   389  	// 386:".*mapaccess"
   390  	// amd64:".*mapaccess"
   391  	// arm:".*mapaccess"
   392  	// arm64:".*mapaccess"
   393  	m[k] = append(m[k+1], 100)
   394  }
   395  
   396  func mapAppendAssignmentComplex128() {
   397  	m := make(map[complex128][]complex128, 0)
   398  	var k complex128 = 0
   399  
   400  	// 386:-".*mapaccess"
   401  	// amd64:-".*mapaccess"
   402  	// arm:-".*mapaccess"
   403  	// arm64:-".*mapaccess"
   404  	m[k] = append(m[k], 1)
   405  
   406  	// 386:-".*mapaccess"
   407  	// amd64:-".*mapaccess"
   408  	// arm:-".*mapaccess"
   409  	// arm64:-".*mapaccess"
   410  	m[k] = append(m[k], 1, 2, 3)
   411  
   412  	a := []complex128{7, 8, 9, 0}
   413  
   414  	// 386:-".*mapaccess"
   415  	// amd64:-".*mapaccess"
   416  	// arm:-".*mapaccess"
   417  	// arm64:-".*mapaccess"
   418  	m[k] = append(m[k], a...)
   419  
   420  	// Exceptions
   421  
   422  	// 386:".*mapaccess"
   423  	// amd64:".*mapaccess"
   424  	// arm:".*mapaccess"
   425  	// arm64:".*mapaccess"
   426  	m[k] = append(a, m[k]...)
   427  
   428  	// 386:".*mapaccess"
   429  	// amd64:".*mapaccess"
   430  	// arm:".*mapaccess"
   431  	// arm64:".*mapaccess"
   432  	sinkAppend, m[k] = !sinkAppend, append(m[k], 99)
   433  
   434  	// 386:".*mapaccess"
   435  	// amd64:".*mapaccess"
   436  	// arm:".*mapaccess"
   437  	// arm64:".*mapaccess"
   438  	m[k] = append(m[k+1], 100)
   439  }
   440  
   441  func mapAppendAssignmentString() {
   442  	m := make(map[string][]string, 0)
   443  	var k string = "key"
   444  
   445  	// 386:-".*mapaccess"
   446  	// amd64:-".*mapaccess"
   447  	// arm:-".*mapaccess"
   448  	// arm64:-".*mapaccess"
   449  	m[k] = append(m[k], "1")
   450  
   451  	// 386:-".*mapaccess"
   452  	// amd64:-".*mapaccess"
   453  	// arm:-".*mapaccess"
   454  	// arm64:-".*mapaccess"
   455  	m[k] = append(m[k], "1", "2", "3")
   456  
   457  	a := []string{"7", "8", "9", "0"}
   458  
   459  	// 386:-".*mapaccess"
   460  	// amd64:-".*mapaccess"
   461  	// arm:-".*mapaccess"
   462  	// arm64:-".*mapaccess"
   463  	m[k] = append(m[k], a...)
   464  
   465  	// Exceptions
   466  
   467  	// 386:".*mapaccess"
   468  	// amd64:".*mapaccess"
   469  	// arm:".*mapaccess"
   470  	// arm64:".*mapaccess"
   471  	m[k] = append(a, m[k]...)
   472  
   473  	// 386:".*mapaccess"
   474  	// amd64:".*mapaccess"
   475  	// arm:".*mapaccess"
   476  	// arm64:".*mapaccess"
   477  	sinkAppend, m[k] = !sinkAppend, append(m[k], "99")
   478  
   479  	// 386:".*mapaccess"
   480  	// amd64:".*mapaccess"
   481  	// arm:".*mapaccess"
   482  	// arm64:".*mapaccess"
   483  	m[k] = append(m[k+"1"], "100")
   484  }
   485
View as plain text