home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / program / compiler / sozobon / scsrc20 / szadb / start.s < prev    next >
Text File  |  1990-02-21  |  7KB  |  284 lines
  1. *************************************************************************
  2. *                                    *
  3. *    DSTART.S    Startup module for C programs using dLibs    *
  4. *            modified for szadb                                    *
  5. *************************************************************************
  6.  
  7. *
  8. * entry points
  9. *
  10. .globl    _ossp
  11. .globl    __base            * basepage pointer
  12. .globl    __start            * startup entry point
  13. .globl    _etext            * end of text segment
  14. .globl    _edata            * end of data segment
  15. .globl    _end            * end of BSS segment (end of program)
  16. .globl    __break            * location of stack/heap break
  17. .globl    __exit            * terminate immediately with exit code
  18. .globl    __argc            * number of arguments
  19. .globl    __argv            * argument list pointer
  20. .globl    __envp            * environment string pointer
  21. .globl    _errno            * system error number
  22. .globl    _gemdos            * trap #1 (gemdos) hook
  23. .globl    _bios            * trap #13 (bios) hook
  24. .globl    _xbios            * trap #14 (xbios) hook
  25. .globl    _bdos            * trap #2 (bdos) hook
  26.  
  27. *
  28. * external references
  29. *
  30. .globl    __STKSIZ        * Stack size value from C (unsigned long)
  31. .globl    __main            * Initial entry point for C program
  32. .globl    _main            * C program main() function
  33.  
  34. *
  35. * useful constants
  36. *
  37. MINSTK        equ    1024    * Minimum 1K stack size
  38. MARGIN        equ    512    * Minimum memory to return to OS
  39.  
  40. *
  41. * GEMDOS functions
  42. *
  43. Cconws        equ    $09    * Console write string
  44. Pterm        equ    $4C    * Process terminate (with exit code)
  45. Mshrink        equ    $4A    * Shrink program space
  46.  
  47. *
  48. * basepage offsets
  49. *
  50. p_hitpa        equ    $04    * top of TPA
  51. p_tbase        equ    $08    * base of text
  52. p_tlen        equ    $0C    * length of text
  53. p_dbase        equ    $10    * base of data
  54. p_dlen        equ    $14    * length of data
  55. p_bbase        equ    $18    * base of BSS
  56. p_blen        equ    $1C    * length of BSS
  57. p_env        equ    $2C    * environment string
  58. p_cmdlin    equ    $80    * command line image
  59.  
  60. *
  61. * STARTUP ROUTINE (must be first object in link)
  62. *
  63. .text
  64. __start:
  65. *
  66. * save initial stack and basepage pointers
  67. *
  68.     move.l    sp,a5            * a5 = initial stack pointer
  69.     move.l    4(sp),a4        * a4 = basepage address
  70.     move.l    a4,__base
  71.     move.l    p_tbase(a4),d3
  72.     add.l    p_tlen(a4),d3
  73.     move.l    d3,_etext        * end of text segment
  74.     move.l    p_dbase(a4),d3
  75.     add.l    p_dlen(a4),d3
  76.     move.l    d3,_edata        * end of data segment
  77.     move.l    p_bbase(a4),d3
  78.     add.l    p_blen(a4),d3
  79.     move.l    d3,_end            * end of BSS (end of program)
  80.     move.l    d3,__break;        * set initial _break value
  81.     move.l    p_env(a4),__envp    * save environment pointer
  82. *
  83. * call C function to get command line arguments
  84. *
  85.     lea.l    p_cmdlin(a4),a0        * get pointer to command line image
  86.     move.b    (a0)+,d0
  87.     ext.w    d0            * extract length
  88.     move.w    d0,-(sp)        * cmdlen
  89.     move.l    a0,-(sp)        * cmdline
  90.     jsr    __initar        * call _initargs(cmdline, cmdlen)
  91.     addq.l    #6,sp
  92. *
  93. * calculate free space available to program
  94. *
  95.     move.l    __break,d3
  96.     move.l    d3,a3            * a3 = base of free space
  97.     neg.l    d3
  98.     add.l    p_hitpa(a4),d3
  99.     sub.l    #MARGIN,d3        * d3 = free space
  100. *
  101. * calculate new stack size (store in d2)
  102. *
  103.     move.l    #__STKSIZ,a2        * a2 = &_STKSIZ
  104.     move.l    a2,d2            * if __STKSIZ is undefined
  105.     beq    minimum            *   use MINSTK
  106.     move.l    (a2),d2            * if __STKSIZ is positive
  107.     bpl    setstk            *   use __STKSIZ
  108.     add.l    d3,d2            * if __STKSIZ is negative
  109.     cmp.l    #MINSTK,d2        *   try (free space + __STKSIZ)
  110.     bge    setstk            * if < MINSTK
  111. minimum:
  112.     move.l    #MINSTK,d2        *   use MINSTK
  113. *
  114. * check to see if there is enough room for requested stack
  115. *
  116. setstk:
  117.     cmp.l    d3,d2
  118.     blt    shrink            * if (available < requested)
  119.     move.l    #stkerr,-(sp)
  120.     move.w    #Cconws,-(sp)
  121.     trap    #1            *   report a stack error
  122.     addq.l    #6,sp
  123.     move.w    #-39,-(sp)
  124.     move.w    #Pterm,-(sp)
  125.     trap    #1            *   and return error -39 (ENSMEM)
  126. *
  127. * set up new stack pointer and Mshrink
  128. *
  129. shrink:
  130.     add.l    a3,d2            * new stack = free base + stack size
  131.     move.l    d2,sp
  132.     sub.l    a4,d2            * keep space = new stack - __base
  133.     move.l    d2,-(sp)
  134.     move.l    a4,-(sp)
  135.     clr.w    -(sp)
  136.     move.w    #Mshrink,-(sp)
  137.     trap    #1            * Mshrink(0, _base, keep);
  138.     add.l    #12,sp
  139. *
  140. * Look at kernel sp
  141. *
  142.     move.l    #0,-(sp)
  143.     move.w    #$20,-(sp)
  144.     trap    #1
  145.     add.w    #6,sp
  146.     move.l    d0,_ossp
  147. *
  148. * call C entry point function _main()
  149. *
  150.     jsr    __main            * if _main returns
  151.     move.w    d0,4(sp)        *   insert return value and fall thru
  152.  
  153. *
  154. * void _exit(code)
  155. *   int code;
  156. *
  157. * Terminate process with a return value of <code>
  158. *
  159. __exit:
  160.     tst.l    (sp)+            * pop return PC off the stack
  161.     move.w    (sp)+,d7        * exit code
  162.  
  163.     move.l    _ossp,d0        * old system stack pointer
  164.     move.l    d0,-(sp)
  165.     move.w    #$20,-(sp)
  166.     trap    #1
  167.     add.w    #6,sp
  168.  
  169.     move.w    d7,-(sp)
  170.     move.w    #Pterm,-(sp)
  171.     trap    #1            *   and terminate.
  172.  
  173. *
  174. * operating system trap hooks for C
  175. *
  176.  
  177. *
  178. * long gemdos(function, [parameter, ...])
  179. *   int function;
  180. *
  181. _gemdos:
  182.     move.l    (sp)+,traprtn        * save return address
  183.     trap    #1            * do gemdos trap
  184.     bra    chkstk
  185.  
  186. *
  187. * long bios(function, [parameter, ...])
  188. *   int function;
  189. *
  190. _bios:
  191.     move.l    (sp)+,traprtn        * save return address
  192.     trap    #13            * do bios trap
  193.     bra    chkstk
  194.  
  195. *
  196. * long xbios(function, [parameter, ...])
  197. *   int function;
  198. *
  199. _xbios:
  200.     move.l    (sp)+,traprtn        * save return address
  201.     trap    #14            * do xbios trap
  202.     bra    chkstk
  203.  
  204. *
  205. * int bdos(function, parameter)
  206. *   int function;
  207. *   long parameter;
  208. *
  209. _bdos:
  210.     move.l    (sp),traprtn        * save return address
  211.     move.l    a6,(sp)            * save old frame pointer
  212.     move.l    sp,a6            * set up frame pointer
  213.     tst.l    -(a6)            *   (fake "link a6,#0")
  214.     move.w    8(a6),d0        * function code in D0.W
  215.     move.l    10(a6),d1        * parameter value in D1.L
  216.     trap    #2            * do bdos trap
  217.     move.l    (sp)+,a6        * restore old frame pointer
  218.  
  219. *
  220. * check for stack overflow (done after all OS traps)
  221. *
  222. chkstk:
  223. *    cmp.l    __break,sp
  224. *    bgt    nosweat            * if (_break > sp)
  225. *    move.l    #stkovf,-(sp)
  226. *    move.w    #Cconws,-(sp)
  227. *    trap    #1            *   report a stack overflow
  228. *    addq.l    #6,sp
  229. *    move.w    #-1,-(sp)
  230. *    move.w    #Pterm,-(sp)
  231. *    trap    #1            *   and return error -1 (ERROR)
  232. nosweat:
  233.     move.l    traprtn,-(sp)        * else, restore return address
  234.     rts                * and do a normal return.
  235.  
  236. *
  237. * this call to _main ensures that it the user's main() function will be
  238. * linked, even if it is in a library.
  239. *
  240.     jsr    _main            * NO PATH TO THIS STATEMENT
  241.  
  242. * THE FOLLOWING IS SELF MODIFYING CODE, DO NOT DISTURB
  243.     move.l    #$644c6962,$7320(sp)
  244.     moveq.l    #$31,d3
  245.     move.l    $0(a2,d0),d7
  246.  
  247. *
  248. * initialized data space
  249. *
  250. .data
  251. .even
  252. stkerr:                    * not enough memory for stack
  253.     .dc.b    'Not enough memory',$d,$a,0
  254. stkovf:                    * impending stack overflow
  255.     .dc.b    'Stack overflow',$d,$a,0
  256. _errno:                    * system error number
  257.     .dc.w    0
  258. __argc:                    * number of command line args
  259.     .dc.w    0
  260. __argv:                    * pointer to command line arg list
  261.     .dc.l    0
  262. *
  263. * uninitialized data space
  264. *
  265. .bss
  266. .even
  267. __base:                    * pointer to basepage
  268.     .ds.l    1
  269. _etext:                    * pointer to end of text segment
  270.     .ds.l    1
  271. _edata:                    * pointer to end of data segment
  272.     .ds.l    1
  273. _end:                    * pointer to end of BSS (end of program)
  274.     .ds.l    1
  275. __break:                * pointer to stack/heap break
  276.     .ds.l    1
  277. __envp:                    * pointer to environment string
  278.     .ds.l    1
  279. traprtn:                * storage for return PC in trap hooks
  280.     .ds.l    1
  281. _ossp:
  282.     .ds.l    1
  283. .end
  284.