chiark - git - mdw - ssr/blob - StraySrc/Libraries/Steel/s/os

   1 ;
   2 ; os.s
   3 ;
   4 ; RISC OS kernel interface
   5 ;
   6 ; © 1994-1998 Straylight
   7 ;
   8
   9 ;----- Licensing note -------------------------------------------------------
  10 ;
  11 ; This file is part of Straylight's Steel library.
  12 ;
  13 ; Steel is free software; you can redistribute it and/or modify
  14 ; it under the terms of the GNU General Public License as published by
  15 ; the Free Software Foundation; either version 2, or (at your option)
  16 ; any later version.
  17 ;
  18 ; Steel is distributed in the hope that it will be useful,
  19 ; but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 ; GNU General Public License for more details.
  22 ;
  23 ; You should have received a copy of the GNU General Public License
  24 ; along with Steel.  If not, write to the Free Software Foundation,
  25 ; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  26
  27 ;----- Standard stuff -------------------------------------------------------
  28
  29                 GET     libs:header
  30                 GET     libs:swis
  31
  32 ;----- Generic SWI interface ------------------------------------------------
  33
  34                 AREA    |C$$Code|,CODE,READONLY
  35                 GET     libs:s.swihack
  36
  37 ; --- os_swi ---
  38 ;
  39 ; On entry:     a1 == SWI number
  40 ;               a2 == pointer to register set
  41
  42                 EXPORT  os_swi
  43
  44 os_swi          STMFD   R13!,{R1,R4-R10,R14}    ;Save registers
  45                 BIC     R10,R0,#&20000          ;Strip the X bit
  46                 LDMIA   R1,{R0-R9}              ;Load lots of registers
  47                 MOV     R14,PC                  ;Set return address
  48                 LDR     PC,_swihack             ;And call the hacky routine
  49                 LDR     R10,[R13],#4            ;Reload regset pointer
  50                 STMIA   R10,{R0-R9}             ;Save output registers
  51                 LDMFD   R13!,{R4-R10,PC}^       ;And return to caller
  52
  53                 LTORG
  54
  55 ; --- os_swix ---
  56 ;
  57 ; On entry:     a1 == SWI number
  58 ;               a2 == pointer to register set
  59
  60                 EXPORT  os_swix
  61
  62 os_swix         STMFD   R13!,{R1,R4-R10,R14}    ;Save registers
  63                 ORR     R10,R0,#&20000          ;Set the X bit
  64                 LDMIA   R1,{R0-R9}              ;Load lots of registers
  65                 MOV     R14,PC                  ;Set return address
  66                 LDR     PC,_swihack             ;And call the hacky routine
  67                 LDR     R10,[R13],#4            ;Reload regset pointer
  68                 STMIA   R10,{R0-R9}             ;Save output registers
  69                 MOVVC   R0,#0                   ;Return zero on no error
  70                 LDMFD   R13!,{R4-R10,PC}^       ;And return to caller
  71
  72                 LTORG
  73
  74 ;----- Fixed-parameter non-returning SWI interfaces -------------------------
  75
  76 ; --- os_swi0, os_swi1, os_swi2, os_swi3 ---
  77 ;
  78 ; On entry:     a1 == SWI number
  79 ;               a2,a3,a4 == R0,R1,R2 on entry to SWI
  80 ; On exit:      a1 == pointer to possible error
  81
  82                 EXPORT  os_swi0
  83                 EXPORT  os_swi1
  84                 EXPORT  os_swi2
  85                 EXPORT  os_swi3
  86 os_swi0
  87 os_swi1
  88 os_swi2
  89 os_swi3         STMFD   R13!,{R4-R10,R14}       ;Save registers
  90                 ORR     R10,R0,#&20000          ;Set the X bit
  91                 MOV     R0,R1
  92                 MOV     R1,R2
  93                 MOV     R2,R3
  94                 MOV     R14,PC                  ;Set return address
  95                 LDR     PC,_swihack             ;And call the hacky routine
  96                 MOVVC   R0,#0                   ;Return zero on no error
  97                 LDMFD   R13!,{R4-R10,PC}^       ;And return to caller
  98
  99                 LTORG
 100
 101 ; --- os_swi4, os_swi5, os_swi6 ---
 102 ;
 103 ; On entry:     a1 == SWI number
 104 ;               a2,a3,a4 == R0,R1,R2 on entry to SWI
 105 ;               [sp,#0],[sp,#4],[sp,#8] == R3,R4,R5 on entry to SWI
 106 ; On exit:      a1 == pointer to possible error
 107
 108                 EXPORT  os_swi4
 109                 EXPORT  os_swi5
 110                 EXPORT  os_swi6
 111 os_swi4
 112 os_swi5
 113 os_swi6         MOV     R12,R12                 ;Remember stack position
 114                 STMFD   R13!,{R1,R4-R10,R14}    ;Save registers
 115                 ORR     R10,R0,#&20000          ;Set the X bit
 116                 MOV     R0,R1
 117                 MOV     R1,R2
 118                 MOV     R2,R3
 119                 LDMIA   R12,{R3-R5}
 120                 MOV     R14,PC                  ;Set return address
 121                 LDR     PC,_swihack             ;And call the hacky routine
 122                 MOVVC   R0,#0                   ;Return zero on no error
 123                 LDMFD   R13!,{R4-R10,PC}^       ;And return to caller
 124
 125                 LTORG
 126
 127 ;----- Fixed-parameter, returning SWI interfaces ----------------------------
 128
 129 ; --- os__doSWI ---
 130 ;
 131 ; CAUTION: NOTHING LIKE APCS
 132 ;
 133 ; On entry:     R0-R5 == SWI registers
 134 ;               R6-R11 == where to output registers
 135 ;               R14 == SWI number
 136 ;               sp points to saved R4-R11 and R14 on stack
 137 ; On exit:      R0 == pointer to possible error
 138
 139 os__doSWI       ROUT
 140
 141                 STMFD   sp!,{R6-R11}            ;Save the pointers away
 142                 ORR     R10,R14,#&20000         ;Put in the X bit anyway
 143                 MOV     R14,PC
 144                 LDR     PC,_swihack
 145                 ADDVS   sp,sp,#24               ;Point back at saved regs
 146                 LDMVSFD sp!,{R4-R11,pc}^        ;If it failed, return now
 147
 148                 ; --- Refind the the pointers and store ---
 149
 150                 LDMFD   sp!,{R6-R11}            ;Get the output pointers
 151                 CMP     R6,#0
 152                 STRNE   R0,[R6]
 153                 CMP     R7,#0
 154                 STRNE   R1,[R7]
 155                 CMP     R8,#0
 156                 STRNE   R2,[R8]
 157                 CMP     R9,#0
 158                 STRNE   R3,[R9]
 159                 CMP     R10,#0
 160                 STRNE   R4,[R10]
 161                 CMP     R11,#0
 162                 STRNE   R5,[R11]
 163
 164                 ; --- Now return to the caller ---
 165
 166                 MOV     R0,#0                   ;There was no error
 167                 LDMFD   sp!,{R4-R11,pc}^        ;Return to caller
 168
 169                 LTORG
 170
 171 ; --- os_swi1r ---
 172
 173                 EXPORT  os_swi1r
 174 os_swi1r        MOV     ip,sp
 175                 STMFD   sp!,{R4-R11,lr}         ;We corrupt lots of registers
 176
 177                 MOV     R14,R0
 178
 179                 MOV     R0,R1
 180
 181                 MOV     R6,R2
 182                 MOV     R7,#0
 183                 MOV     R8,#0
 184                 MOV     R9,#0
 185                 MOV     R10,#0
 186                 MOV     R11,#0
 187
 188                 B       os__doSWI
 189
 190 ; --- os_swi2r ---
 191
 192                 EXPORT  os_swi2r
 193 os_swi2r        MOV     ip,sp
 194                 STMFD   sp!,{R4-R11,lr}         ;We corrupt lots of registers
 195
 196                 MOV     R14,R0
 197
 198                 MOV     R0,R1
 199                 MOV     R1,R2
 200
 201                 MOV     R6,R3
 202                 LDMIA   ip!,{R7}
 203                 MOV     R8,#0
 204                 MOV     R9,#0
 205                 MOV     R10,#0
 206                 MOV     R11,#0
 207
 208                 B       os__doSWI
 209
 210 ; --- os_swi3r ---
 211
 212                 EXPORT  os_swi3r
 213 os_swi3r        MOV     ip,sp
 214                 STMFD   sp!,{R4-R11,lr}         ;We corrupt lots of registers
 215
 216                 MOV     R14,R0
 217
 218                 MOV     R0,R1
 219                 MOV     R1,R2
 220                 MOV     R2,R3
 221
 222                 LDMIA   ip!,{R6-R8}
 223                 MOV     R9,#0
 224                 MOV     R10,#0
 225                 MOV     R11,#0
 226
 227                 B       os__doSWI
 228
 229 ; --- os_swi4r ---
 230
 231                 EXPORT  os_swi4r
 232 os_swi4r        MOV     ip,sp
 233                 STMFD   sp!,{R4-R11,lr}         ;We corrupt lots of registers
 234
 235                 MOV     R14,R0
 236
 237                 MOV     R0,R1
 238                 MOV     R1,R2
 239                 MOV     R2,R3
 240                 LDMIA   ip!,{R3}
 241
 242                 LDMIA   ip!,{R6-R9}
 243                 MOV     R10,#0
 244                 MOV     R11,#0
 245
 246                 B       os__doSWI
 247
 248 ; --- os_swi5r ---
 249
 250                 EXPORT  os_swi5r
 251 os_swi5r        MOV     ip,sp
 252                 STMFD   sp!,{R4-R11,lr}         ;We corrupt lots of registers
 253
 254                 MOV     R14,R0
 255
 256                 MOV     R0,R1
 257                 MOV     R1,R2
 258                 MOV     R2,R3
 259                 LDMIA   ip!,{R3,R4}
 260
 261                 LDMIA   ip!,{R6-R10}
 262                 MOV     R11,#0
 263
 264                 B       os__doSWI
 265
 266 ; --- os_swi6r ---
 267
 268                 EXPORT  os_swi6r
 269 os_swi6r        MOV     ip,sp
 270                 STMFD   sp!,{R4-R11,lr}         ;We corrupt lots of registers
 271
 272                 MOV     R14,R0
 273
 274                 MOV     R0,R1
 275                 MOV     R1,R2
 276                 MOV     R2,R3
 277                 LDMIA   ip!,{R3-R5}
 278
 279                 LDMIA   ip!,{R6-R11}
 280
 281                 B       os__doSWI
 282
 283 ;----- Variable number of registers -----------------------------------------
 284
 285 ; --- os_swiv ---
 286 ;
 287 ; On entry:     a1 == SWI number
 288 ;               a2... == registers
 289 ; On exit:      a1 == pointer to possible to area
 290
 291                 EXPORT  os_swiv
 292
 293 os_swiv         MOV     R12,R13
 294                 STMFD   R13!,{R4-R10,R14}       ;Save registers
 295                 ORR     R10,R0,#&20000          ;Set the X bit
 296                 MOV     R0,R1
 297                 MOV     R1,R2
 298                 MOV     R2,R3
 299                 LDMIA   R12,{R3-R9}
 300                 MOV     R14,PC                  ;Set return address
 301                 LDR     PC,_swihack             ;And call the hacky routine
 302                 MOVVC   R0,#0                   ;Return zero on no error
 303                 LDMFD   R13!,{R4-R10,PC}^       ;And return to caller
 304
 305                 LTORG
 306
 307 ; --- os_swivr ---
 308 ;
 309 ; On entry:     a1 == SWI number
 310 ;               a2 == pointer to os_regset
 311 ;               a3... == registers to pass
 312 ; On exit:      a1 == pointer to possible error
 313
 314                 EXPORT  os_swivr
 315
 316 os_swivr        MOV     R12,R13
 317                 STMFD   R13!,{R1,R4-R10,R14}    ;Save registers
 318                 ORR     R10,R0,#&20000          ;Set the X bit
 319                 MOV     R0,R2
 320                 MOV     R1,R3
 321                 LDMIA   R12,{R2-R9}
 322                 MOV     R14,PC                  ;Set return address
 323                 LDR     PC,_swihack             ;And call the hacky routine
 324                 LDR     R12,[R13],#4            ;Load regset pointer
 325                 LDMVCIA R12,{R0-R9}             ;Save all of them away
 326                 MOVVC   R0,#0                   ;Return zero on no error
 327                 LDMFD   R13!,{R4-R10,PC}^       ;And return to caller
 328
 329                 LTORG
 330
 331 ;----- Veneers to specific routines -----------------------------------------
 332
 333 ; --- os_byte ---
 334 ;
 335 ; On entry:     a1 == reason code for OS_Byte
 336 ;               a2 == pointer to x value
 337 ;               a3 == pointer to y value
 338
 339                 EXPORT  os_byte
 340 os_byte         STMFD   sp!,{v1,v2,lr}          ;Save registers away
 341                 MOV     v1,a2
 342                 MOV     v2,a3
 343                 LDR     a2,[v1]
 344                 LDR     a3,[v2]
 345                 SWI     XOS_Byte
 346                 STRVC   a2,[v1]
 347                 STRVC   a3,[v2]
 348                 MOVVC   a1,#0
 349                 LDMFD   sp!,{v1,v2,pc}^
 350
 351 ; --- os_word ---
 352 ;
 353 ; On entry:     a1 == reason code for OS_Word
 354 ;               a2 == pointer to parameter block
 355
 356                 EXPORT  os_word
 357 os_word         SWI     XOS_Word
 358                 MOVVC   a1,#0
 359                 MOVS    pc,lr
 360
 361 ; --- os_gbpb ---
 362 ;
 363 ; On entry:     a1 == pointer to `reg block'
 364
 365                 EXPORT  os_gbpb
 366 os_gbpb         STMFD   sp!,{a1,v1-v6,lr}
 367                 LDMIA   a1,{a1-a4,v1-v6}
 368                 SWI     XOS_GBPB
 369                 LDR     lr,[sp],#4
 370                 STMVCIA lr,{a1-a4,v1-v6}
 371                 MOVVC   a1,#0
 372                 LDMFD   sp!,{v1-v6,pc}^
 373
 374                 LTORG
 375
 376 ; --- os_file ---
 377 ;
 378 ; On entry:     a1 == pointer to `reg block'
 379
 380                 EXPORT  os_file
 381 os_file         STMFD   sp!,{a1,v1-v6,lr}
 382                 LDMIA   a1,{a1-a4,v1-v6}
 383                 SWI     XOS_File
 384                 LDR     lr,[sp],#4
 385                 STMVCIA lr,{a1-a4,v1-v6}
 386                 MOVVC   a1,#0
 387                 LDMFD   sp!,{v1-v6,pc}^
 388
 389                 LTORG
 390
 391 ; --- os_args ---
 392 ;
 393 ; On entry:     a1 == pointer to a real reg block
 394
 395                 EXPORT  os_args
 396 os_args         STMFD   sp!,{a1,v1-v6,lr}
 397                 LDMIA   a1,{a1-a4,v1-v6}
 398                 SWI     XOS_Args
 399                 LDR     lr,[sp],#4
 400                 STMVCIA lr,{a1-a4,v1-v6}
 401                 MOVVC   a1,#0
 402                 LDMFD   sp!,{v1-v6,pc}^
 403
 404                 LTORG
 405
 406 ; --- os_find ---
 407 ;
 408 ; On entry:     a1 == pointer to a real reg block
 409
 410                 EXPORT  os_find
 411 os_find         STMFD   sp!,{a1,v1-v6,lr}
 412                 LDMIA   a1,{a1-a4,v1-v6}
 413                 SWI     XOS_Find
 414                 LDR     lr,[sp],#4
 415                 STMVCIA lr,{a1-a4,v1-v6}
 416                 MOVVC   a1,#0
 417                 LDMFD   sp!,{v1-v6,pc}^
 418
 419                 LTORG
 420
 421 ; --- os_cli ---
 422 ;
 423 ; On entry:     a1 == pointer to command string
 424
 425                 EXPORT  os_cli
 426 os_cli          SWI     XOS_CLI
 427                 MOVVC   a1,#0
 428                 MOVS    pc,lr
 429
 430 ; --- os_read_var_val ---
 431 ;
 432 ; On entry:     a1 == pointer to variable name
 433 ;               a2 == pointer to buffer to store the value
 434 ;               a3 == size of the buffer
 435
 436                 EXPORT  os_read_var_val
 437 os_read_var_val STMFD   sp!,{v1,lr}
 438                 MOV     a4,#0
 439                 MOV     v1,#3
 440                 SWI     XOS_ReadVarVal
 441                 MOV     v1,#0
 442                 MOVVS   a3,#0
 443                 STRB    v1,[a2,a3]
 444                 MOVVC   a1,#0
 445                 LDMFD   sp!,{v1,pc}^
 446
 447 ;----- That's all, folks ----------------------------------------------------
 448
 449                 END