← 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_arm.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_arm.s
 
1
// Copyright 2013 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
// System calls and other sys.stuff for ARM, NetBSD
 
6
// /usr/src/sys/kern/syscalls.master for syscall numbers.
 
7
//
 
8
 
 
9
#include "zasm_GOOS_GOARCH.h"
 
10
 
 
11
// Exit the entire program (like C exit)
 
12
TEXT runtime·exit(SB),7,$-4
 
13
        MOVW 0(FP), R0  // arg 1 exit status
 
14
        SWI $0xa00001
 
15
        MOVW.CS $0, R9  // crash on syscall failure
 
16
        MOVW.CS R9, (R9)
 
17
        RET
 
18
 
 
19
TEXT runtime·exit1(SB),7,$-4
 
20
        SWI $0xa00136   // sys__lwp_exit
 
21
        MOVW $1, R9     // crash
 
22
        MOVW R9, (R9)
 
23
        RET
 
24
        
 
25
TEXT runtime·open(SB),7,$-8
 
26
        MOVW 0(FP), R0
 
27
        MOVW 4(FP), R1
 
28
        MOVW 8(FP), R2
 
29
        SWI $0xa00005
 
30
        RET
 
31
 
 
32
TEXT runtime·close(SB),7,$-8
 
33
        MOVW 0(FP), R0
 
34
        SWI $0xa00006
 
35
        RET
 
36
 
 
37
TEXT runtime·read(SB),7,$-8
 
38
        MOVW 0(FP), R0
 
39
        MOVW 4(FP), R1
 
40
        MOVW 8(FP), R2
 
41
        SWI $0xa00003
 
42
        RET
 
43
 
 
44
TEXT runtime·write(SB),7,$-4
 
45
        MOVW    0(FP), R0       // arg 1 - fd
 
46
        MOVW    4(FP), R1       // arg 2 - buf
 
47
        MOVW    8(FP), R2       // arg 3 - nbyte
 
48
        SWI $0xa00004   // sys_write
 
49
        RET
 
50
 
 
51
// int32 lwp_create(void *context, uintptr flags, void *lwpid)
 
52
TEXT runtime·lwp_create(SB),7,$0
 
53
        MOVW context+0(FP), R0
 
54
        MOVW flags+4(FP), R1
 
55
        MOVW lwpid+8(FP), R2
 
56
        SWI $0xa00135   // sys__lwp_create
 
57
        RET
 
58
 
 
59
TEXT runtime·osyield(SB),7,$0
 
60
        SWI $0xa0015e   // sys_sched_yield
 
61
        RET
 
62
 
 
63
TEXT runtime·lwp_park(SB),7,$0
 
64
        MOVW 0(FP), R0  // arg 1 - abstime
 
65
        MOVW 4(FP), R1  // arg 2 - unpark
 
66
        MOVW 8(FP), R2  // arg 3 - hint
 
67
        MOVW 12(FP), R3 // arg 4 - unparkhint
 
68
        SWI $0xa001b2   // sys__lwp_park
 
69
        RET
 
70
 
 
71
TEXT runtime·lwp_unpark(SB),7,$0
 
72
        MOVW    0(FP), R0       // arg 1 - lwp
 
73
        MOVW    4(FP), R1       // arg 2 - hint
 
74
        SWI $0xa00141 // sys__lwp_unpark
 
75
        RET
 
76
 
 
77
TEXT runtime·lwp_self(SB),7,$0
 
78
        SWI $0xa00137   // sys__lwp_self
 
79
        RET
 
80
 
 
81
TEXT runtime·lwp_tramp(SB),7,$0
 
82
        MOVW R0, R9 // m
 
83
        MOVW R1, R10 // g
 
84
 
 
85
        BL runtime·emptyfunc(SB) // fault if stack check is wrong
 
86
        BL (R2)
 
87
        MOVW $2, R9  // crash (not reached)
 
88
        MOVW R9, (R9)
 
89
        RET
 
90
 
 
91
TEXT runtime·usleep(SB),7,$16
 
92
        MOVW usec+0(FP), R0
 
93
        MOVW R0, R2
 
94
        MOVW $1000000, R1
 
95
        DIV R1, R0
 
96
        // 0(R13) is the saved LR, don't use it
 
97
        MOVW R0, 4(R13) // tv_sec.low
 
98
        MOVW $0, R0
 
99
        MOVW R0, 8(R13) // tv_sec.high
 
100
        MOD R1, R2
 
101
        MOVW $1000, R1
 
102
        MUL R1, R2
 
103
        MOVW R2, 12(R13) // tv_nsec
 
104
 
 
105
        MOVW $4(R13), R0 // arg 1 - rqtp
 
106
        MOVW $0, R1      // arg 2 - rmtp
 
107
        SWI $0xa001ae   // sys_nanosleep
 
108
        RET
 
109
 
 
110
TEXT runtime·raise(SB),7,$16
 
111
        SWI $0xa00137   // sys__lwp_self, the returned R0 is arg 1
 
112
        MOVW    sig+0(FP), R1   // arg 2 - signal
 
113
        SWI $0xa0013e   // sys__lwp_kill
 
114
        RET
 
115
 
 
116
TEXT runtime·setitimer(SB),7,$-4
 
117
        MOVW 0(FP), R0  // arg 1 - which
 
118
        MOVW 4(FP), R1  // arg 2 - itv
 
119
        MOVW 8(FP), R2  // arg 3 - oitv
 
120
        SWI $0xa001a9   // sys_setitimer
 
121
        RET
 
122
 
 
123
// func now() (sec int64, nsec int32)
 
124
TEXT time·now(SB), 7, $32
 
125
        MOVW $0, R0     // CLOCK_REALTIME
 
126
        MOVW $8(R13), R1
 
127
        SWI $0xa001ab   // clock_gettime
 
128
 
 
129
        MOVW 8(R13), R0 // sec.low
 
130
        MOVW 12(R13), R1 // sec.high
 
131
        MOVW 16(R13), R2 // nsec
 
132
 
 
133
        MOVW R0, 0(FP)
 
134
        MOVW R1, 4(FP)
 
135
        MOVW R2, 8(FP)
 
136
        RET
 
137
 
 
138
// int64 nanotime(void) so really
 
139
// void nanotime(int64 *nsec)
 
140
TEXT runtime·nanotime(SB), 7, $32
 
141
        MOVW $0, R0 // CLOCK_REALTIME
 
142
        MOVW $8(R13), R1
 
143
        SWI $0xa001ab   // clock_gettime
 
144
 
 
145
        MOVW 8(R13), R0 // sec.low
 
146
        MOVW 12(R13), R4 // sec.high
 
147
        MOVW 16(R13), R2 // nsec
 
148
 
 
149
        MOVW $1000000000, R3
 
150
        MULLU R0, R3, (R1, R0)
 
151
        MUL R3, R4
 
152
        ADD.S R2, R0
 
153
        ADC R4, R1
 
154
 
 
155
        MOVW 0(FP), R3
 
156
        MOVW R0, 0(R3)
 
157
        MOVW R1, 4(R3)
 
158
        RET
 
159
 
 
160
TEXT runtime·getcontext(SB),7,$-4
 
161
        MOVW 0(FP), R0  // arg 1 - context
 
162
        SWI $0xa00133   // sys_getcontext
 
163
        MOVW.CS $0, R9  // crash on syscall failure
 
164
        MOVW.CS R9, (R9)
 
165
        RET
 
166
 
 
167
TEXT runtime·sigprocmask(SB),7,$0
 
168
        MOVW 0(FP), R0  // arg 1 - how
 
169
        MOVW 4(FP), R1  // arg 2 - set
 
170
        MOVW 8(FP), R2  // arg 3 - oset
 
171
        SWI $0xa00125   // sys_sigprocmask
 
172
        MOVW.CS $0, R9  // crash on syscall failure
 
173
        MOVW.CS R9, (R9)
 
174
        RET
 
175
 
 
176
TEXT runtime·sigreturn_tramp(SB),7,$-4
 
177
        // in runtime·sigtramp, we saved ucontext into m->tls[0],
 
178
        // here we just load it and call sys_setcontext
 
179
        MOVW m_tls(m), R0
 
180
        SWI $0xa00134   // sys_setcontext
 
181
        // something failed, we have to exit
 
182
        MOVW $0x4242, R0 // magic return number
 
183
        SWI $0xa00001   // sys_exit
 
184
        B -2(PC)        // continue exit
 
185
 
 
186
TEXT runtime·sigaction(SB),7,$4
 
187
        MOVW 0(FP), R0  // arg 1 - signum
 
188
        MOVW 4(FP), R1  // arg 2 - nsa
 
189
        MOVW 8(FP), R2  // arg 3 - osa
 
190
        MOVW $runtime·sigreturn_tramp(SB), R3   // arg 4 - tramp
 
191
        MOVW $2, R4     // arg 5 - vers
 
192
        MOVW R4, 4(R13)
 
193
        ADD $4, R13     // pass arg 5 on stack
 
194
        SWI $0xa00154   // sys___sigaction_sigtramp
 
195
        SUB $4, R13
 
196
        MOVW.CS $3, R9  // crash on syscall failure
 
197
        MOVW.CS R9, (R9)
 
198
        RET
 
199
 
 
200
TEXT runtime·sigtramp(SB),7,$24
 
201
        // this might be called in external code context,
 
202
        // where g and m are not set.
 
203
        // first save R0, because _cgo_load_gm will clobber it
 
204
        // TODO(adonovan): call runtime·badsignal if m=0, like other platforms?
 
205
        MOVW    R0, 4(R13) // signum
 
206
        MOVW    _cgo_load_gm(SB), R0
 
207
        CMP     $0, R0
 
208
        BL.NE   (R0)
 
209
 
 
210
        // save g
 
211
        MOVW R10, R4
 
212
        MOVW R10, 20(R13)
 
213
 
 
214
        // g = m->signal
 
215
        MOVW m_gsignal(R9), R10
 
216
 
 
217
        // R0 is already saved
 
218
        MOVW R1, 8(R13) // info
 
219
        MOVW R2, 12(R13) // context
 
220
        MOVW R4, 16(R13) // gp
 
221
        // we also save the ucontext into m->tls[0] for easy
 
222
        // signal return
 
223
        MOVW R2, m_tls(m)
 
224
 
 
225
        BL runtime·sighandler(SB)
 
226
 
 
227
        // restore g
 
228
        MOVW 20(R13), R10
 
229
        RET
 
230
 
 
231
TEXT runtime·mmap(SB),7,$12
 
232
        MOVW 0(FP), R0  // arg 1 - addr
 
233
        MOVW 4(FP), R1  // arg 2 - len
 
234
        MOVW 8(FP), R2  // arg 3 - prot
 
235
        MOVW 12(FP), R3 // arg 4 - flags
 
236
        // arg 5 (fid) and arg6 (offset_lo, offset_hi) are passed on stack
 
237
        // note the C runtime only passes the 32-bit offset_lo to us
 
238
        MOVW 16(FP), R4         // arg 5
 
239
        MOVW R4, 4(R13)
 
240
        MOVW 20(FP), R5         // arg 6 lower 32-bit
 
241
        MOVW R5, 8(R13)
 
242
        MOVW $0, R6 // higher 32-bit for arg 6
 
243
        MOVW R6, 12(R13)
 
244
        ADD $4, R13 // pass arg 5 and arg 6 on stack
 
245
        SWI $0xa000c5   // sys_mmap
 
246
        SUB $4, R13
 
247
        RET
 
248
 
 
249
TEXT runtime·munmap(SB),7,$0
 
250
        MOVW 0(FP), R0  // arg 1 - addr
 
251
        MOVW 4(FP), R1  // arg 2 - len
 
252
        SWI $0xa00049   // sys_munmap
 
253
        MOVW.CS $0, R9  // crash on syscall failure
 
254
        MOVW.CS R9, (R9)
 
255
        RET
 
256
 
 
257
TEXT runtime·madvise(SB),7,$0
 
258
        MOVW 0(FP), R0  // arg 1 - addr
 
259
        MOVW 4(FP), R1  // arg 2 - len
 
260
        MOVW 8(FP), R2  // arg 3 - behav
 
261
        SWI $0xa0004b   // sys_madvise
 
262
        // ignore failure - maybe pages are locked
 
263
        RET
 
264
 
 
265
TEXT runtime·sigaltstack(SB),7,$-4
 
266
        MOVW 0(FP), R0  // arg 1 - nss
 
267
        MOVW 4(FP), R1  // arg 2 - oss
 
268
        SWI $0xa00119   // sys___sigaltstack14
 
269
        MOVW.CS $0, R9  // crash on syscall failure
 
270
        MOVW.CS R9, (R9)
 
271
        RET
 
272
 
 
273
TEXT runtime·sysctl(SB),7,$8
 
274
        MOVW 0(FP), R0  // arg 1 - name
 
275
        MOVW 4(FP), R1  // arg 2 - namelen
 
276
        MOVW 8(FP), R2  // arg 3 - oldp
 
277
        MOVW 12(FP), R3 // arg 4 - oldlenp
 
278
        MOVW 16(FP), R4 // arg 5 - newp
 
279
        MOVW R4, 4(R13)
 
280
        MOVW 20(FP), R4 // arg 6 - newlen
 
281
        MOVW R4, 8(R13)
 
282
        ADD $4, R13     // pass arg 5 and 6 on stack
 
283
        SWI $0xa000ca   // sys___sysctl
 
284
        SUB $4, R13
 
285
        RET
 
286
 
 
287
TEXT runtime·casp(SB),7,$0
 
288
        B       runtime·cas(SB)
 
289
 
 
290
// TODO(minux): this is only valid for ARMv6+
 
291
// bool armcas(int32 *val, int32 old, int32 new)
 
292
// Atomically:
 
293
//      if(*val == old){
 
294
//              *val = new;
 
295
//              return 1;
 
296
//      }else
 
297
//              return 0;
 
298
TEXT runtime·cas(SB),7,$0
 
299
        B runtime·armcas(SB)