about summary refs log tree commit diff stats
path: root/init.linux
blob: 6e482b9658fbba93be24050e60bdd84838eb2f46 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
# Some OS-specific preliminaries for Linux.

# Memory layout
#
#          0 - 0x08047ffff - reserved for the kernel
# 0x08048000 - 0xbffffffff - available for user programs
# 0xc0000000 - 0xfffffffff - reserved for the kernel
== code 0x09000000
== data 0x0a000000

# Syscalls
#
# We don't have libc, so we need to know Linux's precise syscall layout.
# These are not real functions. Pass arguments in specific registers.
== code

# http://man7.org/linux/man-pages/man2/exit.2.html
syscall_exit:  # status/ebx: int
    b8/copy-to-eax 1/imm32
    cd/syscall 0x80/imm8

# http://man7.org/linux/man-pages/man2/read.2.html
syscall_read:  # fd/ebx: int, buf/ecx: addr, size/edx: int -> nbytes-or-error/eax: int
    b8/copy-to-eax 3/imm32
    cd/syscall 0x80/imm8
    c3/return

# http://man7.org/linux/man-pages/man2/write.2.html
syscall_write:  # fd/ebx: int, buf/ecx: addr, size/edx: int -> nbytes-or-error/eax: int
    b8/copy-to-eax 4/imm32
    cd/syscall 0x80/imm8
    c3/return

# http://man7.org/linux/man-pages/man2/open.2.html
syscall_open:  # filename/ebx: (addr kernel-string), flags/ecx: int, dummy=0x180/edx -> fd-or-error/eax: int
    b8/copy-to-eax 5/imm32
    cd/syscall 0x80/imm8
    c3/return

# http://man7.org/linux/man-pages/man2/close.2.html
syscall_close:  # fd/ebx: int -> status/eax
    b8/copy-to-eax 6/imm32
    cd/syscall 0x80/imm8
    c3/return

# http://man7.org/linux/man-pages/man2/creat.2.html
syscall_creat:  # filename/ebx: (addr kernel-string) -> fd-or-error/eax: int
    b8/copy-to-eax 8/imm32
    cd/syscall 0x80/imm8
    c3/return

# http://man7.org/linux/man-pages/man2/unlink.2.html
syscall_unlink:  # filename/ebx: (addr kernel-string) -> status/eax: int
    b8/copy-to-eax 0xa/imm32
    cd/syscall 0x80/imm8
    c3/return

# http://man7.org/linux/man-pages/man2/rename.2.html
syscall_rename:  # source/ebx: (addr kernel-string), dest/ecx: (addr kernel-string) -> status/eax: int
    b8/copy-to-eax 0x26/imm32
    cd/syscall 0x80/imm8
    c3/return

# https://github.com/torvalds/linux/blob/fa121bb3fed6313b1f0af23952301e06cf6d32ed/mm/nommu.c#L1352
syscall_mmap:  # arg/ebx: (addr mmap_arg_struct) -> status/eax: int
    # the important thing: ebx+4 contains the 32-bit size to be allocated
    b8/copy-to-eax 0x5a/imm32
    cd/syscall 0x80/imm8
    c3/return

syscall_ioctl:  # fd/ebx: int, cmd/ecx: int, arg/edx: (addr _)
    b8/copy-to-eax 0x36/imm32
    cd/syscall 0x80/imm8
    c3/return

syscall_nanosleep:  # req/ebx: (addr timespec)
    b8/copy-to-eax 0xa2/imm32  # 162
    cd/syscall 0x80/imm8
    c3/return

syscall_clock_gettime:  # clock/ebx: int, out/ecx: (addr timespec)
    b8/copy-to-eax 0x109/imm32  # 265
    cd/syscall 0x80/imm8
    c3/return
25384db8907f846f3c053379cf5b431c4d28760'>e25384db8 ^
8b2a9401a ^
405b86068


b5aafb4cf ^
405b86068
8b2a9401a ^
990dc2d71 ^
405b86068
8b2a9401a ^
990dc2d71 ^



405b86068
e8376067e ^





4de5b82fd ^
e8376067e ^
4de5b82fd ^
e8376067e ^

4de5b82fd ^
e8376067e ^
405b86068


8b2a9401a ^
405b86068








ff02ce2d5 ^

405b86068


8b2a9401a ^





405b86068





286e5958d ^
405b86068









286e5958d ^
405b86068
















8b2a9401a ^
b5aafb4cf ^
405b86068

b5aafb4cf ^
4de5b82fd ^
405b86068
8b2a9401a ^


405b86068
8b2a9401a ^
4de5b82fd ^
405b86068

8b2a9401a ^
405b86068



8b2a9401a ^
405b86068











db4f617af ^
405b86068
db4f617af ^
405b86068

8b2a9401a ^







286e5958d ^

8b2a9401a ^











405b86068

ff02ce2d5 ^
8b2a9401a ^














db4f617af ^
e792940f5 ^
286e5958d ^
e792940f5 ^

8b2a9401a ^



405b86068

ff02ce2d5 ^
405b86068
















07d5a8085 ^
405b86068
fa111b906 ^
405b86068
405b86068
ff02ce2d5 ^
405b86068


















07d5a8085 ^

405b86068
07d5a8085 ^
405b86068


405b86068




990dc2d71 ^






405b86068
990dc2d71 ^
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305


                                     
                                         












                                                                    
                                       


                                                                 
 
                                                                




                                 
                                                                


                                       
                                                           
 






                                                


                                                           
                                                
                  
 
                                                       

                            
 






                                                                              
                            
       
                              



                                                                    
                                                                   


                                                    
                                                     
 
                                                             
                                       
 
                                                             



                                                                 
 





                                                                             
                                    
         
                                                    

                        
                                                
 


                                                                           
           








                       

                                                


                                       





                                                                   





                                               
                                               









                                              
                                              
















                                              
                                                                             
                                     

                    
                                                       
                                                                         
                     


                                                                         
 
                                                                  
                                                            

                        
                                                                    



                              
                                                                          











                                                                             
                                          
   
                            

                                   







                                                                

                   











                                                                           

                                                                          
                   














                                                                          
                                                      
                                      
                                                                   

                                                                     



                                                                       

                                                                          
                                                  
















                                                  
                                                       
                              
                             
             
 
                                                      


















                                                          

                                                     
 
                                                     


                       




                                                                             






                              
       
               
#
#
#            Nimrod's Runtime Library
#        (c) Copyright 2012 Andreas Rumpf
#
#    See the file "copying.txt", included in this
#    distribution, for details about the copyright.
#

# string & sequence handling procedures needed by the code generator

# strings are dynamically resized, have a length field
# and are zero-terminated, so they can be casted to C
# strings easily
# we don't use refcounts because that's a behaviour
# the programmer may not want

proc resize(old: int): int {.inline.} =
  if old <= 0: result = 4
  elif old < 65536: result = old * 2
  else: result = old * 3 div 2 # for large arrays * 3/2 is better

proc cmpStrings(a, b: NimString): int {.inline, compilerProc.} =
  if a == b: return 0
  if a == nil: return -1
  if b == nil: return 1
  return c_strcmp(a.data, b.data)

proc eqStrings(a, b: NimString): bool {.inline, compilerProc.} =
  if a == b: return true
  if a == nil or b == nil: return false
  return a.len == b.len and
    c_memcmp(a.data, b.data, a.len * sizeof(char)) == 0'i32

when defined(allocAtomic):
  template allocStr(size: expr): expr =
    cast[NimString](allocAtomic(size))
else:
  template allocStr(size: expr): expr =
    cast[NimString](newObj(addr(strDesc), size))

proc rawNewString(space: int): NimString {.compilerProc.} =
  var s = space
  if s < 8: s = 7
  result = allocStr(sizeof(TGenericSeq) + s + 1)
  result.space = s

proc mnewString(len: int): NimString {.compilerProc.} =
  result = rawNewString(len)
  result.len = len

proc copyStrLast(s: NimString, start, last: int): NimString {.compilerProc.} =
  var start = max(start, 0)
  var len = min(last, s.len-1) - start + 1
  if len > 0:
    result = rawNewString(len)
    result.len = len
    c_memcpy(result.data, addr(s.data[start]), len * sizeof(Char))
    #result.data[len] = '\0'
  else:
    result = rawNewString(len)

proc copyStr(s: NimString, start: int): NimString {.compilerProc.} =
  result = copyStrLast(s, start, s.len-1)

proc toNimStr(str: CString, len: int): NimString {.compilerProc.} =
  result = rawNewString(len)
  result.len = len
  c_memcpy(result.data, str, (len+1) * sizeof(Char))
  #result.data[len] = '\0' # readline relies on this!

proc cstrToNimstr(str: CString): NimString {.compilerProc.} =
  result = toNimstr(str, c_strlen(str))

proc copyString(src: NimString): NimString {.compilerProc.} =
  if src != nil:
    result = rawNewString(src.space)
    result.len = src.len
    c_memcpy(result.data, src.data, (src.len + 1) * sizeof(Char))

proc copyStringRC1(src: NimString): NimString {.compilerProc.} =
  if src != nil:
    var s = src.space
    if s < 8: s = 7
    when defined(newObjRC1):
      result = cast[NimString](newObjRC1(addr(strDesc), sizeof(TGenericSeq) +
                               s+1))
    else:
      result = allocStr(sizeof(TGenericSeq) + s + 1)
    result.space = s
    result.len = src.len
    c_memcpy(result.data, src.data, src.len + 1)

proc hashString(s: string): int {.compilerproc.} =
  # the compiler needs exactly the same hash function!
  # this used to be used for efficient generation of string case statements
  var h = 0
  for i in 0..Len(s)-1:
    h = h +% Ord(s[i])
    h = h +% h shl 10
    h = h xor (h shr 6)
  h = h +% h shl 3
  h = h xor (h shr 11)
  h = h +% h shl 15
  result = h

proc addChar(s: NimString, c: char): NimString =
  # is compilerproc!
  result = s
  if result.len >= result.space:
    result.space = resize(result.space)
    result = cast[NimString](growObj(result,
      sizeof(TGenericSeq) + (result.space+1) * sizeof(char)))
    #var space = resize(result.space)
    #result = rawNewString(space)
    #copyMem(result, s, s.len * sizeof(char) + sizeof(TGenericSeq))
    #result.space = space
  result.data[result.len] = c
  result.data[result.len+1] = '\0'
  inc(result.len)

# These routines should be used like following:
#   <Nimrod code>
#   s &= "Hello " & name & ", how do you feel?"
#
#   <generated C code>
#   {
#     s = resizeString(s, 6 + name->len + 17);
#     appendString(s, strLit1);
#     appendString(s, strLit2);
#     appendString(s, strLit3);
#   }
#
#   <Nimrod code>
#   s = "Hello " & name & ", how do you feel?"
#
#   <generated C code>
#   {
#     string tmp0;
#     tmp0 = rawNewString(6 + name->len + 17);
#     appendString(s, strLit1);
#     appendString(s, strLit2);
#     appendString(s, strLit3);
#     s = tmp0;
#   }
#
#   <Nimrod code>
#   s = ""
#
#   <generated C code>
#   s = rawNewString(0);

proc resizeString(dest: NimString, addlen: int): NimString {.compilerproc.} =
  if dest.len + addLen <= dest.space:
    result = dest
  else: # slow path:
    var sp = max(resize(dest.space), dest.len + addLen)
    result = cast[NimString](growObj(dest, sizeof(TGenericSeq) + sp + 1))
    result.space = sp
    #result = rawNewString(sp)
    #copyMem(result, dest, dest.len * sizeof(char) + sizeof(TGenericSeq))
    # DO NOT UPDATE LEN YET: dest.len = newLen

proc appendString(dest, src: NimString) {.compilerproc, inline.} =
  c_memcpy(addr(dest.data[dest.len]), src.data, src.len + 1)
  inc(dest.len, src.len)

proc appendChar(dest: NimString, c: char) {.compilerproc, inline.} =
  dest.data[dest.len] = c
  dest.data[dest.len+1] = '\0'
  inc(dest.len)

proc setLengthStr(s: NimString, newLen: int): NimString {.compilerProc.} =
  var n = max(newLen, 0)
  if n <= s.space:
    result = s
  else:
    result = resizeString(s, n)
  result.len = n
  result.data[n] = '\0'

# ----------------- sequences ----------------------------------------------

proc incrSeq(seq: PGenericSeq, elemSize: int): PGenericSeq {.compilerProc.} =
  # increments the length by one:
  # this is needed for supporting ``add``;
  #
  #  add(seq, x)  generates:
  #  seq = incrSeq(seq, sizeof(x));
  #  seq[seq->len-1] = x;
  when false:
    # broken version:
    result = seq
    if result.len >= result.space:
      var s = resize(result.space)
      result = cast[PGenericSeq](newSeq(extGetCellType(seq), s))
      genericSeqAssign(result, seq, XXX)
      #copyMem(result, seq, seq.len * elemSize + GenericSeqSize)
    inc(result.len)
  else:
    result = seq
    if result.len >= result.space:
      result.space = resize(result.space)
      result = cast[PGenericSeq](growObj(result, elemSize * result.space +
                                 GenericSeqSize))
      # set new elements to zero:
      #var s = cast[TAddress](result)
      #zeroMem(cast[pointer](s + GenericSeqSize + (result.len * elemSize)),
      #  (result.space - result.len) * elemSize)
      # for i in len .. space-1:
      #   seq->data[i] = 0
    inc(result.len)

proc setLengthSeq(seq: PGenericSeq, elemSize, newLen: int): PGenericSeq {.
    compilerRtl.} =
  when false:
    # broken version:
    result = seq
    if result.space < newLen:
      var s = max(resize(result.space), newLen)
      result = cast[PGenericSeq](newSeq(extGetCellType(seq), s))
    result.len = newLen
  else:
    result = seq
    if result.space < newLen:
      result.space = max(resize(result.space), newLen)
      result = cast[PGenericSeq](growObj(result, elemSize * result.space +
                                 GenericSeqSize))
    elif newLen < result.len:
      # we need to decref here, otherwise the GC leaks!
      when not defined(boehmGC) and not defined(nogc):
        for i in newLen..result.len-1:
          forAllChildrenAux(cast[pointer](cast[TAddress](result) +%
                            GenericSeqSize +% (i*%elemSize)),
                            extGetCellType(result).base, waZctDecRef)
      # and set the memory to nil:
      zeroMem(cast[pointer](cast[TAddress](result) +% GenericSeqSize +%
             (newLen*%elemSize)), (result.len-%newLen) *% elemSize)
    result.len = newLen

# --------------- other string routines ----------------------------------
proc nimIntToStr(x: int): string {.compilerRtl.} =
  result = newString(sizeof(x)*4)
  var i = 0
  var y = x
  while True:
    var d = y div 10
    result[i] = chr(abs(int(y - d*10)) + ord('0'))
    inc(i)
    y = d
    if y == 0: break
  if x < 0:
    result[i] = '-'
    inc(i)
  setLen(result, i)
  # mirror the string:
  for j in 0..i div 2 - 1:
    swap(result[j], result[i-j-1])

proc nimFloatToStr(x: float): string {.compilerproc.} =
  var buf: array [0..59, char]
  c_sprintf(buf, "%#.16e", x)
  return $buf

proc nimInt64ToStr(x: int64): string {.compilerRtl.} =
  # we don't rely on C's runtime here as some C compiler's
  # int64 support is weak
  result = newString(sizeof(x)*4)
  var i = 0
  var y = x
  while True:
    var d = y div 10
    result[i] = chr(abs(int(y - d*10)) + ord('0'))
    inc(i)
    y = d
    if y == 0: break
  if x < 0:
    result[i] = '-'
    inc(i)
  setLen(result, i)
  # mirror the string:
  for j in 0..i div 2 - 1:
    swap(result[j], result[i-j-1])

proc nimBoolToStr(x: bool): string {.compilerproc.} =
  return if x: "true" else: "false"

proc nimCharToStr(x: char): string {.compilerproc.} =
  result = newString(1)
  result[0] = x

proc binaryStrSearch(x: openarray[string], y: string): int {.compilerproc.} =
  var
    a = 0
    b = len(x)
  while a < b:
    var mid = (a + b) div 2
    if x[mid] < y:
      a = mid + 1
    else:
      b = mid
  if a < len(x) and x[a] == y:
    result = a
  else:
    result = -1