← Back to branch summary

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

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2014-11-18 15:12:26 UTC
  • mfrom: (14.2.12 vivid-proposed)
  • Revision ID: package-import@ubuntu.com-20141118151226-zug7vn93mn3dtiz3
Tags: 2:1.3.2-1ubuntu1
* Merge from Debian unstable.  Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - Support co-installability with gccgo-go tool:
    - d/rules,golang-go.install: Rename bin/go -> bin/golang-go
    - d/golang-go.{postinst,prerm}: Install/remove /usr/bin/go using
      alternatives.
  - d/copyright: Amendments for full compiliance with copyright format.
  - d/control: Demote golang-go.tools to Suggests to support Ubuntu MIR.
  - dropped patches (now upstream):
    - d/p/issue27650045_40001_50001.diff
    - d/p/issue28050043_60001_70001.diff
    - d/p/issue54790044_100001_110001.diff

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/runtime/sys_nacl_amd64p32.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
#include "zasm_GOOS_GOARCH.h"
 
6
#include "../../cmd/ld/textflag.h"
 
7
#include "syscall_nacl.h"
 
8
 
 
9
#define NACL_SYSCALL(code) \
 
10
        MOVL $(0x10000 + ((code)<<5)), AX; CALL AX
 
11
 
 
12
#define NACL_SYSJMP(code) \
 
13
        MOVL $(0x10000 + ((code)<<5)), AX; JMP AX
 
14
 
 
15
TEXT runtime·settls(SB),NOSPLIT,$0
 
16
        MOVL    DI, TLS // really BP
 
17
        RET
 
18
 
 
19
TEXT runtime·exit(SB),NOSPLIT,$0
 
20
        MOVL arg1+0(FP), DI
 
21
        NACL_SYSJMP(SYS_exit)
 
22
 
 
23
TEXT runtime·exit1(SB),NOSPLIT,$0
 
24
        MOVL arg1+0(FP), DI
 
25
        NACL_SYSJMP(SYS_thread_exit)
 
26
 
 
27
TEXT runtime·open(SB),NOSPLIT,$0
 
28
        MOVL arg1+0(FP), DI
 
29
        MOVL arg2+4(FP), SI
 
30
        MOVL arg3+8(FP), DX
 
31
        NACL_SYSJMP(SYS_open)
 
32
 
 
33
TEXT runtime·close(SB),NOSPLIT,$0
 
34
        MOVL arg1+0(FP), DI
 
35
        NACL_SYSJMP(SYS_close)
 
36
 
 
37
TEXT runtime·read(SB),NOSPLIT,$0
 
38
        MOVL arg1+0(FP), DI
 
39
        MOVL arg2+4(FP), SI
 
40
        MOVL arg3+8(FP), DX
 
41
        NACL_SYSJMP(SYS_read)
 
42
 
 
43
TEXT syscall·naclWrite(SB), NOSPLIT, $16-20
 
44
        MOVL arg1+0(FP), DI
 
45
        MOVL arg2+4(FP), SI
 
46
        MOVL arg3+8(FP), DX
 
47
        MOVL DI, 0(SP)
 
48
        MOVL SI, 4(SP)
 
49
        MOVL DX, 8(SP)
 
50
        CALL runtime·write(SB)
 
51
        MOVL AX, ret+16(FP)
 
52
        RET
 
53
 
 
54
TEXT runtime·write(SB),NOSPLIT,$16-12
 
55
        // If using fake time and writing to stdout or stderr,
 
56
        // emit playback header before actual data.
 
57
        MOVQ runtime·timens(SB), AX
 
58
        CMPQ AX, $0
 
59
        JEQ write
 
60
        MOVL arg1+0(FP), DI
 
61
        CMPL DI, $1
 
62
        JEQ playback
 
63
        CMPL DI, $2
 
64
        JEQ playback
 
65
 
 
66
write:
 
67
        // Ordinary write.
 
68
        MOVL arg1+0(FP), DI
 
69
        MOVL arg2+4(FP), SI
 
70
        MOVL arg3+8(FP), DX
 
71
        NACL_SYSCALL(SYS_write)
 
72
        RET
 
73
 
 
74
        // Write with playback header.
 
75
        // First, lock to avoid interleaving writes.
 
76
playback:
 
77
        MOVL $1, BX
 
78
        XCHGL   runtime·writelock(SB), BX
 
79
        CMPL BX, $0
 
80
        JNE playback
 
81
 
 
82
        // Playback header: 0 0 P B <8-byte time> <4-byte data length>
 
83
        MOVL $(('B'<<24) | ('P'<<16)), 0(SP)
 
84
        BSWAPQ AX
 
85
        MOVQ AX, 4(SP)
 
86
        MOVL arg3+8(FP), DX
 
87
        BSWAPL DX
 
88
        MOVL DX, 12(SP)
 
89
        MOVL $1, DI // standard output
 
90
        MOVL SP, SI
 
91
        MOVL $16, DX
 
92
        NACL_SYSCALL(SYS_write)
 
93
 
 
94
        // Write actual data.
 
95
        MOVL $1, DI // standard output
 
96
        MOVL arg2+4(FP), SI
 
97
        MOVL arg3+8(FP), DX
 
98
        NACL_SYSCALL(SYS_write)
 
99
 
 
100
        // Unlock.
 
101
        MOVL    $0, runtime·writelock(SB)
 
102
 
 
103
        RET
 
104
 
 
105
TEXT runtime·nacl_exception_stack(SB),NOSPLIT,$0
 
106
        MOVL arg1+0(FP), DI
 
107
        MOVL arg2+4(FP), SI
 
108
        NACL_SYSJMP(SYS_exception_stack)
 
109
 
 
110
TEXT runtime·nacl_exception_handler(SB),NOSPLIT,$0
 
111
        MOVL arg1+0(FP), DI
 
112
        MOVL arg2+4(FP), SI
 
113
        NACL_SYSJMP(SYS_exception_handler)
 
114
 
 
115
TEXT runtime·nacl_sem_create(SB),NOSPLIT,$0
 
116
        MOVL arg1+0(FP), DI
 
117
        NACL_SYSJMP(SYS_sem_create)
 
118
 
 
119
TEXT runtime·nacl_sem_wait(SB),NOSPLIT,$0
 
120
        MOVL arg1+0(FP), DI
 
121
        NACL_SYSJMP(SYS_sem_wait)
 
122
 
 
123
TEXT runtime·nacl_sem_post(SB),NOSPLIT,$0
 
124
        MOVL arg1+0(FP), DI
 
125
        NACL_SYSJMP(SYS_sem_post)
 
126
 
 
127
TEXT runtime·nacl_mutex_create(SB),NOSPLIT,$0
 
128
        MOVL arg1+0(FP), DI
 
129
        NACL_SYSJMP(SYS_mutex_create)
 
130
 
 
131
TEXT runtime·nacl_mutex_lock(SB),NOSPLIT,$0
 
132
        MOVL arg1+0(FP), DI
 
133
        NACL_SYSJMP(SYS_mutex_lock)
 
134
 
 
135
TEXT runtime·nacl_mutex_trylock(SB),NOSPLIT,$0
 
136
        MOVL arg1+0(FP), DI
 
137
        NACL_SYSJMP(SYS_mutex_trylock)
 
138
 
 
139
TEXT runtime·nacl_mutex_unlock(SB),NOSPLIT,$0
 
140
        MOVL arg1+0(FP), DI
 
141
        NACL_SYSJMP(SYS_mutex_unlock)
 
142
 
 
143
TEXT runtime·nacl_cond_create(SB),NOSPLIT,$0
 
144
        MOVL arg1+0(FP), DI
 
145
        NACL_SYSJMP(SYS_cond_create)
 
146
 
 
147
TEXT runtime·nacl_cond_wait(SB),NOSPLIT,$0
 
148
        MOVL arg1+0(FP), DI
 
149
        MOVL arg2+4(FP), SI
 
150
        NACL_SYSJMP(SYS_cond_wait)
 
151
 
 
152
TEXT runtime·nacl_cond_signal(SB),NOSPLIT,$0
 
153
        MOVL arg1+0(FP), DI
 
154
        NACL_SYSJMP(SYS_cond_signal)
 
155
 
 
156
TEXT runtime·nacl_cond_broadcast(SB),NOSPLIT,$0
 
157
        MOVL arg1+0(FP), DI
 
158
        NACL_SYSJMP(SYS_cond_broadcast)
 
159
 
 
160
TEXT runtime·nacl_cond_timed_wait_abs(SB),NOSPLIT,$0
 
161
        MOVL arg1+0(FP), DI
 
162
        MOVL arg2+4(FP), SI
 
163
        MOVL arg3+8(FP), DX
 
164
        NACL_SYSJMP(SYS_cond_timed_wait_abs)
 
165
 
 
166
TEXT runtime·nacl_thread_create(SB),NOSPLIT,$0
 
167
        MOVL arg1+0(FP), DI
 
168
        MOVL arg2+4(FP), SI
 
169
        MOVL arg3+8(FP), DX
 
170
        MOVL arg4+12(FP), CX
 
171
        NACL_SYSJMP(SYS_thread_create)
 
172
 
 
173
TEXT runtime·mstart_nacl(SB),NOSPLIT,$0
 
174
        NACL_SYSCALL(SYS_tls_get)
 
175
        SUBL    $8, AX
 
176
        MOVL    AX, TLS
 
177
        JMP runtime·mstart(SB)
 
178
 
 
179
TEXT runtime·nacl_nanosleep(SB),NOSPLIT,$0
 
180
        MOVL arg1+0(FP), DI
 
181
        MOVL arg2+4(FP), SI
 
182
        NACL_SYSJMP(SYS_nanosleep)
 
183
 
 
184
TEXT runtime·osyield(SB),NOSPLIT,$0
 
185
        NACL_SYSJMP(SYS_sched_yield)
 
186
 
 
187
TEXT runtime·mmap(SB),NOSPLIT,$8
 
188
        MOVL arg1+0(FP), DI
 
189
        MOVL arg2+4(FP), SI
 
190
        MOVL arg3+8(FP), DX
 
191
        MOVL arg4+12(FP), CX
 
192
        MOVL arg5+16(FP), R8
 
193
        MOVL arg6+20(FP), AX
 
194
        MOVQ AX, 0(SP)
 
195
        MOVL SP, R9
 
196
        NACL_SYSCALL(SYS_mmap)
 
197
        CMPL AX, $-4095
 
198
        JNA 2(PC)
 
199
        NEGL AX
 
200
        RET
 
201
 
 
202
TEXT time·now(SB),NOSPLIT,$16
 
203
        MOVQ runtime·timens(SB), AX
 
204
        CMPQ AX, $0
 
205
        JEQ realtime
 
206
        MOVQ $0, DX
 
207
        MOVQ $1000000000, CX
 
208
        DIVQ CX
 
209
        MOVQ AX, sec+0(FP)
 
210
        MOVL DX, nsec+8(FP)
 
211
        RET
 
212
realtime:
 
213
        MOVL $0, DI // real time clock
 
214
        LEAL 0(SP), AX
 
215
        MOVL AX, SI // timespec
 
216
        NACL_SYSCALL(SYS_clock_gettime)
 
217
        MOVL 0(SP), AX // low 32 sec
 
218
        MOVL 4(SP), CX // high 32 sec
 
219
        MOVL 8(SP), BX // nsec
 
220
 
 
221
        // sec is in AX, nsec in BX
 
222
        MOVL    AX, sec+0(FP)
 
223
        MOVL    CX, sec+4(FP)
 
224
        MOVL    BX, nsec+8(FP)
 
225
        RET
 
226
 
 
227
TEXT syscall·now(SB),NOSPLIT,$0
 
228
        JMP time·now(SB)
 
229
 
 
230
TEXT runtime·nacl_clock_gettime(SB),NOSPLIT,$0
 
231
        MOVL arg1+0(FP), DI
 
232
        MOVL arg2+4(FP), SI
 
233
        NACL_SYSJMP(SYS_clock_gettime)
 
234
 
 
235
TEXT runtime·nanotime(SB),NOSPLIT,$16
 
236
        MOVQ runtime·timens(SB), AX
 
237
        CMPQ AX, $0
 
238
        JEQ 2(PC)
 
239
        RET
 
240
        MOVL $0, DI // real time clock
 
241
        LEAL 0(SP), AX
 
242
        MOVL AX, SI // timespec
 
243
        NACL_SYSCALL(SYS_clock_gettime)
 
244
        MOVQ 0(SP), AX // sec
 
245
        MOVL 8(SP), DX // nsec
 
246
 
 
247
        // sec is in AX, nsec in DX
 
248
        // return nsec in AX
 
249
        IMULQ   $1000000000, AX
 
250
        ADDQ    DX, AX
 
251
        RET
 
252
 
 
253
TEXT runtime·sigtramp(SB),NOSPLIT,$80
 
254
        // restore TLS register at time of execution,
 
255
        // in case it's been smashed.
 
256
        // the TLS register is really BP, but for consistency
 
257
        // with non-NaCl systems it is referred to here as TLS.
 
258
        // NOTE: Cannot use SYS_tls_get here (like we do in mstart_nacl),
 
259
        // because the main thread never calls tls_set.
 
260
        LEAL ctxt+0(FP), AX
 
261
        MOVL (16*4+5*8)(AX), AX
 
262
        MOVL    AX, TLS
 
263
 
 
264
        // check that m exists
 
265
        get_tls(CX)
 
266
        MOVL    m(CX), BX
 
267
        
 
268
        CMPL    BX, $0
 
269
        JEQ     nom
 
270
 
 
271
        // save g
 
272
        MOVL    g(CX), DI
 
273
        MOVL    DI, 20(SP)
 
274
        
 
275
        // g = m->gsignal
 
276
        MOVL    m_gsignal(BX), BX
 
277
        MOVL    BX, g(CX)
 
278
 
 
279
//JMP debughandler
 
280
 
 
281
        // copy arguments for sighandler
 
282
        MOVL    $11, 0(SP) // signal
 
283
        MOVL    $0, 4(SP) // siginfo
 
284
        LEAL    ctxt+0(FP), AX
 
285
        MOVL    AX, 8(SP) // context
 
286
        MOVL    DI, 12(SP) // g
 
287
 
 
288
        CALL    runtime·sighandler(SB)
 
289
 
 
290
        // restore g
 
291
        get_tls(CX)
 
292
        MOVL    20(SP), BX
 
293
        MOVL    BX, g(CX)
 
294
 
 
295
sigtramp_ret:
 
296
        // Enable exceptions again.
 
297
        NACL_SYSCALL(SYS_exception_clear_flag)
 
298
 
 
299
        // Restore registers as best we can. Impossible to do perfectly.
 
300
        // See comment in sys_nacl_386.s for extended rationale.
 
301
        LEAL    ctxt+0(FP), SI
 
302
        ADDL    $64, SI
 
303
        MOVQ    0(SI), AX
 
304
        MOVQ    8(SI), CX
 
305
        MOVQ    16(SI), DX
 
306
        MOVQ    24(SI), BX
 
307
        MOVL    32(SI), SP      // MOVL for SP sandboxing
 
308
        // 40(SI) is saved BP aka TLS, already restored above
 
309
        // 48(SI) is saved SI, never to be seen again
 
310
        MOVQ    56(SI), DI
 
311
        MOVQ    64(SI), R8
 
312
        MOVQ    72(SI), R9
 
313
        MOVQ    80(SI), R10
 
314
        MOVQ    88(SI), R11
 
315
        MOVQ    96(SI), R12
 
316
        MOVQ    104(SI), R13
 
317
        MOVQ    112(SI), R14
 
318
        // 120(SI) is R15, which is owned by Native Client and must not be modified
 
319
        MOVQ    128(SI), SI // saved PC
 
320
        // 136(SI) is saved EFLAGS, never to be seen again
 
321
        JMP     SI
 
322
 
 
323
debughandler:
 
324
        // print basic information
 
325
        LEAL    ctxt+0(FP), DI
 
326
        MOVL    $runtime·sigtrampf(SB), AX
 
327
        MOVL    AX, 0(SP)
 
328
        MOVQ    (16*4+16*8)(DI), BX // rip
 
329
        MOVQ    BX, 8(SP)
 
330
        MOVQ    (16*4+0*8)(DI), BX // rax
 
331
        MOVQ    BX, 16(SP)
 
332
        MOVQ    (16*4+1*8)(DI), BX // rcx
 
333
        MOVQ    BX, 24(SP)
 
334
        MOVQ    (16*4+2*8)(DI), BX // rdx
 
335
        MOVQ    BX, 32(SP)
 
336
        MOVQ    (16*4+3*8)(DI), BX // rbx
 
337
        MOVQ    BX, 40(SP)
 
338
        MOVQ    (16*4+7*8)(DI), BX // rdi
 
339
        MOVQ    BX, 48(SP)
 
340
        MOVQ    (16*4+15*8)(DI), BX // r15
 
341
        MOVQ    BX, 56(SP)
 
342
        MOVQ    (16*4+4*8)(DI), BX // rsp
 
343
        MOVQ    0(BX), BX
 
344
        MOVQ    BX, 64(SP)
 
345
        CALL    runtime·printf(SB)
 
346
        
 
347
        LEAL    ctxt+0(FP), DI
 
348
        MOVQ    (16*4+16*8)(DI), BX // rip
 
349
        MOVL    BX, 0(SP)
 
350
        MOVQ    (16*4+4*8)(DI), BX // rsp
 
351
        MOVL    BX, 4(SP)
 
352
        MOVL    $0, 8(SP)       // lr
 
353
        get_tls(CX)
 
354
        MOVL    g(CX), BX
 
355
        MOVL    BX, 12(SP)      // gp
 
356
        CALL    runtime·traceback(SB)
 
357
 
 
358
notls:
 
359
        MOVL    0, AX
 
360
        RET
 
361
 
 
362
nom:
 
363
        MOVL    0, AX
 
364
        RET
 
365
 
 
366
// cannot do real signal handling yet, because gsignal has not been allocated.
 
367
MOVL $1, DI; NACL_SYSCALL(SYS_exit)
 
368
 
 
369
TEXT runtime·nacl_sysinfo(SB),NOSPLIT,$16
 
370
/*
 
371
        MOVL    di+0(FP), DI
 
372
        LEAL    12(DI), BX
 
373
        MOVL    8(DI), AX
 
374
        ADDL    4(DI), AX
 
375
        ADDL    $2, AX
 
376
        LEAL    (BX)(AX*4), BX
 
377
        MOVL    BX, runtime·nacl_irt_query(SB)
 
378
auxloop:
 
379
        MOVL    0(BX), DX
 
380
        CMPL    DX, $0
 
381
        JNE     2(PC)
 
382
        RET
 
383
        CMPL    DX, $32
 
384
        JEQ     auxfound
 
385
        ADDL    $8, BX
 
386
        JMP     auxloop
 
387
auxfound:
 
388
        MOVL    4(BX), BX
 
389
        MOVL    BX, runtime·nacl_irt_query(SB)
 
390
 
 
391
        LEAL    runtime·nacl_irt_basic_v0_1_str(SB), DI
 
392
        LEAL    runtime·nacl_irt_basic_v0_1(SB), SI
 
393
        MOVL    runtime·nacl_irt_basic_v0_1_size(SB), DX
 
394
        MOVL    runtime·nacl_irt_query(SB), BX
 
395
        CALL    BX
 
396
 
 
397
        LEAL    runtime·nacl_irt_memory_v0_3_str(SB), DI
 
398
        LEAL    runtime·nacl_irt_memory_v0_3(SB), SI
 
399
        MOVL    runtime·nacl_irt_memory_v0_3_size(SB), DX
 
400
        MOVL    runtime·nacl_irt_query(SB), BX
 
401
        CALL    BX
 
402
 
 
403
        LEAL    runtime·nacl_irt_thread_v0_1_str(SB), DI
 
404
        LEAL    runtime·nacl_irt_thread_v0_1(SB), SI
 
405
        MOVL    runtime·nacl_irt_thread_v0_1_size(SB), DX
 
406
        MOVL    runtime·nacl_irt_query(SB), BX
 
407
        CALL    BX
 
408
 
 
409
        // TODO: Once we have a NaCl SDK with futex syscall support,
 
410
        // try switching to futex syscalls and here load the
 
411
        // nacl-irt-futex-0.1 table.
 
412
*/
 
413
        RET