Return to cvinfo.h CVS log

Up to [WindowsNT SDKs] / mstools / samples / sdktools / image / symedit

Annotation of mstools/samples/sdktools/image/symedit/cvinfo.h, revision 1.1

1.1     ! root        1: /***    cvinfo.h - Generic CodeView information definitions
        !             2:  *
        !             3:  *      Structures, constants, etc. for accessing and interpreting
        !             4:  *      CodeView information.
        !             5:  *
        !             6:  */
        !             7: 
        !             8: 
        !             9: /***    Disclaimer
        !            10:  *
        !            11:  *     Information in this header file is subject to change without notice
        !            12:  *     and does not represent a commitment on the part of Microsoft Corporation
        !            13:  *     to support or maintain this information in future versions of the 
        !            14:  *     software.
        !            15:  *
        !            16:  *     These contents may become obsolete in the future.
        !            17:  *
        !            18:  */
        !            19: 
        !            20: 
        !            21: #ifndef _CV_INFO_INCLUDED
        !            22: #define _CV_INFO_INCLUDED
        !            23: 
        !            24: #pragma pack(1)
        !            25: typedef unsigned long   CV_uoff32_t;
        !            26: typedef          long   CV_off32_t;
        !            27: typedef unsigned short  CV_uoff16_t;
        !            28: typedef          short  CV_off16_t;
        !            29: typedef unsigned short  CV_typ_t;
        !            30: 
        !            31: 
        !            32: 
        !            33: #ifdef _REAL10
        !            34: typedef struct {
        !            35:     char b[10];
        !            36: } REAL10;
        !            37: #endif
        !            38: 
        !            39: #define CV_SIGNATURE_C6         0L /* Actual signature is >64K */
        !            40: #define CV_SIGNATURE_C7         1L /* First explicit signature */
        !            41: #define CV_SIGNATURE_RESERVED   2L /* All signatures from 2 to 64K are reserved */
        !            42: 
        !            43: #define CV_MAXOFFSET   0xffffffff
        !            44: 
        !            45: /**     CodeView Symbol and Type OMF type information is broken up into two
        !            46:  *      ranges.  Type indices less than 0x1000 describe frequently used
        !            47:  *      type information that is frequently used.  Type indices above
        !            48:  *      0x1000 are used to describe more complex features such as function,
        !            49:  *      arrays and structures.
        !            50:  */
        !            51: 
        !            52: 
        !            53: 
        !            54: 
        !            55: /**     Primitive types have predefined meaning that is encoded in the
        !            56:  *      values of the various bit fields in the value.
        !            57:  *
        !            58:  *      A CodeView primitive type is defined as:
        !            59:  *
        !            60:  *      1 1
        !            61:  *      1 089  7654  3  210
        !            62:  *      r mode type  r  sub
        !            63:  *
        !            64:  *      Where
        !            65:  *          mode is the pointer mode
        !            66:  *          type is a type indicator
        !            67:  *          sub  is a subtype enumeration
        !            68:  *          r    is a reserved field
        !            69:  *
        !            70:  *      See Microsoft Symbol and Type OMF (Version 4.0) for more
        !            71:  *      information.
        !            72:  */
        !            73: 
        !            74: 
        !            75: #define CV_MMASK        0x700   /* mode mask */
        !            76: #define CV_TMASK        0x0f0   /* type mask */
        !            77: #define CV_SMASK        0x007   /* subtype mask */
        !            78: 
        !            79: #define CV_MSHIFT       8       /* primitive mode right shift count */
        !            80: #define CV_TSHIFT       4       /* primitive type right shift count */
        !            81: #define CV_SSHIFT       0       /* primitive subtype right shift count */
        !            82: 
        !            83: /*
        !            84:  *      macros to extract primitive mode, type and size
        !            85:  */
        !            86: 
        !            87: #define CV_MODE(typ)    (((typ) & CV_MMASK) >> CV_MSHIFT)
        !            88: #define CV_TYPE(typ)    (((typ) & CV_TMASK) >> CV_TSHIFT)
        !            89: #define CV_SUBT(typ)    (((typ) & CV_SMASK) >> CV_SSHIFT)
        !            90: 
        !            91: /*
        !            92:  *      macros to insert new primitive mode, type and size
        !            93:  */
        !            94: 
        !            95: #define CV_NEWMODE(typ, nm)     (((typ) & ~CV_MMASK) | ((nm) << CV_MSHIFT))
        !            96: #define CV_NEWTYPE(typ, nt)     (((typ) & ~CV_TMASK) | ((nt) << CV_TSHIFT))
        !            97: #define CV_NEWSUBT(typ, ns)     (((typ) & ~CV_SMASK) | ((ns) << CV_SSHIFT))
        !            98: 
        !            99: /*
        !           100:  *      pointer mode enumeration values
        !           101:  */
        !           102: 
        !           103: typedef enum CV_prmode_e {
        !           104:     CV_TM_DIRECT = 0,           /* mode is not a pointer */
        !           105:     CV_TM_NPTR   = 1,           /* mode is a near pointer */
        !           106:     CV_TM_FPTR   = 2,           /* mode is a far pointer */
        !           107:     CV_TM_HPTR   = 3,           /* mode is a huge pointer */
        !           108:     CV_TM_NPTR32 = 4,           /* mode is a 32 bit near pointer */
        !           109:     CV_TM_FPTR32 = 5,           /* mode is a 32 bit far pointer */
        !           110:     CV_TM_NPTR64 = 6            /* mode is a 64 bit near pointer */
        !           111: } CV_prmode_e;
        !           112: 
        !           113: /*
        !           114:  *      type enumeration values
        !           115:  */
        !           116: 
        !           117: typedef enum CV_type_e {
        !           118:     CV_SPECIAL      = 0x00,     /* special type size values */
        !           119:     CV_SIGNED       = 0x01,     /* signed integral size values */
        !           120:     CV_UNSIGNED     = 0x02,     /* unsigned integral size values */
        !           121:     CV_BOOLEAN      = 0x03,     /* Boolean size values */
        !           122:     CV_REAL         = 0x04,     /* real number size values */
        !           123:     CV_COMPLEX      = 0x05,     /* complex number size values */
        !           124:     CV_SPECIAL2     = 0x06,     /* second set of special types */
        !           125:     CV_INT          = 0x07,     /* integral (int) values */
        !           126:     CV_CVRESERVED   = 0x0f
        !           127: } CV_type_e;
        !           128: 
        !           129: /*
        !           130:  *      subtype enumeration values for CV_SPECIAL
        !           131:  */
        !           132: 
        !           133: typedef enum CV_special_e {
        !           134:     CV_SP_NOTYPE    = 0x00,
        !           135:     CV_SP_ABS       = 0x01,
        !           136:     CV_SP_SEGMENT   = 0x02,
        !           137:     CV_SP_VOID      = 0x03,
        !           138:     CV_SP_CURRENCY  = 0x04,
        !           139:     CV_SP_NBASICSTR = 0x05,
        !           140:     CV_SP_FBASICSTR = 0x06,
        !           141:     CV_SP_NOTTRANS  = 0x07
        !           142: } CV_special_e;
        !           143: 
        !           144: /*
        !           145:  *      subtype enumeration values for CV_SPECIAL2
        !           146:  */
        !           147: 
        !           148: 
        !           149: typedef enum CV_special2_e {
        !           150:     CV_S2_BIT       = 0x00,
        !           151:     CV_S2_PASCHAR   = 0x01      /* Pascal CHAR */
        !           152: } CV_special2_e;
        !           153: 
        !           154: /*
        !           155:  *      subtype enumeration values for CV_SIGNED, CV_UNSIGNED and CV_BOOLEAN
        !           156:  */
        !           157: 
        !           158: typedef enum CV_integral_e {
        !           159:     CV_IN_1BYTE     = 0x00,
        !           160:     CV_IN_2BYTE     = 0x01,
        !           161:     CV_IN_4BYTE     = 0x02,
        !           162:     CV_IN_8BYTE     = 0x03
        !           163: } CV_integral_e;
        !           164: 
        !           165: /*
        !           166:  *      subtype enumeration values for CV_REAL and CV_COMPLEX
        !           167:  */
        !           168: 
        !           169: typedef enum CV_real_e {
        !           170:     CV_RC_REAL32    = 0x00,
        !           171:     CV_RC_REAL64    = 0x01,
        !           172:     CV_RC_REAL80    = 0x02,
        !           173:     CV_RC_REAL128   = 0x03,
        !           174:     CV_RC_REAL48    = 0x04
        !           175: } CV_real_e;
        !           176: 
        !           177: /*
        !           178:  *      subtype enumeration values for CV_INT (really int)
        !           179:  */
        !           180: 
        !           181: typedef enum CV_int_e {
        !           182:     CV_RI_CHAR      = 0x00,
        !           183:     CV_RI_WCHAR     = 0x01,
        !           184:     CV_RI_INT2      = 0x02,
        !           185:     CV_RI_UINT2     = 0x03,
        !           186:     CV_RI_INT4      = 0x04,
        !           187:     CV_RI_UINT4     = 0x05,
        !           188:     CV_RI_INT8      = 0x06,
        !           189:     CV_RI_UINT8     = 0x07
        !           190: } CV_int_e;
        !           191: 
        !           192: /*
        !           193:  *      macros to check the type of a primitive
        !           194:  */
        !           195: 
        !           196: #define CV_TYP_IS_DIRECT(typ)   (CV_MODE(typ) == CV_TM_DIRECT)
        !           197: #define CV_TYP_IS_PTR(typ)      (CV_MODE(typ) != CV_TM_DIRECT)
        !           198: #define CV_TYP_IS_NPTR(typ)     (CV_MODE(typ) == CV_TM_NPTR)
        !           199: #define CV_TYP_IS_FPTR(typ)     (CV_MODE(typ) == CV_TM_FPTR)
        !           200: #define CV_TYP_IS_HPTR(typ)     (CV_MODE(typ) == CV_TM_HPTR)
        !           201: #define CV_TYP_IS_NPTR32(typ)   (CV_MODE(typ) == CV_TM_NPTR32)
        !           202: #define CV_TYP_IS_FPTR32(typ)   (CV_MODE(typ) == CV_TM_FPTR32)
        !           203: 
        !           204: #define CV_TYP_IS_SIGNED(typ)  (((CV_TYPE(typ) == CV_SIGNED)  && \
        !           205:                                         CV_TYP_IS_DIRECT(typ)) || \
        !           206:                                         (typ == T_INT2)        || \
        !           207:                                         (typ == T_INT4)        || \
        !           208:                                         (typ == T_INT8)        || \
        !           209:                                         (typ == T_RCHAR))
        !           210: 
        !           211: #define CV_TYP_IS_UNSIGNED(typ) (((CV_TYPE(typ) == CV_UNSIGNED) && \
        !           212:                                          CV_TYP_IS_DIRECT(typ)) || \
        !           213:                                          (typ == T_UINT2)       || \
        !           214:                                          (typ == T_UINT4)       || \
        !           215:                                          (typ == T_UINT8)       || \
        !           216:                                          (typ == T_RCHAR))
        !           217: 
        !           218: #define CV_TYP_IS_REAL(typ)     ((CV_TYPE(typ) == CV_REAL)  && CV_TYP_IS_DIRECT(typ))
        !           219: 
        !           220: #define CV_FIRST_NONPRIM 0x1000
        !           221: #define CV_IS_PRIMITIVE(typ)       ((typ) < CV_FIRST_NONPRIM)
        !           222: 
        !           223: 
        !           224: 
        !           225: /*
        !           226:  *      selected values for type_index - for a more complete definition, see
        !           227:  *      Microsoft Symbol and Type OMF document
        !           228:  */
        !           229: 
        !           230: /*
        !           231:  *      Special Types
        !           232:  */
        !           233: 
        !           234: #define T_NOTYPE        0x0000  /* uncharacterized type (no type) */
        !           235: #define T_ABS           0x0001  /* absolute symbol */
        !           236: #define T_SEGMENT       0x0002  /* segment type */
        !           237: #define T_VOID          0x0003  /* void */
        !           238: #define T_PVOID         0x0103  /* near pointer to void */
        !           239: #define T_PFVOID        0x0203  /* far pointer to void */
        !           240: #define T_PHVOID        0x0303  /* huge pointer to void */
        !           241: #define T_32PVOID       0x0403  /* 16:32 near pointer to void */
        !           242: #define T_32PFVOID      0x0503  /* 16:32 far pointer to void */
        !           243: #define T_CURRENCY      0x0004  /* BASIC 8 byte currency value */
        !           244: #define T_NBASICSTR     0x0005  /* Near BASIC string */
        !           245: #define T_FBASICSTR     0x0006  /* Far BASIC string */
        !           246: #define T_NOTTRANS      0x0007  /* type not translated by cvpack */
        !           247: #define T_BIT           0x0060  /* bit */
        !           248: #define T_PASCHAR       0x0061  /* Pascal CHAR */
        !           249: 
        !           250: /*
        !           251:  *      Character types
        !           252:  */
        !           253: 
        !           254: #define T_CHAR          0x0010  /* 8 bit signed */
        !           255: #define T_UCHAR         0x0020  /* 8 bit unsigned */
        !           256: #define T_PCHAR         0x0110  /* near pointer to 8 bit signed */
        !           257: #define T_PUCHAR        0x0120  /* near pointer to 8 bit unsigned */
        !           258: #define T_PFCHAR        0x0210  /* far pointer to 8 bit signed */
        !           259: #define T_PFUCHAR       0x0220  /* far pointer to 8 bit unsigned */
        !           260: #define T_PHCHAR        0x0310  /* huge pointer to 8 bit signed */
        !           261: #define T_PHUCHAR       0x0320  /* huge pointer to 8 bit unsigned */
        !           262: #define T_32PCHAR       0x0410  /* 16:32 near pointer to 8 bit signed */
        !           263: #define T_32PUCHAR      0x0420  /* 16:32 near pointer to 8 bit unsigned */
        !           264: #define T_32PFCHAR      0x0510  /* 16:32 far pointer to 8 bit signed */
        !           265: #define T_32PFUCHAR     0x0520  /* 16:32 far pointer to 8 bit unsigned */
        !           266: 
        !           267: /*
        !           268:  *      really a character types
        !           269:  */
        !           270: 
        !           271: #define T_RCHAR         0x0070  /* really a char */
        !           272: #define T_PRCHAR        0x0170  /* 16:16 near pointer to a real char */
        !           273: #define T_PFRCHAR       0x0270  /* 16:16 far pointer to a real char */
        !           274: #define T_PHRCHAR       0x0370  /* 16:16 huge pointer to a real char */
        !           275: #define T_32PRCHAR      0x0470  /* 16:32 near pointer to a real char */
        !           276: #define T_32PFRCHAR     0x0570  /* 16:32 far pointer to a real char */
        !           277: 
        !           278: /*
        !           279:  *      really a wide character types (UNICODE)
        !           280:  */
        !           281: 
        !           282: #define T_WCHAR         0x0071  /* wide char */
        !           283: #define T_PWCHAR        0x0171  /* 16:16 near pointer to a wide char */
        !           284: #define T_PFWCHAR       0x0271  /* 16:16 far pointer to a wide char */
        !           285: #define T_PHWCHAR       0x0371  /* 16:16 huge pointer to a wide char */
        !           286: #define T_32PWCHAR      0x0471  /* 16:32 near pointer to a wide char */
        !           287: #define T_32PFWCHAR     0x0571  /* 16:32 far pointer to a wide char */
        !           288: 
        !           289: /*
        !           290:  *      16 bit short types
        !           291:  */
        !           292: 
        !           293: #define T_SHORT         0x0011  /* 16 bit signed */
        !           294: #define T_USHORT        0x0021  /* 16 bit unsigned */
        !           295: #define T_PSHORT        0x0111  /* near pointer to 16 bit signed */
        !           296: #define T_PUSHORT       0x0121  /* near pointer to 16 bit unsigned */
        !           297: #define T_PFSHORT       0x0211  /* far pointer to 16 bit signed */
        !           298: #define T_PFUSHORT      0x0221  /* far pointer to 16 bit unsigned */
        !           299: #define T_PHSHORT       0x0311  /* huge pointer to 16 bit signed */
        !           300: #define T_PHUSHORT      0x0321  /* huge pointer to 16 bit unsigned */
        !           301: 
        !           302: #define T_32PSHORT      0x0411  /* 16:32 near pointer to 16 bit signed */
        !           303: #define T_32PUSHORT     0x0421  /* 16:32 near pointer to 16 bit unsigned */
        !           304: #define T_32PFSHORT     0x0511  /* 16:32 far pointer to 16 bit signed */
        !           305: #define T_32PFUSHORT    0x0521  /* 16:32 far pointer to 16 bit unsigned */
        !           306: 
        !           307: /*
        !           308:  *      16 bit int types
        !           309:  */
        !           310: 
        !           311: #define T_INT2          0x0072  /* 16 bit signed int */
        !           312: #define T_UINT2         0x0073  /* 16 bit unsigned int */
        !           313: #define T_PINT2         0x0172  /* near pointer to 16 bit signed int */
        !           314: #define T_PUINT2        0x0173  /* near pointer to 16 bit unsigned int */
        !           315: #define T_PFINT2        0x0272  /* far pointer to 16 bit signed int */
        !           316: #define T_PFUINT2       0x0273  /* far pointer to 16 bit unsigned int */
        !           317: #define T_PHINT2        0x0372  /* huge pointer to 16 bit signed int */
        !           318: #define T_PHUINT2       0x0373  /* huge pointer to 16 bit unsigned int */
        !           319: 
        !           320: #define T_32PINT2       0x0472  /* 16:32 near pointer to 16 bit signed int */
        !           321: #define T_32PUINT2      0x0473  /* 16:32 near pointer to 16 bit unsigned int */
        !           322: #define T_32PFINT2      0x0572  /* 16:32 far pointer to 16 bit signed int */
        !           323: #define T_32PFUINT2     0x0573  /* 16:32 far pointer to 16 bit unsigned int */
        !           324: 
        !           325: /*
        !           326:  *      32 bit long types
        !           327:  */
        !           328: 
        !           329: #define T_LONG          0x0012  /* 32 bit signed */
        !           330: #define T_ULONG         0x0022  /* 32 bit unsigned */
        !           331: #define T_PLONG         0x0112  /* near pointer to 32 bit signed */
        !           332: #define T_PLONG         0x0112  /* near pointer to 32 bit signed */
        !           333: #define T_PULONG        0x0122  /* near pointer to 32 bit unsigned */
        !           334: #define T_PFLONG        0x0212  /* far pointer to 32 bit signed */
        !           335: #define T_PFULONG       0x0222  /* far pointer to 32 bit unsigned */
        !           336: #define T_PHLONG        0x0312  /* huge pointer to 32 bit signed */
        !           337: #define T_PHULONG       0x0322  /* huge pointer to 32 bit unsigned */
        !           338: 
        !           339: #define T_32PLONG       0x0412  /* 16:32 near pointer to 32 bit signed */
        !           340: #define T_32PULONG      0x0422  /* 16:32 near pointer to 32 bit unsigned */
        !           341: #define T_32PFLONG      0x0512  /* 16:32 far pointer to 32 bit signed */
        !           342: #define T_32PFULONG     0x0522  /* 16:32 far pointer to 32 bit unsigned */
        !           343: 
        !           344: /*
        !           345:  *      32 bit int types
        !           346:  */
        !           347: 
        !           348: #define T_INT4          0x0074  /* 32 bit signed int */
        !           349: #define T_UINT4         0x0075  /* 32 bit unsigned int */
        !           350: #define T_PINT4         0x0174  /* near pointer to 32 bit signed int */
        !           351: #define T_PUINT4        0x0175  /* near pointer to 32 bit unsigned int */
        !           352: #define T_PFINT4        0x0274  /* far pointer to 32 bit signed int */
        !           353: #define T_PFUINT4       0x0275  /* far pointer to 32 bit unsigned int */
        !           354: #define T_PHINT4        0x0374  /* huge pointer to 32 bit signed int */
        !           355: #define T_PHUINT4       0x0375  /* huge pointer to 32 bit unsigned int */
        !           356: 
        !           357: #define T_32PINT4       0x0474  /* 16:32 near pointer to 32 bit signed int */
        !           358: #define T_32PUINT4      0x0475  /* 16:32 near pointer to 32 bit unsigned int */
        !           359: #define T_32PFINT4      0x0574  /* 16:32 far pointer to 32 bit signed int */
        !           360: #define T_32PFUINT4     0x0575  /* 16:32 far pointer to 32 bit unsigned int */
        !           361: 
        !           362: /*
        !           363:  *      64 bit quad types
        !           364:  */
        !           365: 
        !           366: 
        !           367: #define T_QUAD          0x0013  /* 64 bit signed */
        !           368: #define T_UQUAD         0x0023  /* 64 bit unsigned */
        !           369: #define T_PQUAD         0x0113  /* near pointer to 64 bit signed */
        !           370: #define T_PUQUAD        0x0123  /* near pointer to 64 bit unsigned */
        !           371: #define T_PFQUAD        0x0213  /* far pointer to 64 bit signed */
        !           372: #define T_PFUQUAD       0x0223  /* far pointer to 64 bit unsigned */
        !           373: #define T_PHQUAD        0x0313  /* huge pointer to 64 bit signed */
        !           374: #define T_PHUQUAD       0x0323  /* huge pointer to 64 bit unsigned */
        !           375: 
        !           376: /*
        !           377:  *      64 bit int types
        !           378:  */
        !           379: 
        !           380: #define T_INT8          0x0076  /* 64 bit signed int */
        !           381: #define T_UINT8         0x0077  /* 64 bit unsigned int */
        !           382: #define T_PINT8         0x0176  /* near pointer to 64 bit signed int */
        !           383: #define T_PUINT8        0x0177  /* near pointer to 64 bit unsigned int */
        !           384: #define T_PFINT8        0x0276  /* far pointer to 64 bit signed int */
        !           385: #define T_PFUINT8       0x0277  /* far pointer to 64 bit unsigned int */
        !           386: #define T_PHINT8        0x0376  /* huge pointer to 64 bit signed int */
        !           387: #define T_PHUINT8       0x0377  /* huge pointer to 64 bit unsigned int */
        !           388: 
        !           389: #define T_32PINT8       0x0476  /* 16:32 near pointer to 64 bit signed int */
        !           390: #define T_32PUINT8      0x0477  /* 16:32 near pointer to 64 bit unsigned int */
        !           391: #define T_32PFINT8      0x0576  /* 16:32 far pointer to 64 bit signed int */
        !           392: #define T_32PFUINT8     0x0577  /* 16:32 far pointer to 64 bit unsigned int */
        !           393: 
        !           394: /*
        !           395:  *      32 bit real types
        !           396:  */
        !           397: 
        !           398: #define T_REAL32        0x0040  /* 32 bit real */
        !           399: #define T_PREAL32       0x0140  /* near pointer to 32 bit real */
        !           400: #define T_PFREAL32      0x0240  /* far pointer to 32 bit real */
        !           401: #define T_PHREAL32      0x0340  /* huge pointer to 32 bit real */
        !           402: #define T_32PREAL32     0x0440  /* 16:32 near pointer to 32 bit real */
        !           403: #define T_32PFREAL32    0x0540  /* 16:32 far pointer to 32 bit real */
        !           404: 
        !           405: /*
        !           406:  *      48 bit real types
        !           407:  */
        !           408: 
        !           409: #define T_REAL48        0x0044  /* 48 bit real */
        !           410: #define T_PREAL48       0x0144  /* near pointer to 48 bit real */
        !           411: #define T_PFREAL48      0x0244  /* far pointer to 48 bit real */
        !           412: #define T_PHREAL48      0x0344  /* huge pointer to 48 bit real */
        !           413: #define T_32PREAL48     0x0444  /* 16:32 near pointer to 48 bit real */
        !           414: #define T_32PFREAL48    0x0544  /* 16:32 far pointer to 48 bit real */
        !           415: 
        !           416: /*
        !           417:  *      64 bit real types
        !           418:  */
        !           419: 
        !           420: #define T_REAL64        0x0041  /* 64 bit real */
        !           421: #define T_PREAL64       0x0141  /* near pointer to 64 bit real */
        !           422: #define T_PFREAL64      0x0241  /* far pointer to 64 bit real */
        !           423: #define T_PHREAL64      0x0341  /* huge pointer to 64 bit real */
        !           424: #define T_32PREAL64     0x0441  /* 16:32 near pointer to 64 bit real */
        !           425: #define T_32PFREAL64    0x0541  /* 16:32 far pointer to 64 bit real */
        !           426: 
        !           427: /*
        !           428:  *      80 bit real types
        !           429:  */
        !           430: 
        !           431: #define T_REAL80        0x0042  /* 80 bit real */
        !           432: #define T_PREAL80       0x0142  /* near pointer to 80 bit real */
        !           433: #define T_PFREAL80      0x0242  /* far pointer to 80 bit real */
        !           434: #define T_PHREAL80      0x0342  /* huge pointer to 80 bit real */
        !           435: #define T_32PREAL80     0x0442  /* 16:32 near pointer to 80 bit real */
        !           436: #define T_32PFREAL80    0x0542  /* 16:32 far pointer to 80 bit real */
        !           437: 
        !           438: /*
        !           439:  *      128 bit real types
        !           440:  */
        !           441: 
        !           442: #define T_REAL128       0x0043  /* 128 bit real */
        !           443: #define T_PREAL128      0x0143  /* near pointer to 128 bit real */
        !           444: #define T_PFREAL128     0x0243  /* far pointer to 128 bit real */
        !           445: #define T_PHREAL128     0x0343  /* huge pointer to 128 bit real */
        !           446: #define T_32PREAL128    0x0443  /* 16:32 near pointer to 128 bit real */
        !           447: #define T_32PFREAL128   0x0543  /* 16:32 far pointer to 128 bit real */
        !           448: 
        !           449: /*
        !           450:  *      32 bit complex types
        !           451:  */
        !           452: 
        !           453: #define T_CPLX32        0x0050  /* 32 bit complex */
        !           454: #define T_PCPLX32       0x0150  /* near pointer to 32 bit complex */
        !           455: #define T_PFCPLX32      0x0250  /* far pointer to 32 bit complex */
        !           456: #define T_PHCPLX32      0x0350  /* huge pointer to 32 bit complex */
        !           457: #define T_32PCPLX32     0x0450  /* 16:32 near pointer to 32 bit complex */
        !           458: #define T_32PFCPLX32    0x0550  /* 16:32 far pointer to 32 bit complex */
        !           459: 
        !           460: /*
        !           461:  *      48 bit complex types
        !           462:  */
        !           463: 
        !           464: #define T_CPLX48        0x0054  /* 48 bit complex */
        !           465: #define T_PCPLX48       0x0154  /* near pointer to 48 bit complex */
        !           466: #define T_PFCPLX48      0x0254  /* far pointer to 48 bit complex */
        !           467: #define T_PHCPLX48      0x0354  /* huge pointer to 48 bit complex */
        !           468: #define T_32PCPLX48     0x0454  /* 16:32 near pointer to 48 bit complex */
        !           469: #define T_32PFCPLX48    0x0554  /* 16:32 far pointer to 48 bit complex */
        !           470: 
        !           471: /*
        !           472:  *      64 bit complex types
        !           473:  */
        !           474: 
        !           475: #define T_CPLX64        0x0051  /* 64 bit complex */
        !           476: #define T_PCPLX64       0x0151  /* near pointer to 64 bit complex */
        !           477: #define T_PFCPLX64      0x0251  /* far pointer to 64 bit complex */
        !           478: #define T_PHCPLX64      0x0351  /* huge pointer to 64 bit complex */
        !           479: #define T_32PCPLX64     0x0451  /* 16:32 near pointer to 64 bit complex */
        !           480: #define T_32PFCPLX64    0x0551  /* 16:32 far pointer to 64 bit complex */
        !           481: 
        !           482: /*
        !           483:  *      80 bit complex types
        !           484:  */
        !           485: 
        !           486: #define T_CPLX80        0x0052  /* 80 bit complex */
        !           487: #define T_PCPLX80       0x0152  /* near pointer to 80 bit complex */
        !           488: #define T_PFCPLX80      0x0252  /* far pointer to 80 bit complex */
        !           489: #define T_PHCPLX80      0x0352  /* huge pointer to 80 bit complex */
        !           490: #define T_32PCPLX80     0x0452  /* 16:32 near pointer to 80 bit complex */
        !           491: #define T_32PFCPLX80    0x0552  /* 16:32 far pointer to 80 bit complex */
        !           492: 
        !           493: /*
        !           494:  *      128 bit complex types
        !           495:  */
        !           496: 
        !           497: #define T_CPLX128       0x0053  /* 128 bit complex */
        !           498: #define T_PCPLX128      0x0153  /* near pointer to 128 bit complex */
        !           499: #define T_PFCPLX128     0x0253  /* far pointer to 128 bit complex */
        !           500: #define T_PHCPLX128     0x0353  /* huge pointer to 128 bit real */
        !           501: #define T_32PCPLX128    0x0453  /* 16:32 near pointer to 128 bit complex */
        !           502: #define T_32PFCPLX128   0x0553  /* 16:32 far pointer to 128 bit complex */
        !           503: 
        !           504: /*
        !           505:  *      boolean types
        !           506:  */
        !           507: 
        !           508: #define T_BOOL08        0x0030  /* 8 bit boolean */
        !           509: #define T_BOOL16        0x0031  /* 16 bit boolean */
        !           510: #define T_BOOL32        0x0032  /* 32 bit boolean */
        !           511: #define T_PBOOL08       0x0130  /* near pointer to  8 bit boolean */
        !           512: #define T_PBOOL16       0x0131  /* near pointer to 16 bit boolean */
        !           513: #define T_PBOOL32       0x0132  /* near pointer to 32 bit boolean */
        !           514: #define T_PFBOOL08      0x0230  /* far pointer to  8 bit boolean */
        !           515: #define T_PFBOOL16      0x0231  /* far pointer to 16 bit boolean */
        !           516: #define T_PFBOOL32      0x0232  /* far pointer to 32 bit boolean */
        !           517: #define T_PHBOOL08      0x0330  /* huge pointer to  8 bit boolean */
        !           518: #define T_PHBOOL16      0x0331  /* huge pointer to 16 bit boolean */
        !           519: #define T_PHBOOL32      0x0332  /* huge pointer to 32 bit boolean */
        !           520: 
        !           521: #define T_32PBOOL08     0x0430  /* 16:32 near pointer to 8 bit boolean */
        !           522: #define T_32PFBOOL08    0x0530  /* 16:32 far pointer to 8 bit boolean */
        !           523: #define T_32PBOOL16     0x0431  /* 16:32 near pointer to 18 bit boolean */
        !           524: #define T_32PFBOOL16    0x0531  /* 16:32 far pointer to 16 bit boolean */
        !           525: #define T_32PBOOL32     0x0432  /* 16:32 near pointer to 32 bit boolean */
        !           526: #define T_32PFBOOL32    0x0532  /* 16:32 far pointer to 32 bit boolean */
        !           527: 
        !           528: 
        !           529: #define T_NCVPTR        0x01f0  /* CV Internal type for created near pointers */
        !           530: #define T_FCVPTR        0x02f0  /* CV Internal type for created far pointers */
        !           531: #define T_HCVPTR        0x03f0  /* CV Internal type for created huge pointers */
        !           532: 
        !           533: /**     No leaf index can have a value of 0x0000.  The leaf indices are
        !           534:  *      separated into ranges depending upon the use of the type record.
        !           535:  *      The second range is for the type records that are directly referenced
        !           536:  *      in symbols. The first range is for type records that are not
        !           537:  *      referenced by symbols but instead are referenced by other type
        !           538:  *      records.  All type records must have a starting leaf index in these
        !           539:  *      first two ranges.  The third range of leaf indices are used to build
        !           540:  *      up complex lists such as the field list of a class type record.  No
        !           541:  *      type record can begin with one of the leaf indices. The fourth ranges
        !           542:  *      of type indices are used to represent numeric data in a symbol or
        !           543:  *      type record. These leaf indices are greater than 0x8000.  At the
        !           544:  *      point that type or symbol processor is expecting a numeric field, the
        !           545:  *      next two bytes in the type record are examined.  If the value is less
        !           546:  *      than 0x8000, then the two bytes contain the numeric value.  If the
        !           547:  *      value is greater than 0x8000, then the data follows the leaf index in
        !           548:  *      a format specified by the leaf index. The final range of leaf indices
        !           549:  *      are used to force alignment of subfields within a complex type record..
        !           550:  */
        !           551: 
        !           552: /*
        !           553:  *      leaf indices starting records but referenced from symbol records
        !           554:  */
        !           555: 
        !           556: #define LF_MODIFIER     0x0001
        !           557: #define LF_POINTER      0x0002
        !           558: #define LF_ARRAY        0x0003
        !           559: #define LF_CLASS        0x0004
        !           560: #define LF_STRUCTURE    0x0005
        !           561: #define LF_UNION        0x0006
        !           562: #define LF_ENUM         0x0007
        !           563: #define LF_PROCEDURE    0x0008
        !           564: #define LF_MFUNCTION    0x0009
        !           565: #define LF_VTSHAPE      0x000a
        !           566: #define LF_COBOL0       0x000b
        !           567: #define LF_COBOL1       0x000c
        !           568: #define LF_BARRAY       0x000d
        !           569: #define LF_LABEL        0x000e
        !           570: #define LF_NULL         0x000f
        !           571: #define LF_NOTTRAN      0x0010
        !           572: #define LF_DIMARRAY     0x0011
        !           573: #define LF_VFTPATH      0x0012
        !           574: #define LF_PRECOMP      0x0013  /* not refereced from symbol */
        !           575: #define LF_ENDPRECOMP   0x0014  /* not refereced from symbol */
        !           576: #define LF_OEM          0x0015
        !           577: #define LF_TYPESERVER   0x0016
        !           578: 
        !           579: /*
        !           580:  * leaf indices starting records but referenced only from type records
        !           581:  */
        !           582: 
        !           583: #define LF_SKIP         0x0200
        !           584: #define LF_ARGLIST      0x0201
        !           585: #define LF_DEFARG       0x0202
        !           586: #define LF_LIST         0x0203
        !           587: #define LF_FIELDLIST    0x0204
        !           588: #define LF_DERIVED      0x0205
        !           589: #define LF_BITFIELD     0x0206
        !           590: #define LF_METHODLIST   0x0207
        !           591: #define LF_DIMCONU      0x0208
        !           592: #define LF_DIMCONLU     0x0209
        !           593: #define LF_DIMVARU      0x020a
        !           594: #define LF_DIMVARLU     0x020b
        !           595: #define LF_REFSYM       0x020c
        !           596: 
        !           597: #define LF_BCLASS       0x0400
        !           598: #define LF_VBCLASS      0x0401
        !           599: #define LF_IVBCLASS     0x0402
        !           600: #define LF_ENUMERATE    0x0403
        !           601: #define LF_FRIENDFCN    0x0404
        !           602: #define LF_INDEX        0x0405
        !           603: #define LF_MEMBER       0x0406
        !           604: #define LF_STMEMBER     0x0407
        !           605: #define LF_METHOD       0x0408
        !           606: #define LF_NESTTYPE     0x0409
        !           607: #define LF_VFUNCTAB     0x040a
        !           608: #define LF_FRIENDCLS    0x040b
        !           609: 
        !           610: #define LF_NUMERIC      0x8000
        !           611: #define LF_CHAR         0x8000
        !           612: #define LF_SHORT        0x8001
        !           613: #define LF_USHORT       0x8002
        !           614: #define LF_LONG         0x8003
        !           615: #define LF_ULONG        0x8004
        !           616: #define LF_REAL32       0x8005
        !           617: #define LF_REAL64       0x8006
        !           618: #define LF_REAL80       0x8007
        !           619: #define LF_REAL128      0x8008
        !           620: #define LF_QUADWORD     0x8009
        !           621: #define LF_UQUADWORD    0x800a
        !           622: #define LF_REAL48       0x800b
        !           623: 
        !           624: #define LF_PAD0         0xf0
        !           625: #define LF_PAD1         0xf1
        !           626: #define LF_PAD2         0xf2
        !           627: #define LF_PAD3         0xf3
        !           628: #define LF_PAD4         0xf4
        !           629: #define LF_PAD5         0xf5
        !           630: #define LF_PAD6         0xf6
        !           631: #define LF_PAD7         0xf7
        !           632: #define LF_PAD8         0xf8
        !           633: #define LF_PAD9         0xf9
        !           634: #define LF_PAD10        0xfa
        !           635: #define LF_PAD11        0xfb
        !           636: #define LF_PAD12        0xfc
        !           637: #define LF_PAD13        0xfd
        !           638: #define LF_PAD14        0xfe
        !           639: #define LF_PAD15        0xff
        !           640: 
        !           641: /*
        !           642:  * end of leaf indices
        !           643:  */
        !           644: 
        !           645: /*
        !           646:  *      Type enum for pointer records
        !           647:  *      Pointers can be one of the following types
        !           648:  */
        !           649: 
        !           650: typedef enum CV_ptrtype_e {
        !           651:     CV_PTR_NEAR         = 0x00, /* near pointer */
        !           652:     CV_PTR_FAR          = 0x01, /* far pointer */
        !           653:     CV_PTR_HUGE         = 0x02, /* huge pointer */
        !           654:     CV_PTR_BASE_SEG     = 0x03, /* based on segment */
        !           655:     CV_PTR_BASE_VAL     = 0x04, /* based on value of base */
        !           656:     CV_PTR_BASE_SEGVAL  = 0x05, /* based on segment value of base */
        !           657:     CV_PTR_BASE_ADDR    = 0x06, /* based on address of base */
        !           658:     CV_PTR_BASE_SEGADDR = 0x07, /* based on segment address of base */
        !           659:     CV_PTR_BASE_TYPE    = 0x08, /* based on type */
        !           660:     CV_PTR_BASE_SELF    = 0x09, /* based on self */
        !           661:     CV_PTR_NEAR32       = 0x0a, /* 16:32 near pointer */
        !           662:     CV_PTR_FAR32        = 0x0b, /* 16:32 far pointer */
        !           663:     CV_PTR_UNUSEDPTR    = 0x0c  /* first unused pointer type */
        !           664: } CV_ptrtype_e;
        !           665: 
        !           666: /*
        !           667:  *      Mode enum for pointers
        !           668:  *      Pointers can have one of the following modes
        !           669:  */
        !           670: 
        !           671: typedef enum CV_ptrmode_e {
        !           672:     CV_PTR_MODE_PTR     = 0x00, /* "normal" pointer */
        !           673:     CV_PTR_MODE_REF     = 0x01, /* reference */
        !           674:     CV_PTR_MODE_PMEM    = 0x02, /* pointer to data member */
        !           675:     CV_PTR_MODE_PMFUNC  = 0x03, /* pointer to member function */
        !           676:     CV_PTR_MODE_RESERVED= 0x04  /* first unused pointer mode */
        !           677: } CV_ptrmode_e;
        !           678: 
        !           679: /*
        !           680:  *      Enumeration for function call type
        !           681:  */
        !           682: 
        !           683: typedef enum CV_call_e {
        !           684:     CV_CALL_NEAR_C      = 0x00, /* near right to left push, caller pops stack */
        !           685:     CV_CALL_FAR_C       = 0x01, /* far right to left push, caller pops stack */
        !           686:     CV_CALL_NEAR_PASCAL = 0x02, /* near left to right push, callee pops stack */
        !           687:     CV_CALL_FAR_PASCAL  = 0x03, /* far left to right push, callee pops stack */
        !           688:     CV_CALL_NEAR_FAST   = 0x04, /* near left to right push with regs, callee pops stack */
        !           689:     CV_CALL_FAR_FAST    = 0x05, /* far left to right push with regs, callee pops stack */
        !           690:     CV_CALL_PCODE       = 0x06, /* pcode */
        !           691:     CV_CALL_NEAR_STD    = 0x07, /* near standard call */
        !           692:     CV_CALL_FAR_STD     = 0x08, /* far standard call */
        !           693:     CV_CALL_NEAR_SYS    = 0x09, /* near sys call */
        !           694:     CV_CALL_FAR_SYS     = 0x0a, /* far sys call */
        !           695:     CV_CALL_THISCALL    = 0x0b, /* this call (this passed in register) */
        !           696:     CV_CALL_MIPSCALL    = 0x0c, /* Mips call */
        !           697:     CV_CALL_GENERIC     = 0x0d, // Generic call sequence
        !           698:        CV_CALL_ALPHACALL       = 0x0e, // Alpha call
        !           699:        CV_CALL_RESERVED        = 0x0f  // first unused call enumeration
        !           700: 
        !           701: } CV_call_e;
        !           702: 
        !           703: /*
        !           704:  *      Values for the access protection of class attributes
        !           705:  */
        !           706: 
        !           707: typedef enum CV_access_e {
        !           708:     CV_private   = 1,
        !           709:     CV_protected = 2,
        !           710:     CV_public    = 3
        !           711: } CV_access_e;
        !           712: 
        !           713: /*
        !           714:  *      enumeration for method properties
        !           715:  */
        !           716: 
        !           717: typedef enum CV_methodprop_e {
        !           718:     CV_MTvanilla        = 0x00,
        !           719:     CV_MTvirtual        = 0x01,
        !           720:     CV_MTstatic         = 0x02,
        !           721:     CV_MTfriend         = 0x03,
        !           722:     CV_MTintro          = 0x04,
        !           723:     CV_MTpurevirt       = 0x05,
        !           724:     CV_MTpureintro      = 0x06
        !           725: } CV_methodprop_e;
        !           726: 
        !           727: /*
        !           728:  *      enumeration for virtual shape table entries
        !           729:  */
        !           730: 
        !           731: typedef enum CV_VTS_desc_e {
        !           732:     CV_VTS_near         = 0x00,
        !           733:     CV_VTS_far          = 0x01,
        !           734:     CV_VTS_thin         = 0x02,
        !           735:     CV_VTS_outer        = 0x03,
        !           736:     CV_VTS_meta         = 0x04,
        !           737:     CV_VTS_near32       = 0x05,
        !           738:     CV_VTS_far32        = 0x06,
        !           739:     CV_VTS_unused       = 0x07
        !           740: } CV_VTS_desc_e;
        !           741: 
        !           742: /*
        !           743:  *      enumeration for LF_LABEL address modes
        !           744:  */
        !           745: 
        !           746: typedef enum CV_LABEL_TYPE_e {
        !           747:     CV_LABEL_NEAR = 0,          /* near return */
        !           748:     CV_LABEL_FAR  = 4           /* far return */
        !           749: } CV_LABEL_TYPE_e;
        !           750: 
        !           751: /*
        !           752:  *      enumeration for LF_MODIFIER values
        !           753:  */
        !           754: 
        !           755: typedef struct CV_modifier_t {
        !           756:     unsigned short  MOD_const       :1;
        !           757:     unsigned short  MOD_volatile    :1;
        !           758:     unsigned short  MOD_unused      :14;
        !           759: } CV_modifier_t;
        !           760: 
        !           761: /*
        !           762:  *  bit field structure describing class/struct/union/enum properties
        !           763:  */
        !           764: 
        !           765: typedef struct CV_prop_t {
        !           766:     unsigned short  packed      :1; /* structure is packed */
        !           767:     unsigned short  ctor        :1; /* constructors or destructors present */
        !           768:     unsigned short  ovlops      :1; /* overloaded operators present */
        !           769:     unsigned short  isnested    :1; /* this is a nested class */
        !           770:     unsigned short  cnested     :1; /* this class contains nested types */
        !           771:     unsigned short  opassign    :1; /* overloaded assignment (=) */
        !           772:     unsigned short  opcast      :1; /* casting methods */
        !           773:     unsigned short  fwdref      :1; /* forward reference (incomplete defn) */
        !           774:     unsigned short  scoped      :1; /* scoped definition */
        !           775:     unsigned short  reserved    :7;
        !           776: } CV_prop_t;
        !           777: 
        !           778: /*
        !           779:  *  class field attribute
        !           780:  */
        !           781: 
        !           782: typedef struct CV_fldattr_t {
        !           783:     unsigned short  access      :2; /* access protection CV_access_t */
        !           784:     unsigned short  mprop       :3; /* method properties CV_methodprop_t */
        !           785:     unsigned short  pseudo      :1; /* compiler generated fcn and does not exist */
        !           786:     unsigned short  noinherit   :1; /* true if class cannot be inherited */
        !           787:     unsigned short  noconstruct :1; /* true if class cannot be constructed */
        !           788:     unsigned short  unused      :8; /* unused */
        !           789: } CV_fldattr_t;
        !           790: 
        !           791: /*
        !           792:  *  Structures to access to the type records
        !           793:  */
        !           794: 
        !           795: typedef struct TYPTYPE {
        !           796:     unsigned short  len;
        !           797:     unsigned short  leaf;
        !           798: #ifdef CV
        !           799:     unsigned char   data[];
        !           800: #else
        !           801:     unsigned char   data[1];
        !           802: #endif
        !           803: } TYPTYPE;                      /* general types record */
        !           804: 
        !           805: typedef enum CV_PMEMBER {
        !           806:     CV_PDM16_NONVIRT    = 0x00, /* 16:16 data no virtual fcn or base (null = -1) */
        !           807:     CV_PDM16_VFCN       = 0x01, /* 16:16 data with virtual functions null = 0 */
        !           808:     CV_PDM16_VBASE      = 0x02, /* 16:16 data with virtual bases null = (,,-1) */
        !           809:     CV_PDM32_NVVFCN     = 0x03, /* 16:32 data w/wo virtual functions null = 0x80000000 */
        !           810:     CV_PDM32_VBASE      = 0x04, /* 16:32 data with virtual bases (,,-1L) */
        !           811: 
        !           812:     CV_PMF16_NEARNVSA   = 0x05, /* 16:16 near method nonvirtual single address point */
        !           813:     CV_PMF16_NEARNVMA   = 0x06, /* 16:16 near method nonvirtual multiple address points */
        !           814:     CV_PMF16_NEARVBASE  = 0x07, /* 16:16 near method virtual bases */
        !           815:     CV_PMF16_FARNVSA    = 0x08, /* 16:16 far method nonvirtual single address point */
        !           816:     CV_PMF16_FARNVMA    = 0x09, /* 16:16 far method nonvirtual multiple address points */
        !           817:     CV_PMF16_FARVBASE   = 0x0a, /* 16:16 far method virtual bases */
        !           818: 
        !           819:     CV_PMF32_NVSA       = 0x0b, /* 16:32 method nonvirtual single address point */
        !           820:     CV_PMF32_NVMA       = 0x0c, /* 16:32 method nonvirtual multiple address point */
        !           821:     CV_PMF32_VBASE      = 0x0d  /* 16:32 method virtual bases */
        !           822: } CV_PMEMBER;
        !           823: 
        !           824: 
        !           825: /*
        !           826:  *  memory representation of pointer to member.  These representations are
        !           827:  *  indexed by the enumeration above in the LF_POINTER record
        !           828:  */
        !           829: 
        !           830: /*  representation of a 16:16 pointer to data for a class with no
        !           831:  *  virtual functions or virtual bases
        !           832:  */
        !           833: 
        !           834: struct CV_PDMR16_NONVIRT {
        !           835:     CV_off16_t      mdisp;      /* displacement to data (NULL = -1) */
        !           836: };
        !           837: 
        !           838: 
        !           839: /*
        !           840:  *  representation of a 16:16 pointer to data for a class with virtual
        !           841:  *  functions
        !           842:  */
        !           843: 
        !           844: struct CV_PMDR16_VFCN {
        !           845:     CV_off16_t      mdisp;      /* displacement to data ( NULL = 0) */
        !           846: };
        !           847: 
        !           848: /*
        !           849:  *  representation of a 16:16 pointer to data for a class with
        !           850:  *  virtual bases
        !           851:  */
        !           852: 
        !           853: struct CV_PDMR16_VBASE {
        !           854:     CV_off16_t      mdisp;      /* displacement to data */
        !           855:     CV_off16_t      pdisp;      /* this pointer displacement to vbptr */
        !           856:     CV_off16_t      vdisp;      /* displacement within vbase table */
        !           857: };
        !           858: 
        !           859: /*
        !           860:  *  representation of a 16:32 near pointer to data for a class with
        !           861:  *  or without virtual functions and no virtual bases
        !           862:  */
        !           863: 
        !           864: struct CV_PDMR32_NVVFCN {
        !           865:     CV_off32_t      mdisp;      /* displacement to data (NULL = 0x80000000) */
        !           866: };
        !           867: 
        !           868: 
        !           869: /*
        !           870:  *  representation of a 16:32 near pointer to data for a class
        !           871:  *  with virtual bases
        !           872:  */
        !           873: 
        !           874: 
        !           875: struct CV_PDMR32_VBASE {
        !           876:     CV_off32_t      mdisp;      /* displacement to data */
        !           877:     CV_off32_t      pdisp;      /* this pointer displacement */
        !           878:     CV_off32_t      vdisp;      /* vbase table displacement */
        !           879: };
        !           880: 
        !           881: /*
        !           882:  *  representation of a 16:16 pointer to near member function for a
        !           883:  *  class with no virtual functions or bases and a single address point
        !           884:  */
        !           885: 
        !           886: struct CV_PMFR16_NEARNVSA {
        !           887:     CV_uoff16_t     off;        /* near address of function (NULL = 0) */
        !           888: };
        !           889: 
        !           890: 
        !           891: /*
        !           892:  *  representation of a 16:16 pointer to far member function for a
        !           893:  *  class with no virtual bases and a single address point
        !           894:  */
        !           895: 
        !           896: struct CV_PMFR16_FARNVSA {
        !           897:     CV_uoff16_t     off;        /* offset of function (NULL = 0:0) */
        !           898:     unsigned short  seg;        /* segment of function */
        !           899: };
        !           900: 
        !           901: 
        !           902: 
        !           903: /*
        !           904:  *  representation of a 16:16 near pointer to member functions of an
        !           905:  *  class with no virtual bases and multiple address points
        !           906:  */
        !           907: 
        !           908: struct CV_PMFR16_NEARNVMA {
        !           909:     CV_uoff16_t     off;        /* offset of function (NULL = 0,x) */
        !           910:     signed short    disp;
        !           911: };
        !           912: 
        !           913: /*
        !           914:  *  representation of a 16:16 far pointer to member functions of a
        !           915:  *  class with no virtual bases and multiple address points
        !           916:  */
        !           917: 
        !           918: struct CV_PMFR16_FARNVMA {
        !           919:     CV_uoff16_t     off;        /* offset of function (NULL = 0:0,x) */
        !           920:     unsigned short  seg;
        !           921:     signed short    disp;
        !           922: };
        !           923: 
        !           924: /*
        !           925:  *  representation of a 16:16 near pointer to member function of a
        !           926:  *  class with virtual bases
        !           927:  */
        !           928: 
        !           929: struct CV_PMFR16_NEARVBASE {
        !           930:     CV_uoff16_t     off;        /* offset of function (NULL = 0,x,x,x) */
        !           931:     CV_off16_t      mdisp;      /* displacement to data */
        !           932:     CV_off16_t      pdisp;      /* this pointer displacement */
        !           933:     CV_off16_t      vdisp;      /* vbase table displacement */
        !           934: };
        !           935: 
        !           936: /*
        !           937:  *  representation of a 16:16 far pointer to member function of a
        !           938:  *  class with virtual bases
        !           939:  */
        !           940: 
        !           941: struct CV_PMFR16_FARVBASE {
        !           942:     CV_uoff16_t     off;        /* offset of function (NULL = 0:0,x,x,x) */
        !           943:     unsigned short  seg;
        !           944:     CV_off16_t      mdisp;      /* displacement to data */
        !           945:     CV_off16_t      pdisp;      /* this pointer displacement */
        !           946:     CV_off16_t      vdisp;      /* vbase table displacement */
        !           947: 
        !           948: };
        !           949: 
        !           950: /*
        !           951:  *  representation of a 16:32 near pointer to member function for a
        !           952:  *  class with no virtual bases and a single address point
        !           953:  */
        !           954: 
        !           955: struct CV_PMFR32_NVSA {
        !           956:     CV_uoff32_t      off;       /* near address of function (NULL = 0L) */
        !           957: };
        !           958: 
        !           959: /*
        !           960:  *  representation of a 16:32 near pointer to member function for a
        !           961:  *  class with no virtual bases and multiple address points
        !           962:  */
        !           963: 
        !           964: struct CV_PMFR32_NVMA {
        !           965:     CV_uoff32_t     off;        /* near address of function (NULL = 0L,x) */
        !           966:     CV_off32_t      disp;
        !           967: };
        !           968: 
        !           969: /*
        !           970:  *  representation of a 16:32 near pointer to member function for a
        !           971:  *  class with virtual bases
        !           972:  */
        !           973: 
        !           974: struct CV_PMFR32_VBASE {
        !           975:     CV_uoff32_t     off;        /* near address of function (NULL = 0L,x,x,x) */
        !           976:     CV_off32_t      mdisp;      /* displacement to data */
        !           977:     CV_off32_t      pdisp;      /* this pointer displacement */
        !           978:     CV_off32_t      vdisp;      /* vbase table displacement */
        !           979: };
        !           980: 
        !           981: /*
        !           982:  *  Easy leaf - used for generic casting to reference leaf field
        !           983:  *  of a subfield of a complex list
        !           984:  */
        !           985: 
        !           986: typedef struct lfEasy {
        !           987:     unsigned short  leaf;       /* LF_... */
        !           988: } lfEasy;
        !           989: 
        !           990: 
        !           991: /*      The following type records are basically variant records of the
        !           992:  *      above structure.  The "unsigned short leaf" of the above structure and
        !           993:  *      the "unsigned short leaf" of the following type definitions are the
        !           994:  *      same symbol.  When the OMF record is locked via the MHOMFLock API
        !           995:  *      call, the address of the "unsigned short leaf" is returned
        !           996:  */
        !           997: 
        !           998: /*
        !           999:  *      Type record for LF_MODIFIER
        !          1000:  */
        !          1001: 
        !          1002: typedef struct lfModifier {
        !          1003:     unsigned short  leaf;       /* LF_MODIFIER */
        !          1004:     CV_modifier_t   attr;       /* modifier attribute modifier_t */
        !          1005:     CV_typ_t        type;       /* modified type */
        !          1006: } lfModifier;
        !          1007: 
        !          1008: /*
        !          1009:  *      type record for LF_POINTER
        !          1010:  */
        !          1011: 
        !          1012: typedef struct lfPointer {
        !          1013:     struct lfPointerBody {
        !          1014:         unsigned short      leaf; /* LF_POINTER */
        !          1015:         struct {
        !          1016:             unsigned char   ptrtype     :5; /* ordinal specifying pointer type (ptrtype-t) */
        !          1017:             unsigned char   ptrmode     :3; /* ordinal specifying pointer mode (ptrmode_t) */
        !          1018:             unsigned char   isflat32    :1; /* true if 0:32 pointer */
        !          1019:             unsigned char   isvolatile  :1; /* TRUE if volatile pointer */
        !          1020:             unsigned char   isconst     :1; /* TRUE if const pointer */
        !          1021:             unsigned char   unused      :5;
        !          1022:         } attr;
        !          1023:         CV_typ_t    utype;      /* type index of the underlying type */
        !          1024:     } u;
        !          1025:     union  {
        !          1026:         struct {
        !          1027:             CV_typ_t        pmclass; /* index of containing class for pointer to member */
        !          1028:             unsigned short  pmenum; /* enumeration specifying pm format */
        !          1029:         } pm;
        !          1030:         unsigned short      bseg; /* base segment if PTR_BASE_SEG */
        !          1031:         unsigned char       Sym[1]; /* copy of base symbol record (including length) */
        !          1032:         struct  {
        !          1033:             unsigned short  index; /* type index if CV_PTR_BASE_TYPE */
        !          1034:             unsigned char   name[1]; /* name of base type */
        !          1035:         } btype;
        !          1036:     } pbase;
        !          1037: } lfPointer;
        !          1038: 
        !          1039: /*
        !          1040:  *      type record for LF_ARRAY
        !          1041:  */
        !          1042: 
        !          1043: typedef struct lfArray {
        !          1044:     unsigned short  leaf;       /* LF_ARRAY */
        !          1045:     CV_typ_t        elemtype;   /* type index of element type */
        !          1046:     CV_typ_t        idxtype;    /* type index of indexing type */
        !          1047:     unsigned char   data[];     /* variable length data specifying */
        !          1048:                                 /* size in bytes and name */
        !          1049: } lfArray;
        !          1050: 
        !          1051: /*
        !          1052:  *      type record for LF_CLASS, LF_STRUCTURE
        !          1053:  */
        !          1054: 
        !          1055: typedef struct lfClass {
        !          1056:     unsigned short  leaf;       /* LF_CLASS, LF_STRUCT */
        !          1057:     unsigned short  count;      /* count of number of elements in class */
        !          1058:     CV_typ_t        field;      /* type index of LF_FIELD descriptor list */
        !          1059:     CV_prop_t       property;   /* property attribute field (prop_t) */
        !          1060:     CV_typ_t        derived;    /* type index of derived from list if not zero */
        !          1061:     CV_typ_t        vshape;     /* type index of vshape table for this class */
        !          1062:     unsigned char   data[];     /* data describing length of structure in */
        !          1063:                                 /* bytes and name */
        !          1064: } lfClass;
        !          1065: typedef lfClass lfStructure;
        !          1066: 
        !          1067: /*
        !          1068:  *      type record for LF_UNION
        !          1069:  */
        !          1070: 
        !          1071: typedef struct lfUnion {
        !          1072:     unsigned short  leaf;       /* LF_UNION */
        !          1073:     unsigned short  count;      /* count of number of elements in class */
        !          1074:     CV_typ_t        field;      /* type index of LF_FIELD descriptor list */
        !          1075:     CV_prop_t       property;   /* property attribute field */
        !          1076:     unsigned char   data[];     /* variable length data describing length of */
        !          1077:                                 /* structure and name */
        !          1078: } lfUnion;
        !          1079: 
        !          1080: /*
        !          1081:  *      type record for LF_ENUM
        !          1082:  */
        !          1083: 
        !          1084: typedef struct lfEnum {
        !          1085:     unsigned short  leaf;       /* LF_ENUM */
        !          1086:     unsigned short  count;      /* count of number of elements in class */
        !          1087:     CV_typ_t        utype;      /* underlying type of the enum */
        !          1088:     CV_typ_t        field;      /* type index of LF_FIELD descriptor list */
        !          1089:     CV_prop_t       property;   /* property attribute field */
        !          1090:     unsigned char   Name[1];    /* length prefixed name of enum */
        !          1091: } lfEnum;
        !          1092: 
        !          1093: /*
        !          1094:  *      Type record for LF_PROCEDURE
        !          1095:  */
        !          1096: 
        !          1097: typedef struct lfProc {
        !          1098:     unsigned short  leaf;       /* LF_PROCEDURE */
        !          1099:     CV_typ_t        rvtype;     /* type index of return value */
        !          1100:     unsigned char   calltype;   /* calling convention (call_t) */
        !          1101:     unsigned char   reserved;   /* reserved for future use */
        !          1102:     unsigned short  parmcount;  /* number of parameters */
        !          1103:     CV_typ_t        arglist;    /* type index of argument list */
        !          1104: } lfProc;
        !          1105: 
        !          1106: /*
        !          1107:  *      Type record for member function
        !          1108:  */
        !          1109: 
        !          1110: typedef struct lfMFunc {
        !          1111:     unsigned short  leaf;       /* LF_MFUNCTION */
        !          1112:     CV_typ_t        rvtype;     /* type index of return value */
        !          1113:     CV_typ_t        classtype;  /* type index of containing class */
        !          1114:     CV_typ_t        thistype;   /* type index of this pointer (model specific) */
        !          1115:     unsigned char   calltype;   /* calling convention (call_t) */
        !          1116:     unsigned char   reserved;   /* reserved for future use */
        !          1117:     unsigned short  parmcount;  /* number of parameters */
        !          1118:     CV_typ_t        arglist;    /* type index of argument list */
        !          1119:     long            thisadjust; /* this adjuster (long because pad required anyway) */
        !          1120: } lfMFunc;
        !          1121: 
        !          1122: /*
        !          1123:  *     type record for virtual function table shape
        !          1124:  */
        !          1125: 
        !          1126: typedef struct lfVTShape {
        !          1127:     unsigned short  leaf;       /* LF_VTSHAPE */
        !          1128:     unsigned short  count;      /* number of entries in vfunctable */
        !          1129:     unsigned char   desc[];     /* variable number of 4 bit (VTS_desc) descriptors */
        !          1130: } lfVTShape;
        !          1131: 
        !          1132: /*
        !          1133:  *      type record for cobol0
        !          1134:  */
        !          1135: 
        !          1136: typedef struct lfCobol0 {
        !          1137:     unsigned short  leaf;       /* LF_COBOL0 */
        !          1138:     CV_typ_t        type;
        !          1139:     unsigned char   data[];
        !          1140: } lfCobol0;
        !          1141: 
        !          1142: /*
        !          1143:  *      type record for cobol1
        !          1144:  */
        !          1145: 
        !          1146: typedef struct lfCobol1 {
        !          1147:     unsigned short  leaf;       /* LF_COBOL1 */
        !          1148:     unsigned char   data[];
        !          1149: } lfCobol1;
        !          1150: 
        !          1151: /*
        !          1152:  *      type record for basic array
        !          1153:  */
        !          1154: 
        !          1155: typedef struct lfBArray {
        !          1156:     unsigned short  leaf;       /* LF_BARRAY */
        !          1157:     CV_typ_t        utype;      /* type index of underlying type */
        !          1158: } lfBArray;
        !          1159: 
        !          1160: /*
        !          1161:  *      type record for assembler labels
        !          1162:  */
        !          1163: 
        !          1164: typedef struct lfLabel {
        !          1165:     unsigned short  leaf;       /* LF_LABEL */
        !          1166:     unsigned short  mode;       /* addressing mode of label */
        !          1167: } lfLabel;
        !          1168: 
        !          1169: /*
        !          1170:  *      type record for dimensioned arrays
        !          1171:  */
        !          1172: 
        !          1173: typedef struct lfDimArray {
        !          1174:     unsigned short  leaf;       /* LF_DIMARRAY */
        !          1175:     CV_typ_t        utype;      /* underlying type of the array */
        !          1176:     CV_typ_t        diminfo;    /* dimension information */
        !          1177:     char            name[1];    /* length prefixed name */
        !          1178: } lfDimArray;
        !          1179: 
        !          1180: /*
        !          1181:  *      type record describing path to virtual function table
        !          1182:  */
        !          1183: 
        !          1184: 
        !          1185: typedef struct lfVFTPath {
        !          1186:     unsigned short  leaf;       /* LF_VFTPATH */
        !          1187:     unsigned short  count;      /* count of number of bases in path */
        !          1188:     CV_typ_t        base[1];    /* bases from root to leaf */
        !          1189: } lfVFTPath;
        !          1190: 
        !          1191: /*
        !          1192:  *      type record describing inclusion of precompiled types
        !          1193:  */
        !          1194: 
        !          1195: typedef struct lfPreComp {
        !          1196:     unsigned short  leaf;       /* LF_PRECOMP */
        !          1197:     unsigned short  start;      /* starting type index included */
        !          1198:     unsigned short  count;      /* number of types in inclusion */
        !          1199:     unsigned long   signature;  /* signature */
        !          1200:     unsigned char   name[];     /* length prefixed name of included type file */
        !          1201: } lfPreComp;
        !          1202: 
        !          1203: /*
        !          1204:  *      type record describing end of precompiled types that will be
        !          1205:  *      included by another file
        !          1206:  */
        !          1207: 
        !          1208: typedef struct lfEndPreComp {
        !          1209:     unsigned short  leaf;       /* LF_ENDPRECOMP */
        !          1210:     unsigned long   signature;  /* signature */
        !          1211: } lfEndPreComp;
        !          1212: 
        !          1213: /*
        !          1214:  *      description of type records that can be referenced from
        !          1215:  *      type records referenced by symbols
        !          1216:  */
        !          1217: 
        !          1218: /*
        !          1219:  *      type record for skip record
        !          1220:  */
        !          1221: 
        !          1222: typedef struct lfSkip {
        !          1223:     unsigned short  leaf;       /* LF_SKIP */
        !          1224:     CV_typ_t        type;       /* next valid index */
        !          1225:     unsigned char   data[];     /* pad data */
        !          1226: } lfSkip;
        !          1227: 
        !          1228: /*
        !          1229:  *      argument list leaf
        !          1230:  */
        !          1231: 
        !          1232: typedef struct lfArgList {
        !          1233:     unsigned short  leaf;       /* LF_ARGLIST */
        !          1234:     unsigned short  count;      /* number of arguments */
        !          1235:     CV_typ_t        arg[];      /* number of arguments */
        !          1236: } lfArgList;
        !          1237: 
        !          1238: /*
        !          1239:  *      derived class list leaf
        !          1240:  */
        !          1241: 
        !          1242: typedef struct lfDerived {
        !          1243:     unsigned short  leaf;       /* LF_DERIVED */
        !          1244:     unsigned short  count;      /* number of arguments */
        !          1245:     CV_typ_t        drvdcls[];  /* type indices of derived classes */
        !          1246: } lfDerived;
        !          1247: 
        !          1248: /*
        !          1249:  *      leaf for default arguments
        !          1250:  */
        !          1251: 
        !          1252: typedef struct lfDefArg {
        !          1253:     unsigned short  leaf;       /* LF_DEFARG */
        !          1254:     CV_typ_t        type;       /* type of resulting expression */
        !          1255:     unsigned char   expr[];     /* length prefixed expression string */
        !          1256: } lfDefArg;
        !          1257: 
        !          1258: /*
        !          1259:  *      list leaf
        !          1260:  *          This list should no longer be used because the utilities cannot
        !          1261:  *          verify the contents of the list without knowing what type of list
        !          1262:  *          it is.  New specific leaf indices should be used instead.
        !          1263:  */
        !          1264: 
        !          1265: typedef struct lfList {
        !          1266:     unsigned short  leaf;       /* LF_LIST */
        !          1267:     char            data[];     /* data format specified by indexing type */
        !          1268: } lfList;
        !          1269: 
        !          1270: /*
        !          1271:  *      field list leaf
        !          1272:  *      This is the header leaf for a complex list of class and structure
        !          1273:  *      subfields.
        !          1274:  */
        !          1275: 
        !          1276: typedef struct lfFieldList {
        !          1277:     unsigned short  leaf;       /* LF_FIELDLIST */
        !          1278:     char            data[];     /* field list sub lists */
        !          1279: } lfFieldList;
        !          1280: 
        !          1281: /*
        !          1282:  *  type record for non-static methods and friends in method list
        !          1283:  */
        !          1284: 
        !          1285: typedef struct mlMethod {
        !          1286:     CV_fldattr_t   attr;        /* method attribute */
        !          1287:     CV_typ_t       index;       /* index to type record for procedure */
        !          1288: #ifdef CV
        !          1289:     unsigned long  vbaseoff[0]; /* offset in vfunctable if intro virtual */
        !          1290: #else
        !          1291: //    unsigned long   vbaseoff[1];
        !          1292: #endif
        !          1293: } mlMethod;
        !          1294: 
        !          1295: typedef struct lfMethodList {
        !          1296:     unsigned short leaf;
        !          1297:     unsigned char  mList[];     /* really a mlMethod type */
        !          1298: } lfMethodList;
        !          1299: 
        !          1300: /*
        !          1301:  *      type record for LF_BITFIELD
        !          1302:  */
        !          1303: 
        !          1304: typedef struct lfBitfield {
        !          1305:     unsigned short  leaf;       /* LF_BITFIELD */
        !          1306:     unsigned char   length;
        !          1307:     unsigned char   position;
        !          1308:     CV_typ_t        type;       /* type of bitfield */
        !          1309: 
        !          1310: } lfBitfield;
        !          1311: 
        !          1312: /*
        !          1313:  *      type record for dimensioned array with constant bounds
        !          1314:  */
        !          1315: 
        !          1316: typedef struct lfDimCon {
        !          1317:     unsigned short  leaf;       /* LF_DIMCONU or LF_DIMCONLU */
        !          1318:     unsigned short  rank;       /* number of dimensions */
        !          1319:     CV_typ_t        typ;        /* type of index */
        !          1320:     unsigned char   dim[];      /* array of dimension information with */
        !          1321:                                 /* either upper bounds or lower/upper bound */
        !          1322: } lfDimCon;
        !          1323: 
        !          1324: /*
        !          1325:  *      type record for dimensioned array with variable bounds
        !          1326:  */
        !          1327: 
        !          1328: typedef struct lfDimVar {
        !          1329:     unsigned short  leaf;       /* LF_DIMVARU or LF_DIMVARLU */
        !          1330:     unsigned short  rank;       /* number of dimensions */
        !          1331:     CV_typ_t        typ;        /* type of index */
        !          1332:     unsigned char   dim[];      /* array of type indices for either */
        !          1333:                                 /* variable upper bound or variable */
        !          1334:                                 /* lower/upper bound.  The referenced */
        !          1335:                                 /* types must be LF_REFSYM or T_VOID */
        !          1336: } lfDimVar;
        !          1337: 
        !          1338: /*
        !          1339:  *      type record for referenced symbol
        !          1340:  */
        !          1341: 
        !          1342: typedef struct lfRefSym {
        !          1343:     unsigned short  leaf;       /* LF_REFSYM */
        !          1344:     unsigned char   Sym[1];     /* copy of referenced symbol record */
        !          1345:                                 /* (including length) */
        !          1346: } lfRefSym;
        !          1347: 
        !          1348: /**     the following are numeric leaves.  They are used to indicate the
        !          1349:  *      size of the following variable length data.  When the numeric
        !          1350:  *      data is a single byte less than 0x8000, then the data is output
        !          1351:  *      directly.  If the data is more the 0x8000 or is a negative value,
        !          1352:  *      then the data is preceeded by the proper index.
        !          1353:  */
        !          1354: 
        !          1355: /*      signed character leaf */
        !          1356: 
        !          1357: typedef struct lfChar {
        !          1358:     unsigned short  leaf;       /* LF_CHAR */
        !          1359:     signed char     val;        /* signed 8-bit value */
        !          1360: } lfChar;
        !          1361: 
        !          1362: /*      signed short leaf */
        !          1363: 
        !          1364: typedef struct lfShort {
        !          1365:     unsigned short  leaf;       /* LF_SHORT */
        !          1366:     short           val;        /* signed 16-bit value */
        !          1367: } lfShort;
        !          1368: 
        !          1369: /*      unsigned short leaf */
        !          1370: 
        !          1371: typedef struct lfUShort {
        !          1372:     unsigned short  leaf;       /* LF_unsigned short */
        !          1373:     unsigned short  val;        /* unsigned 16-bit value */
        !          1374: } lfUShort;
        !          1375: 
        !          1376: /*      signed long leaf */
        !          1377: 
        !          1378: typedef struct lfLong {
        !          1379:     unsigned short  leaf;       /* LF_LONG */
        !          1380:     long            val;        /* signed 32-bit value */
        !          1381: } lfLong;
        !          1382: 
        !          1383: /*      unsigned long leaf */
        !          1384: 
        !          1385: typedef struct lfULong {
        !          1386:     unsigned short  leaf;       /* LF_ULONG */
        !          1387:     unsigned long   val;        /* unsigned 32-bit value */
        !          1388: } lfULong;
        !          1389: 
        !          1390: /*      real 32-bit leaf */
        !          1391: 
        !          1392: typedef struct lfReal32 {
        !          1393:     unsigned short  leaf;       /* LF_REAL32 */
        !          1394:     float           val;        /* 32-bit real value */
        !          1395: } lfReal32;
        !          1396: 
        !          1397: /*      real 48-bit leaf */
        !          1398: 
        !          1399: typedef struct lfReal48 {
        !          1400:     unsigned short  leaf;       /* LF_REAL48 */
        !          1401:     unsigned char   val[6];     /* 48-bit real value */
        !          1402: } lfReal48;
        !          1403: 
        !          1404: /*      real 64-bit leaf */
        !          1405: 
        !          1406: typedef struct lfReal64 {
        !          1407:     unsigned short  leaf;       /* LF_REAL64 */
        !          1408:     double          val;        /* 64-bit real value */
        !          1409: } lfReal64;
        !          1410: 
        !          1411: /*      real 80-bit leaf */
        !          1412: 
        !          1413: typedef struct lfReal80 {
        !          1414:     unsigned short  leaf;       /* LF_REAL80 */
        !          1415:     REAL10          val;        /* real 80-bit value */
        !          1416: } lfReal80;
        !          1417: 
        !          1418: /*      real 128-bit leaf */
        !          1419: 
        !          1420: typedef struct lfReal128 {
        !          1421:     unsigned short  leaf;       /* LF_REAL128 */
        !          1422:     char            val[16];    /* real 128-bit value */
        !          1423: } lfReal128;
        !          1424: 
        !          1425: /************************************************************************/
        !          1426: 
        !          1427: /*      index leaf - contains type index of another leaf */
        !          1428: /*      a major use of this leaf is to allow the compilers to emit a */
        !          1429: /*      long complex list (LF_FIELD) in smaller pieces. */
        !          1430: 
        !          1431: typedef struct lfIndex {
        !          1432:     unsigned short  leaf;       /* LF_INDEX */
        !          1433:     CV_typ_t        index;      /* type index of referenced leaf */
        !          1434: } lfIndex;
        !          1435: 
        !          1436: /*      subfield record for base class field */
        !          1437: 
        !          1438: typedef struct lfBClass {
        !          1439:     unsigned short  leaf;       /* LF_BCLASS */
        !          1440:     CV_typ_t        index;      /* type index of base class */
        !          1441:     CV_fldattr_t    attr;       /* attribute */
        !          1442:     unsigned char   offset[];   /* variable length offset of base within class */
        !          1443: } lfBClass;
        !          1444: 
        !          1445: /*      subfield record for direct and indirect virtual base class field */
        !          1446: 
        !          1447: typedef struct lfVBClass {
        !          1448:     unsigned short  leaf;       /* LF_VBCLASS | LV_IVBCLASS */
        !          1449:     CV_typ_t        index;      /* type index of direct virtual base class */
        !          1450:     CV_typ_t        vbptr;      /* type index of virtual base pointer */
        !          1451:     CV_fldattr_t    attr;       /* attribute */
        !          1452:     unsigned char   vbpoff[];   /* virtual base pointer offset from address point */
        !          1453:                                 /* followed by virtual base offset from vbtable */
        !          1454: } lfVBClass;
        !          1455: 
        !          1456: /*      subfield record for friend class */
        !          1457: 
        !          1458: typedef struct lfFriendCls {
        !          1459:     unsigned short  leaf;       /* LF_FRIENDCLS */
        !          1460:     CV_typ_t        index;      /* index to type record of friend class */
        !          1461: } lfFriendCls;
        !          1462: 
        !          1463: /*      subfield record for friend function */
        !          1464: 
        !          1465: typedef struct lfFriendFcn {
        !          1466:     unsigned short  leaf;       /* LF_FRIENDFCN */
        !          1467:     CV_typ_t        index;      /* index to type record of friend function */
        !          1468:     char            Name[1];    /* name of friend function */
        !          1469: } lfFriendFcn;
        !          1470: 
        !          1471: /*      subfield record for non-static data members */
        !          1472: 
        !          1473: typedef struct lfMember {
        !          1474:     unsigned short  leaf;       /* LF_MEMBER */
        !          1475:     CV_typ_t        index;      /* index of type record for field */
        !          1476:     CV_fldattr_t    attr;       /* attribute mask */
        !          1477:     unsigned char   offset[];   /* variable length offset of field followed */
        !          1478:                                 /* by length prefixed name of field */
        !          1479: } lfMember;
        !          1480: 
        !          1481: /*  type record for static data members */
        !          1482: 
        !          1483: typedef struct lfSTMember {
        !          1484:     unsigned short  leaf;       /* LF_STMEMBER */
        !          1485:     CV_typ_t        index;      /* index of type record for field */
        !          1486:     CV_fldattr_t    attr;       /* attribute mask */
        !          1487:     char            Name[1];    /* length prefixed name of field */
        !          1488: } lfSTMember;
        !          1489: 
        !          1490: /*      subfield record for virtual function table pointer */
        !          1491: 
        !          1492: typedef struct lfVFuncTab {
        !          1493:     unsigned short  leaf;       /* LF_VFUNCTAB */
        !          1494:     CV_typ_t        type;       /* type index of pointer */
        !          1495: } lfVFuncTab;
        !          1496: 
        !          1497: /*      subfield record for method and friend list */
        !          1498: 
        !          1499: typedef struct lfMethod {
        !          1500:     unsigned short  leaf;       /* LF_METHOD */
        !          1501:     unsigned short  count;      /* number of occurances of function */
        !          1502:     CV_typ_t        mList;      /* index to LF_METHODLIST record */
        !          1503:     char            Name[1];    /* length prefixed name of method */
        !          1504: } lfMethod;
        !          1505: 
        !          1506: /*      subfield record for enumerate */
        !          1507: 
        !          1508: typedef struct lfEnumerate {
        !          1509:     unsigned short  leaf;       /* LF_ENUMERATE */
        !          1510:     CV_fldattr_t    attr;       /* access (ACC_...) */
        !          1511:     unsigned char   value[];    /* variable length value field followed */
        !          1512:                                 /* by length prefixed name */
        !          1513: } lfEnumerate;
        !          1514: 
        !          1515: /*  type record for nested (scoped) type definition */
        !          1516: 
        !          1517: typedef struct lfNestType {
        !          1518:     unsigned short  leaf;       /* LF_NESTTYPE */
        !          1519:     CV_typ_t        index;      /* index of nested type definition */
        !          1520:     unsigned char   Name[1];    /* length prefixed type name */
        !          1521: } lfNestType;
        !          1522: 
        !          1523: /*  type record for pad leaf */
        !          1524: 
        !          1525: typedef struct lfPad {
        !          1526:     unsigned char   leaf;
        !          1527: } SYM_PAD;
        !          1528: 
        !          1529: /*  Symbol definitions */
        !          1530: 
        !          1531: typedef enum SYM_ENUM_e {
        !          1532:     S_COMPILE    =  0x0001,     /* Compile flags symbol */
        !          1533:     S_REGISTER   =  0x0002,     /* Register variable */
        !          1534:     S_CONSTANT   =  0x0003,     /* constant symbol */
        !          1535:     S_UDT        =  0x0004,     /* User defined type */
        !          1536:     S_SSEARCH    =  0x0005,     /* Start Search */
        !          1537:     S_END        =  0x0006,     /* Block, procedure, "with" or thunk end */
        !          1538:     S_SKIP       =  0x0007,     /* Reserve symbol space in $$Symbols table */
        !          1539:     S_CVRESERVE  =  0x0008,     /* Reserve symbol for CV internal use */
        !          1540:     S_OBJNAME    =  0x0009,     /* path to object file name */
        !          1541:     S_ENDARG     =  0x000a,     /* end of argument list */
        !          1542:     S_COBOLUDT   =  0x000b,     /* special UDT for cobol -- not packed */
        !          1543: 
        !          1544:     S_BPREL16    =  0x0100,     /* BP-relative */
        !          1545:     S_LDATA16    =  0x0101,     /* Module-local symbol */
        !          1546:     S_GDATA16    =  0x0102,     /* Global data symbol */
        !          1547:     S_PUB16      =  0x0103,     /* a public symbol */
        !          1548:     S_LPROC16    =  0x0104,     /* Local procedure start */
        !          1549:     S_GPROC16    =  0x0105,     /* Global procedure start */
        !          1550:     S_THUNK16    =  0x0106,     /* Thunk Start */
        !          1551:     S_BLOCK16    =  0x0107,     /* block start */
        !          1552:     S_WITH16     =  0x0108,     /* with start */
        !          1553:     S_LABEL16    =  0x0109,     /* code label */
        !          1554:     S_CEXMODEL16 =  0x010a,     /* change execution model */
        !          1555:     S_VFTABLE16  =  0x010b,     /* address of virtual function table */
        !          1556:     S_REGREL16   =  0x010c,     /* register relative address */
        !          1557: 
        !          1558:     S_BPREL32    =  0x0200,     /* BP-relative */
        !          1559:     S_LDATA32    =  0x0201,     /* Module-local symbol */
        !          1560:     S_GDATA32    =  0x0202,     /* Global data symbol */
        !          1561:     S_PUB32      =  0x0203,     /* a public symbol (CV internal reserved) */
        !          1562:     S_LPROC32    =  0x0204,     /* Local procedure start */
        !          1563:     S_GPROC32    =  0x0205,     /* Global procedure start */
        !          1564:     S_THUNK32    =  0x0206,     /* Thunk Start */
        !          1565:     S_BLOCK32    =  0x0207,     /* block start */
        !          1566:     S_WITH32     =  0x0208,     /* with start */
        !          1567:     S_LABEL32    =  0x0209,     /* code label */
        !          1568:     S_CEXMODEL32 =  0x020a,     /* change execution model */
        !          1569:     S_VFTABLE32  =  0x020b,     /* address of virtual function table */
        !          1570:     S_REGREL32   =  0x020c,     /* register relative address */
        !          1571:     S_LTHREAD32  =  0x020d,
        !          1572:     S_GTHREAD32  =  0x020e,
        !          1573: 
        !          1574:     S_LPROCMIPS  =  0x0300,     /* Local procedure start */
        !          1575:     S_GPROCMIPS  =  0x0301,     /* Global procedure start */
        !          1576: 
        !          1577:     S_PROCREF    =  0x400,      /* Procedure reference */
        !          1578:     S_DATAREF    =  0x401,      /* Data reference */
        !          1579:     S_ALIGN      =  0x402       /* Page Alignment */
        !          1580: } SYM_ENUM_e;
        !          1581: 
        !          1582: /*  enum describing the compile flag source language */
        !          1583: 
        !          1584: typedef enum {
        !          1585:     CV_CFL_C        = 0x00,
        !          1586:     CV_CFL_CXX      = 0x01,
        !          1587:     CV_CFL_FORTRAN  = 0x02,
        !          1588:     CV_CFL_MASM     = 0x03,
        !          1589:     CV_CFL_PASCAL   = 0x04,
        !          1590:     CV_CFL_BASIC    = 0x05,
        !          1591:     CV_CFL_COBOL    = 0x06
        !          1592: } CV_CFL_LANG;
        !          1593: 
        !          1594: /*  enum describing target processor */
        !          1595: 
        !          1596: typedef enum CV_CPU_TYPE_e {
        !          1597:     CV_CFL_8080         = 0x00,
        !          1598:     CV_CFL_8086         = 0x01,
        !          1599:     CV_CFL_80286        = 0x02,
        !          1600:     CV_CFL_80386        = 0x03,
        !          1601:     CV_CFL_80486        = 0x04,
        !          1602:     CV_CFL_PENTIUM      = 0x05,
        !          1603:     CV_CFL_MIPSR4000    = 0x10,
        !          1604:     CV_CFL_M68000       = 0x20,
        !          1605:     CV_CFL_M68010       = 0x21,
        !          1606:     CV_CFL_M68020       = 0x22,
        !          1607:     CV_CFL_M68030       = 0x23,
        !          1608:     CV_CFL_M68040       = 0x24,
        !          1609:     CV_CFL_ALPHA        = 0x30
        !          1610: 
        !          1611: } CV_CPU_TYPE_e;
        !          1612: 
        !          1613: /*  enum describing compile flag ambiant data model */
        !          1614: 
        !          1615: typedef enum {
        !          1616:     CV_CFL_DNEAR    = 0x00,
        !          1617:     CV_CFL_DFAR     = 0x01,
        !          1618:     CV_CFL_DHUGE    = 0x02
        !          1619: } CV_CFL_DATA;
        !          1620: 
        !          1621: /*  enum describing compile flag ambiant code model */
        !          1622: 
        !          1623: typedef enum CV_CFL_CODE_e {
        !          1624:     CV_CFL_CNEAR    = 0x00,
        !          1625:     CV_CFL_CFAR     = 0x01,
        !          1626:     CV_CFL_CHUGE    = 0x02
        !          1627: } CV_CFL_CODE_e;
        !          1628: 
        !          1629: /*  enum describing compile flag target floating point package */
        !          1630: 
        !          1631: typedef enum CV_CFL_FPKG_e {
        !          1632:     CV_CFL_NDP      = 0x00,
        !          1633:     CV_CFL_EMU      = 0x01,
        !          1634:     CV_CFL_ALT      = 0x02
        !          1635: } CV_CFL_FPKG_e;
        !          1636: 
        !          1637: typedef struct SYMTYPE {
        !          1638:     unsigned short      reclen; /* Record length */
        !          1639:     unsigned short      rectyp; /* Record type */
        !          1640:     char        data[];
        !          1641: } SYMTYPE;
        !          1642: 
        !          1643: /*
        !          1644:  *  cobol information ---
        !          1645:  */
        !          1646: 
        !          1647: typedef enum CV_COBOL_e {
        !          1648:     CV_COBOL_dontstop,
        !          1649:     CV_COBOL_pfm,
        !          1650:     CV_COBOL_false,
        !          1651:     CV_COBOL_extcall
        !          1652: } CV_COBOL_e;
        !          1653: 
        !          1654: struct {
        !          1655:     unsigned short subtype;     /* see CV_COBOL_e above */
        !          1656:     unsigned short flag;
        !          1657: } cobol;
        !          1658: 
        !          1659: 
        !          1660: /*      non-model specific symbol types */
        !          1661: 
        !          1662: typedef struct REGSYM {
        !          1663:     unsigned short  reclen;     /* Record length */
        !          1664:     unsigned short  rectyp;     /* S_REGISTER */
        !          1665:     unsigned short  typind;     /* Type index */
        !          1666:     unsigned short  reg;        /* register enumerate */
        !          1667:     unsigned char   name[1];    /* Length-prefixed name */
        !          1668: } REGSYM;
        !          1669: 
        !          1670: typedef struct CONSTSYM {
        !          1671:     unsigned short  reclen;     /* Record length */
        !          1672:     unsigned short  rectyp;     /* S_CONSTANT */
        !          1673:     CV_typ_t        typind;     /* Type index (containing enum if enumerate) */
        !          1674:     unsigned short  value;      /* numeric leaf containing value */
        !          1675:     unsigned char   name[];     /* Length-prefixed name */
        !          1676: } CONSTSYM;
        !          1677: 
        !          1678: typedef struct UDTSYM {
        !          1679:     unsigned short  reclen;     /* Record length */
        !          1680:     unsigned short  rectyp;     /* S_UDT |S_COBOLUDT */
        !          1681:     CV_typ_t        typind;     /* Type index */
        !          1682:     unsigned char   name[1];    /* Length-prefixed name */
        !          1683: } UDTSYM;
        !          1684: 
        !          1685: typedef struct SEARCHSYM {
        !          1686:     unsigned short  reclen;     /* Record length */
        !          1687:     unsigned short  rectyp;     /* S_SSEARCH */
        !          1688:     unsigned long   startsym;   /* offset of the procedure */
        !          1689:     unsigned short  seg;        /* segment of symbol */
        !          1690: } SEARCHSYM;
        !          1691: 
        !          1692: typedef struct CFLAGSYM {
        !          1693:     unsigned short  reclen;     /* Record length */
        !          1694:     unsigned short  rectyp;     /* S_COMPILE */
        !          1695:     unsigned char   machine;    /* target processor */
        !          1696:     struct  {
        !          1697:         unsigned char   language    :8; /* language index */
        !          1698:         unsigned char   pcode       :1; /* true if pcode present */
        !          1699:         unsigned char   floatprec   :2; /* floating precision */
        !          1700:         unsigned char   floatpkg    :2; /* float package */
        !          1701:         unsigned char   ambdata     :3; /* ambiant data model */
        !          1702:         unsigned char   ambcode     :3; /* ambiant code model */
        !          1703:         unsigned char   mode32      :1; /* true if compiled 32 bit mode */
        !          1704:         unsigned char   pad         :4; /* reserved */
        !          1705:     } flags;
        !          1706:     unsigned char       ver[1]; /* Length-prefixed compiler version string */
        !          1707: } CFLAGSYM;
        !          1708: 
        !          1709: typedef struct OBJNAMESYM {
        !          1710:     unsigned short  reclen;     /* Record length */
        !          1711:     unsigned short  rectyp;     /* S_OBJNAME */
        !          1712:     unsigned long   signature;  /* signature */
        !          1713:     unsigned char   name[1];    /* Length-prefixed name */
        !          1714: } OBJNAMESYM;
        !          1715: 
        !          1716: /*      symbol types for 16:16 memory model */
        !          1717: 
        !          1718: typedef struct BPRELSYM16 {
        !          1719:     unsigned short  reclen;     /* Record length */
        !          1720:     unsigned short  rectyp;     /* S_BPREL16 */
        !          1721:     CV_off16_t      off;        /* BP-relative offset */
        !          1722:     CV_typ_t        typind;     /* Type index */
        !          1723:     unsigned char   name[1];    /* Length-prefixed name */
        !          1724: } BPRELSYM16;
        !          1725: 
        !          1726: typedef struct DATASYM16 {
        !          1727:     unsigned short  reclen;     /* Record length */
        !          1728:     unsigned short  rectyp;     /* S_LDATA16 or S_GDATA16 or S_PUB16 */
        !          1729:     CV_uoff16_t     off;        /* offset of symbol */
        !          1730:     unsigned short  seg;        /* segment of symbol */
        !          1731:     CV_typ_t        typind;     /* Type index */
        !          1732:     unsigned char   name[1];    /* Length-prefixed name */
        !          1733: } DATASYM16;
        !          1734: typedef DATASYM16 PUBSYM16;
        !          1735: 
        !          1736: typedef struct PROCSYM16 {
        !          1737:     unsigned short  reclen;     /* Record length */
        !          1738:     unsigned short  rectyp;     /* S_GPROC16 or S_LPROC16 */
        !          1739:     unsigned long   pParent;    /* pointer to the parent */
        !          1740:     unsigned long   pEnd;       /* pointer to this blocks end */
        !          1741:     unsigned long   pNext;      /* pointer to next symbol */
        !          1742:     unsigned short  len;        /* Proc length */
        !          1743:     unsigned short  DbgStart;   /* Debug start offset */
        !          1744:     unsigned short  DbgEnd;     /* Debug end offset */
        !          1745:     CV_uoff16_t     off;        /* offset of symbol */
        !          1746:     unsigned short  seg;        /* segment of symbol */
        !          1747:     CV_typ_t        typind;     /* Type index */
        !          1748:     char            rtntyp;     /* Return type (NEAR/FAR) */
        !          1749:     unsigned char   name[1];    /* Length-prefixed name */
        !          1750: } PROCSYM16;
        !          1751: 
        !          1752: typedef struct THUNKSYM16 {
        !          1753:     unsigned short  reclen;     /* Record length */
        !          1754:     unsigned short  rectyp;     /* S_THUNK16 */
        !          1755:     unsigned long   pParent;    /* pointer to the parent */
        !          1756:     unsigned long   pEnd;       /* pointer to this blocks end */
        !          1757:     unsigned long   pNext;      /* pointer to next symbol */
        !          1758:     CV_uoff16_t     off;        /* offset of symbol */
        !          1759:     unsigned short  seg;        /* segment of symbol */
        !          1760:     unsigned short  len;        /* length of thunk */
        !          1761:     unsigned char   ord;        /* ordinal specifying type of thunk */
        !          1762:     unsigned char   name[1];    /* name of thunk */
        !          1763: #ifdef CV
        !          1764:     unsigned char   variant[0]; /* variant portion of thunk */
        !          1765: #else
        !          1766:     unsigned char   variant[1]; /* variant portion of thunk */
        !          1767: #endif
        !          1768: } THUNKSYM16;
        !          1769: 
        !          1770: typedef enum {
        !          1771:     THUNK_ORDINAL_NOTYPE,
        !          1772:     THUNK_ORDINAL_ADJUSTOR,
        !          1773:     THUNK_ORDINAL_VCALL
        !          1774: } THUNK_ORDINAL;
        !          1775: 
        !          1776: typedef struct LABELSYM16 {
        !          1777:     unsigned short  reclen;     /* Record length */
        !          1778:     unsigned short  rectyp;     /* S_LABEL16 */
        !          1779:     CV_uoff16_t     off;        /* offset of symbol */
        !          1780:     unsigned short  seg;        /* segment of symbol */
        !          1781:     char            rtntyp;     /* Return type (NEAR/FAR) */
        !          1782:     unsigned char   name[1];    /* Length-prefixed name */
        !          1783: } LABELSYM16;
        !          1784: 
        !          1785: typedef enum CV_RETURN_TYPE_e {
        !          1786:     CV_RETURN_NEAR = 0,         /* near return */
        !          1787:     CV_RETURN_FAR  = 4          /* far return */
        !          1788: } CV_RETURN_TYPE_e;
        !          1789: 
        !          1790: typedef struct BLOCKSYM16 {
        !          1791:     unsigned short  reclen;     /* Record length */
        !          1792:     unsigned short  rectyp;     /* S_BLOCK16 */
        !          1793:     unsigned long   pParent;    /* pointer to the parent */
        !          1794:     unsigned long   pEnd;       /* pointer to this blocks end */
        !          1795:     unsigned short  len;        /* Block length */
        !          1796:     CV_uoff16_t     off;        /* offset of symbol */
        !          1797:     unsigned short  seg;        /* segment of symbol */
        !          1798:     unsigned char   name[1];    /* Length-prefixed name */
        !          1799: } BLOCKSYM16;
        !          1800: 
        !          1801: typedef struct WITHSYM16 {
        !          1802:     unsigned short  reclen;     /* Record length */
        !          1803:     unsigned short  rectyp;     /* S_WITH16 */
        !          1804:     unsigned long   pParent;    /* pointer to the parent */
        !          1805:     unsigned long   pEnd;       /* pointer to this blocks end */
        !          1806:     unsigned short  len;        /* Block length */
        !          1807:     CV_uoff16_t     off;        /* offset of symbol */
        !          1808:     unsigned short  seg;        /* segment of symbol */
        !          1809:     unsigned char   name[1];    /* Length-prefixed name */
        !          1810: } WITHSYM16;
        !          1811: 
        !          1812: typedef enum CEXM_MODEL_e {
        !          1813:     CEXM_MDL_table  = 0x00,     /* not executable */
        !          1814:     CEXM_MDL_native = 0x20,     /* native */
        !          1815:     CEXM_MDL_cobol  = 0x21,     /* cobol */
        !          1816:     CEXM_MDL_pcode  = 0x40      /* pcode */
        !          1817: } CEXM_MODEL_e;
        !          1818: 
        !          1819: typedef struct CEXMSYM16 {
        !          1820:     unsigned short  reclen;     /* Record length */
        !          1821:     unsigned short  rectyp;     /* S_CEXMODEL16 */
        !          1822:     CV_uoff16_t     off;        /* offset of symbol */
        !          1823:     unsigned short  seg;        /* segment of symbol */
        !          1824:     unsigned short  model;      /* execution model */
        !          1825:     union variant {
        !          1826:         struct  {
        !          1827:             CV_uoff16_t pcdtable; /* offset to pcode function table */
        !          1828:             CV_uoff16_t pcdspi; /* offset to segment pcode information */
        !          1829:         } pcode;
        !          1830:     } u;
        !          1831: } CEXMSYM16;
        !          1832: 
        !          1833: typedef struct VPATHSYM16 {
        !          1834:     unsigned short  reclen;     /* record length */
        !          1835:     unsigned short  rectyp;     /* S_VFTPATH16 */
        !          1836:     CV_uoff16_t     off;        /* offset of virtual function table */
        !          1837:     unsigned short  seg;        /* segment of virtual function table */
        !          1838:     CV_typ_t        root;       /* type index of the root of path */
        !          1839:     CV_typ_t        path;       /* type index of the path record */
        !          1840: } VPATHSYM16;
        !          1841: 
        !          1842: typedef struct REGREL16 {
        !          1843:     unsigned short  reclen;     /* Record length */
        !          1844:     unsigned short  rectyp;     /* S_REGREL16 */
        !          1845:     CV_uoff16_t     off;        /* offset of symbol */
        !          1846:     unsigned short  reg;        /* register index */
        !          1847:     CV_typ_t        typind;     /* Type index */
        !          1848:     unsigned char   name[1];    /* Length-prefixed name */
        !          1849: } REGREL16;
        !          1850: 
        !          1851: typedef struct BPRELSYM32 {
        !          1852:     unsigned short  reclen;     /* Record length */
        !          1853:     unsigned short  rectyp;     /* S_BPREL32 */
        !          1854:     CV_off32_t      off;        /* BP-relative offset */
        !          1855:     CV_typ_t        typind;     /* Type index */
        !          1856:     unsigned char   name[1];    /* Length-prefixed name */
        !          1857: } BPRELSYM32;
        !          1858: 
        !          1859: typedef struct DATASYM32 {
        !          1860:     unsigned short  reclen;     /* Record length */
        !          1861:     unsigned short  rectyp;     /* S_LDATA32, S_GDATA32, S_LTHREAD32,
        !          1862:                                    S_GTHREAD32 or S_PUB32 */
        !          1863:     CV_uoff32_t     off;
        !          1864:     unsigned short  seg;
        !          1865:     CV_typ_t        typind;     /* Type index */
        !          1866:     unsigned char   name[1];    /* Length-prefixed name */
        !          1867: } DATASYM32;
        !          1868: typedef DATASYM32 PUBSYM32;
        !          1869: 
        !          1870: typedef struct PROCSYM32 {
        !          1871:     unsigned short  reclen;     /* Record length */
        !          1872:     unsigned short  rectyp;     /* S_GPROC32 or S_LPROC32 */
        !          1873:     unsigned long   pParent;    /* pointer to the parent */
        !          1874:     unsigned long   pEnd;       /* pointer to this blocks end */
        !          1875:     unsigned long   pNext;      /* pointer to next symbol */
        !          1876:     unsigned long   len;        /* Proc length */
        !          1877:     unsigned long   DbgStart;   /* Debug start offset */
        !          1878:     unsigned long   DbgEnd;     /* Debug end offset */
        !          1879:     CV_uoff32_t     off;
        !          1880:     unsigned short  seg;
        !          1881:     CV_typ_t        typind;     /* Type index */
        !          1882:     char            rtntyp;     /* Return type (NEAR/FAR) */
        !          1883:     unsigned char   name[1];    /* Length-prefixed name */
        !          1884: } PROCSYM32;
        !          1885: 
        !          1886: typedef struct THUNKSYM32 {
        !          1887:     unsigned short  reclen;     /* Record length */
        !          1888:     unsigned short  rectyp;     /* S_THUNK32 */
        !          1889:     unsigned long   pParent;    /* pointer to the parent */
        !          1890:     unsigned long   pEnd;       /* pointer to this blocks end */
        !          1891:     unsigned long   pNext;      /* pointer to next symbol */
        !          1892:     CV_uoff32_t     off;
        !          1893:     unsigned short  seg;
        !          1894:     unsigned short  len;        /* length of thunk */
        !          1895:     unsigned char   ord;        /* ordinal specifying type of thunk */
        !          1896:     unsigned char   name[1];    /* Length-prefixed name */
        !          1897: #ifdef CV
        !          1898:     unsigned char   variant[0]; /* variant portion of thunk */
        !          1899: #else
        !          1900:     unsigned char   variant[1]; /* variant portion of thunk */
        !          1901: #endif
        !          1902: } THUNKSYM32;
        !          1903: 
        !          1904: typedef struct LABELSYM32 {
        !          1905:     unsigned short  reclen;     /* Record length */
        !          1906:     unsigned short  rectyp;     /* S_LABEL32 */
        !          1907:     CV_uoff32_t     off;
        !          1908:     unsigned short  seg;
        !          1909:     char            rtntyp;     /* Return type (NEAR/FAR) */
        !          1910:     unsigned char   name[1];    /* Length-prefixed name */
        !          1911: } LABELSYM32;
        !          1912: 
        !          1913: typedef struct BLOCKSYM32 {
        !          1914:     unsigned short  reclen;     /* Record length */
        !          1915:     unsigned short  rectyp;     /* S_BLOCK32 */
        !          1916:     unsigned long   pParent;    /* pointer to the parent */
        !          1917:     unsigned long   pEnd;       /* pointer to this blocks end */
        !          1918:     unsigned long   len;        /* Block length */
        !          1919:     CV_uoff32_t     off;        /* Offset in code segment */
        !          1920:     unsigned short  seg;        /* segment of label */
        !          1921:     unsigned char   name[1];    /* Length-prefixed name */
        !          1922: } BLOCKSYM32;
        !          1923: 
        !          1924: typedef struct WITHSYM32 {
        !          1925:     unsigned short  reclen;     /* Record length */
        !          1926:     unsigned short  rectyp;     /* S_WITH32 */
        !          1927:     unsigned long   pParent;    /* pointer to the parent */
        !          1928:     unsigned long   pEnd;       /* pointer to this blocks end */
        !          1929:     unsigned long   len;        /* Block length */
        !          1930:     CV_uoff32_t     off;        /* Offset in code segment */
        !          1931:     unsigned short  seg;        /* segment of label */
        !          1932:     unsigned char   name[1];    /* Length-prefixed expression string */
        !          1933: } WITHSYM32;
        !          1934: 
        !          1935: typedef struct VPATHSYM32 {
        !          1936:     unsigned short  reclen;     /* record length */
        !          1937:     unsigned short  rectyp;     /* S_VFTPATH32 */
        !          1938:     CV_uoff32_t     off;        /* offset of virtual function table */
        !          1939:     unsigned short  seg;        /* segment of virtual function table */
        !          1940:     CV_typ_t        root;       /* type index of the root of path */
        !          1941:     CV_typ_t        path;       /* type index of the path record */
        !          1942: } VPATHSYM32;
        !          1943: 
        !          1944: typedef struct REGREL32 {
        !          1945:     unsigned short  reclen;     /* Record length */
        !          1946:     unsigned short  rectyp;     /* S_REGREL32 */
        !          1947:     CV_uoff32_t     off;        /* offset of symbol */
        !          1948:     unsigned short  reg;        /* register index for symbol */
        !          1949:     CV_typ_t        typind;     /* Type index */
        !          1950:     unsigned char   name[1];    /* Length-prefixed name */
        !          1951: } REGREL32, * LPREGREL32;
        !          1952: 
        !          1953: typedef struct PROCSYMMIPS {
        !          1954:     unsigned short  reclen;     /* Record length */
        !          1955:     unsigned short  rectyp;     /* S_GPROCMIPS or S_LPROCMIPS */
        !          1956:     unsigned long   pParent;    /* pointer to the parent */
        !          1957:     unsigned long   pEnd;       /* pointer to this blocks end */
        !          1958:     unsigned long   pNext;      /* pointer to next symbol */
        !          1959:     unsigned long   len;        /* Proc length */
        !          1960:     unsigned long   DbgStart;   /* Debug start offset */
        !          1961:     unsigned long   DbgEnd;     /* Debug end offset */
        !          1962:     unsigned long   regSave;    /* int register save mask */
        !          1963:     unsigned long   fpSave;     /* fp register save mask */
        !          1964:     unsigned long   intOff;     /* int register save offset */
        !          1965:     unsigned long   fpOff;      /* fp register save offset */
        !          1966:     CV_uoff32_t     off;        /* Symbol offset */
        !          1967:     unsigned short  seg;        /* Symbol segment */
        !          1968:     CV_typ_t        typind;     /* Type index */
        !          1969:     char            retReg;     /* Register return value is in */
        !          1970:     char            frameReg;   /* Frame pointer register */
        !          1971:     unsigned char   name[1];    /* Length-prefixed name */
        !          1972: } PROCSYMMIPS, *PROCPTRMIPS;
        !          1973: 
        !          1974: /*  generic block definition symbols */
        !          1975: /*  these are similar to the equivalent 16:16 or 16:32 symbols but */
        !          1976: /*  only define the length, type and linkage fields */
        !          1977: 
        !          1978: typedef struct PROCSYM {
        !          1979:     unsigned short  reclen;     /* Record length */
        !          1980:     unsigned short  rectyp;     /* S_GPROC16 or S_LPROC16 */
        !          1981:     unsigned long   pParent;    /* pointer to the parent */
        !          1982:     unsigned long   pEnd;       /* pointer to this blocks end */
        !          1983:     unsigned long   pNext;      /* pointer to next symbol */
        !          1984: } PROCSYM;
        !          1985: 
        !          1986: typedef struct THUNKSYM {
        !          1987:     unsigned short  reclen;     /* Record length */
        !          1988:     unsigned short  rectyp;     /* S_THUNK */
        !          1989:     unsigned long   pParent;    /* pointer to the parent */
        !          1990:     unsigned long   pEnd;       /* pointer to this blocks end */
        !          1991:     unsigned long   pNext;      /* pointer to next symbol */
        !          1992: } THUNKSYM;
        !          1993: 
        !          1994: typedef struct BLOCKSYM {
        !          1995:     unsigned short  reclen;     /* Record length */
        !          1996:     unsigned short  rectyp;     /* S_BLOCK16 */
        !          1997:     unsigned long   pParent;    /* pointer to the parent */
        !          1998:     unsigned long   pEnd;       /* pointer to this blocks end */
        !          1999: } BLOCKSYM;
        !          2000: 
        !          2001: typedef struct WITHSYM {
        !          2002:     unsigned short  reclen;     /* Record length */
        !          2003:     unsigned short  rectyp;     /* S_WITH16 */
        !          2004:     unsigned long   pParent;    /* pointer to the parent */
        !          2005:     unsigned long   pEnd;       /* pointer to this blocks end */
        !          2006: } WITHSYM;
        !          2007: 
        !          2008: typedef enum CV_HREG_e {
        !          2009:     /*
        !          2010:      *  Register set for the Intel 80x86 and ix86 processor series
        !          2011:      *  (plus PCODE registers)
        !          2012:      */
        !          2013: 
        !          2014:     CV_REG_NONE  =   0,
        !          2015:     CV_REG_AL    =   1,
        !          2016:     CV_REG_CL    =   2,
        !          2017:     CV_REG_DL    =   3,
        !          2018:     CV_REG_BL    =   4,
        !          2019:     CV_REG_AH    =   5,
        !          2020:     CV_REG_CH    =   6,
        !          2021:     CV_REG_DH    =   7,
        !          2022:     CV_REG_BH    =   8,
        !          2023:     CV_REG_AX    =   9,
        !          2024:     CV_REG_CX    =  10,
        !          2025:     CV_REG_DX    =  11,
        !          2026:     CV_REG_BX    =  12,
        !          2027:     CV_REG_SP    =  13,
        !          2028:     CV_REG_BP    =  14,
        !          2029:     CV_REG_SI    =  15,
        !          2030:     CV_REG_DI    =  16,
        !          2031:     CV_REG_EAX   =  17,
        !          2032:     CV_REG_ECX   =  18,
        !          2033:     CV_REG_EDX   =  19,
        !          2034:     CV_REG_EBX   =  20,
        !          2035:     CV_REG_ESP   =  21,
        !          2036:     CV_REG_EBP   =  22,
        !          2037:     CV_REG_ESI   =  23,
        !          2038:     CV_REG_EDI   =  24,
        !          2039:     CV_REG_ES    =  25,
        !          2040:     CV_REG_CS    =  26,
        !          2041:     CV_REG_SS    =  27,
        !          2042:     CV_REG_DS    =  28,
        !          2043:     CV_REG_FS    =  29,
        !          2044:     CV_REG_GS    =  30,
        !          2045:     CV_REG_IP    =  31,
        !          2046:     CV_REG_FLAGS =  32,
        !          2047:     CV_REG_EIP   =  33,
        !          2048:     CV_REG_EFLAGS = 34,
        !          2049:     CV_REG_TEMP  =  40,         /* PCODE Temp */
        !          2050:     CV_REG_TEMPH =  41,         /* PCODE TempH */
        !          2051:     CV_REG_QUOTE =  42,         /* PCODE Quote */
        !          2052:     CV_REG_PCDR3 =  43,         /* PCODE reserved */
        !          2053:     CV_REG_PCDR4 =  44,         /* PCODE reserved */
        !          2054:     CV_REG_PCDR5 =  45,         /* PCODE reserved */
        !          2055:     CV_REG_PCDR6 =  46,         /* PCODE reserved */
        !          2056:     CV_REG_PCDR7 =  47,         /* PCODE reserved */
        !          2057:     CV_REG_CR0   =  80,         /* CR0 -- control registers */
        !          2058:     CV_REG_CR1   =  81,
        !          2059:     CV_REG_CR2   =  82,
        !          2060:     CV_REG_CR3   =  83,
        !          2061:     CV_REG_DR0   =  90,         /* Debug register */
        !          2062:     CV_REG_DR1   =  91,
        !          2063:     CV_REG_DR2   =  92,
        !          2064:     CV_REG_DR3   =  93,
        !          2065:     CV_REG_DR4   =  94,
        !          2066:     CV_REG_DR5   =  95,
        !          2067:     CV_REG_DR6   =  96,
        !          2068:     CV_REG_DR7   =  97,
        !          2069:     CV_REG_ST0   =  128,
        !          2070:     CV_REG_ST1   =  129,
        !          2071:     CV_REG_ST2   =  130,
        !          2072:     CV_REG_ST3   =  131,
        !          2073:     CV_REG_ST4   =  132,
        !          2074:     CV_REG_ST5   =  133,
        !          2075:     CV_REG_ST6   =  134,
        !          2076:     CV_REG_ST7   =  135,
        !          2077:     CV_REG_CTRL  =  136,
        !          2078:     CV_REG_STAT  =  137,
        !          2079:     CV_REG_TAG   =  138,
        !          2080:     CV_REG_FPIP  =  139,
        !          2081:     CV_REG_FPCS  =  140,
        !          2082:     CV_REG_FPDO  =  141,
        !          2083:     CV_REG_FPDS  =  142,
        !          2084:     CV_REG_ISEM  =  143,
        !          2085:     CV_REG_FPEIP =  144,
        !          2086:     CV_REG_FPEDO =  145,
        !          2087: 
        !          2088:     /*
        !          2089:      * registers for the 68K processors
        !          2090:      */
        !          2091: 
        !          2092:     CV_R68_D0   =   0,
        !          2093:     CV_R68_D1   =   1,
        !          2094:     CV_R68_D2   =   2,
        !          2095:     CV_R68_D3   =   3,
        !          2096:     CV_R68_D4   =   4,
        !          2097:     CV_R68_D5   =   5,
        !          2098:     CV_R68_D6   =   6,
        !          2099:     CV_R68_D7   =   7,
        !          2100:     CV_R68_A0   =   8,
        !          2101:     CV_R68_A1   =   9,
        !          2102:     CV_R68_A2   =   10,
        !          2103:     CV_R68_A3   =   11,
        !          2104:     CV_R68_A4   =   12,
        !          2105:     CV_R68_A5   =   13,
        !          2106:     CV_R68_A6   =   14,
        !          2107:     CV_R68_A7   =   15,
        !          2108:     CV_R68_CCR  =   16,
        !          2109:     CV_R68_SR   =   17,
        !          2110:     CV_R68_USP  =   18,
        !          2111:     CV_R68_MSP  =   19,
        !          2112:     CV_R68_SFC  =   20,
        !          2113:     CV_R68_DFC  =   21,
        !          2114:     CV_R68_CACR =   22,
        !          2115:     CV_R68_VBR  =   23,
        !          2116:     CV_R68_CAAR =   24,
        !          2117:     CV_R68_ISP  =   25,
        !          2118:     CV_R68_PC   =   26,
        !          2119:                                 /* reserved  27 */
        !          2120:     CV_R68_FPCR =   28,
        !          2121:     CV_R68_FPSR =   29,
        !          2122:     CV_R68_FPIAR=   30,
        !          2123:                                 /* reserved  31 */
        !          2124:     CV_R68_FP0  =   32,
        !          2125:     CV_R68_FP1  =   33,
        !          2126:     CV_R68_FP2  =   34,
        !          2127:     CV_R68_FP3  =   35,
        !          2128:     CV_R68_FP4  =   36,
        !          2129:     CV_R68_FP5  =   37,
        !          2130:     CV_R68_FP6  =   38,
        !          2131:     CV_R68_FP7  =   39,
        !          2132:                                 /* reserved  40-50 */
        !          2133:     CV_R68_PSR  =   51,
        !          2134:     CV_R68_PCSR =   52,
        !          2135:     CV_R68_VAL  =   53,
        !          2136:     CV_R68_CRP  =   54,
        !          2137:     CV_R68_SRP  =   55,
        !          2138:     CV_R68_DRP  =   56,
        !          2139:     CV_R68_TC   =   57,
        !          2140:     CV_R68_AC   =   58,
        !          2141:     CV_R68_SCC  =   59,
        !          2142:     CV_R68_CAL  =   60,
        !          2143:     CV_R68_TT0  =   61,
        !          2144:     CV_R68_TT1  =   62,
        !          2145:                                 /* reserved  63 */
        !          2146:     CV_R68_BAD0 =   64,
        !          2147:     CV_R68_BAD1 =   65,
        !          2148:     CV_R68_BAD2 =   66,
        !          2149:     CV_R68_BAD3 =   67,
        !          2150:     CV_R68_BAD4 =   68,
        !          2151:     CV_R68_BAD5 =   69,
        !          2152:     CV_R68_BAD6 =   70,
        !          2153:     CV_R68_BAD7 =   71,
        !          2154:     CV_R68_BAC0 =   72,
        !          2155:     CV_R68_BAC1 =   73,
        !          2156:     CV_R68_BAC2 =   74,
        !          2157:     CV_R68_BAC3 =   75,
        !          2158:     CV_R68_BAC4 =   76,
        !          2159:     CV_R68_BAC5 =   77,
        !          2160:     CV_R68_BAC6 =   78,
        !          2161:     CV_R68_BAC7 =   79,
        !          2162: 
        !          2163:     /*
        !          2164:      * Register set for the MIPS 4000
        !          2165:      */
        !          2166: 
        !          2167:     CV_M4_NOREG    =   CV_REG_NONE,
        !          2168: 
        !          2169:     CV_M4_IntZERO  =   10,      /* CPU REGISTER */
        !          2170:     CV_M4_IntAT    =   11,
        !          2171:     CV_M4_IntV0    =   12,
        !          2172:     CV_M4_IntV1    =   13,
        !          2173:     CV_M4_IntA0    =   14,
        !          2174:     CV_M4_IntA1    =   15,
        !          2175:     CV_M4_IntA2    =   16,
        !          2176:     CV_M4_IntA3    =   17,
        !          2177:     CV_M4_IntT0    =   18,
        !          2178:     CV_M4_IntT1    =   19,
        !          2179:     CV_M4_IntT2    =   20,
        !          2180:     CV_M4_IntT3    =   21,
        !          2181:     CV_M4_IntT4    =   22,
        !          2182:     CV_M4_IntT5    =   23,
        !          2183:     CV_M4_IntT6    =   24,
        !          2184:     CV_M4_IntT7    =   25,
        !          2185:     CV_M4_IntS0    =   26,
        !          2186:     CV_M4_IntS1    =   27,
        !          2187:     CV_M4_IntS2    =   28,
        !          2188:     CV_M4_IntS3    =   29,
        !          2189:     CV_M4_IntS4    =   30,
        !          2190:     CV_M4_IntS5    =   31,
        !          2191:     CV_M4_IntS6    =   32,
        !          2192:     CV_M4_IntS7    =   33,
        !          2193:     CV_M4_IntT8    =   34,
        !          2194:     CV_M4_IntT9    =   35,
        !          2195:     CV_M4_IntKT0   =   36,
        !          2196:     CV_M4_IntKT1   =   37,
        !          2197:     CV_M4_IntGP    =   38,
        !          2198:     CV_M4_IntSP    =   39,
        !          2199:     CV_M4_IntS8    =   40,
        !          2200:     CV_M4_IntRA    =   41,
        !          2201:     CV_M4_IntLO    =   42,
        !          2202:     CV_M4_IntHI    =   43,
        !          2203: 
        !          2204:     CV_M4_Fir      =   50,
        !          2205:     CV_M4_Psr      =   51,
        !          2206: 
        !          2207:     CV_M4_FltF0    =   60,      /* Floating point registers */
        !          2208:     CV_M4_FltF1    =   61,
        !          2209:     CV_M4_FltF2    =   62,
        !          2210:     CV_M4_FltF3    =   63,
        !          2211:     CV_M4_FltF4    =   64,
        !          2212:     CV_M4_FltF5    =   65,
        !          2213:     CV_M4_FltF6    =   66,
        !          2214:     CV_M4_FltF7    =   67,
        !          2215:     CV_M4_FltF8    =   68,
        !          2216:     CV_M4_FltF9    =   69,
        !          2217:     CV_M4_FltF10   =   70,
        !          2218:     CV_M4_FltF11   =   71,
        !          2219:     CV_M4_FltF12   =   72,
        !          2220:     CV_M4_FltF13   =   73,
        !          2221:     CV_M4_FltF14   =   74,
        !          2222:     CV_M4_FltF15   =   75,
        !          2223:     CV_M4_FltF16   =   76,
        !          2224:     CV_M4_FltF17   =   77,
        !          2225:     CV_M4_FltF18   =   78,
        !          2226:     CV_M4_FltF19   =   79,
        !          2227:     CV_M4_FltF20   =   80,
        !          2228:     CV_M4_FltF21   =   81,
        !          2229:     CV_M4_FltF22   =   82,
        !          2230:     CV_M4_FltF23   =   83,
        !          2231:     CV_M4_FltF24   =   84,
        !          2232:     CV_M4_FltF25   =   85,
        !          2233:     CV_M4_FltF26   =   86,
        !          2234:     CV_M4_FltF27   =   87,
        !          2235:     CV_M4_FltF28   =   88,
        !          2236:     CV_M4_FltF29   =   89,
        !          2237:     CV_M4_FltF30   =   90,
        !          2238:     CV_M4_FltF31   =   92,
        !          2239:     CV_M4_FltFsr   =   93,
        !          2240: 
        !          2241:     /*
        !          2242:      * Register set for the ALPHA AXP
        !          2243:      */
        !          2244: 
        !          2245:     CV_ALPHA_NOREG    = CV_REG_NONE,
        !          2246: 
        !          2247:        CV_ALPHA_FltF0    =   10,         /* Floating point registers */
        !          2248:        CV_ALPHA_FltF1,         // 11
        !          2249:        CV_ALPHA_FltF2,         // 12
        !          2250:        CV_ALPHA_FltF3,         // 13
        !          2251:        CV_ALPHA_FltF4,         // 14
        !          2252:        CV_ALPHA_FltF5,         // 15
        !          2253:        CV_ALPHA_FltF6,         // 16
        !          2254:        CV_ALPHA_FltF7,         // 17
        !          2255:        CV_ALPHA_FltF8,         // 18
        !          2256:        CV_ALPHA_FltF9,         // 19
        !          2257:        CV_ALPHA_FltF10,        // 20
        !          2258:        CV_ALPHA_FltF11,        // 21
        !          2259:        CV_ALPHA_FltF12,        // 22
        !          2260:        CV_ALPHA_FltF13,        // 23
        !          2261:        CV_ALPHA_FltF14,        // 24
        !          2262:        CV_ALPHA_FltF15,        // 25
        !          2263:        CV_ALPHA_FltF16,        // 26
        !          2264:        CV_ALPHA_FltF17,        // 27
        !          2265:        CV_ALPHA_FltF18,        // 28
        !          2266:        CV_ALPHA_FltF19,        // 29
        !          2267:        CV_ALPHA_FltF20,        // 30
        !          2268:        CV_ALPHA_FltF21,        // 31
        !          2269:        CV_ALPHA_FltF22,        // 32
        !          2270:        CV_ALPHA_FltF23,        // 33
        !          2271:        CV_ALPHA_FltF24,        // 34
        !          2272:        CV_ALPHA_FltF25,        // 35
        !          2273:        CV_ALPHA_FltF26,        // 36
        !          2274:        CV_ALPHA_FltF27,        // 37
        !          2275:        CV_ALPHA_FltF28,        // 38
        !          2276:        CV_ALPHA_FltF29,        // 39
        !          2277:        CV_ALPHA_FltF30,        // 30
        !          2278:        CV_ALPHA_FltF31,        // 41
        !          2279: 
        !          2280:        CV_ALPHA_IntV0,         // 42   Integer registers
        !          2281:        CV_ALPHA_IntT0,         // 43
        !          2282:        CV_ALPHA_IntT1,         // 44
        !          2283:        CV_ALPHA_IntT2,         // 45
        !          2284:        CV_ALPHA_IntT3,         // 46
        !          2285:        CV_ALPHA_IntT4,         // 47
        !          2286:        CV_ALPHA_IntT5,         // 48
        !          2287:        CV_ALPHA_IntT6,         // 49
        !          2288:        CV_ALPHA_IntT7,         // 50
        !          2289:        CV_ALPHA_IntS0,         // 51
        !          2290:        CV_ALPHA_IntS1,         // 52
        !          2291:        CV_ALPHA_IntS2,         // 53
        !          2292:        CV_ALPHA_IntS3,         // 54
        !          2293:        CV_ALPHA_IntS4,         // 55
        !          2294:        CV_ALPHA_IntS5,         // 56
        !          2295:        CV_ALPHA_IntFP,         // 57
        !          2296:        CV_ALPHA_IntA0,         // 58
        !          2297:        CV_ALPHA_IntA1,         // 59
        !          2298:        CV_ALPHA_IntA2,         // 60
        !          2299:        CV_ALPHA_IntA3,         // 61
        !          2300:        CV_ALPHA_IntA4,         // 62
        !          2301:        CV_ALPHA_IntA5,         // 63
        !          2302:        CV_ALPHA_IntT8,         // 64
        !          2303:        CV_ALPHA_IntT9,         // 65
        !          2304:        CV_ALPHA_IntT10,        // 66
        !          2305:        CV_ALPHA_IntT11,        // 67
        !          2306:        CV_ALPHA_IntRA,         // 68
        !          2307:        CV_ALPHA_IntT12,        // 69
        !          2308:        CV_ALPHA_IntAT,         // 70
        !          2309:        CV_ALPHA_IntGP,         // 71
        !          2310:        CV_ALPHA_IntSP,         // 72
        !          2311:        CV_ALPHA_IntZERO,       // 73
        !          2312: 
        !          2313: 
        !          2314:        CV_ALPHA_Fpcr,          // 74   Control registers
        !          2315:        CV_ALPHA_Fir,           // 75
        !          2316:        CV_ALPHA_Psr,           // 76
        !          2317:        CV_ALPHA_FltFsr         // 77
        !          2318: 
        !          2319: } CV_HREG_e;
        !          2320: 
        !          2321: 
        !          2322: #pragma pack()
        !          2323: 
        !          2324: #endif /* CV_INFO_INCLUDED */

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