Return to stack.h CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / include / kernel

Annotation of qemu/roms/openbios/include/kernel/stack.h, revision 1.1.1.1

1.1       root        1: /* stack.h
                      2:  * tag: stack and stack access functions
                      3:  *
                      4:  * Copyright (C) 2003 Patrick Mauritz, Stefan Reinauer
                      5:  *
                      6:  * See the file "COPYING" for further information about
                      7:  * the copyright and warranty status of this work.
                      8:  */
                      9: 
                     10: #ifndef __STACK_H
                     11: #define __STACK_H
                     12: 
                     13: #define dstacksize 512
                     14: extern int  dstackcnt;
                     15: extern cell dstack[dstacksize];
                     16: 
                     17: #define rstacksize 512
                     18: extern int  rstackcnt;
                     19: extern cell rstack[rstacksize];
                     20: 
                     21: extern int dbgrstackcnt;
                     22: 
                     23: //typedef struct opaque_xt *xt_t;
                     24: //typedef struct opaque_ihandle *ihandle_t;
                     25: //typedef struct opaque_phandle *phandle_t;
                     26: 
                     27: typedef ucell xt_t;
                     28: typedef ucell ihandle_t;
                     29: typedef ucell phandle_t;
                     30: 
                     31: 
                     32: 
                     33: #ifdef NATIVE_BITWIDTH_EQUALS_HOST_BITWIDTH
                     34: 
                     35: static inline ucell pointer2cell(const void* x)
                     36: {
                     37:     return (ucell)(uintptr_t)x;
                     38: }
                     39: 
                     40: static inline void* cell2pointer(ucell x)
                     41: {
                     42:     return (void*)(uintptr_t)x;
                     43: }
                     44: 
                     45: #endif
                     46: 
                     47: static inline void PUSH(ucell value) {
                     48:        dstack[++dstackcnt] = (value);
                     49: }
                     50: static inline void PUSH_xt( xt_t xt ) { PUSH( (ucell)xt ); }
                     51: static inline void PUSH_ih( ihandle_t ih ) { PUSH( (ucell)ih ); }
                     52: static inline void PUSH_ph( phandle_t ph ) { PUSH( (ucell)ph ); }
                     53: 
                     54: static inline ucell POP(void) {
                     55:        return (ucell) dstack[dstackcnt--];
                     56: }
                     57: static inline xt_t POP_xt( void ) { return (xt_t)POP(); }
                     58: static inline ihandle_t POP_ih( void ) { return (ihandle_t)POP(); }
                     59: static inline phandle_t POP_ph( void ) { return (phandle_t)POP(); }
                     60: 
                     61: static inline void DROP(void) {
                     62:        dstackcnt--;
                     63: }
                     64: 
                     65: static inline void DDROP(void) {
                     66:        dstackcnt -= 2;
                     67: }
                     68: 
                     69: static inline void DPUSH(ducell value) {
                     70: #ifdef NEED_FAKE_INT128_T
                     71:        dstack[++dstackcnt] = (cell) value.lo;
                     72:        dstack[++dstackcnt] = (cell) value.hi;
                     73: #else
                     74:        dstack[++dstackcnt] = (cell) value;
                     75:        dstack[++dstackcnt] = (cell) (value >> bitspercell);
                     76: #endif
                     77: }
                     78: 
                     79: static inline ducell DPOP(void) {
                     80: #ifdef NEED_FAKE_INT128_T
                     81:        ducell du;
                     82:        du.hi = (ucell) dstack[dstackcnt--];
                     83:        du.lo = (ucell) dstack[dstackcnt--];
                     84:        return du;
                     85: #else
                     86:        ducell du;
                     87:         du = ((ducell)(ucell) dstack[dstackcnt--]) << bitspercell;
                     88:        du |= (ucell) dstack[dstackcnt--];
                     89:        return du;
                     90: #endif
                     91: }
                     92: 
                     93: static inline ucell GETTOS(void) {
                     94:        return dstack[dstackcnt];
                     95: }
                     96: 
                     97: #define GETITEM(number) (dstack[dstackcnt - number])
                     98: static inline void PUSHR(ucell value) {
                     99:        rstack[++rstackcnt] = (value);
                    100: }
                    101: 
                    102: static inline ucell POPR(void) {
                    103:        return (ucell) rstack[rstackcnt--];
                    104: }
                    105: static inline ucell GETTORS(void) {
                    106:        return rstack[rstackcnt];
                    107: }
                    108: 
                    109: 
                    110: #if defined(DEBUG_DSTACK) || defined(FCOMPILER)
                    111: void printdstack(void);
                    112: #endif
                    113: #if defined(DEBUG_RSTACK) || defined(FCOMPILER)
                    114: void printrstack(void);
                    115: #endif
                    116: 
                    117: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.