1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// This input was created by taking the instruction productions in
// the old assembler's (6a's) grammar and hand-writing complete
// instructions for each rule, to guarantee we cover the same space.
#include "../../../../../runtime/textflag.h"
TEXT foo(SB), DUPOK|NOSPLIT, $0
// LTYPE1 nonrem { outcode($1, &$2); }
NEGQ R11
NEGQ 4(R11)
NEGQ foo+4(SB)
// LTYPE2 rimnon { outcode($1, &$2); }
INT $4
DIVB R11
DIVB 4(R11)
DIVB foo+4(SB)
// LTYPE3 rimrem { outcode($1, &$2); }
SUBQ $4, DI
SUBQ R11, DI
SUBQ 4(R11), DI
SUBQ foo+4(SB), DI
SUBQ $4, 8(R12)
SUBQ R11, 8(R12)
SUBQ R11, foo+4(SB)
// LTYPE4 remrim { outcode($1, &$2); }
CMPB CX, $4
// LTYPER nonrel { outcode($1, &$2); }
label:
JB -4(PC) // JCS -4(PC)
JB label // JCS 17
// LTYPEC spec3 { outcode($1, &$2); }
JCS 2(PC)
JMP -4(PC)
JCS 2(PC)
JMP label // JMP 17
JCS 2(PC)
JMP foo+4(SB)
JCS 2(PC)
JMP bar<>+4(SB)
JCS 2(PC)
JMP bar<>+4(SB)(R11*4)
JCS 2(PC)
JMP *4(SP) // JMP 4(SP)
JCS 2(PC)
JMP *(R12) // JMP (R12)
JCS 2(PC)
// JMP *(R12*4) // TODO: This line is silently dropped on the floor!
JCS 2(PC)
JMP *(R12)(R13*4) // JMP (R12)(R13*4)
JCS 2(PC)
JMP *(AX) // JMP (AX)
JCS 2(PC)
JMP *(SP) // JMP (SP)
JCS 2(PC)
// JMP *(AX*4) // TODO: This line is silently dropped on the floor!
JCS 2(PC)
JMP *(AX)(AX*4) // JMP (AX)(AX*4)
JCS 2(PC)
JMP 4(SP)
JCS 2(PC)
JMP (R12)
JCS 2(PC)
// JMP (R12*4) // TODO: This line is silently dropped on the floor!
JCS 2(PC)
JMP (R12)(R13*4)
JCS 2(PC)
JMP (AX)
JCS 2(PC)
JMP (SP)
JCS 2(PC)
// JMP (AX*4) // TODO: This line is silently dropped on the floor!
JCS 2(PC)
JMP (AX)(AX*4)
JCS 2(PC)
JMP R13
// LTYPEN spec4 { outcode($1, &$2); }
NOP
NOP AX
NOP foo+4(SB)
// LTYPES spec5 { outcode($1, &$2); }
SHLL CX, R12
SHLL CX, foo+4(SB)
// Old syntax, still accepted:
SHLL CX, R11:AX // SHLL CX, AX, R11
// LTYPEM spec6 { outcode($1, &$2); }
MOVL AX, R11
MOVL $4, R11
// MOVL AX, 0(AX):DS // no longer works - did it ever?
// LTYPEI spec7 { outcode($1, &$2); }
IMULB DX
IMULW DX, BX
IMULL R11, R12
IMULQ foo+4(SB), R11
// LTYPEXC spec8 { outcode($1, &$2); }
CMPPD X1, X2, 4
CMPPD foo+4(SB), X2, 4
// LTYPEX spec9 { outcode($1, &$2); }
PINSRW $4, AX, X2
PINSRW $4, foo+4(SB), X2
// LTYPERT spec10 { outcode($1, &$2); }
JCS 2(PC)
RETFL $4
// Was bug: LOOP is a branch instruction.
JCS 2(PC)
loop:
LOOP loop // LOOP
// Intel pseudonyms for our own renamings.
PADDD M2, M1 // PADDL M2, M1
MOVDQ2Q X1, M1 // MOVQ X1, M1
MOVNTDQ X1, (AX) // MOVNTO X1, (AX)
MOVOA (AX), X1 // MOVO (AX), X1
// Tests for SP indexed addresses.
MOVQ foo(SP)(AX*1), BX // 488b1c04
MOVQ foo+32(SP)(CX*2), DX // 488b544c20
MOVQ foo+32323(SP)(R8*4), R9 // 4e8b8c84437e0000
MOVL foo(SP)(SI*8), DI // 8b3cf4
MOVL foo+32(SP)(R10*1), R11 // 468b5c1420
MOVL foo+32323(SP)(R12*2), R13 // 468bac64437e0000
MOVW foo(SP)(AX*4), R8 // 66448b0484
MOVW foo+32(SP)(R9*8), CX // 66428b4ccc20
MOVW foo+32323(SP)(AX*1), DX // 668b9404437e0000
MOVB foo(SP)(AX*2), AL // 8a0444
MOVB foo+32(SP)(CX*4), AH // 8a648c20
MOVB foo+32323(SP)(CX*8), R9 // 448a8ccc437e0000
// Tests for TLS reference.
MOVQ (TLS), AX
MOVQ 8(TLS), DX
// LTYPE0 nonnon { outcode($1, &$2); }
RET // c3
RET foo(SB)
|
