← 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_386.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_386.s
12
12
TEXT runtime·exit(SB),7,$-4
13
13
        MOVL    $1, AX
14
14
        INT     $0x80
15
 
        MOVL    $0xf1, 0xf1  // crash
 
15
        MOVL    $0xf1, 0xf1             // crash
16
16
        RET
17
17
 
18
18
TEXT runtime·exit1(SB),7,$-4
19
 
        MOVL    $302, AX                // sys_threxit
 
19
        MOVL    $310, AX                // sys__lwp_exit
20
20
        INT     $0x80
21
21
        JAE     2(PC)
22
 
        MOVL    $0xf1, 0xf1  // crash
 
22
        MOVL    $0xf1, 0xf1             // crash
 
23
        RET
 
24
 
 
25
TEXT runtime·open(SB),7,$-4
 
26
        MOVL    $5, AX
 
27
        INT     $0x80
 
28
        RET
 
29
 
 
30
TEXT runtime·close(SB),7,$-4
 
31
        MOVL    $6, AX
 
32
        INT     $0x80
 
33
        RET
 
34
 
 
35
TEXT runtime·read(SB),7,$-4
 
36
        MOVL    $3, AX
 
37
        INT     $0x80
23
38
        RET
24
39
 
25
40
TEXT runtime·write(SB),7,$-4
27
42
        INT     $0x80
28
43
        RET
29
44
 
30
 
TEXT runtime·usleep(SB),7,$20
 
45
TEXT runtime·usleep(SB),7,$24
31
46
        MOVL    $0, DX
32
47
        MOVL    usec+0(FP), AX
33
48
        MOVL    $1000000, CX
34
49
        DIVL    CX
35
 
        MOVL    AX, 12(SP)              // tv_sec
 
50
        MOVL    AX, 12(SP)              // tv_sec - l32
 
51
        MOVL    $0, 16(SP)              // tv_sec - h32
36
52
        MOVL    $1000, AX
37
53
        MULL    DX
38
 
        MOVL    AX, 16(SP)              // tv_nsec
 
54
        MOVL    AX, 20(SP)              // tv_nsec
39
55
 
40
56
        MOVL    $0, 0(SP)
41
57
        LEAL    12(SP), AX
42
58
        MOVL    AX, 4(SP)               // arg 1 - rqtp
43
59
        MOVL    $0, 8(SP)               // arg 2 - rmtp
44
 
        MOVL    $240, AX                // sys_nanosleep
 
60
        MOVL    $430, AX                // sys_nanosleep
45
61
        INT     $0x80
46
62
        RET
47
63
 
48
 
TEXT runtime·raisesigpipe(SB),7,$12
49
 
        MOVL    $299, AX                // sys_getthrid
 
64
TEXT runtime·raise(SB),7,$12
 
65
        MOVL    $311, AX                // sys__lwp_self
50
66
        INT     $0x80
51
67
        MOVL    $0, 0(SP)
52
 
        MOVL    AX, 4(SP)               // arg 1 - pid
53
 
        MOVL    $13, 8(SP)              // arg 2 - signum == SIGPIPE
54
 
        MOVL    $37, AX                 // sys_kill
 
68
        MOVL    AX, 4(SP)               // arg 1 - target
 
69
        MOVL    sig+0(FP), AX
 
70
        MOVL    AX, 8(SP)               // arg 2 - signo
 
71
        MOVL    $318, AX                // sys__lwp_kill
55
72
        INT     $0x80
56
73
        RET
57
74
 
67
84
        MOVL    $0, AX
68
85
        STOSL                           // arg 6 - pad
69
86
        MOVSL                           // arg 7 - offset
70
 
        MOVL    $0, AX                  // top 64 bits of file offset
 
87
        MOVL    $0, AX                  // top 32 bits of file offset
71
88
        STOSL
72
89
        MOVL    $197, AX                // sys_mmap
73
90
        INT     $0x80
74
 
        JCC     2(PC)
75
 
        NEGL    AX
76
91
        RET
77
92
 
78
93
TEXT runtime·munmap(SB),7,$-4
79
94
        MOVL    $73, AX                 // sys_munmap
80
95
        INT     $0x80
81
96
        JAE     2(PC)
82
 
        MOVL    $0xf1, 0xf1  // crash
 
97
        MOVL    $0xf1, 0xf1             // crash
 
98
        RET
 
99
 
 
100
TEXT runtime·madvise(SB),7,$-4
 
101
        MOVL    $75, AX                 // sys_madvise
 
102
        INT     $0x80
 
103
        // ignore failure - maybe pages are locked
83
104
        RET
84
105
 
85
106
TEXT runtime·setitimer(SB),7,$-4
86
 
        MOVL    $83, AX
 
107
        MOVL    $425, AX                // sys_setitimer
87
108
        INT     $0x80
88
109
        RET
89
110
 
90
111
// func now() (sec int64, nsec int32)
91
112
TEXT time·now(SB), 7, $32
92
 
        MOVL    $116, AX
93
113
        LEAL    12(SP), BX
94
 
        MOVL    BX, 4(SP)
95
 
        MOVL    $0, 8(SP)
 
114
        MOVL    $0, 4(SP)               // arg 1 - clock_id
 
115
        MOVL    BX, 8(SP)               // arg 2 - tp
 
116
        MOVL    $427, AX                // sys_clock_gettime
96
117
        INT     $0x80
97
 
        MOVL    12(SP), AX              // sec
98
 
        MOVL    16(SP), BX              // usec
99
118
 
100
 
        // sec is in AX, usec in BX
 
119
        MOVL    12(SP), AX              // sec - l32
101
120
        MOVL    AX, sec+0(FP)
102
 
        MOVL    $0, sec+4(FP)
103
 
        IMULL   $1000, BX
 
121
        MOVL    16(SP), AX              // sec - h32
 
122
        MOVL    AX, sec+4(FP)
 
123
 
 
124
        MOVL    20(SP), BX              // nsec
104
125
        MOVL    BX, nsec+8(FP)
105
126
        RET
106
127
 
107
128
// int64 nanotime(void) so really
108
129
// void nanotime(int64 *nsec)
109
130
TEXT runtime·nanotime(SB),7,$32
110
 
        MOVL    $116, AX
111
131
        LEAL    12(SP), BX
112
 
        MOVL    BX, 4(SP)
113
 
        MOVL    $0, 8(SP)
 
132
        MOVL    $0, 4(SP)               // arg 1 - clock_id
 
133
        MOVL    BX, 8(SP)               // arg 2 - tp
 
134
        MOVL    $427, AX                // sys_clock_gettime
114
135
        INT     $0x80
115
 
        MOVL    12(SP), AX              // sec
116
 
        MOVL    16(SP), BX              // usec
117
 
 
118
 
        // sec is in AX, usec in BX
119
 
        // convert to DX:AX nsec
120
 
        MOVL    $1000000000, CX
121
 
        MULL    CX
122
 
        IMULL   $1000, BX
 
136
 
 
137
        MOVL    16(SP), CX              // sec - h32
 
138
        IMULL   $1000000000, CX
 
139
 
 
140
        MOVL    12(SP), AX              // sec - l32
 
141
        MOVL    $1000000000, BX
 
142
        MULL    BX                      // result in dx:ax
 
143
 
 
144
        MOVL    20(SP), BX              // nsec
123
145
        ADDL    BX, AX
124
 
        ADCL    $0, DX
125
 
        
 
146
        ADCL    CX, DX                  // add high bits with carry
 
147
 
126
148
        MOVL    ret+0(FP), DI
127
149
        MOVL    AX, 0(DI)
128
150
        MOVL    DX, 4(DI)
129
151
        RET
130
152
 
131
 
TEXT runtime·sigaction(SB),7,$-4
132
 
        MOVL    $46, AX                 // sys_sigaction
133
 
        INT     $0x80
134
 
        JAE     2(PC)
135
 
        MOVL    $0xf1, 0xf1  // crash
 
153
TEXT runtime·getcontext(SB),7,$-4
 
154
        MOVL    $307, AX                // sys_getcontext
 
155
        INT     $0x80
 
156
        JAE     2(PC)
 
157
        MOVL    $0xf1, 0xf1             // crash
 
158
        RET
 
159
 
 
160
TEXT runtime·sigprocmask(SB),7,$-4
 
161
        MOVL    $293, AX                // sys_sigprocmask
 
162
        INT     $0x80
 
163
        JAE     2(PC)
 
164
        MOVL    $0xf1, 0xf1             // crash
 
165
        RET
 
166
 
 
167
TEXT runtime·sigreturn_tramp(SB),7,$0
 
168
        LEAL    140(SP), AX             // Load address of ucontext
 
169
        MOVL    AX, 4(SP)
 
170
        MOVL    $308, AX                // sys_setcontext
 
171
        INT     $0x80
 
172
        MOVL    $-1, 4(SP)              // Something failed...
 
173
        MOVL    $1, AX                  // sys_exit
 
174
        INT     $0x80
 
175
 
 
176
TEXT runtime·sigaction(SB),7,$24
 
177
        LEAL    arg0+0(FP), SI
 
178
        LEAL    4(SP), DI
 
179
        CLD
 
180
        MOVSL                           // arg 1 - sig
 
181
        MOVSL                           // arg 2 - act
 
182
        MOVSL                           // arg 3 - oact
 
183
        LEAL    runtime·sigreturn_tramp(SB), AX
 
184
        STOSL                           // arg 4 - tramp
 
185
        MOVL    $2, AX
 
186
        STOSL                           // arg 5 - vers
 
187
        MOVL    $340, AX                // sys___sigaction_sigtramp
 
188
        INT     $0x80
 
189
        JAE     2(PC)
 
190
        MOVL    $0xf1, 0xf1             // crash
136
191
        RET
137
192
 
138
193
TEXT runtime·sigtramp(SB),7,$44
141
196
        // check that m exists
142
197
        MOVL    m(CX), BX
143
198
        CMPL    BX, $0
144
 
        JNE     2(PC)
 
199
        JNE     5(PC)
 
200
        MOVL    signo+0(FP), BX
 
201
        MOVL    BX, 0(SP)
145
202
        CALL    runtime·badsignal(SB)
 
203
        RET
146
204
 
147
205
        // save g
148
206
        MOVL    g(CX), DI
149
207
        MOVL    DI, 20(SP)
150
 
        
 
208
 
151
209
        // g = m->gsignal
152
210
        MOVL    m_gsignal(BX), BX
153
211
        MOVL    BX, g(CX)
167
225
        get_tls(CX)
168
226
        MOVL    20(SP), BX
169
227
        MOVL    BX, g(CX)
170
 
        
171
 
        // call sigreturn
172
 
        MOVL    context+8(FP), AX
173
 
        MOVL    $0, 0(SP)               // syscall gap
174
 
        MOVL    AX, 4(SP)               // arg 1 - sigcontext
175
 
        MOVL    $103, AX                // sys_sigreturn
176
 
        INT     $0x80
177
 
        MOVL    $0xf1, 0xf1  // crash
178
228
        RET
179
229
 
180
 
// int32 rfork_thread(int32 flags, void *stack, M *m, G *g, void (*fn)(void));
181
 
TEXT runtime·rfork_thread(SB),7,$8
182
 
        MOVL    flags+8(SP), AX
183
 
        MOVL    stack+12(SP), CX
184
 
 
185
 
        // Copy m, g, fn off parent stack for use by child.
186
 
        SUBL    $16, CX
187
 
        MOVL    mm+16(SP), SI
188
 
        MOVL    SI, 0(CX)
189
 
        MOVL    gg+20(SP), SI
190
 
        MOVL    SI, 4(CX)
191
 
        MOVL    fn+24(SP), SI
192
 
        MOVL    SI, 8(CX)
193
 
        MOVL    $1234, 12(CX)
194
 
        MOVL    CX, SI
195
 
 
196
 
        MOVL    $0, 0(SP)               // syscall gap
197
 
        MOVL    AX, 4(SP)               // arg 1 - flags
198
 
        MOVL    $251, AX                // sys_rfork
 
230
// int32 lwp_create(void *context, uintptr flags, void *lwpid);
 
231
TEXT runtime·lwp_create(SB),7,$16
 
232
        MOVL    $0, 0(SP)
 
233
        MOVL    context+0(FP), AX
 
234
        MOVL    AX, 4(SP)               // arg 1 - context
 
235
        MOVL    flags+4(FP), AX
 
236
        MOVL    AX, 8(SP)               // arg 2 - flags
 
237
        MOVL    lwpid+8(FP), AX
 
238
        MOVL    AX, 12(SP)              // arg 3 - lwpid
 
239
        MOVL    $309, AX                // sys__lwp_create
199
240
        INT     $0x80
200
 
 
201
 
        // Return if rfork syscall failed
202
 
        JCC     4(PC)
 
241
        JCC     2(PC)
203
242
        NEGL    AX
204
 
        MOVL    AX, 48(SP)
205
 
        RET
206
 
 
207
 
        // In parent, return.
208
 
        CMPL    AX, $0
209
 
        JEQ     3(PC)
210
 
        MOVL    AX, 48(SP)
211
 
        RET
212
 
 
213
 
        // In child, on new stack.
214
 
        MOVL    SI, SP
215
 
 
216
 
        // Paranoia: check that SP is as we expect.
217
 
        MOVL    12(SP), BP
218
 
        CMPL    BP, $1234
219
 
        JEQ     2(PC)
220
 
        INT     $3
221
 
 
222
 
        // Reload registers
223
 
        MOVL    0(SP), BX               // m
224
 
        MOVL    4(SP), DX               // g
225
 
        MOVL    8(SP), SI               // fn
226
 
 
227
 
        // Initialize m->procid to thread ID
228
 
        MOVL    $299, AX                // sys_getthrid
229
 
        INT     $0x80
230
 
        MOVL    AX, m_procid(BX)
 
243
        RET
 
244
 
 
245
TEXT runtime·lwp_tramp(SB),7,$0
231
246
 
232
247
        // Set FS to point at m->tls
233
248
        LEAL    m_tls(BX), BP
236
251
        CALL    runtime·settls(SB)
237
252
        POPL    AX
238
253
        POPAL
239
 
        
 
254
 
240
255
        // Now segment is established.  Initialize m, g.
241
256
        get_tls(AX)
242
257
        MOVL    DX, g(AX)
259
274
        RET
260
275
 
261
276
TEXT runtime·sigaltstack(SB),7,$-8
262
 
        MOVL    $288, AX                // sys_sigaltstack
 
277
        MOVL    $281, AX                // sys___sigaltstack14
263
278
        MOVL    new+4(SP), BX
264
279
        MOVL    old+8(SP), CX
265
280
        INT     $0x80
277
292
 
278
293
TEXT runtime·settls(SB),7,$16
279
294
        // adjust for ELF: wants to use -8(GS) and -4(GS) for g and m
280
 
        MOVL    20(SP), CX
 
295
        MOVL    base+0(FP), CX
281
296
        ADDL    $8, CX
282
 
        MOVL    CX, 0(CX)
283
297
        MOVL    $0, 0(SP)               // syscall gap
284
 
        MOVL    $9, 4(SP)               // I386_SET_GSBASE (machine/sysarch.h)
285
 
        MOVL    CX, 8(SP)               // pointer to base
286
 
        MOVL    $165, AX                // sys_sysarch
 
298
        MOVL    CX, 4(SP)               // arg 1 - ptr
 
299
        MOVL    $317, AX                // sys__lwp_setprivate
287
300
        INT     $0x80
288
301
        JCC     2(PC)
289
 
        MOVL    $0xf1, 0xf1  // crash
 
302
        MOVL    $0xf1, 0xf1             // crash
290
303
        RET
291
304
 
292
305
TEXT runtime·osyield(SB),7,$-4
293
 
        MOVL    $298, AX                // sys_sched_yield
294
 
        INT     $0x80
295
 
        RET
296
 
 
297
 
TEXT runtime·thrsleep(SB),7,$-4
298
 
        MOVL    $300, AX                // sys_thrsleep
299
 
        INT     $0x80
300
 
        RET
301
 
 
302
 
TEXT runtime·thrwakeup(SB),7,$-4
303
 
        MOVL    $301, AX                // sys_thrwakeup
 
306
        MOVL    $350, AX                // sys_sched_yield
 
307
        INT     $0x80
 
308
        RET
 
309
 
 
310
TEXT runtime·lwp_park(SB),7,$-4
 
311
        MOVL    $434, AX                // sys__lwp_park
 
312
        INT     $0x80
 
313
        RET
 
314
 
 
315
TEXT runtime·lwp_unpark(SB),7,$-4
 
316
        MOVL    $321, AX                // sys__lwp_unpark
 
317
        INT     $0x80
 
318
        RET
 
319
 
 
320
TEXT runtime·lwp_self(SB),7,$-4
 
321
        MOVL    $311, AX                // sys__lwp_self
304
322
        INT     $0x80
305
323
        RET
306
324