.gitignore: update to ignore all make created files
[keystone-rtos/ibl.git] / src / interp / coff / coffdefs.h
1 /*
2  *
3  * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com/ 
4  * 
5  * 
6  *  Redistribution and use in source and binary forms, with or without 
7  *  modification, are permitted provided that the following conditions 
8  *  are met:
9  *
10  *    Redistributions of source code must retain the above copyright 
11  *    notice, this list of conditions and the following disclaimer.
12  *
13  *    Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the 
15  *    documentation and/or other materials provided with the   
16  *    distribution.
17  *
18  *    Neither the name of Texas Instruments Incorporated nor the names of
19  *    its contributors may be used to endorse or promote products derived
20  *    from this software without specific prior written permission.
21  *
22  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
23  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
24  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
26  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
27  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
28  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
31  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
32  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33  *
34 */
38 /**************************************************************************/
39 /*  COFFDEFS.H                                                            */
40 /*     Definitions of COFF symbol type and storage class fields.          */
41 /**************************************************************************/
42 #ifndef COFFDEFS_H
43 #define COFFDEFS_H
45 #if defined(TOOL_ASSEMBLER)
46    #error The COFF submodule should no longer be used by the assembler; use TICOFF04
47 #endif
49 /*------------------------------------------------------------------------*/
50 /*   STORAGE CLASSES                                                      */
51 /*------------------------------------------------------------------------*/
52 #define  C_NULL          0
53 #define  C_AUTO          1     /* AUTOMATIC VARIABLE                      */
54 #define  C_EXT           2     /* EXTERNAL SYMBOL                         */
55 #define  C_STAT          3     /* STATIC                                  */
56 #define  C_REG           4     /* REGISTER VARIABLE                       */
57 #define  C_EXTREF        5     /* EXTERNAL DEFINITION                     */
58 #define  C_LABEL         6     /* LABEL                                   */
59 #define  C_ULABEL        7     /* UNDEFINED LABEL                         */
60 #define  C_MOS           8     /* MEMBER OF STRUCTURE                     */
61 #define  C_ARG           9     /* FUNCTION ARGUMENT                       */
62 #define  C_STRTAG        10    /* STRUCTURE TAG                           */
63 #define  C_MOU           11    /* MEMBER OF UNION                         */
64 #define  C_UNTAG         12    /* UNION TAG                               */
65 #define  C_TPDEF         13    /* TYPE DEFINITION                         */
66 #define  C_USTATIC       14    /* UNDEFINED STATIC                        */
67 #define  C_ENTAG         15    /* ENUMERATION TAG                         */
68 #define  C_MOE           16    /* MEMBER OF ENUMERATION                   */
69 #define  C_REGPARM       17    /* REGISTER PARAMETER                      */
70 #define  C_FIELD         18    /* BIT FIELD                               */
71 #define  C_UEXT          19    /* TENTATIVE EXTERNAL DEFINITION           */
72 #define  C_STATLAB       20    /* STATIC LOAD-TIME LABEL                  */
73 #define  C_EXTLAB        21    /* EXTERNAL LOAD-TIME LABEL                */
74 #define  C_VREG          22    /* VIRTUAL REGISTER VARIABLE               */
75 #define  C_SYSTEM        23    /* SYSTEM-WIDE SYMBOL                      */
76 #define  C_STATREG       24    /* STATIC REGISTER VARIABLE                */
77 #define  C_EXTREG        25    /* EXTERNAL REGISTER VARIABLE              */
78 #define  C_EXTREFREG     26    /* EXTERNAL REGISTER VARIABLE REFERENCE    */
79 #define  C_VARARG        27    /* LAST DECLARED PARAMETER OF VARARG FN    */
80 #define  C_EXTDEF        28    /* C_EXT DEFINED IN DIFFERENT FILE         */
81 #define  C_USTATREG      29    /* UNDEFINED STATIC REGISTER VARIABLE      */
83 #define  C_BLOCK         100   /* ".BB" OR ".EB"                          */
84 #define  C_FCN           101   /* ".BF" OR ".EF"                          */
85 #define  C_EOS           102   /* END OF STRUCTURE                        */
86 #define  C_FILE          103   /* FILE NAME                               */
87 #define  C_LINE          104   /* DUMMY SCLASS FOR LINE NUMBER ENTRY      */
88 #define  C_ALIAS         105   /* DUPLICATE TAG                           */
89 #define  C_PREF          106   /* DUMMY SCLASS FOR REF PRAGMA TABLE ENTRY */
91 #define  C_GRPTAG        107   /* TAG FOR GROUPED GLOBAL VARIABLES        */
92 #define  C_SMOG          108   /* STATIC MEMBER OF GROUP                  */
93 #define  C_EMOG          109   /* EXTERN MEMBER OF GROUP                  */
94 #define  C_EOG           110   /* END OF GROUP                            */
96 /*------------------------------------------------------------------------*/
97 /* STORAGE CLASS QUALIFIERS                                               */
98 /*------------------------------------------------------------------------*/
99 #define CQ_NEAR          0x0001
100 #define CQ_FAR           0x0002
101 #define CQ_INLINE        0x0004        /* INLINE THIS FUNCTION DEFINITION   */
102 #define CQ_SUPPRESS      0x0008        /* INLINE AND EMIT NO ICODE OUTPUT   */
103 #define CQ_CONTROL       0x0010        /* SYMBOL IS A "CONTROL REGISTER"    */
104 #define CQ_INTERRUPT     0x0020        /* INTERRUPT FUNCTION                */
105 #define CQ_TRAP          0x0040        /* (MVP CODE GENERATOR)              */
106 #define CQ_GREGISTER     0x0080        /* GLOBAL REGISTER SYMBOL            */
107 #define CQ_PORT          0x0100        /* 370 PORT VARIABLE                 */
108 #define CQ_SYSTEM        0x0200        /* MVP SHARED SYMBOL (MP AND PPs)    */
109 #define CQ_SYSTEMPP      0x0400        /* MVP SHARED SYMBOL (PPs only)      */
110 #define CQ_REENTRANT     0x0800        /* FUNCTION IS REENTRANT/NEEDS STACK */
111 #define CQ_NMI_INTERRUPT 0x1000        /* NMI INTERRUPT FUNCTION            */
112  
113 #define CQ_ALIASED       0x2000        /* ADDRESS OF SYMBOL TAKEN SOMEWHERE */
114 #define CQ_WRITTEN       0x4000        /* VARIABLE IS MODIFIED BY CODE      */
115 #define CQ_TOUCHED       0x8000        /* VARIABLE IS REFERENCED BY CODE    */
117 #define CQ_ICODE (  CQ_NEAR | CQ_INLINE   | CQ_CONTROL   | CQ_TRAP       \
118                   | CQ_FAR  | CQ_SUPPRESS | CQ_INTERRUPT | CQ_GREGISTER  \
119                   | CQ_PORT | CQ_SYSTEM   | CQ_SYSTEMPP  | CQ_REENTRANT  \
120                   | CQ_NMI_INTERRUPT)
121                                                         
122 /*------------------------------------------------------------------------*/
123 /* STORAGE CLASS MACROS                                                   */
124 /*------------------------------------------------------------------------*/
125 #define ISLOCAL(c) ((c) == C_AUTO   || (c) == C_REG     || (c) == C_VREG)
126 #define ISPARM(c)  ((c) == C_ARG    || (c) == C_REGPARM || (c) == C_VARARG)
127 #define ISAUTO(c)  ((c) == C_AUTO   || (c) == C_ARG     || (c) == C_VARARG)
128 #define ISREG(c)   ((c) == C_REG    || (c) == C_REGPARM || (c) == C_VREG || \
129                     (c) == C_EXTREG || (c) == C_STATREG || (c) == C_EXTREFREG)
130 #define ISTAG(c)   ((c) == C_STRTAG || (c) == C_UNTAG   || (c) == C_ENTAG)
131 #define ISGROUP(c) ((c) == C_GRPTAG)
133 #define ISMOS(c)   ((c) == C_MOS    || (c) == C_MOU     || \
134                     (c) == C_MOE    || (c) == C_FIELD)
136 #define ISXDEF(c)  ((c) == C_STAT   || (c) == C_STATREG || \
137                     (c) == C_EXT    || (c) == C_EXTDEF  || (c) == C_EXTREG)
139 #define ISEXT(c)   ((c) == C_USTATIC || (c) == C_STAT   || (c) == C_STATREG  ||\
140                     (c) == C_EXTREF  || (c) == C_UEXT   || (c) == C_EXTREFREG||\
141                     (c) == C_EXT     || (c) == C_EXTDEF || (c) == C_EXTREG   ||\
142                     (c) == C_EXTLAB  || (c) == C_SYSTEM)
144 #define ISGLOB(c)  ((c) == C_EXTREF  || (c) == C_UEXT   || (c) == C_EXTREFREG||\
145                     (c) == C_EXT     || (c) == C_EXTDEF || (c) == C_EXTREG   ||\
146                     (c) == C_EXTLAB  || (c) == C_SYSTEM)
148 #define ISNEAR(cq)          (((cq) & CQ_NEAR) != 0)
149 #define ISFAR(cq)           (((cq) & CQ_FAR) != 0)
150 #define ISCONTROL(cq)       (((cq) & CQ_CONTROL) != 0)
151 #define ISGREGISTER(cq)     (((cq) & CQ_GREGISTER) != 0)
152 #define ISPORT(cq)          (((cq) & CQ_PORT)    != 0)
153 #define ISINTERRUPT(cq)     (((cq) & CQ_INTERRUPT) != 0)
154 #define ISNMIINTERRUPT(cq)  (((cq) & CQ_NMI_INTERRUPT) != 0)
155 #define ISREENTRANT(cq)     (((cq) & CQ_REENTRANT) != 0)
156 #define ISTRAP(cq)          (((cq) & CQ_TRAP) != 0)
157 #define ISINT_OR_TRAP(cq)   (((cq) & (CQ_TRAP | CQ_INTERRUPT)) != 0)
159 /*-------------------------------------------------------------------------*/
160 /* COFF BASIC TYPES - PACKED INTO THE LOWER 4 BITS OF THE TYPE FIELD       */
161 /*-------------------------------------------------------------------------*/
162 #define  CT_NULL     0x80       /* UNDEFINED OR ERROR TYPE (NO TYPE INFO)  */
163 #define  CT_VOID     0          /* VOID TYPE                               */
164 #define  CT_SCHAR    1          /* CHARACTER (EXPLICITLY "signed")         */
165 #define  CT_CHAR     2          /* CHARACTER (IMPLICITLY SIGNED)           */
166 #define  CT_SHORT    3          /* SHORT INTEGER                           */
167 #define  CT_INT      4          /* INTEGER                                 */
168 #define  CT_LONG     5          /* LONG INTEGER                            */
169 #define  CT_FLOAT    6          /* SINGLE PRECISION FLOATING POINT         */
170 #define  CT_DOUBLE   7          /* DOUBLE PRECISION FLOATING POINT         */
171 #define  CT_STRUCT   8          /* STRUCTURE                               */
172 #define  CT_UNION    9          /* UNION                                   */
173 #define  CT_ENUM     10         /* ENUMERATION                             */
174 #define  CT_LDOUBLE  11         /* LONG DOUBLE FLOATING POINT              */
175 #define  CT_UCHAR    12         /* UNSIGNED CHARACTER                      */
176 #define  CT_USHORT   13         /* UNSIGNED SHORT                          */
177 #define  CT_UINT     14         /* UNSIGNED INTEGER                        */
178 #define  CT_ULONG    15         /* UNSIGNED LONG                           */
180 /*-------------------------------------------------------------------------*/
181 /* COFF DERIVED TYPES: 2 BITS EACH                                         */
182 /*-------------------------------------------------------------------------*/
183 #define  DCT_NON     0x0        /* NO DERIVED TYPE                         */
184 #define  DCT_PTR     0x1        /* POINTER                                 */
185 #define  DCT_FCN     0x2        /* FUNCTION                                */
186 #define  DCT_ARY     0x3        /* ARRAY                                   */
188 /*-------------------------------------------------------------------------*/
189 /* COFF TYPE FIELD MASKS AND SIZES                                         */
190 /*-------------------------------------------------------------------------*/
191 #define  N_BCTMASK     0xF      /* MASK FOR BASIC TYPE                     */
192 #define  N_CTMASK      0x30     /* MASK FOR FIRST DERIVED TYPE             */
193 #define  N_DCTMAX      12       /* MAXIMUM DERIVED TYPES                   */
194 #define  N_BCTSHFT     4        /* SHIFT AMOUNT (WIDTH) FOR BASIC TYPE     */
195 #define  N_CTSHIFT     2        /* SHIFT AMOUNT (WIDTH) FOR DERIVED TYPES  */
197 /*-------------------------------------------------------------------------*/
198 /* COFF TYPE MANIPULATION MACROS                                           */
199 /*                                                                         */
200 /*    BCTYPE(t)    - Return basic type from t                              */
201 /*    DCTYPE(t)    - Return all derived types from t                       */
202 /*    DCTYPE1(t)   - Return 1st derived type from t                        */
203 /*    CTQUAL(t,q)  - Return qualification of type                          */
204 /*    CTUNQUAL(t,q)- Return unqualified version of type                    */
205 /*                                                                         */
206 /*    MKCTYPE()    - Build a type from basic and several derived types     */
207 /*    CDERIVE(d,t) - Build a type from basic and one derived type          */
208 /*    CINCREF(t)   - Convert 't' into pointer to 't'                       */
209 /*    CDECREF(t)   - Remove first derviation from t                        */
210 /*                                                                         */
211 /*    ISCINT(t)    - TRUE if t is an integral type                         */
212 /*    ISCSGN(t)    - TRUE if t is a signed type                            */
213 /*    ISCUNS(t)    - TRUE if t is an unsigned type                         */
214 /*    ISCFLT(t)    - TRUE if t is a floating point type                    */
215 /*    ISCDBL(t)    - TRUE if t is a double or long double type             */
216 /*    ISCPTR(t)    - TRUE if t is a pointer                                */
217 /*    ISCFCN(t)    - TRUE if t is a function                               */
218 /*    ISCARY(t)    - TRUE if t is an array                                 */
219 /*    ISCSTR(t)    - TRUE if t is a struct, union, or enum type            */
220 /*    ISCAGG(t)    - TRUE if t is an array, struct, or union               */
221 /*                                                                         */
222 /*    CITOU(t)     - convert signed type to unsigned equivalent            */
223 /*    CUTOI(t)     - convert unsigned type to signed equivalent            */
224 /*    CNOSIGN(t)   - convert signed or unsigned type to "plain" equivalent */
225 /*-------------------------------------------------------------------------*/
226 #define BCTYPE(t)    ((int)((t) & N_BCTMASK))  
227 #define DCTYPE(t)    ((t) & ~N_BCTMASK)
228 #define DCTYPE1(t)   (((t) & N_CTMASK) >> N_BCTSHFT)
230 #define CTQUAL(t,q)  ((int)(DCTYPE(t) ? DCTYPE1(q) : BCTYPE(q)))
231 #define CTUNQUAL(t,q) (ISCPTR(t) ? ((q) & ~N_CTMASK) : ((q) & ~N_BCTMASK))
233 #define MKCTYPE(basic, d1,d2,d3,d4,d5,d6) \
234                     ((basic) | ((d1) <<  4) | ((d2) <<  6) | ((d3) <<  8) |\
235                                ((d4) << 10) | ((d5) << 12) | ((d6) << 14))
236 #define CDERIVE(d,t) ((DCTYPE(t) << N_CTSHIFT) | ((d) << N_BCTSHFT) | BCTYPE(t))
237 #define CINCREF(t)   ((DCTYPE(t) << N_CTSHIFT) | (DCT_PTR<<N_BCTSHFT)|BCTYPE(t))
238 #define CDECREF(t)   (DCTYPE((t) >> N_CTSHIFT) | BCTYPE(t))
240 #define ISCSGN(t)    (((t) >= CT_SCHAR && (t) <= CT_LONG)  || (t) == CT_ENUM)
241 #define ISCUNS(t)    ((t) >= CT_UCHAR  && (t) <= CT_ULONG)
242 #define ISCINT(t)    (((t) >= CT_SCHAR && (t) <= CT_LONG)  || (t) == CT_ENUM ||\
243                       ((t) >= CT_UCHAR  && (t) <= CT_ULONG))
244 #define ISCFLT(t)    ((t) == CT_FLOAT || (t) == CT_DOUBLE || (t) == CT_LDOUBLE)
245 #define ISCDBL(t)    ((t) == CT_DOUBLE || (t) == CT_LDOUBLE)
246 #define ISCPTR(t)    (((t) & N_CTMASK) == (DCT_PTR << N_BCTSHFT)) 
247 #define ISCFCN(t)    (((t) & N_CTMASK) == (DCT_FCN << N_BCTSHFT))
248 #define ISCARY(t)    (((t) & N_CTMASK) == (DCT_ARY << N_BCTSHFT))
249 #define ISCSTR(t)    ((t) == CT_STRUCT || (t) == CT_UNION || (t) == CT_ENUM)
250 #define ISCAGG(t)    (ISCARY(t) || (t) == CT_STRUCT || (t) == CT_UNION)
251 #define ISCCHAR(t)   ((t) == CT_CHAR || (t) == CT_SCHAR || (t) == CT_UCHAR)
252 #define ISCSHORT(t)  ((t) == CT_SHORT || (t) == CT_USHORT)
253 #define ISCLONG(t)   ((t) == CT_LONG || (t) == CT_ULONG)
255 #define CITOU(t)     ((t) + (CT_UCHAR - ((t) == CT_SCHAR ? CT_SCHAR : CT_CHAR)))
256 #define CUTOI(t)     ((t) - (CT_UCHAR - CT_CHAR))
257 #define CNOSIGN(t)   (ISCUNS(t) ? CUTOI(t) : (t) == CT_SCHAR ? CT_CHAR : (t))
259 /*------------------------------------------------------------------------*/
260 /* ILLEGAL COFF TYPES USED TO MARK SPECIAL OBJECTS.                       */
261 /*                                                                        */
262 /* CT_VENEER  - DENOTES A VENEER OF A FUNCTION.                           */
263 /*------------------------------------------------------------------------*/
264 #define CT_VENEER     (MKCTYPE(CT_VOID, DCT_FCN, DCT_FCN, 0, 0, 0, 0))
265 #define ISCVENEER(t)  ((t) == CT_VENEER)
267 #endif /* COFFDEFS_H */