github.com/sbinet/go@v0.0.0-20160827155028-54d7de7dd62b/src/cmd/asm/internal/asm/operand_test.go (about)

     1  // Copyright 2015 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package asm
     6  
     7  import (
     8  	"os"
     9  	"testing"
    10  
    11  	"cmd/asm/internal/arch"
    12  	"cmd/asm/internal/lex"
    13  	"cmd/internal/obj"
    14  )
    15  
    16  // A simple in-out test: Do we print what we parse?
    17  
    18  func setArch(goarch string) (*arch.Arch, *obj.Link) {
    19  	os.Setenv("GOOS", "linux") // obj can handle this OS for all architectures.
    20  	os.Setenv("GOARCH", goarch)
    21  	architecture := arch.Set(goarch)
    22  	if architecture == nil {
    23  		panic("asm: unrecognized architecture " + goarch)
    24  	}
    25  	return architecture, obj.Linknew(architecture.LinkArch)
    26  }
    27  
    28  func newParser(goarch string) *Parser {
    29  	architecture, ctxt := setArch(goarch)
    30  	return NewParser(ctxt, architecture, nil)
    31  }
    32  
    33  func testOperandParser(t *testing.T, parser *Parser, tests []operandTest) {
    34  	for _, test := range tests {
    35  		parser.start(lex.Tokenize(test.input))
    36  		addr := obj.Addr{}
    37  		parser.operand(&addr)
    38  		result := obj.Dconv(&emptyProg, &addr)
    39  		if result != test.output {
    40  			t.Errorf("fail at %s: got %s; expected %s\n", test.input, result, test.output)
    41  		}
    42  	}
    43  }
    44  
    45  func TestAMD64OperandParser(t *testing.T) {
    46  	parser := newParser("amd64")
    47  	testOperandParser(t, parser, amd64OperandTests)
    48  }
    49  
    50  func Test386OperandParser(t *testing.T) {
    51  	parser := newParser("386")
    52  	testOperandParser(t, parser, x86OperandTests)
    53  }
    54  
    55  func TestARMOperandParser(t *testing.T) {
    56  	parser := newParser("arm")
    57  	testOperandParser(t, parser, armOperandTests)
    58  }
    59  func TestARM64OperandParser(t *testing.T) {
    60  	parser := newParser("arm64")
    61  	testOperandParser(t, parser, arm64OperandTests)
    62  }
    63  
    64  func TestPPC64OperandParser(t *testing.T) {
    65  	parser := newParser("ppc64")
    66  	testOperandParser(t, parser, ppc64OperandTests)
    67  }
    68  
    69  func TestMIPS64OperandParser(t *testing.T) {
    70  	parser := newParser("mips64")
    71  	testOperandParser(t, parser, mips64OperandTests)
    72  }
    73  
    74  func TestS390XOperandParser(t *testing.T) {
    75  	parser := newParser("s390x")
    76  	testOperandParser(t, parser, s390xOperandTests)
    77  }
    78  
    79  type operandTest struct {
    80  	input, output string
    81  }
    82  
    83  // Examples collected by scanning all the assembly in the standard repo.
    84  
    85  var amd64OperandTests = []operandTest{
    86  	{"$(-1.0)", "$(-1.0)"},
    87  	{"$(0.0)", "$(0.0)"},
    88  	{"$(0x2000000+116)", "$33554548"},
    89  	{"$(0x3F<<7)", "$8064"},
    90  	{"$(112+8)", "$120"},
    91  	{"$(1<<63)", "$-9223372036854775808"},
    92  	{"$-1", "$-1"},
    93  	{"$0", "$0"},
    94  	{"$0-0", "$0"},
    95  	{"$0-16", "$-16"},
    96  	{"$0x000FFFFFFFFFFFFF", "$4503599627370495"},
    97  	{"$0x01", "$1"},
    98  	{"$0x02", "$2"},
    99  	{"$0x04", "$4"},
   100  	{"$0x3FE", "$1022"},
   101  	{"$0x7fffffe00000", "$140737486258176"},
   102  	{"$0xfffffffffffff001", "$-4095"},
   103  	{"$1", "$1"},
   104  	{"$1.0", "$(1.0)"},
   105  	{"$10", "$10"},
   106  	{"$1000", "$1000"},
   107  	{"$1000000", "$1000000"},
   108  	{"$1000000000", "$1000000000"},
   109  	{"$__tsan_func_enter(SB)", "$__tsan_func_enter(SB)"},
   110  	{"$main(SB)", "$main(SB)"},
   111  	{"$masks<>(SB)", "$masks<>(SB)"},
   112  	{"$setg_gcc<>(SB)", "$setg_gcc<>(SB)"},
   113  	{"$shifts<>(SB)", "$shifts<>(SB)"},
   114  	{"$~(1<<63)", "$9223372036854775807"},
   115  	{"$~0x3F", "$-64"},
   116  	{"$~15", "$-16"},
   117  	{"(((8)&0xf)*4)(SP)", "32(SP)"},
   118  	{"(((8-14)&0xf)*4)(SP)", "40(SP)"},
   119  	{"(6+8)(AX)", "14(AX)"},
   120  	{"(8*4)(BP)", "32(BP)"},
   121  	{"(AX)", "(AX)"},
   122  	{"(AX)(CX*8)", "(AX)(CX*8)"},
   123  	{"(BP)(CX*4)", "(BP)(CX*4)"},
   124  	{"(BP)(DX*4)", "(BP)(DX*4)"},
   125  	{"(BP)(R8*4)", "(BP)(R8*4)"},
   126  	{"(BX)", "(BX)"},
   127  	{"(DI)", "(DI)"},
   128  	{"(DI)(BX*1)", "(DI)(BX*1)"},
   129  	{"(DX)", "(DX)"},
   130  	{"(R9)", "(R9)"},
   131  	{"(R9)(BX*8)", "(R9)(BX*8)"},
   132  	{"(SI)", "(SI)"},
   133  	{"(SI)(BX*1)", "(SI)(BX*1)"},
   134  	{"(SI)(DX*1)", "(SI)(DX*1)"},
   135  	{"(SP)", "(SP)"},
   136  	{"(SP)(AX*4)", "(SP)(AX*4)"},
   137  	{"32(SP)(BX*2)", "32(SP)(BX*2)"},
   138  	{"32323(SP)(R8*4)", "32323(SP)(R8*4)"},
   139  	{"+3(PC)", "3(PC)"},
   140  	{"-1(DI)(BX*1)", "-1(DI)(BX*1)"},
   141  	{"-3(PC)", "-3(PC)"},
   142  	{"-64(SI)(BX*1)", "-64(SI)(BX*1)"},
   143  	{"-96(SI)(BX*1)", "-96(SI)(BX*1)"},
   144  	{"AL", "AL"},
   145  	{"AX", "AX"},
   146  	{"BP", "BP"},
   147  	{"BX", "BX"},
   148  	{"CX", "CX"},
   149  	{"DI", "DI"},
   150  	{"DX", "DX"},
   151  	{"R10", "R10"},
   152  	{"R10", "R10"},
   153  	{"R11", "R11"},
   154  	{"R12", "R12"},
   155  	{"R13", "R13"},
   156  	{"R14", "R14"},
   157  	{"R15", "R15"},
   158  	{"R8", "R8"},
   159  	{"R9", "R9"},
   160  	{"SI", "SI"},
   161  	{"SP", "SP"},
   162  	{"X0", "X0"},
   163  	{"X1", "X1"},
   164  	{"X10", "X10"},
   165  	{"X11", "X11"},
   166  	{"X12", "X12"},
   167  	{"X13", "X13"},
   168  	{"X14", "X14"},
   169  	{"X15", "X15"},
   170  	{"X2", "X2"},
   171  	{"X3", "X3"},
   172  	{"X4", "X4"},
   173  	{"X5", "X5"},
   174  	{"X6", "X6"},
   175  	{"X7", "X7"},
   176  	{"X8", "X8"},
   177  	{"X9", "X9"},
   178  	{"_expand_key_128<>(SB)", "_expand_key_128<>(SB)"},
   179  	{"_seek<>(SB)", "_seek<>(SB)"},
   180  	{"a2+16(FP)", "a2+16(FP)"},
   181  	{"addr2+24(FP)", "addr2+24(FP)"},
   182  	{"asmcgocall<>(SB)", "asmcgocall<>(SB)"},
   183  	{"b+24(FP)", "b+24(FP)"},
   184  	{"b_len+32(FP)", "b_len+32(FP)"},
   185  	{"racecall<>(SB)", "racecall<>(SB)"},
   186  	{"rcv_name+20(FP)", "rcv_name+20(FP)"},
   187  	{"retoffset+28(FP)", "retoffset+28(FP)"},
   188  	{"runtime·_GetStdHandle(SB)", "runtime._GetStdHandle(SB)"},
   189  	{"sync\u2215atomic·AddInt64(SB)", "sync/atomic.AddInt64(SB)"},
   190  	{"timeout+20(FP)", "timeout+20(FP)"},
   191  	{"ts+16(FP)", "ts+16(FP)"},
   192  	{"x+24(FP)", "x+24(FP)"},
   193  	{"x·y(SB)", "x.y(SB)"},
   194  	{"x·y(SP)", "x.y(SP)"},
   195  	{"x·y+8(SB)", "x.y+8(SB)"},
   196  	{"x·y+8(SP)", "x.y+8(SP)"},
   197  	{"y+56(FP)", "y+56(FP)"},
   198  	{"·AddUint32(SB)", "\"\".AddUint32(SB)"},
   199  	{"·callReflect(SB)", "\"\".callReflect(SB)"},
   200  	{"[):[o-FP", ""}, // Issue 12469 - asm hung parsing the o-FP range on non ARM platforms.
   201  }
   202  
   203  var x86OperandTests = []operandTest{
   204  	{"$(2.928932188134524e-01)", "$(0.29289321881345243)"},
   205  	{"$-1", "$-1"},
   206  	{"$0", "$0"},
   207  	{"$0x00000000", "$0"},
   208  	{"$runtime·badmcall(SB)", "$runtime.badmcall(SB)"},
   209  	{"$setg_gcc<>(SB)", "$setg_gcc<>(SB)"},
   210  	{"$~15", "$-16"},
   211  	{"(-64*1024+104)(SP)", "-65432(SP)"},
   212  	{"(0*4)(BP)", "(BP)"},
   213  	{"(1*4)(DI)", "4(DI)"},
   214  	{"(4*4)(BP)", "16(BP)"},
   215  	{"(AX)", "(AX)"},
   216  	{"(BP)(CX*4)", "(BP)(CX*4)"},
   217  	{"(BP*8)", "0(BP*8)"},
   218  	{"(BX)", "(BX)"},
   219  	{"(SP)", "(SP)"},
   220  	{"*AX", "AX"}, // TODO: Should make * illegal here; a simple alias for JMP AX.
   221  	{"*runtime·_GetStdHandle(SB)", "*runtime._GetStdHandle(SB)"},
   222  	{"-(4+12)(DI)", "-16(DI)"},
   223  	{"-1(DI)(BX*1)", "-1(DI)(BX*1)"},
   224  	{"-96(DI)(BX*1)", "-96(DI)(BX*1)"},
   225  	{"0(AX)", "(AX)"},
   226  	{"0(BP)", "(BP)"},
   227  	{"0(BX)", "(BX)"},
   228  	{"4(AX)", "4(AX)"},
   229  	{"AL", "AL"},
   230  	{"AX", "AX"},
   231  	{"BP", "BP"},
   232  	{"BX", "BX"},
   233  	{"CX", "CX"},
   234  	{"DI", "DI"},
   235  	{"DX", "DX"},
   236  	{"F0", "F0"},
   237  	{"GS", "GS"},
   238  	{"SI", "SI"},
   239  	{"SP", "SP"},
   240  	{"X0", "X0"},
   241  	{"X1", "X1"},
   242  	{"X2", "X2"},
   243  	{"X3", "X3"},
   244  	{"X4", "X4"},
   245  	{"X5", "X5"},
   246  	{"X6", "X6"},
   247  	{"X7", "X7"},
   248  	{"asmcgocall<>(SB)", "asmcgocall<>(SB)"},
   249  	{"ax+4(FP)", "ax+4(FP)"},
   250  	{"ptime-12(SP)", "ptime-12(SP)"},
   251  	{"runtime·_NtWaitForSingleObject(SB)", "runtime._NtWaitForSingleObject(SB)"},
   252  	{"s(FP)", "s(FP)"},
   253  	{"sec+4(FP)", "sec+4(FP)"},
   254  	{"shifts<>(SB)(CX*8)", "shifts<>(SB)(CX*8)"},
   255  	{"x+4(FP)", "x+4(FP)"},
   256  	{"·AddUint32(SB)", "\"\".AddUint32(SB)"},
   257  	{"·reflectcall(SB)", "\"\".reflectcall(SB)"},
   258  	{"[):[o-FP", ""}, // Issue 12469 - asm hung parsing the o-FP range on non ARM platforms.
   259  }
   260  
   261  var armOperandTests = []operandTest{
   262  	{"$0", "$0"},
   263  	{"$256", "$256"},
   264  	{"(R0)", "(R0)"},
   265  	{"(R11)", "(R11)"},
   266  	{"(g)", "(g)"},
   267  	{"-12(R4)", "-12(R4)"},
   268  	{"0(PC)", "0(PC)"},
   269  	{"1024", "1024"},
   270  	{"12(R(1))", "12(R1)"},
   271  	{"12(R13)", "12(R13)"},
   272  	{"R0", "R0"},
   273  	{"R0->(32-1)", "R0->31"},
   274  	{"R0<<R1", "R0<<R1"},
   275  	{"R0>>R(1)", "R0>>R1"},
   276  	{"R0@>(32-1)", "R0@>31"},
   277  	{"R1", "R1"},
   278  	{"R11", "R11"},
   279  	{"R12", "R12"},
   280  	{"R13", "R13"},
   281  	{"R14", "R14"},
   282  	{"R15", "R15"},
   283  	{"R1<<2(R3)", "R1<<2(R3)"},
   284  	{"R(1)<<2(R(3))", "R1<<2(R3)"},
   285  	{"R2", "R2"},
   286  	{"R3", "R3"},
   287  	{"R4", "R4"},
   288  	{"R(4)", "R4"},
   289  	{"R5", "R5"},
   290  	{"R6", "R6"},
   291  	{"R7", "R7"},
   292  	{"R8", "R8"},
   293  	{"[R0,R1,g,R15]", "[R0,R1,g,R15]"},
   294  	{"[R0-R7]", "[R0,R1,R2,R3,R4,R5,R6,R7]"},
   295  	{"[R(0)-R(7)]", "[R0,R1,R2,R3,R4,R5,R6,R7]"},
   296  	{"[R0]", "[R0]"},
   297  	{"[R1-R12]", "[R1,R2,R3,R4,R5,R6,R7,R8,R9,g,R11,R12]"},
   298  	{"armCAS64(SB)", "armCAS64(SB)"},
   299  	{"asmcgocall<>(SB)", "asmcgocall<>(SB)"},
   300  	{"c+28(FP)", "c+28(FP)"},
   301  	{"g", "g"},
   302  	{"gosave<>(SB)", "gosave<>(SB)"},
   303  	{"retlo+12(FP)", "retlo+12(FP)"},
   304  	{"runtime·_sfloat2(SB)", "runtime._sfloat2(SB)"},
   305  	{"·AddUint32(SB)", "\"\".AddUint32(SB)"},
   306  	{"(R1, R3)", "(R1, R3)"},
   307  	{"[R0,R1,g,R15", ""}, // Issue 11764 - asm hung parsing ']' missing register lists.
   308  	{"[):[o-FP", ""},     // Issue 12469 - there was no infinite loop for ARM; these are just sanity checks.
   309  	{"[):[R0-FP", ""},
   310  	{"(", ""}, // Issue 12466 - backed up before beginning of line.
   311  }
   312  
   313  var ppc64OperandTests = []operandTest{
   314  	{"$((1<<63)-1)", "$9223372036854775807"},
   315  	{"$(-64*1024)", "$-65536"},
   316  	{"$(1024 * 8)", "$8192"},
   317  	{"$-1", "$-1"},
   318  	{"$-24(R4)", "$-24(R4)"},
   319  	{"$0", "$0"},
   320  	{"$0(R1)", "$(R1)"},
   321  	{"$0.5", "$(0.5)"},
   322  	{"$0x7000", "$28672"},
   323  	{"$0x88888eef", "$2290650863"},
   324  	{"$1", "$1"},
   325  	{"$_main<>(SB)", "$_main<>(SB)"},
   326  	{"$argframe(FP)", "$argframe(FP)"},
   327  	{"$runtime·tlsg(SB)", "$runtime.tlsg(SB)"},
   328  	{"$~3", "$-4"},
   329  	{"(-288-3*8)(R1)", "-312(R1)"},
   330  	{"(16)(R7)", "16(R7)"},
   331  	{"(8)(g)", "8(g)"},
   332  	{"(CTR)", "(CTR)"},
   333  	{"(R0)", "(R0)"},
   334  	{"(R3)", "(R3)"},
   335  	{"(R4)", "(R4)"},
   336  	{"(R5)", "(R5)"},
   337  	{"(R5)(R6*1)", "(R5)(R6*1)"},
   338  	{"(R5+R6)", "(R5)(R6*1)"}, // Old syntax.
   339  	{"-1(R4)", "-1(R4)"},
   340  	{"-1(R5)", "-1(R5)"},
   341  	{"6(PC)", "6(PC)"},
   342  	{"CR7", "CR7"},
   343  	{"CTR", "CTR"},
   344  	{"F14", "F14"},
   345  	{"F15", "F15"},
   346  	{"F16", "F16"},
   347  	{"F17", "F17"},
   348  	{"F18", "F18"},
   349  	{"F19", "F19"},
   350  	{"F20", "F20"},
   351  	{"F21", "F21"},
   352  	{"F22", "F22"},
   353  	{"F23", "F23"},
   354  	{"F24", "F24"},
   355  	{"F25", "F25"},
   356  	{"F26", "F26"},
   357  	{"F27", "F27"},
   358  	{"F28", "F28"},
   359  	{"F29", "F29"},
   360  	{"F30", "F30"},
   361  	{"F31", "F31"},
   362  	{"LR", "LR"},
   363  	{"R0", "R0"},
   364  	{"R1", "R1"},
   365  	{"R11", "R11"},
   366  	{"R12", "R12"},
   367  	{"R13", "R13"},
   368  	{"R14", "R14"},
   369  	{"R15", "R15"},
   370  	{"R16", "R16"},
   371  	{"R17", "R17"},
   372  	{"R18", "R18"},
   373  	{"R19", "R19"},
   374  	{"R2", "R2"},
   375  	{"R20", "R20"},
   376  	{"R21", "R21"},
   377  	{"R22", "R22"},
   378  	{"R23", "R23"},
   379  	{"R24", "R24"},
   380  	{"R25", "R25"},
   381  	{"R26", "R26"},
   382  	{"R27", "R27"},
   383  	{"R28", "R28"},
   384  	{"R29", "R29"},
   385  	{"R3", "R3"},
   386  	{"R31", "R31"},
   387  	{"R4", "R4"},
   388  	{"R5", "R5"},
   389  	{"R6", "R6"},
   390  	{"R7", "R7"},
   391  	{"R8", "R8"},
   392  	{"R9", "R9"},
   393  	{"SPR(269)", "SPR(269)"},
   394  	{"a(FP)", "a(FP)"},
   395  	{"g", "g"},
   396  	{"ret+8(FP)", "ret+8(FP)"},
   397  	{"runtime·abort(SB)", "runtime.abort(SB)"},
   398  	{"·AddUint32(SB)", "\"\".AddUint32(SB)"},
   399  	{"·trunc(SB)", "\"\".trunc(SB)"},
   400  	{"[):[o-FP", ""}, // Issue 12469 - asm hung parsing the o-FP range on non ARM platforms.
   401  }
   402  
   403  var arm64OperandTests = []operandTest{
   404  	{"$0", "$0"},
   405  	{"$0.5", "$(0.5)"},
   406  	{"0(R26)", "(R26)"},
   407  	{"0(RSP)", "(RSP)"},
   408  	{"$1", "$1"},
   409  	{"$-1", "$-1"},
   410  	{"$1000", "$1000"},
   411  	{"$1000000000", "$1000000000"},
   412  	{"$0x7fff3c000", "$34358935552"},
   413  	{"$1234", "$1234"},
   414  	{"$~15", "$-16"},
   415  	{"$16", "$16"},
   416  	{"-16(RSP)", "-16(RSP)"},
   417  	{"16(RSP)", "16(RSP)"},
   418  	{"1(R1)", "1(R1)"},
   419  	{"-1(R4)", "-1(R4)"},
   420  	{"18740(R5)", "18740(R5)"},
   421  	{"$2", "$2"},
   422  	{"$-24(R4)", "$-24(R4)"},
   423  	{"-24(RSP)", "-24(RSP)"},
   424  	{"$24(RSP)", "$24(RSP)"},
   425  	{"-32(RSP)", "-32(RSP)"},
   426  	{"$48", "$48"},
   427  	{"$(-64*1024)(R7)", "$-65536(R7)"},
   428  	{"$(8-1)", "$7"},
   429  	{"a+0(FP)", "a(FP)"},
   430  	{"a1+8(FP)", "a1+8(FP)"},
   431  	{"·AddInt32(SB)", `"".AddInt32(SB)`},
   432  	{"runtime·divWVW(SB)", "runtime.divWVW(SB)"},
   433  	{"$argframe+0(FP)", "$argframe(FP)"},
   434  	{"$asmcgocall<>(SB)", "$asmcgocall<>(SB)"},
   435  	{"EQ", "EQ"},
   436  	{"F29", "F29"},
   437  	{"F3", "F3"},
   438  	{"F30", "F30"},
   439  	{"g", "g"},
   440  	{"LR", "R30"},
   441  	{"(LR)", "(R30)"},
   442  	{"R0", "R0"},
   443  	{"R10", "R10"},
   444  	{"R11", "R11"},
   445  	{"$4503601774854144.0", "$(4503601774854144.0)"},
   446  	{"$runtime·badsystemstack(SB)", "$runtime.badsystemstack(SB)"},
   447  	{"ZR", "ZR"},
   448  	{"(ZR)", "(ZR)"},
   449  	{"(R29, RSP)", "(R29, RSP)"},
   450  	{"[):[o-FP", ""}, // Issue 12469 - asm hung parsing the o-FP range on non ARM platforms.
   451  }
   452  
   453  var mips64OperandTests = []operandTest{
   454  	{"$((1<<63)-1)", "$9223372036854775807"},
   455  	{"$(-64*1024)", "$-65536"},
   456  	{"$(1024 * 8)", "$8192"},
   457  	{"$-1", "$-1"},
   458  	{"$-24(R4)", "$-24(R4)"},
   459  	{"$0", "$0"},
   460  	{"$0(R1)", "$(R1)"},
   461  	{"$0.5", "$(0.5)"},
   462  	{"$0x7000", "$28672"},
   463  	{"$0x88888eef", "$2290650863"},
   464  	{"$1", "$1"},
   465  	{"$_main<>(SB)", "$_main<>(SB)"},
   466  	{"$argframe(FP)", "$argframe(FP)"},
   467  	{"$~3", "$-4"},
   468  	{"(-288-3*8)(R1)", "-312(R1)"},
   469  	{"(16)(R7)", "16(R7)"},
   470  	{"(8)(g)", "8(g)"},
   471  	{"(R0)", "(R0)"},
   472  	{"(R3)", "(R3)"},
   473  	{"(R4)", "(R4)"},
   474  	{"(R5)", "(R5)"},
   475  	{"-1(R4)", "-1(R4)"},
   476  	{"-1(R5)", "-1(R5)"},
   477  	{"6(PC)", "6(PC)"},
   478  	{"F14", "F14"},
   479  	{"F15", "F15"},
   480  	{"F16", "F16"},
   481  	{"F17", "F17"},
   482  	{"F18", "F18"},
   483  	{"F19", "F19"},
   484  	{"F20", "F20"},
   485  	{"F21", "F21"},
   486  	{"F22", "F22"},
   487  	{"F23", "F23"},
   488  	{"F24", "F24"},
   489  	{"F25", "F25"},
   490  	{"F26", "F26"},
   491  	{"F27", "F27"},
   492  	{"F28", "F28"},
   493  	{"F29", "F29"},
   494  	{"F30", "F30"},
   495  	{"F31", "F31"},
   496  	{"R0", "R0"},
   497  	{"R1", "R1"},
   498  	{"R11", "R11"},
   499  	{"R12", "R12"},
   500  	{"R13", "R13"},
   501  	{"R14", "R14"},
   502  	{"R15", "R15"},
   503  	{"R16", "R16"},
   504  	{"R17", "R17"},
   505  	{"R18", "R18"},
   506  	{"R19", "R19"},
   507  	{"R2", "R2"},
   508  	{"R20", "R20"},
   509  	{"R21", "R21"},
   510  	{"R22", "R22"},
   511  	{"R23", "R23"},
   512  	{"R24", "R24"},
   513  	{"R25", "R25"},
   514  	{"R26", "R26"},
   515  	{"R27", "R27"},
   516  	{"R29", "R29"},
   517  	{"R3", "R3"},
   518  	{"R31", "R31"},
   519  	{"R4", "R4"},
   520  	{"R5", "R5"},
   521  	{"R6", "R6"},
   522  	{"R7", "R7"},
   523  	{"R8", "R8"},
   524  	{"R9", "R9"},
   525  	{"LO", "LO"},
   526  	{"a(FP)", "a(FP)"},
   527  	{"g", "g"},
   528  	{"RSB", "RSB"},
   529  	{"ret+8(FP)", "ret+8(FP)"},
   530  	{"runtime·abort(SB)", "runtime.abort(SB)"},
   531  	{"·AddUint32(SB)", "\"\".AddUint32(SB)"},
   532  	{"·trunc(SB)", "\"\".trunc(SB)"},
   533  	{"[):[o-FP", ""}, // Issue 12469 - asm hung parsing the o-FP range on non ARM platforms.
   534  }
   535  
   536  var s390xOperandTests = []operandTest{
   537  	{"$((1<<63)-1)", "$9223372036854775807"},
   538  	{"$(-64*1024)", "$-65536"},
   539  	{"$(1024 * 8)", "$8192"},
   540  	{"$-1", "$-1"},
   541  	{"$-24(R4)", "$-24(R4)"},
   542  	{"$0", "$0"},
   543  	{"$0(R1)", "$(R1)"},
   544  	{"$0.5", "$(0.5)"},
   545  	{"$0x7000", "$28672"},
   546  	{"$0x88888eef", "$2290650863"},
   547  	{"$1", "$1"},
   548  	{"$_main<>(SB)", "$_main<>(SB)"},
   549  	{"$argframe(FP)", "$argframe(FP)"},
   550  	{"$~3", "$-4"},
   551  	{"(-288-3*8)(R1)", "-312(R1)"},
   552  	{"(16)(R7)", "16(R7)"},
   553  	{"(8)(g)", "8(g)"},
   554  	{"(R0)", "(R0)"},
   555  	{"(R3)", "(R3)"},
   556  	{"(R4)", "(R4)"},
   557  	{"(R5)", "(R5)"},
   558  	{"-1(R4)", "-1(R4)"},
   559  	{"-1(R5)", "-1(R5)"},
   560  	{"6(PC)", "6(PC)"},
   561  	{"R0", "R0"},
   562  	{"R1", "R1"},
   563  	{"R2", "R2"},
   564  	{"R3", "R3"},
   565  	{"R4", "R4"},
   566  	{"R5", "R5"},
   567  	{"R6", "R6"},
   568  	{"R7", "R7"},
   569  	{"R8", "R8"},
   570  	{"R9", "R9"},
   571  	{"R10", "R10"},
   572  	{"R11", "R11"},
   573  	{"R12", "R12"},
   574  	// {"R13", "R13"}, R13 is g
   575  	{"R14", "R14"},
   576  	{"R15", "R15"},
   577  	{"F0", "F0"},
   578  	{"F1", "F1"},
   579  	{"F2", "F2"},
   580  	{"F3", "F3"},
   581  	{"F4", "F4"},
   582  	{"F5", "F5"},
   583  	{"F6", "F6"},
   584  	{"F7", "F7"},
   585  	{"F8", "F8"},
   586  	{"F9", "F9"},
   587  	{"F10", "F10"},
   588  	{"F11", "F11"},
   589  	{"F12", "F12"},
   590  	{"F13", "F13"},
   591  	{"F14", "F14"},
   592  	{"F15", "F15"},
   593  	{"V0", "V0"},
   594  	{"V1", "V1"},
   595  	{"V2", "V2"},
   596  	{"V3", "V3"},
   597  	{"V4", "V4"},
   598  	{"V5", "V5"},
   599  	{"V6", "V6"},
   600  	{"V7", "V7"},
   601  	{"V8", "V8"},
   602  	{"V9", "V9"},
   603  	{"V10", "V10"},
   604  	{"V11", "V11"},
   605  	{"V12", "V12"},
   606  	{"V13", "V13"},
   607  	{"V14", "V14"},
   608  	{"V15", "V15"},
   609  	{"V16", "V16"},
   610  	{"V17", "V17"},
   611  	{"V18", "V18"},
   612  	{"V19", "V19"},
   613  	{"V20", "V20"},
   614  	{"V21", "V21"},
   615  	{"V22", "V22"},
   616  	{"V23", "V23"},
   617  	{"V24", "V24"},
   618  	{"V25", "V25"},
   619  	{"V26", "V26"},
   620  	{"V27", "V27"},
   621  	{"V28", "V28"},
   622  	{"V29", "V29"},
   623  	{"V30", "V30"},
   624  	{"V31", "V31"},
   625  	{"a(FP)", "a(FP)"},
   626  	{"g", "g"},
   627  	{"ret+8(FP)", "ret+8(FP)"},
   628  	{"runtime·abort(SB)", "runtime.abort(SB)"},
   629  	{"·AddUint32(SB)", "\"\".AddUint32(SB)"},
   630  	{"·trunc(SB)", "\"\".trunc(SB)"},
   631  	{"[):[o-FP", ""}, // Issue 12469 - asm hung parsing the o-FP range on non ARM platforms.
   632  }