← Back to branch summary

~ubuntu-branches/ubuntu/vivid/golang/vivid

« back to all changes in this revision

Viewing changes to src/pkg/runtime/sys_netbsd_amd64.s

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-20 14:06:23 UTC
  • mfrom: (14.1.23 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130820140623-b414jfxi3m0qkmrq
Tags: 2:1.1.2-2ubuntu1
https://launchpad.net/bugs/1211749
https://launchpad.net/bugs/1202027
* Merge from Debian unstable (LP: #1211749, #1202027). Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - d/control,control.cross: Update Breaks/Replaces for Ubuntu
    versions to ensure smooth upgrades, regenerate control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/runtime/sys_netbsd_amd64.s
8
8
 
9
9
#include "zasm_GOOS_GOARCH.h"
10
10
 
11
 
// int64 rfork_thread(int32 flags, void *stack, M *m, G *g, void (*fn)(void));
12
 
TEXT runtime·rfork_thread(SB),7,$0
13
 
        MOVL    flags+8(SP), DI
14
 
        MOVQ    stack+16(SP), SI
15
 
 
16
 
        // Copy m, g, fn off parent stack for use by child.
17
 
        MOVQ    mm+24(SP), R8
18
 
        MOVQ    gg+32(SP), R9
19
 
        MOVQ    fn+40(SP), R12
20
 
 
21
 
        MOVL    $251, AX                // sys_rfork
22
 
        SYSCALL
23
 
 
24
 
        // Return if rfork syscall failed
25
 
        JCC     3(PC)
26
 
        NEGL    AX
27
 
        RET
28
 
 
29
 
        // In parent, return.
30
 
        CMPL    AX, $0
31
 
        JEQ     2(PC)
32
 
        RET
33
 
 
34
 
        // In child, on new stack.
35
 
        MOVQ    SI, SP
36
 
 
37
 
        // Initialize m->procid to thread ID
38
 
        MOVL    $299, AX                // sys_getthrid
39
 
        SYSCALL
40
 
        MOVQ    AX, m_procid(R8)
41
 
 
 
11
// int32 lwp_create(void *context, uintptr flags, void *lwpid)
 
12
TEXT runtime·lwp_create(SB),7,$0
 
13
        MOVQ    context+0(FP), DI
 
14
        MOVQ    flags+8(FP), SI
 
15
        MOVQ    lwpid+16(FP), DX
 
16
        MOVL    $309, AX                // sys__lwp_create
 
17
        SYSCALL
 
18
        JCC     2(PC)
 
19
        NEGQ    AX
 
20
        RET
 
21
 
 
22
TEXT runtime·lwp_tramp(SB),7,$0
 
23
        
42
24
        // Set FS to point at m->tls.
43
25
        LEAQ    m_tls(R8), DI
44
26
        CALL    runtime·settls(SB)
45
27
 
46
 
        // In child, set up new stack
 
28
        // Set up new stack.
47
29
        get_tls(CX)
48
30
        MOVQ    R8, m(CX)
49
31
        MOVQ    R9, g(CX)
52
34
        // Call fn
53
35
        CALL    R12
54
36
 
55
 
        // It shouldn't return.  If it does, exit
56
 
        MOVL    $302, AX                // sys_threxit
 
37
        // It shouldn't return.  If it does, exit.
 
38
        MOVL    $310, AX                // sys__lwp_exit
57
39
        SYSCALL
58
40
        JMP     -3(PC)                  // keep exiting
59
41
 
60
42
TEXT runtime·osyield(SB),7,$0
61
 
        MOVL $298, AX                   // sys_sched_yield
62
 
        SYSCALL
63
 
        RET
64
 
 
65
 
TEXT runtime·thrsleep(SB),7,$0
66
 
        MOVQ    8(SP), DI               // arg 1 - ident
67
 
        MOVL    16(SP), SI              // arg 2 - clock_id
68
 
        MOVQ    24(SP), DX              // arg 3 - tp
69
 
        MOVQ    32(SP), R10             // arg 4 - lock
70
 
        MOVL    $300, AX                // sys_thrsleep
71
 
        SYSCALL
72
 
        RET
73
 
 
74
 
TEXT runtime·thrwakeup(SB),7,$0
75
 
        MOVQ    8(SP), DI               // arg 1 - ident
76
 
        MOVL    16(SP), SI              // arg 2 - n
77
 
        MOVL    $301, AX                // sys_thrwakeup
 
43
        MOVL    $350, AX                // sys_sched_yield
 
44
        SYSCALL
 
45
        RET
 
46
 
 
47
TEXT runtime·lwp_park(SB),7,$0
 
48
        MOVQ    8(SP), DI               // arg 1 - abstime
 
49
        MOVL    16(SP), SI              // arg 2 - unpark
 
50
        MOVQ    24(SP), DX              // arg 3 - hint
 
51
        MOVQ    32(SP), R10             // arg 4 - unparkhint
 
52
        MOVL    $434, AX                // sys__lwp_park
 
53
        SYSCALL
 
54
        RET
 
55
 
 
56
TEXT runtime·lwp_unpark(SB),7,$0
 
57
        MOVQ    8(SP), DI               // arg 1 - lwp
 
58
        MOVL    16(SP), SI              // arg 2 - hint
 
59
        MOVL    $321, AX                // sys__lwp_unpark
 
60
        SYSCALL
 
61
        RET
 
62
 
 
63
TEXT runtime·lwp_self(SB),7,$0
 
64
        MOVL    $311, AX                // sys__lwp_self
78
65
        SYSCALL
79
66
        RET
80
67
 
83
70
        MOVL    8(SP), DI               // arg 1 - exit status
84
71
        MOVL    $1, AX                  // sys_exit
85
72
        SYSCALL
86
 
        MOVL    $0xf1, 0xf1  // crash
 
73
        MOVL    $0xf1, 0xf1             // crash
87
74
        RET
88
75
 
89
76
TEXT runtime·exit1(SB),7,$-8
90
 
        MOVL    $302, AX                // sys_threxit
91
 
        SYSCALL
92
 
        MOVL    $0xf1, 0xf1  // crash
 
77
        MOVL    $310, AX                // sys__lwp_exit
 
78
        SYSCALL
 
79
        MOVL    $0xf1, 0xf1             // crash
 
80
        RET
 
81
 
 
82
TEXT runtime·open(SB),7,$-8
 
83
        MOVQ    8(SP), DI               // arg 1 pathname
 
84
        MOVL    16(SP), SI              // arg 2 flags
 
85
        MOVL    20(SP), DX              // arg 3 mode
 
86
        MOVL    $5, AX
 
87
        SYSCALL
 
88
        RET
 
89
 
 
90
TEXT runtime·close(SB),7,$-8
 
91
        MOVL    8(SP), DI               // arg 1 fd
 
92
        MOVL    $6, AX
 
93
        SYSCALL
 
94
        RET
 
95
 
 
96
TEXT runtime·read(SB),7,$-8
 
97
        MOVL    8(SP), DI               // arg 1 fd
 
98
        MOVQ    16(SP), SI              // arg 2 buf
 
99
        MOVL    24(SP), DX              // arg 3 count
 
100
        MOVL    $3, AX
 
101
        SYSCALL
93
102
        RET
94
103
 
95
104
TEXT runtime·write(SB),7,$-8
112
121
 
113
122
        MOVQ    SP, DI                  // arg 1 - rqtp
114
123
        MOVQ    $0, SI                  // arg 2 - rmtp
115
 
        MOVL    $240, AX                // sys_nanosleep
 
124
        MOVL    $430, AX                // sys_nanosleep
116
125
        SYSCALL
117
126
        RET
118
127
 
119
 
TEXT runtime·raisesigpipe(SB),7,$16
120
 
        MOVL    $299, AX                // sys_getthrid
 
128
TEXT runtime·raise(SB),7,$16
 
129
        MOVL    $311, AX                // sys__lwp_self
121
130
        SYSCALL
122
 
        MOVQ    AX, DI                  // arg 1 - pid
123
 
        MOVQ    $13, SI                 // arg 2 - signum == SIGPIPE
124
 
        MOVL    $37, AX                 // sys_kill
 
131
        MOVQ    AX, DI                  // arg 1 - target
 
132
        MOVL    sig+0(FP), SI           // arg 2 - signo
 
133
        MOVL    $318, AX                // sys__lwp_kill
125
134
        SYSCALL
126
135
        RET
127
136
 
129
138
        MOVL    8(SP), DI               // arg 1 - which
130
139
        MOVQ    16(SP), SI              // arg 2 - itv
131
140
        MOVQ    24(SP), DX              // arg 3 - oitv
132
 
        MOVL    $83, AX                 // sys_setitimer
 
141
        MOVL    $425, AX                // sys_setitimer
133
142
        SYSCALL
134
143
        RET
135
144
 
136
145
// func now() (sec int64, nsec int32)
137
146
TEXT time·now(SB), 7, $32
138
 
        LEAQ    8(SP), DI               // arg 1 - tp
139
 
        MOVQ    $0, SI                  // arg 2 - tzp
140
 
        MOVL    $116, AX                // sys_gettimeofday
 
147
        MOVQ    $0, DI                  // arg 1 - clock_id
 
148
        LEAQ    8(SP), SI               // arg 2 - tp
 
149
        MOVL    $427, AX                // sys_clock_gettime
141
150
        SYSCALL
142
151
        MOVQ    8(SP), AX               // sec
143
 
        MOVL    16(SP), DX      // usec
 
152
        MOVL    16(SP), DX              // nsec
144
153
 
145
 
        // sec is in AX, usec in DX
 
154
        // sec is in AX, nsec in DX
146
155
        MOVQ    AX, sec+0(FP)
147
 
        IMULQ   $1000, DX
148
156
        MOVL    DX, nsec+8(FP)
149
157
        RET
150
158
 
151
159
TEXT runtime·nanotime(SB),7,$32
152
 
        LEAQ    8(SP), DI               // arg 1 - tp
153
 
        MOVQ    $0, SI                  // arg 2 - tzp
154
 
        MOVL    $116, AX                // sys_gettimeofday
 
160
        MOVQ    $0, DI                  // arg 1 - clock_id
 
161
        LEAQ    8(SP), SI               // arg 2 - tp
 
162
        MOVL    $427, AX                // sys_clock_gettime
155
163
        SYSCALL
156
164
        MOVQ    8(SP), AX               // sec
157
 
        MOVL    16(SP), DX      // usec
 
165
        MOVL    16(SP), DX              // nsec
158
166
 
159
 
        // sec is in AX, usec in DX
 
167
        // sec is in AX, nsec in DX
160
168
        // return nsec in AX
161
169
        IMULQ   $1000000000, AX
162
 
        IMULQ   $1000, DX
163
170
        ADDQ    DX, AX
164
171
        RET
165
172
 
 
173
TEXT runtime·getcontext(SB),7,$-8
 
174
        MOVQ    8(SP), DI               // arg 1 - context
 
175
        MOVL    $307, AX                // sys_getcontext
 
176
        SYSCALL
 
177
        JCC     2(PC)
 
178
        MOVL    $0xf1, 0xf1             // crash
 
179
        RET
 
180
 
 
181
TEXT runtime·sigprocmask(SB),7,$0
 
182
        MOVL    8(SP), DI               // arg 1 - how
 
183
        MOVQ    16(SP), SI              // arg 2 - set
 
184
        MOVQ    24(SP), DX              // arg 3 - oset
 
185
        MOVL    $293, AX                // sys_sigprocmask
 
186
        SYSCALL
 
187
        JCC     2(PC)
 
188
        MOVL    $0xf1, 0xf1             // crash
 
189
        RET
 
190
 
 
191
TEXT runtime·sigreturn_tramp(SB),7,$-8
 
192
        MOVQ    R15, DI                 // Load address of ucontext
 
193
        MOVQ    $308, AX                // sys_setcontext
 
194
        SYSCALL
 
195
        MOVQ    $-1, DI                 // Something failed...
 
196
        MOVL    $1, AX                  // sys_exit
 
197
        SYSCALL
 
198
 
166
199
TEXT runtime·sigaction(SB),7,$-8
167
200
        MOVL    8(SP), DI               // arg 1 - signum
168
201
        MOVQ    16(SP), SI              // arg 2 - nsa
169
202
        MOVQ    24(SP), DX              // arg 3 - osa
170
 
        MOVL    $46, AX
 
203
                                        // arg 4 - tramp
 
204
        LEAQ    runtime·sigreturn_tramp(SB), R10
 
205
        MOVQ    $2, R8                  // arg 5 - vers
 
206
        MOVL    $340, AX                // sys___sigaction_sigtramp
171
207
        SYSCALL
172
208
        JCC     2(PC)
173
 
        MOVL    $0xf1, 0xf1  // crash
 
209
        MOVL    $0xf1, 0xf1             // crash
174
210
        RET
175
211
 
176
212
TEXT runtime·sigtramp(SB),7,$64
177
213
        get_tls(BX)
178
 
        
 
214
 
179
215
        // check that m exists
180
216
        MOVQ    m(BX), BP
181
217
        CMPQ    BP, $0
182
 
        JNE     2(PC)
 
218
        JNE     4(PC)
 
219
        MOVQ    DI, 0(SP)
183
220
        CALL    runtime·badsignal(SB)
 
221
        RET
184
222
 
185
223
        // save g
186
224
        MOVQ    g(BX), R10
187
225
        MOVQ    R10, 40(SP)
188
 
        
 
226
 
189
227
        // g = m->signal
190
228
        MOVQ    m_gsignal(BP), BP
191
229
        MOVQ    BP, g(BX)
192
 
        
 
230
 
193
231
        MOVQ    DI, 0(SP)
194
232
        MOVQ    SI, 8(SP)
195
233
        MOVQ    DX, 16(SP)
196
234
        MOVQ    R10, 24(SP)
197
 
        
 
235
 
198
236
        CALL    runtime·sighandler(SB)
199
237
 
200
238
        // restore g
213
251
        SUBQ    $16, SP
214
252
        MOVQ    R9, 8(SP)               // arg 7 - offset (passed on stack)
215
253
        MOVQ    $0, R9                  // arg 6 - pad
216
 
        MOVL    $197, AX
 
254
        MOVL    $197, AX                // sys_mmap
217
255
        SYSCALL
218
 
        JCC     2(PC)
219
 
        NEGL    AX
220
256
        ADDQ    $16, SP
221
257
        RET
222
258
 
226
262
        MOVL    $73, AX                 // sys_munmap
227
263
        SYSCALL
228
264
        JCC     2(PC)
229
 
        MOVL    $0xf1, 0xf1  // crash
 
265
        MOVL    $0xf1, 0xf1             // crash
 
266
        RET
 
267
 
 
268
 
 
269
TEXT runtime·madvise(SB),7,$0
 
270
        MOVQ    addr+0(FP), DI          // arg 1 - addr
 
271
        MOVQ    len+8(FP), SI           // arg 2 - len
 
272
        MOVQ    behav+16(FP), DX        // arg 3 - behav
 
273
        MOVQ    $75, AX                 // sys_madvise
 
274
        SYSCALL
 
275
        // ignore failure - maybe pages are locked
230
276
        RET
231
277
 
232
278
TEXT runtime·sigaltstack(SB),7,$-8
233
279
        MOVQ    new+8(SP), DI           // arg 1 - nss
234
280
        MOVQ    old+16(SP), SI          // arg 2 - oss
235
 
        MOVQ    $288, AX                // sys_sigaltstack
 
281
        MOVQ    $281, AX                // sys___sigaltstack14
236
282
        SYSCALL
237
283
        JCC     2(PC)
238
 
        MOVL    $0xf1, 0xf1  // crash
 
284
        MOVL    $0xf1, 0xf1             // crash
239
285
        RET
240
286
 
241
287
// set tls base to DI
242
288
TEXT runtime·settls(SB),7,$8
243
289
        // adjust for ELF: wants to use -16(FS) and -8(FS) for g and m
244
 
        ADDQ    $16, DI
245
 
        MOVQ    DI, 0(SP)
246
 
        MOVQ    SP, SI
247
 
        MOVQ    $12, DI                 // AMD64_SET_FSBASE (machine/sysarch.h)
248
 
        MOVQ    $165, AX                // sys_sysarch
 
290
        ADDQ    $16, DI                 // arg 1 - ptr
 
291
        MOVQ    $317, AX                // sys__lwp_setprivate
249
292
        SYSCALL
250
293
        JCC     2(PC)
251
 
        MOVL    $0xf1, 0xf1  // crash
 
294
        MOVL    $0xf1, 0xf1             // crash
252
295
        RET
253
296
 
254
297
TEXT runtime·sysctl(SB),7,$0
261
304
        MOVQ    $202, AX                // sys___sysctl
262
305
        SYSCALL
263
306
        JCC 3(PC)
264
 
        NEGL    AX
 
307
        NEGQ    AX
265
308
        RET
266
309
        MOVL    $0, AX
267
310
        RET