← Back to branch summary

~ubuntu-branches/ubuntu/utopic/golang/utopic

« back to all changes in this revision

Viewing changes to src/pkg/runtime/sys_plan9_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_plan9_amd64.s
 
1
// Copyright 2010 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
 
 
7
// setldt(int entry, int address, int limit)
 
8
TEXT runtime·setldt(SB),7,$0
 
9
        RET
 
10
 
 
11
TEXT runtime·open(SB),7,$0
 
12
        MOVQ    $0x8000, AX
 
13
        MOVQ    $14, BP
 
14
        SYSCALL
 
15
        RET
 
16
 
 
17
TEXT runtime·pread(SB),7,$0
 
18
        MOVQ    $0x8000, AX
 
19
        MOVQ    $50, BP
 
20
        SYSCALL
 
21
        RET
 
22
 
 
23
TEXT runtime·pwrite(SB),7,$0
 
24
        MOVQ    $0x8000, AX
 
25
        MOVQ    $51, BP
 
26
        SYSCALL
 
27
        RET
 
28
 
 
29
// int32 _seek(int64*, int32, int64, int32)
 
30
TEXT _seek<>(SB),7,$0
 
31
        MOVQ    $0x8000, AX
 
32
        MOVQ    $39, BP
 
33
        SYSCALL
 
34
        RET
 
35
 
 
36
// int64 seek(int32, int64, int32)
 
37
TEXT runtime·seek(SB),7,$56
 
38
        LEAQ    new+48(SP), CX
 
39
        MOVQ    CX, 0(SP)
 
40
        MOVQ    fd+0(FP), CX
 
41
        MOVQ    CX, 8(SP)
 
42
        MOVQ    off+8(FP), CX
 
43
        MOVQ    CX, 16(SP)
 
44
        MOVQ    whence+16(FP), CX
 
45
        MOVQ    CX, 24(SP)
 
46
        CALL    _seek<>(SB)
 
47
        CMPL    AX, $0
 
48
        JGE     2(PC)
 
49
        MOVQ    $-1, new+48(SP)
 
50
        MOVQ    new+48(SP), AX
 
51
        RET
 
52
 
 
53
TEXT runtime·close(SB),7,$0
 
54
        MOVQ    $0x8000, AX
 
55
        MOVQ    $4, BP
 
56
        SYSCALL
 
57
        RET
 
58
 
 
59
TEXT runtime·exits(SB),7,$0
 
60
        MOVQ    $0x8000, AX
 
61
        MOVQ    $8, BP
 
62
        SYSCALL
 
63
        RET
 
64
 
 
65
TEXT runtime·brk_(SB),7,$0
 
66
        MOVQ    $0x8000, AX
 
67
        MOVQ    $24, BP
 
68
        SYSCALL
 
69
        RET
 
70
 
 
71
TEXT runtime·sleep(SB),7,$0
 
72
        MOVQ    $0x8000, AX
 
73
        MOVQ    $17, BP
 
74
        SYSCALL
 
75
        RET
 
76
 
 
77
TEXT runtime·plan9_semacquire(SB),7,$0
 
78
        MOVQ    $0x8000, AX
 
79
        MOVQ    $37, BP
 
80
        SYSCALL
 
81
        RET
 
82
 
 
83
TEXT runtime·plan9_tsemacquire(SB),7,$0
 
84
        MOVQ    $0x8000, AX
 
85
        MOVQ    $52, BP
 
86
        SYSCALL
 
87
        RET
 
88
 
 
89
TEXT runtime·notify(SB),7,$0
 
90
        MOVQ    $0x8000, AX
 
91
        MOVQ    $28, BP
 
92
        SYSCALL
 
93
        RET
 
94
 
 
95
TEXT runtime·noted(SB),7,$0
 
96
        MOVQ    $0x8000, AX
 
97
        MOVQ    $29, BP
 
98
        SYSCALL
 
99
        RET
 
100
        
 
101
TEXT runtime·plan9_semrelease(SB),7,$0
 
102
        MOVQ    $0x8000, AX
 
103
        MOVQ    $38, BP
 
104
        SYSCALL
 
105
        RET
 
106
 
 
107
TEXT runtime·nanotime(SB),7,$0
 
108
        MOVQ    $0x8000, AX
 
109
        MOVQ    $60, BP
 
110
        SYSCALL
 
111
        RET
 
112
 
 
113
TEXT runtime·rfork(SB),7,$0
 
114
        MOVQ    $0x8000, AX
 
115
        MOVQ    $19, BP // rfork
 
116
        SYSCALL
 
117
 
 
118
        // In parent, return.
 
119
        CMPQ    AX, $0
 
120
        JEQ     2(PC)
 
121
        RET
 
122
 
 
123
        // In child on forked stack.
 
124
        MOVQ    mm+24(SP), BX   // m
 
125
        MOVQ    gg+32(SP), DX   // g
 
126
        MOVQ    fn+40(SP), SI   // fn
 
127
 
 
128
        // set SP to be on the new child stack
 
129
        MOVQ    stack+16(SP), CX
 
130
        MOVQ    CX, SP
 
131
 
 
132
        // Initialize m, g.
 
133
        get_tls(AX)
 
134
        MOVQ    DX, g(AX)
 
135
        MOVQ    BX, m(AX)
 
136
 
 
137
        // Initialize AX from pid in TLS.
 
138
        MOVQ    procid(AX), AX
 
139
        MOVQ    AX, m_procid(BX)        // save pid as m->procid
 
140
        
 
141
        CALL    runtime·stackcheck(SB)  // smashes AX, CX
 
142
        
 
143
        MOVQ    0(DX), DX       // paranoia; check they are not nil
 
144
        MOVQ    0(BX), BX
 
145
        
 
146
        CALL    SI      // fn()
 
147
        CALL    runtime·exit(SB)
 
148
        RET
 
149
 
 
150
// This is needed by asm_amd64.s
 
151
TEXT runtime·settls(SB),7,$0
 
152
        RET
 
153
 
 
154
// void sigtramp(void *ureg, int8 *note)
 
155
TEXT runtime·sigtramp(SB),7,$0
 
156
        get_tls(AX)
 
157
 
 
158
        // check that m exists
 
159
        MOVQ    m(AX), BX
 
160
        CMPQ    BX, $0
 
161
        JNE     3(PC)
 
162
        CALL    runtime·badsignal(SB) // will exit
 
163
        RET
 
164
 
 
165
        // save args
 
166
        MOVQ    ureg+8(SP), CX
 
167
        MOVQ    note+16(SP), DX
 
168
 
 
169
        // change stack
 
170
        MOVQ    m_gsignal(BX), R10
 
171
        MOVQ    g_stackbase(R10), BP
 
172
        MOVQ    BP, SP
 
173
 
 
174
        // make room for args and g
 
175
        SUBQ    $32, SP
 
176
 
 
177
        // save g
 
178
        MOVQ    g(AX), BP
 
179
        MOVQ    BP, 24(SP)
 
180
 
 
181
        // g = m->gsignal
 
182
        MOVQ    R10, g(AX)
 
183
 
 
184
        // load args and call sighandler
 
185
        MOVQ    CX, 0(SP)
 
186
        MOVQ    DX, 8(SP)
 
187
        MOVQ    BP, 16(SP)
 
188
 
 
189
        CALL    runtime·sighandler(SB)
 
190
 
 
191
        // restore g
 
192
        get_tls(BX)
 
193
        MOVQ    24(SP), R10
 
194
        MOVQ    R10, g(BX)
 
195
 
 
196
        // call noted(AX)
 
197
        MOVQ    AX, 0(SP)
 
198
        CALL    runtime·noted(SB)
 
199
        RET
 
200
 
 
201
TEXT runtime·setfpmasks(SB),7,$8
 
202
        STMXCSR 0(SP)
 
203
        MOVL    0(SP), AX
 
204
        ANDL    $~0x3F, AX
 
205
        ORL     $(0x3F<<7), AX
 
206
        MOVL    AX, 0(SP)
 
207
        LDMXCSR 0(SP)
 
208
        RET
 
209
 
 
210
#define ERRMAX 128      /* from os_plan9.h */
 
211
 
 
212
// func errstr() String
 
213
// Only used by package syscall.
 
214
// Grab error string due to a syscall made
 
215
// in entersyscall mode, without going
 
216
// through the allocator (issue 4994).
 
217
// See ../syscall/asm_plan9_386.s:/·Syscall/
 
218
TEXT runtime·errstr(SB),7,$0
 
219
        get_tls(AX)
 
220
        MOVQ    m(AX), BX
 
221
        MOVQ    m_errstr(BX), CX
 
222
        MOVQ    CX, 8(SP)
 
223
        MOVQ    $ERRMAX, 16(SP)
 
224
        MOVQ    $0x8000, AX
 
225
        MOVQ    $41, BP
 
226
        SYSCALL
 
227
 
 
228
        // syscall requires caller-save
 
229
        MOVQ    8(SP), CX
 
230
 
 
231
        // push the argument
 
232
        PUSHQ   CX
 
233
        CALL    runtime·findnull(SB)
 
234
        POPQ    CX
 
235
        MOVQ    AX, 16(SP)
 
236
        RET