← Back to branch summary

~ubuntu-branches/ubuntu/saucy/golang/saucy

« back to all changes in this revision

Viewing changes to src/pkg/math/big/arith_amd64.s

  • Committer: Package Import Robot
  • Author(s): Adam Conrad
  • Date: 2013-07-08 05:52:37 UTC
  • mfrom: (29.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20130708055237-at01839e0hp8z3ni
Tags: 2:1.1-1ubuntu1
016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/math/big/arith_amd64.s
5
5
// This file provides fast assembly versions for the elementary
6
6
// arithmetic operations on vectors implemented in arith.go.
7
7
 
8
 
// TODO(gri) - experiment with unrolled loops for faster execution
 
8
// Literal instruction for MOVQ $0, CX.
 
9
// (MOVQ $0, reg is translated to XORQ reg, reg and clears CF.)
 
10
#define ZERO_CX BYTE $0x48; \
 
11
                BYTE $0xc7; \
 
12
                BYTE $0xc1; \
 
13
                BYTE $0x00; \
 
14
                BYTE $0x00; \
 
15
                BYTE $0x00; \
 
16
                BYTE $0x00
9
17
 
10
18
// func mulWW(x, y Word) (z1, z0 Word)
11
19
TEXT ·mulWW(SB),7,$0
28
36
 
29
37
// func addVV(z, x, y []Word) (c Word)
30
38
TEXT ·addVV(SB),7,$0
 
39
        MOVQ z_len+8(FP), DI
 
40
        MOVQ x+24(FP), R8
 
41
        MOVQ y+48(FP), R9
31
42
        MOVQ z+0(FP), R10
32
 
        MOVQ x+16(FP), R8
33
 
        MOVQ y+32(FP), R9
34
 
        MOVL n+8(FP), R11
35
 
        MOVQ $0, BX             // i = 0
36
 
        MOVQ $0, DX             // c = 0
37
 
        JMP E1
38
 
 
39
 
L1:     MOVQ (R8)(BX*8), AX
40
 
        RCRQ $1, DX
41
 
        ADCQ (R9)(BX*8), AX
42
 
        RCLQ $1, DX
43
 
        MOVQ AX, (R10)(BX*8)
44
 
        ADDL $1, BX             // i++
45
 
 
46
 
E1:     CMPQ BX, R11            // i < n
47
 
        JL L1
48
 
 
49
 
        MOVQ DX, c+48(FP)
 
43
 
 
44
        MOVQ $0, CX             // c = 0
 
45
        MOVQ $0, SI             // i = 0
 
46
 
 
47
        // s/JL/JMP/ below to disable the unrolled loop
 
48
        SUBQ $4, DI             // n -= 4
 
49
        JL V1                   // if n < 0 goto V1
 
50
 
 
51
U1:     // n >= 0
 
52
        // regular loop body unrolled 4x
 
53
        RCRQ $1, CX             // CF = c
 
54
        MOVQ 0(R8)(SI*8), R11
 
55
        MOVQ 8(R8)(SI*8), R12
 
56
        MOVQ 16(R8)(SI*8), R13
 
57
        MOVQ 24(R8)(SI*8), R14
 
58
        ADCQ 0(R9)(SI*8), R11
 
59
        ADCQ 8(R9)(SI*8), R12
 
60
        ADCQ 16(R9)(SI*8), R13
 
61
        ADCQ 24(R9)(SI*8), R14
 
62
        MOVQ R11, 0(R10)(SI*8)
 
63
        MOVQ R12, 8(R10)(SI*8)
 
64
        MOVQ R13, 16(R10)(SI*8)
 
65
        MOVQ R14, 24(R10)(SI*8)
 
66
        RCLQ $1, CX             // c = CF
 
67
 
 
68
        ADDQ $4, SI             // i += 4
 
69
        SUBQ $4, DI             // n -= 4
 
70
        JGE U1                  // if n >= 0 goto U1
 
71
 
 
72
V1:     ADDQ $4, DI             // n += 4
 
73
        JLE E1                  // if n <= 0 goto E1
 
74
 
 
75
L1:     // n > 0
 
76
        RCRQ $1, CX             // CF = c
 
77
        MOVQ 0(R8)(SI*8), R11
 
78
        ADCQ 0(R9)(SI*8), R11
 
79
        MOVQ R11, 0(R10)(SI*8)
 
80
        RCLQ $1, CX             // c = CF
 
81
 
 
82
        ADDQ $1, SI             // i++
 
83
        SUBQ $1, DI             // n--
 
84
        JG L1                   // if n > 0 goto L1
 
85
 
 
86
E1:     MOVQ CX, c+72(FP)       // return c
50
87
        RET
51
88
 
52
89
 
53
90
// func subVV(z, x, y []Word) (c Word)
54
 
// (same as addVV_s except for SBBQ instead of ADCQ and label names)
 
91
// (same as addVV except for SBBQ instead of ADCQ and label names)
55
92
TEXT ·subVV(SB),7,$0
 
93
        MOVQ z_len+8(FP), DI
 
94
        MOVQ x+24(FP), R8
 
95
        MOVQ y+48(FP), R9
56
96
        MOVQ z+0(FP), R10
57
 
        MOVQ x+16(FP), R8
58
 
        MOVQ y+32(FP), R9
59
 
        MOVL n+8(FP), R11
60
 
        MOVQ $0, BX             // i = 0
61
 
        MOVQ $0, DX             // c = 0
62
 
        JMP E2
63
 
 
64
 
L2:     MOVQ (R8)(BX*8), AX
65
 
        RCRQ $1, DX
66
 
        SBBQ (R9)(BX*8), AX
67
 
        RCLQ $1, DX
68
 
        MOVQ AX, (R10)(BX*8)
69
 
        ADDL $1, BX             // i++
70
 
 
71
 
E2:     CMPQ BX, R11            // i < n
72
 
        JL L2
73
 
 
74
 
        MOVQ DX, c+48(FP)
 
97
 
 
98
        MOVQ $0, CX             // c = 0
 
99
        MOVQ $0, SI             // i = 0
 
100
 
 
101
        // s/JL/JMP/ below to disable the unrolled loop
 
102
        SUBQ $4, DI             // n -= 4
 
103
        JL V2                   // if n < 0 goto V2
 
104
 
 
105
U2:     // n >= 0
 
106
        // regular loop body unrolled 4x
 
107
        RCRQ $1, CX             // CF = c
 
108
        MOVQ 0(R8)(SI*8), R11
 
109
        MOVQ 8(R8)(SI*8), R12
 
110
        MOVQ 16(R8)(SI*8), R13
 
111
        MOVQ 24(R8)(SI*8), R14
 
112
        SBBQ 0(R9)(SI*8), R11
 
113
        SBBQ 8(R9)(SI*8), R12
 
114
        SBBQ 16(R9)(SI*8), R13
 
115
        SBBQ 24(R9)(SI*8), R14
 
116
        MOVQ R11, 0(R10)(SI*8)
 
117
        MOVQ R12, 8(R10)(SI*8)
 
118
        MOVQ R13, 16(R10)(SI*8)
 
119
        MOVQ R14, 24(R10)(SI*8)
 
120
        RCLQ $1, CX             // c = CF
 
121
 
 
122
        ADDQ $4, SI             // i += 4
 
123
        SUBQ $4, DI             // n -= 4
 
124
        JGE U2                  // if n >= 0 goto U2
 
125
 
 
126
V2:     ADDQ $4, DI             // n += 4
 
127
        JLE E2                  // if n <= 0 goto E2
 
128
 
 
129
L2:     // n > 0
 
130
        RCRQ $1, CX             // CF = c
 
131
        MOVQ 0(R8)(SI*8), R11
 
132
        SBBQ 0(R9)(SI*8), R11
 
133
        MOVQ R11, 0(R10)(SI*8)
 
134
        RCLQ $1, CX             // c = CF
 
135
 
 
136
        ADDQ $1, SI             // i++
 
137
        SUBQ $1, DI             // n--
 
138
        JG L2                   // if n > 0 goto L2
 
139
 
 
140
E2:     MOVQ CX, c+72(FP)       // return c
75
141
        RET
76
142
 
77
143
 
78
144
// func addVW(z, x []Word, y Word) (c Word)
79
145
TEXT ·addVW(SB),7,$0
 
146
        MOVQ z_len+8(FP), DI
 
147
        MOVQ x+24(FP), R8
 
148
        MOVQ y+48(FP), CX       // c = y
80
149
        MOVQ z+0(FP), R10
81
 
        MOVQ x+16(FP), R8
82
 
        MOVQ y+32(FP), AX       // c = y
83
 
        MOVL n+8(FP), R11
84
 
        MOVQ $0, BX             // i = 0
85
 
        JMP E3
86
 
 
87
 
L3:     ADDQ (R8)(BX*8), AX
88
 
        MOVQ AX, (R10)(BX*8)
89
 
        RCLQ $1, AX
90
 
        ANDQ $1, AX
91
 
        ADDL $1, BX             // i++
92
 
 
93
 
E3:     CMPQ BX, R11            // i < n
94
 
        JL L3
95
 
 
96
 
        MOVQ AX, c+40(FP)
 
150
 
 
151
        MOVQ $0, SI             // i = 0
 
152
 
 
153
        // s/JL/JMP/ below to disable the unrolled loop
 
154
        SUBQ $4, DI             // n -= 4
 
155
        JL V3                   // if n < 4 goto V3
 
156
 
 
157
U3:     // n >= 0
 
158
        // regular loop body unrolled 4x
 
159
        MOVQ 0(R8)(SI*8), R11
 
160
        MOVQ 8(R8)(SI*8), R12
 
161
        MOVQ 16(R8)(SI*8), R13
 
162
        MOVQ 24(R8)(SI*8), R14
 
163
        ADDQ CX, R11
 
164
        ZERO_CX
 
165
        ADCQ $0, R12
 
166
        ADCQ $0, R13
 
167
        ADCQ $0, R14
 
168
        SETCS CX                // c = CF
 
169
        MOVQ R11, 0(R10)(SI*8)
 
170
        MOVQ R12, 8(R10)(SI*8)
 
171
        MOVQ R13, 16(R10)(SI*8)
 
172
        MOVQ R14, 24(R10)(SI*8)
 
173
 
 
174
        ADDQ $4, SI             // i += 4
 
175
        SUBQ $4, DI             // n -= 4
 
176
        JGE U3                  // if n >= 0 goto U3
 
177
 
 
178
V3:     ADDQ $4, DI             // n += 4
 
179
        JLE E3                  // if n <= 0 goto E3
 
180
 
 
181
L3:     // n > 0
 
182
        ADDQ 0(R8)(SI*8), CX
 
183
        MOVQ CX, 0(R10)(SI*8)
 
184
        ZERO_CX
 
185
        RCLQ $1, CX             // c = CF
 
186
 
 
187
        ADDQ $1, SI             // i++
 
188
        SUBQ $1, DI             // n--
 
189
        JG L3                   // if n > 0 goto L3
 
190
 
 
191
E3:     MOVQ CX, c+56(FP)       // return c
97
192
        RET
98
193
 
99
194
 
100
195
// func subVW(z, x []Word, y Word) (c Word)
 
196
// (same as addVW except for SUBQ/SBBQ instead of ADDQ/ADCQ and label names)
101
197
TEXT ·subVW(SB),7,$0
 
198
        MOVQ z_len+8(FP), DI
 
199
        MOVQ x+24(FP), R8
 
200
        MOVQ y+48(FP), CX       // c = y
102
201
        MOVQ z+0(FP), R10
103
 
        MOVQ x+16(FP), R8
104
 
        MOVQ y+32(FP), AX       // c = y
105
 
        MOVL n+8(FP), R11
106
 
        MOVQ $0, BX             // i = 0
107
 
        JMP E4
108
 
 
109
 
L4:     MOVQ (R8)(BX*8), DX     // TODO(gri) is there a reverse SUBQ?
110
 
        SUBQ AX, DX
111
 
        MOVQ DX, (R10)(BX*8)
112
 
        RCLQ $1, AX
113
 
        ANDQ $1, AX
114
 
        ADDL $1, BX             // i++
115
 
 
116
 
E4:     CMPQ BX, R11            // i < n
117
 
        JL L4
118
 
 
119
 
        MOVQ AX, c+40(FP)
 
202
        
 
203
        MOVQ $0, SI             // i = 0
 
204
 
 
205
        // s/JL/JMP/ below to disable the unrolled loop
 
206
        SUBQ $4, DI             // n -= 4
 
207
        JL V4                   // if n < 4 goto V4
 
208
 
 
209
U4:     // n >= 0
 
210
        // regular loop body unrolled 4x
 
211
        MOVQ 0(R8)(SI*8), R11
 
212
        MOVQ 8(R8)(SI*8), R12
 
213
        MOVQ 16(R8)(SI*8), R13
 
214
        MOVQ 24(R8)(SI*8), R14
 
215
        SUBQ CX, R11
 
216
        ZERO_CX
 
217
        SBBQ $0, R12
 
218
        SBBQ $0, R13
 
219
        SBBQ $0, R14
 
220
        SETCS CX                // c = CF
 
221
        MOVQ R11, 0(R10)(SI*8)
 
222
        MOVQ R12, 8(R10)(SI*8)
 
223
        MOVQ R13, 16(R10)(SI*8)
 
224
        MOVQ R14, 24(R10)(SI*8)
 
225
 
 
226
        ADDQ $4, SI             // i += 4
 
227
        SUBQ $4, DI             // n -= 4
 
228
        JGE U4                  // if n >= 0 goto U4
 
229
 
 
230
V4:     ADDQ $4, DI             // n += 4
 
231
        JLE E4                  // if n <= 0 goto E4
 
232
 
 
233
L4:     // n > 0
 
234
        MOVQ 0(R8)(SI*8), R11
 
235
        SUBQ CX, R11
 
236
        MOVQ R11, 0(R10)(SI*8)
 
237
        ZERO_CX
 
238
        RCLQ $1, CX             // c = CF
 
239
 
 
240
        ADDQ $1, SI             // i++
 
241
        SUBQ $1, DI             // n--
 
242
        JG L4                   // if n > 0 goto L4
 
243
 
 
244
E4:     MOVQ CX, c+56(FP)       // return c
120
245
        RET
121
246
 
122
247
 
123
248
// func shlVU(z, x []Word, s uint) (c Word)
124
249
TEXT ·shlVU(SB),7,$0
125
 
        MOVL n+8(FP), BX        // i = n
126
 
        SUBL $1, BX             // i--
 
250
        MOVQ z_len+8(FP), BX    // i = z
 
251
        SUBQ $1, BX             // i--
127
252
        JL X8b                  // i < 0        (n <= 0)
128
253
 
129
254
        // n > 0
130
255
        MOVQ z+0(FP), R10
131
 
        MOVQ x+16(FP), R8
132
 
        MOVL s+32(FP), CX
 
256
        MOVQ x+24(FP), R8
 
257
        MOVQ s+48(FP), CX
133
258
        MOVQ (R8)(BX*8), AX     // w1 = x[n-1]
134
259
        MOVQ $0, DX
135
260
        SHLQ CX, DX:AX          // w1>>ŝ
136
 
        MOVQ DX, c+40(FP)
 
261
        MOVQ DX, c+56(FP)
137
262
 
138
 
        CMPL BX, $0
 
263
        CMPQ BX, $0
139
264
        JLE X8a                 // i <= 0
140
265
 
141
266
        // i > 0
143
268
        MOVQ -8(R8)(BX*8), AX   // w1 = x[i-1]
144
269
        SHLQ CX, DX:AX          // w<<s | w1>>ŝ
145
270
        MOVQ DX, (R10)(BX*8)    // z[i] = w<<s | w1>>ŝ
146
 
        SUBL $1, BX             // i--
 
271
        SUBQ $1, BX             // i--
147
272
        JG L8                   // i > 0
148
273
 
149
274
        // i <= 0
151
276
        MOVQ AX, (R10)          // z[0] = w1<<s
152
277
        RET
153
278
 
154
 
X8b:    MOVQ $0, c+40(FP)
 
279
X8b:    MOVQ $0, c+56(FP)
155
280
        RET
156
281
 
157
282
 
158
283
// func shrVU(z, x []Word, s uint) (c Word)
159
284
TEXT ·shrVU(SB),7,$0
160
 
        MOVL n+8(FP), R11
161
 
        SUBL $1, R11            // n--
 
285
        MOVQ z_len+8(FP), R11
 
286
        SUBQ $1, R11            // n--
162
287
        JL X9b                  // n < 0        (n <= 0)
163
288
 
164
289
        // n > 0
165
290
        MOVQ z+0(FP), R10
166
 
        MOVQ x+16(FP), R8
167
 
        MOVL s+32(FP), CX
 
291
        MOVQ x+24(FP), R8
 
292
        MOVQ s+48(FP), CX
168
293
        MOVQ (R8), AX           // w1 = x[0]
169
294
        MOVQ $0, DX
170
295
        SHRQ CX, DX:AX          // w1<<ŝ
171
 
        MOVQ DX, c+40(FP)
 
296
        MOVQ DX, c+56(FP)
172
297
 
173
298
        MOVQ $0, BX             // i = 0
174
299
        JMP E9
178
303
        MOVQ 8(R8)(BX*8), AX    // w1 = x[i+1]
179
304
        SHRQ CX, DX:AX          // w>>s | w1<<ŝ
180
305
        MOVQ DX, (R10)(BX*8)    // z[i] = w>>s | w1<<ŝ
181
 
        ADDL $1, BX             // i++
 
306
        ADDQ $1, BX             // i++
182
307
        
183
308
E9:     CMPQ BX, R11
184
309
        JL L9                   // i < n-1
188
313
        MOVQ AX, (R10)(R11*8)   // z[n-1] = w1>>s
189
314
        RET
190
315
 
191
 
X9b:    MOVQ $0, c+40(FP)
 
316
X9b:    MOVQ $0, c+56(FP)
192
317
        RET
193
318
 
194
319
 
195
320
// func mulAddVWW(z, x []Word, y, r Word) (c Word)
196
321
TEXT ·mulAddVWW(SB),7,$0
197
322
        MOVQ z+0(FP), R10
198
 
        MOVQ x+16(FP), R8
199
 
        MOVQ y+32(FP), R9
200
 
        MOVQ r+40(FP), CX       // c = r
201
 
        MOVL n+8(FP), R11
 
323
        MOVQ x+24(FP), R8
 
324
        MOVQ y+48(FP), R9
 
325
        MOVQ r+56(FP), CX       // c = r
 
326
        MOVQ z_len+8(FP), R11
202
327
        MOVQ $0, BX             // i = 0
203
328
        JMP E5
204
329
 
208
333
        ADCQ $0, DX
209
334
        MOVQ AX, (R10)(BX*8)
210
335
        MOVQ DX, CX
211
 
        ADDL $1, BX             // i++
 
336
        ADDQ $1, BX             // i++
212
337
 
213
338
E5:     CMPQ BX, R11            // i < n
214
339
        JL L5
215
340
 
216
 
        MOVQ CX, c+48(FP)
 
341
        MOVQ CX, c+64(FP)
217
342
        RET
218
343
 
219
344
 
220
345
// func addMulVVW(z, x []Word, y Word) (c Word)
221
346
TEXT ·addMulVVW(SB),7,$0
222
347
        MOVQ z+0(FP), R10
223
 
        MOVQ x+16(FP), R8
224
 
        MOVQ y+32(FP), R9
225
 
        MOVL n+8(FP), R11
 
348
        MOVQ x+24(FP), R8
 
349
        MOVQ y+48(FP), R9
 
350
        MOVQ z_len+8(FP), R11
226
351
        MOVQ $0, BX             // i = 0
227
352
        MOVQ $0, CX             // c = 0
228
353
        JMP E6
234
359
        ADDQ AX, (R10)(BX*8)
235
360
        ADCQ $0, DX
236
361
        MOVQ DX, CX
237
 
        ADDL $1, BX             // i++
 
362
        ADDQ $1, BX             // i++
238
363
 
239
364
E6:     CMPQ BX, R11            // i < n
240
365
        JL L6
241
366
 
242
 
        MOVQ CX, c+40(FP)
 
367
        MOVQ CX, c+56(FP)
243
368
        RET
244
369
 
245
370
 
246
371
// func divWVW(z []Word, xn Word, x []Word, y Word) (r Word)
247
372
TEXT ·divWVW(SB),7,$0
248
373
        MOVQ z+0(FP), R10
249
 
        MOVQ xn+16(FP), DX      // r = xn
250
 
        MOVQ x+24(FP), R8
251
 
        MOVQ y+40(FP), R9
252
 
        MOVL n+8(FP), BX        // i = n
 
374
        MOVQ xn+24(FP), DX      // r = xn
 
375
        MOVQ x+32(FP), R8
 
376
        MOVQ y+56(FP), R9
 
377
        MOVQ z_len+8(FP), BX    // i = z
253
378
        JMP E7
254
379
 
255
380
L7:     MOVQ (R8)(BX*8), AX
256
381
        DIVQ R9
257
382
        MOVQ AX, (R10)(BX*8)
258
383
 
259
 
E7:     SUBL $1, BX             // i--
 
384
E7:     SUBQ $1, BX             // i--
260
385
        JGE L7                  // i >= 0
261
386
 
262
 
        MOVQ DX, r+48(FP)
 
387
        MOVQ DX, r+64(FP)
263
388
        RET
264
389
 
265
390
// func bitLen(x Word) (n int)
266
391
TEXT ·bitLen(SB),7,$0
267
392
        BSRQ x+0(FP), AX
268
393
        JZ Z1
269
 
        INCL AX
270
 
        MOVL AX, n+8(FP)
 
394
        ADDQ $1, AX
 
395
        MOVQ AX, n+8(FP)
271
396
        RET
272
397
 
273
 
Z1:     MOVL $0, n+8(FP)
 
398
Z1:     MOVQ $0, n+8(FP)
274
399
        RET