![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vaxinter.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / spitbol / cint|
Return to vaxinter.s CVS log | Up to [Research Unix] / researchv10no / cmd / spitbol / cint |
1.1 root 1: #
2: # VAXINTER.S
3: #
4: # This file contains the assembly language routines that interface
5: # the Macro SPITBOL compiler written in VAX assembly language to its
6: # operating system interface functions written in C.
7: #
8: # Contents:
9: #
10: # o Overview
11: # o Global variables accessed by OSINT functions
12: # o Interface routines between compiler and OSINT functions
13: # o C callable function get_sp
14: # o C callable function startup
15: # o Compiler callable function sbchk
16: #
17: #-----------
18: #
19: # Overview
20: #
21: # The Macro SPITBOL compiler relies on a set of operating system
22: # interface functions to provide all interaction with the host
23: # operating system. These functions are referred to as OSINT
24: # functions. A typical call to one of these OSINT functions takes
25: # the following form in the VAX version of the compiler:
26: #
27: # ...code to put arguments in registers...
28: # jsb sysxx ; call osint function
29: # .long exit_1 ; address of exit point 1
30: # .long exit_2 ; address of exit point 2
31: # ... ... ; ...
32: # .long exit_n ; address of exit point n
33: # ...instruction following call...
34: #
35: # The OSINT function 'sysxx' can then return in one of n+1 ways:
36: # to one of the n exit points or to the instruction following the
37: # last exit. This is not really very complicated - the jsb places
38: # the return address on the stack, so all the interface function has
39: # to do is add the appropriate offset to the return address and then
40: # pick up the exit address and jump to it OR do a normal return via
41: # an rsb instruction.
42: #
43: # Unfortunately, a C function cannot handle this scheme. So, an
44: # intermediary set of routines have been established to allow the
45: # interfacing of C functions. The mechanism is as follows:
46: #
47: # (1) The compiler calls OSINT functions as described above.
48: #
49: # (2) A set of assembly language interface routines is established,
50: # one per OSINT function, named accordingly. Each interface
51: # routine ...
52: #
53: # (a) saves all compiler registers in global variables
54: # accessible by C functions
55: # (b) calls the OSINT function written in C
56: # (c) restores all compiler registers from the global variables
57: # (d) inspects the OSINT function's return value to determine
58: # which of the n+1 returns should be taken and does so
59: #
60: # (3) A set of C language OSINT functions is established, one per
61: # OSINT function, named differently than the interface routines.
62: # Each OSINT function can access compiler registers via global
63: # variables. NO arguments are passed via the call.
64: #
65: # When an OSINT function returns, it must return a value indicating
66: # which of the n+1 exits should be taken. These return values are
67: # defined in header file 'inter.h'.
68: #
69: # Note: in the actual implementation below, the saving and restoring
70: # of registers is actually done in one common routine accessed by all
71: # interface routines.
72: #
73: # Other notes:
74: #
75: # The Un*x VAX cC ompilers transform "internal" global names to
76: # "external" global names by adding a leading underscore at the front
77: # of the internal name. Thus, the function name 'osopen' becomes
78: # '_osopen'.
79: #
80: # Acknowledgement:
81: #
82: # This interfacing scheme is based on an idea put forth by Andy Koenig.
83: #
84: #-----------
85: #
86: # Global Variables
87: #
88: # The compiler uses 8 registers as described below.
89: #
90: .data
91: .globl _reg_ra
92: .globl _reg_cp
93: .globl _reg_ia
94: .globl _reg_wa
95: .globl _reg_wb
96: .globl _reg_wc
97: .globl _reg_xr
98: .globl _reg_xl
99: .align 2
100: _reg_ra: .space 4 # Register RA (R2)
101: _reg_cp: .space 4 # Register CP (R3)
102: _reg_ia: .space 4 # Register IA (R5)
103: _reg_wa: .space 4 # Register WA (R6)
104: _reg_wb: .space 4 # Register WB (R7)
105: _reg_wc: .space 4 # Register WC (R8)
106: _reg_xr: .space 4 # Register XR (R9)
107: _reg_xl: .space 4 # Register XL (R10)
108: #
109: .globl _rsboff
110: _rsboff: .space 4 # Normal rsb return offset
111: #
112: # The following pointers address those cells in the compiler
113: # that point into the stack when a load module might be written,
114: # and which must therefore be relocated.
115: .globl _strellst
116: _strellst:
117: .long flptr
118: .long stbas
119: .long gtcef
120: .long 0 # end of list marker
121: #
122: # Setup a number of internal addresses in the compiler that cannot
123: # be directly accessed from within C because of naming difficulties.
124: #
125: .globl _ic_type
126: _ic_type: .long b$icl
127: .globl _sc_type
128: _sc_type: .long b$scl
129: .globl _xn_type
130: _xn_type: .long b$xnt
131: .globl _xr_type
132: _xr_type: .long b$xrt
133: #
134: .globl _id1
135: _id1: .long 0,id1l
136: .ascii "(2.0)"
137: id1e:
138: .set id1l,id1e-_id1-8
139: .align 2
140: #
141: .globl _id2
142: _id2: .long 0,id2l
143: .ascii "VAX/UNIX Version"
144: id2e:
145: .set id2l,id2e-_id2-8
146: .align 2
147: #
148: .globl _tscblk
149: .globl _ticblk
150: _ticblk: .space 8
151: _tscblk: .space 108
152: #
153: #-----------
154: #
155: # Interface routines
156: #
157: # Each interface routine takes the following form:
158: #
159: # sysxx: jsb ccaller # call common interface
160: # .long _sysxx # address of C OSINT function
161: # .long n # offset to instruction after
162: # # last procedure exit
163: #
164: # We take advantage of the "internal" to "external" transformation
165: # of names by the C compiler. Specifically, the assembly language
166: # interface routine names match those directly called by the compiler:
167: # 'sysxx'. The corresponding C OSINT functions are also called 'sysxx',
168: # but the C compiler nicely transforms these names into '_sysxx'.
169: #
170: .text
171: .globl sysax
172: sysax: jsb ccaller
173: .long _sysax
174: .long 0
175: #
176: .globl sysbx
177: sysbx: jsb ccaller
178: .long _sysbx
179: .long 0
180: #
181: .globl sysdc
182: sysdc: jsb ccaller
183: .long _sysdc
184: .long 0
185: #
186: .globl sysdm
187: sysdm: jsb ccaller
188: .long _sysdm
189: .long 0
190: #
191: .globl sysdt
192: sysdt: jsb ccaller
193: .long _sysdt
194: .long 0
195: #
196: .globl sysef
197: sysef: jsb ccaller
198: .long _sysef
199: .long 12
200: #
201: # .globl sysej
202: #sysej: jsb ccaller
203: # .long _sysej
204: # .long 0
205: #
206: .globl sysem
207: sysem: jsb ccaller
208: .long _sysem
209: .long 0
210: #
211: .globl sysen
212: sysen: jsb ccaller
213: .long _sysen
214: .long 12
215: #
216: .globl sysep
217: sysep: jsb ccaller
218: .long _sysep
219: .long 0
220: #
221: .globl sysex
222: sysex: jsb ccaller
223: .long _sysex
224: .long 4
225: #
226: # .globl sysfc
227: #sysfc: jsb ccaller
228: # .long _sysfc
229: # .long 4
230: #
231: .globl syshs
232: syshs: jsb ccaller
233: .long _syshs
234: .long 24
235: #
236: .globl sysid
237: sysid: jsb ccaller
238: .long _sysid
239: .long 0
240: #
241: # .globl sysil
242: #sysil: jsb ccaller
243: # .long _sysil
244: # .long 0
245: #
246: # .globl sysin
247: #sysin: jsb ccaller
248: # .long _sysin
249: # .long 12
250: #
251: # .globl sysio
252: #sysio: jsb ccaller
253: # .long _sysio
254: #
255: .globl sysld
256: sysld: jsb ccaller
257: .long _sysld
258: .long 8
259: #
260: .globl sysmm
261: sysmm: jsb ccaller
262: .long _sysmm
263: .long 0
264: #
265: .globl sysmx
266: sysmx: jsb ccaller
267: .long _sysmx
268: .long 0
269: #
270: .globl sysou
271: sysou: jsb ccaller
272: .long _sysou
273: .long 8
274: #
275: # .globl syspi
276: #syspi: jsb ccaller
277: # .long _syspi
278: # .long 0
279: #
280: .globl syspp
281: syspp: jsb ccaller
282: .long _syspp
283: .long 0
284: #
285: # .globl syspr
286: #syspr: jsb ccaller
287: # .long _syspr
288: # .long 4
289: #
290: # .globl sysrd
291: #sysrd: jsb ccaller
292: # .long _sysrd
293: # .long 4
294: #
295: # .globl sysri
296: #sysri: jsb ccaller
297: # .long _sysri
298: # .long 4
299: #
300: .globl sysrw
301: sysrw: jsb ccaller
302: .long _sysrw
303: .long 12
304: #
305: # .globl sysst
306: #sysst: jsb ccaller
307: # .long _sysst
308: # .long 20
309: #
310: # .globl systm
311: #systm: jsb ccaller
312: # .long _systm
313: # .long 0
314: #
315: .globl systt
316: systt: jsb ccaller
317: .long _systt
318: .long 0
319: #
320: .globl sysul
321: sysul: jsb ccaller
322: .long _sysul
323: .long 0
324: #
325: # .globl sysxi
326: #sysxi: jsb ccaller
327: # .long _sysxi
328: # .long 8
329: #
330: #-----------
331: #
332: # CCALLER is called by the OS interface routines to call the
333: # real C OS interface function.
334: #
335: # General calling sequence is:
336: #
337: # jsb ccaller
338: # .long address_of_C_function
339: # .long 4*number_of_exit_points
340: #
341: # Control IS NEVER returned to a interface routine. Instead, control
342: # is returned to the compiler (THE caller of the interface routine).
343: #
344: # The C function that is called MUST ALWAYS return an integer
345: # indicating the proecedure exit to take or that a normal return
346: # is to be performed.
347: #
348: # C function Interpretation
349: # return value
350: # ------------ -------------------------------------------
351: # <0 Do normal return to instruction past
352: # last procedure exit (distance passed
353: # in by dummy routine and saved in _rsboff)
354: # 0 Take procedure exit 1
355: # 4 Take procedure exit 2
356: # 8 Take procedure exit 3
357: # ... ...
358: #
359: ccaller:
360: #
361: # (1) Save registers in global variables
362: #
363: movl r2,_reg_ra # save RA (R2)
364: movl r3,_reg_cp # save CP (R3)
365: movl r5,_reg_ia # save IA (R5)
366: movl r6,_reg_wa # save WA (R6)
367: movl r7,_reg_wb # save WB (R7)
368: movl r8,_reg_wc # save WC (R8)
369: movl r9,_reg_xr # save XR (R9)
370: movl r10,_reg_xl # save XL (R10)
371: #
372: # (2) Fetch address of C function, fetch offset to 1st instruction
373: # past last procedure exit, and call C function.
374: #
375: movl (sp)+,r0 # point to arg list
376: movl (r0)+,r1 # point to C function entry point
377: movl (r0),_rsboff # get adjustment for normal exit
378: calls $0,(r1) # call C interface function
379: #
380: # (3) Restore registers after C function returns.
381: #
382: movl _reg_ra,r2 # restore RA (R2)
383: movl _reg_cp,r3 # restore CP (R3)
384: movl _reg_ia,r5 # restore IA (R5)
385: movl _reg_wa,r6 # restore WA (R6)
386: movl _reg_wb,r7 # restore WB (R7)
387: movl _reg_wc,r8 # restore WC (R8)
388: movl _reg_xr,r9 # restore XR (R9)
389: movl _reg_xl,r10 # restore XL (R10)
390: #
391: # (4) Based on returned value from C function either do a normal
392: # return or take a procedure exit.
393: #
394: tstl r0 # if normal return ...
395: bgeq erexit
396: addl2 _rsboff,(sp) # point to instruction following exits
397: rsb # return
398: # # else (take procedure exit n)
399: erexit: addl3 r0,(sp)+,r11 # point to address of exit
400: jmp *(r11)+ # take procedure exit
401: #
402: #-----------
403: #
404: # _get_sp - get C caller's SP
405: #
406: # _get_sp() returns the current value of the stack pointer from
407: # the point of reference of a C function.
408: #
409: # From C this procedure is called by
410: #
411: # our_sp = get_sp();
412: #
413: # The generated code will look like
414: #
415: # calls #0,_get_sp
416: # movl r0,our_sp
417: #
418: # On entry to _get_sp, the stack looks like
419: #
420: # +---------------+ (<-- SP before 'calls' executed)
421: # | arg cnt (0) |
422: # |---------------| <-- AP
423: # | old PC |
424: # |---------------|
425: # | old FP |
426: # |---------------|
427: # | old AP |
428: # |---------------|
429: # | mask/PSW |
430: # |---------------|
431: # | 0 |
432: # +---------------+ <-- SP <-- FP
433: #
434: # On exit, all these words will be removed from the stack. Therefore,
435: # the current value of the SP from the caller's perspective is AP+4.
436: #
437: .text
438: .globl _get_sp
439: _get_sp:
440: .word 0 # no registers to save
441: addl3 $4,ap,r0 # compute caller's SP
442: ret # done
443: #
444: #-----------
445: #
446: # _startup - startup compiler
447: #
448: # An OSINT C function calls _startup to transfer control
449: # to the compiler.
450: #
451: .text
452: .globl _startup
453: _startup:
454: .word 0
455: movl _reg_ra,r2 # initialize RA (R2)
456: movl _reg_cp,r3 # initialize CP (R3)
457: movl _reg_ia,r5 # initialize IA (R5)
458: movl _reg_wa,r6 # initialize WA (R6)
459: movl _reg_wb,r7 # initialize WB (R7)
460: movl _reg_wc,r8 # initialize WC (R8)
461: movl _reg_xr,r9 # initialize XR (R9)
462: movl _reg_xl,r10 # initialize XL (R10)
463: #
464: movl sp,_initsp # save initial sp
465: subl3 _stacksiz,sp,_lowsp
466: # set lowest legal sp for sbchk
467: #
468: movl _dfltcase,kvcas # set case flag IN compiler
469: #
470: jmp sec04 # transfer control to compiler
471: #
472: #-----------
473: #
474: # sbchk - check for stack overflow
475: #
476: .text
477: .globl sbchk
478: sbchk: cmpl sp,_lowsp # if sp is ok then
479: blssu sb100
480: rsb # return
481: sb100: tstl (sp)+ # else pop stack
482: jmp sec05 # and go to stack overflow section
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.