Version 0.4 from Mike Line
[keystone-rtos/ibl.git] / src / interp / coff / coffdefs.mike.h
1 /**************************************************************************/
2 /*  COFFDEFS.H                                                            */
3 /*     Definitions of COFF symbol type and storage class fields.          */
4 /**************************************************************************/
5 #ifndef COFFDEFS_H
6 #define COFFDEFS_H
8 #if defined(TOOL_ASSEMBLER)
9    #error The COFF submodule should no longer be used by the assembler; use TICOFF04
10 #endif
12 /*------------------------------------------------------------------------*/
13 /*   STORAGE CLASSES                                                      */
14 /*------------------------------------------------------------------------*/
15 #define  C_NULL          0
16 #define  C_AUTO          1     /* AUTOMATIC VARIABLE                      */
17 #define  C_EXT           2     /* EXTERNAL SYMBOL                         */
18 #define  C_STAT          3     /* STATIC                                  */
19 #define  C_REG           4     /* REGISTER VARIABLE                       */
20 #define  C_EXTREF        5     /* EXTERNAL DEFINITION                     */
21 #define  C_LABEL         6     /* LABEL                                   */
22 #define  C_ULABEL        7     /* UNDEFINED LABEL                         */
23 #define  C_MOS           8     /* MEMBER OF STRUCTURE                     */
24 #define  C_ARG           9     /* FUNCTION ARGUMENT                       */
25 #define  C_STRTAG        10    /* STRUCTURE TAG                           */
26 #define  C_MOU           11    /* MEMBER OF UNION                         */
27 #define  C_UNTAG         12    /* UNION TAG                               */
28 #define  C_TPDEF         13    /* TYPE DEFINITION                         */
29 #define  C_USTATIC       14    /* UNDEFINED STATIC                        */
30 #define  C_ENTAG         15    /* ENUMERATION TAG                         */
31 #define  C_MOE           16    /* MEMBER OF ENUMERATION                   */
32 #define  C_REGPARM       17    /* REGISTER PARAMETER                      */
33 #define  C_FIELD         18    /* BIT FIELD                               */
34 #define  C_UEXT          19    /* TENTATIVE EXTERNAL DEFINITION           */
35 #define  C_STATLAB       20    /* STATIC LOAD-TIME LABEL                  */
36 #define  C_EXTLAB        21    /* EXTERNAL LOAD-TIME LABEL                */
37 #define  C_VREG          22    /* VIRTUAL REGISTER VARIABLE               */
38 #define  C_SYSTEM        23    /* SYSTEM-WIDE SYMBOL                      */
39 #define  C_STATREG       24    /* STATIC REGISTER VARIABLE                */
40 #define  C_EXTREG        25    /* EXTERNAL REGISTER VARIABLE              */
41 #define  C_EXTREFREG     26    /* EXTERNAL REGISTER VARIABLE REFERENCE    */
42 #define  C_VARARG        27    /* LAST DECLARED PARAMETER OF VARARG FN    */
43 #define  C_EXTDEF        28    /* C_EXT DEFINED IN DIFFERENT FILE         */
44 #define  C_USTATREG      29    /* UNDEFINED STATIC REGISTER VARIABLE      */
46 #define  C_BLOCK         100   /* ".BB" OR ".EB"                          */
47 #define  C_FCN           101   /* ".BF" OR ".EF"                          */
48 #define  C_EOS           102   /* END OF STRUCTURE                        */
49 #define  C_FILE          103   /* FILE NAME                               */
50 #define  C_LINE          104   /* DUMMY SCLASS FOR LINE NUMBER ENTRY      */
51 #define  C_ALIAS         105   /* DUPLICATE TAG                           */
52 #define  C_PREF          106   /* DUMMY SCLASS FOR REF PRAGMA TABLE ENTRY */
54 #define  C_GRPTAG        107   /* TAG FOR GROUPED GLOBAL VARIABLES        */
55 #define  C_SMOG          108   /* STATIC MEMBER OF GROUP                  */
56 #define  C_EMOG          109   /* EXTERN MEMBER OF GROUP                  */
57 #define  C_EOG           110   /* END OF GROUP                            */
59 /*------------------------------------------------------------------------*/
60 /* STORAGE CLASS QUALIFIERS                                               */
61 /*------------------------------------------------------------------------*/
62 #define CQ_NEAR          0x0001
63 #define CQ_FAR           0x0002
64 #define CQ_INLINE        0x0004        /* INLINE THIS FUNCTION DEFINITION   */
65 #define CQ_SUPPRESS      0x0008        /* INLINE AND EMIT NO ICODE OUTPUT   */
66 #define CQ_CONTROL       0x0010        /* SYMBOL IS A "CONTROL REGISTER"    */
67 #define CQ_INTERRUPT     0x0020        /* INTERRUPT FUNCTION                */
68 #define CQ_TRAP          0x0040        /* (MVP CODE GENERATOR)              */
69 #define CQ_GREGISTER     0x0080        /* GLOBAL REGISTER SYMBOL            */
70 #define CQ_PORT          0x0100        /* 370 PORT VARIABLE                 */
71 #define CQ_SYSTEM        0x0200        /* MVP SHARED SYMBOL (MP AND PPs)    */
72 #define CQ_SYSTEMPP      0x0400        /* MVP SHARED SYMBOL (PPs only)      */
73 #define CQ_REENTRANT     0x0800        /* FUNCTION IS REENTRANT/NEEDS STACK */
74 #define CQ_NMI_INTERRUPT 0x1000        /* NMI INTERRUPT FUNCTION            */
75  
76 #define CQ_ALIASED       0x2000        /* ADDRESS OF SYMBOL TAKEN SOMEWHERE */
77 #define CQ_WRITTEN       0x4000        /* VARIABLE IS MODIFIED BY CODE      */
78 #define CQ_TOUCHED       0x8000        /* VARIABLE IS REFERENCED BY CODE    */
80 #define CQ_ICODE (  CQ_NEAR | CQ_INLINE   | CQ_CONTROL   | CQ_TRAP       \
81                   | CQ_FAR  | CQ_SUPPRESS | CQ_INTERRUPT | CQ_GREGISTER  \
82                   | CQ_PORT | CQ_SYSTEM   | CQ_SYSTEMPP  | CQ_REENTRANT  \
83                   | CQ_NMI_INTERRUPT)
84                                                         
85 /*------------------------------------------------------------------------*/
86 /* STORAGE CLASS MACROS                                                   */
87 /*------------------------------------------------------------------------*/
88 #define ISLOCAL(c) ((c) == C_AUTO   || (c) == C_REG     || (c) == C_VREG)
89 #define ISPARM(c)  ((c) == C_ARG    || (c) == C_REGPARM || (c) == C_VARARG)
90 #define ISAUTO(c)  ((c) == C_AUTO   || (c) == C_ARG     || (c) == C_VARARG)
91 #define ISREG(c)   ((c) == C_REG    || (c) == C_REGPARM || (c) == C_VREG || \
92                     (c) == C_EXTREG || (c) == C_STATREG || (c) == C_EXTREFREG)
93 #define ISTAG(c)   ((c) == C_STRTAG || (c) == C_UNTAG   || (c) == C_ENTAG)
94 #define ISGROUP(c) ((c) == C_GRPTAG)
96 #define ISMOS(c)   ((c) == C_MOS    || (c) == C_MOU     || \
97                     (c) == C_MOE    || (c) == C_FIELD)
99 #define ISXDEF(c)  ((c) == C_STAT   || (c) == C_STATREG || \
100                     (c) == C_EXT    || (c) == C_EXTDEF  || (c) == C_EXTREG)
102 #define ISEXT(c)   ((c) == C_USTATIC || (c) == C_STAT   || (c) == C_STATREG  ||\
103                     (c) == C_EXTREF  || (c) == C_UEXT   || (c) == C_EXTREFREG||\
104                     (c) == C_EXT     || (c) == C_EXTDEF || (c) == C_EXTREG   ||\
105                     (c) == C_EXTLAB  || (c) == C_SYSTEM)
107 #define ISGLOB(c)  ((c) == C_EXTREF  || (c) == C_UEXT   || (c) == C_EXTREFREG||\
108                     (c) == C_EXT     || (c) == C_EXTDEF || (c) == C_EXTREG   ||\
109                     (c) == C_EXTLAB  || (c) == C_SYSTEM)
111 #define ISNEAR(cq)          (((cq) & CQ_NEAR) != 0)
112 #define ISFAR(cq)           (((cq) & CQ_FAR) != 0)
113 #define ISCONTROL(cq)       (((cq) & CQ_CONTROL) != 0)
114 #define ISGREGISTER(cq)     (((cq) & CQ_GREGISTER) != 0)
115 #define ISPORT(cq)          (((cq) & CQ_PORT)    != 0)
116 #define ISINTERRUPT(cq)     (((cq) & CQ_INTERRUPT) != 0)
117 #define ISNMIINTERRUPT(cq)  (((cq) & CQ_NMI_INTERRUPT) != 0)
118 #define ISREENTRANT(cq)     (((cq) & CQ_REENTRANT) != 0)
119 #define ISTRAP(cq)          (((cq) & CQ_TRAP) != 0)
120 #define ISINT_OR_TRAP(cq)   (((cq) & (CQ_TRAP | CQ_INTERRUPT)) != 0)
122 /*-------------------------------------------------------------------------*/
123 /* COFF BASIC TYPES - PACKED INTO THE LOWER 4 BITS OF THE TYPE FIELD       */
124 /*-------------------------------------------------------------------------*/
125 #define  CT_NULL     0x80       /* UNDEFINED OR ERROR TYPE (NO TYPE INFO)  */
126 #define  CT_VOID     0          /* VOID TYPE                               */
127 #define  CT_SCHAR    1          /* CHARACTER (EXPLICITLY "signed")         */
128 #define  CT_CHAR     2          /* CHARACTER (IMPLICITLY SIGNED)           */
129 #define  CT_SHORT    3          /* SHORT INTEGER                           */
130 #define  CT_INT      4          /* INTEGER                                 */
131 #define  CT_LONG     5          /* LONG INTEGER                            */
132 #define  CT_FLOAT    6          /* SINGLE PRECISION FLOATING POINT         */
133 #define  CT_DOUBLE   7          /* DOUBLE PRECISION FLOATING POINT         */
134 #define  CT_STRUCT   8          /* STRUCTURE                               */
135 #define  CT_UNION    9          /* UNION                                   */
136 #define  CT_ENUM     10         /* ENUMERATION                             */
137 #define  CT_LDOUBLE  11         /* LONG DOUBLE FLOATING POINT              */
138 #define  CT_UCHAR    12         /* UNSIGNED CHARACTER                      */
139 #define  CT_USHORT   13         /* UNSIGNED SHORT                          */
140 #define  CT_UINT     14         /* UNSIGNED INTEGER                        */
141 #define  CT_ULONG    15         /* UNSIGNED LONG                           */
143 /*-------------------------------------------------------------------------*/
144 /* COFF DERIVED TYPES: 2 BITS EACH                                         */
145 /*-------------------------------------------------------------------------*/
146 #define  DCT_NON     0x0        /* NO DERIVED TYPE                         */
147 #define  DCT_PTR     0x1        /* POINTER                                 */
148 #define  DCT_FCN     0x2        /* FUNCTION                                */
149 #define  DCT_ARY     0x3        /* ARRAY                                   */
151 /*-------------------------------------------------------------------------*/
152 /* COFF TYPE FIELD MASKS AND SIZES                                         */
153 /*-------------------------------------------------------------------------*/
154 #define  N_BCTMASK     0xF      /* MASK FOR BASIC TYPE                     */
155 #define  N_CTMASK      0x30     /* MASK FOR FIRST DERIVED TYPE             */
156 #define  N_DCTMAX      12       /* MAXIMUM DERIVED TYPES                   */
157 #define  N_BCTSHFT     4        /* SHIFT AMOUNT (WIDTH) FOR BASIC TYPE     */
158 #define  N_CTSHIFT     2        /* SHIFT AMOUNT (WIDTH) FOR DERIVED TYPES  */
160 /*-------------------------------------------------------------------------*/
161 /* COFF TYPE MANIPULATION MACROS                                           */
162 /*                                                                         */
163 /*    BCTYPE(t)    - Return basic type from t                              */
164 /*    DCTYPE(t)    - Return all derived types from t                       */
165 /*    DCTYPE1(t)   - Return 1st derived type from t                        */
166 /*    CTQUAL(t,q)  - Return qualification of type                          */
167 /*    CTUNQUAL(t,q)- Return unqualified version of type                    */
168 /*                                                                         */
169 /*    MKCTYPE()    - Build a type from basic and several derived types     */
170 /*    CDERIVE(d,t) - Build a type from basic and one derived type          */
171 /*    CINCREF(t)   - Convert 't' into pointer to 't'                       */
172 /*    CDECREF(t)   - Remove first derviation from t                        */
173 /*                                                                         */
174 /*    ISCINT(t)    - TRUE if t is an integral type                         */
175 /*    ISCSGN(t)    - TRUE if t is a signed type                            */
176 /*    ISCUNS(t)    - TRUE if t is an unsigned type                         */
177 /*    ISCFLT(t)    - TRUE if t is a floating point type                    */
178 /*    ISCDBL(t)    - TRUE if t is a double or long double type             */
179 /*    ISCPTR(t)    - TRUE if t is a pointer                                */
180 /*    ISCFCN(t)    - TRUE if t is a function                               */
181 /*    ISCARY(t)    - TRUE if t is an array                                 */
182 /*    ISCSTR(t)    - TRUE if t is a struct, union, or enum type            */
183 /*    ISCAGG(t)    - TRUE if t is an array, struct, or union               */
184 /*                                                                         */
185 /*    CITOU(t)     - convert signed type to unsigned equivalent            */
186 /*    CUTOI(t)     - convert unsigned type to signed equivalent            */
187 /*    CNOSIGN(t)   - convert signed or unsigned type to "plain" equivalent */
188 /*-------------------------------------------------------------------------*/
189 #define BCTYPE(t)    ((int)((t) & N_BCTMASK))  
190 #define DCTYPE(t)    ((t) & ~N_BCTMASK)
191 #define DCTYPE1(t)   (((t) & N_CTMASK) >> N_BCTSHFT)
193 #define CTQUAL(t,q)  ((int)(DCTYPE(t) ? DCTYPE1(q) : BCTYPE(q)))
194 #define CTUNQUAL(t,q) (ISCPTR(t) ? ((q) & ~N_CTMASK) : ((q) & ~N_BCTMASK))
196 #define MKCTYPE(basic, d1,d2,d3,d4,d5,d6) \
197                     ((basic) | ((d1) <<  4) | ((d2) <<  6) | ((d3) <<  8) |\
198                                ((d4) << 10) | ((d5) << 12) | ((d6) << 14))
199 #define CDERIVE(d,t) ((DCTYPE(t) << N_CTSHIFT) | ((d) << N_BCTSHFT) | BCTYPE(t))
200 #define CINCREF(t)   ((DCTYPE(t) << N_CTSHIFT) | (DCT_PTR<<N_BCTSHFT)|BCTYPE(t))
201 #define CDECREF(t)   (DCTYPE((t) >> N_CTSHIFT) | BCTYPE(t))
203 #define ISCSGN(t)    (((t) >= CT_SCHAR && (t) <= CT_LONG)  || (t) == CT_ENUM)
204 #define ISCUNS(t)    ((t) >= CT_UCHAR  && (t) <= CT_ULONG)
205 #define ISCINT(t)    (((t) >= CT_SCHAR && (t) <= CT_LONG)  || (t) == CT_ENUM ||\
206                       ((t) >= CT_UCHAR  && (t) <= CT_ULONG))
207 #define ISCFLT(t)    ((t) == CT_FLOAT || (t) == CT_DOUBLE || (t) == CT_LDOUBLE)
208 #define ISCDBL(t)    ((t) == CT_DOUBLE || (t) == CT_LDOUBLE)
209 #define ISCPTR(t)    (((t) & N_CTMASK) == (DCT_PTR << N_BCTSHFT)) 
210 #define ISCFCN(t)    (((t) & N_CTMASK) == (DCT_FCN << N_BCTSHFT))
211 #define ISCARY(t)    (((t) & N_CTMASK) == (DCT_ARY << N_BCTSHFT))
212 #define ISCSTR(t)    ((t) == CT_STRUCT || (t) == CT_UNION || (t) == CT_ENUM)
213 #define ISCAGG(t)    (ISCARY(t) || (t) == CT_STRUCT || (t) == CT_UNION)
214 #define ISCCHAR(t)   ((t) == CT_CHAR || (t) == CT_SCHAR || (t) == CT_UCHAR)
215 #define ISCSHORT(t)  ((t) == CT_SHORT || (t) == CT_USHORT)
216 #define ISCLONG(t)   ((t) == CT_LONG || (t) == CT_ULONG)
218 #define CITOU(t)     ((t) + (CT_UCHAR - ((t) == CT_SCHAR ? CT_SCHAR : CT_CHAR)))
219 #define CUTOI(t)     ((t) - (CT_UCHAR - CT_CHAR))
220 #define CNOSIGN(t)   (ISCUNS(t) ? CUTOI(t) : (t) == CT_SCHAR ? CT_CHAR : (t))
222 /*------------------------------------------------------------------------*/
223 /* ILLEGAL COFF TYPES USED TO MARK SPECIAL OBJECTS.                       */
224 /*                                                                        */
225 /* CT_VENEER  - DENOTES A VENEER OF A FUNCTION.                           */
226 /*------------------------------------------------------------------------*/
227 #define CT_VENEER     (MKCTYPE(CT_VOID, DCT_FCN, DCT_FCN, 0, 0, 0, 0))
228 #define ISCVENEER(t)  ((t) == CT_VENEER)
230 #endif /* COFFDEFS_H */