cvinfo.h

CC386 is a general-purpose 32-bit C compiler. It is not an optimizing compiler but given that the co

    //      type record for LF_POINTER

    #ifndef __cplusplus
        typedef struct lfPointer
        {
        #endif 
        struct lfPointerBody
        {
            unsigned short leaf; // LF_POINTER
            CV_typ_t utype; // type index of the underlying type
            struct lfPointerAttr
            {
                unsigned char ptrtype: 5; 
                    // ordinal specifying pointer type (ptrtype-t)
                unsigned char ptrmode: 3; 
                    // ordinal specifying pointer mode (ptrmode_t)
                unsigned char isflat32: 1; // true if 0:32 pointer
                unsigned char isvolatile: 1; // TRUE if volatile pointer
                unsigned char isconst: 1; // TRUE if const pointer
                unsigned char isunaligned: 1; // TRUE if unaligned pointer
                unsigned char unused: 4;
            } attr;
            #if (defined(__cplusplus) || defined(_MSC_VER)) 
                // for C++ and MS compilers that support unnamed unions
            };
        #else 
        }
        u;
    #endif 
    #ifdef __cplusplus
        typedef struct lfPointer: public lfPointerBody
        {
        #endif 
        union
        {
            struct 
            {
                CV_typ_t pmclass; 
                    // index of containing class for pointer to member
                unsigned short pmenum; // enumeration specifying pm format
            } pm;
            unsigned short bseg; // base segment if PTR_BASE_SEG
            unsigned char Sym[1]; 
                // copy of base symbol record (including length)
            struct
            {
                CV_typ_t index; // type index if CV_PTR_BASE_TYPE
                unsigned char name[1]; // name of base type
            } btype;
        }
        pbase;
    }
    lfPointer;




    //      type record for LF_ARRAY


    typedef struct lfArray
    {
        unsigned short leaf; // LF_ARRAY
        CV_typ_t elemtype; // type index of element type
        CV_typ_t idxtype; // type index of indexing type
        unsigned char data[CV_ZEROLEN]; // variable length data specifying
        // size in bytes and name
    } lfArray;




    //      type record for LF_CLASS, LF_STRUCTURE


    typedef struct lfClass
    {
        unsigned short leaf; // LF_CLASS, LF_STRUCT
        unsigned short count; // count of number of elements in class
        CV_prop_t property; // property attribute field (prop_t)
        CV_typ_t field; // type index of LF_FIELD descriptor list
        CV_typ_t derived; // type index of derived from list if not zero
        CV_typ_t vshape; // type index of vshape table for this class
        unsigned char data[CV_ZEROLEN]; 
            // data describing length of structure in
        // bytes and name
    } lfClass;
    typedef lfClass lfStructure;




    //      type record for LF_UNION


    typedef struct lfUnion
    {
        unsigned short leaf; // LF_UNION
        unsigned short count; // count of number of elements in class
        CV_prop_t property; // property attribute field
        CV_typ_t field; // type index of LF_FIELD descriptor list
        unsigned char data[CV_ZEROLEN]; 
            // variable length data describing length of
        // structure and name
    } lfUnion;




    //      type record for LF_ENUM


    typedef struct lfEnum
    {
        unsigned short leaf; // LF_ENUM
        unsigned short count; // count of number of elements in class
        CV_prop_t property; // property attribute field
        CV_typ_t utype; // underlying type of the enum
        CV_typ_t field; // type index of LF_FIELD descriptor list
        unsigned char Name[1]; // length prefixed name of enum
    } lfEnum;




    //      Type record for LF_PROCEDURE


    typedef struct lfProc
    {
        unsigned short leaf; // LF_PROCEDURE
        CV_typ_t rvtype; // type index of return value
        unsigned char calltype; // calling convention (CV_call_t)
        unsigned char reserved; // reserved for future use
        unsigned short parmcount; // number of parameters
        CV_typ_t arglist; // type index of argument list
    } lfProc;



    //      Type record for member function


    typedef struct lfMFunc
    {
        unsigned short leaf; // LF_MFUNCTION
        CV_typ_t rvtype; // type index of return value
        CV_typ_t classtype; // type index of containing class
        CV_typ_t thistype; // type index of this pointer (model specific)
        unsigned char calltype; // calling convention (call_t)
        unsigned char reserved; // reserved for future use
        unsigned short parmcount; // number of parameters
        CV_typ_t arglist; // type index of argument list
        long thisadjust; // this adjuster (long because pad required anyway)
    } lfMFunc;




    //     type record for virtual function table shape


    typedef struct lfVTShape
    {
        unsigned short leaf; // LF_VTSHAPE
        unsigned short count; // number of entries in vfunctable
        unsigned char desc[CV_ZEROLEN]; // 4 bit (CV_VTS_desc) descriptors
    } lfVTShape;




    //      type record for cobol0


    typedef struct lfCobol0
    {
        unsigned short leaf; // LF_COBOL0
        CV_typ_t type; // parent type record index
        unsigned char data[CV_ZEROLEN];
    } lfCobol0;




    //      type record for cobol1


    typedef struct lfCobol1
    {
        unsigned short leaf; // LF_COBOL1
        unsigned char data[CV_ZEROLEN];
    } lfCobol1;




    //      type record for basic array


    typedef struct lfBArray
    {
        unsigned short leaf; // LF_BARRAY
        CV_typ_t utype; // type index of underlying type
    } lfBArray;

    //      type record for assembler labels


    typedef struct lfLabel
    {
        unsigned short leaf; // LF_LABEL
        unsigned short mode; // addressing mode of label
    } lfLabel;



    //      type record for dimensioned arrays


    typedef struct lfDimArray
    {
        unsigned short leaf; // LF_DIMARRAY
        CV_typ_t utype; // underlying type of the array
        CV_typ_t diminfo; // dimension information
        char name[1]; // length prefixed name
    } lfDimArray;



    //      type record describing path to virtual function table


    typedef struct lfVFTPath
    {
        unsigned short leaf; // LF_VFTPATH
        unsigned short count; // count of number of bases in path
        CV_typ_t base[1]; // bases from root to leaf
    } lfVFTPath;


    //      type record describing inclusion of precompiled types


    typedef struct lfPreComp
    {
        unsigned short leaf; // LF_PRECOMP
        unsigned short start; // starting type index included
        unsigned short count; // number of types in inclusion
        unsigned long signature; // signature
        unsigned char name[CV_ZEROLEN]; 
            // length prefixed name of included type file
    } lfPreComp;


    //      type record describing end of precompiled types that can be
    //      included by another file


    typedef struct lfEndPreComp
    {
        unsigned short leaf; // LF_ENDPRECOMP
        unsigned long signature; // signature
    } lfEndPreComp;





    //      type record for OEM definable type strings


    typedef struct lfOEM
    {
        unsigned short leaf; // LF_OEM
        unsigned short cvOEM; // MS assigned OEM identified
        unsigned short recOEM; // OEM assigned type identifier
        unsigned short count; // count of type indices to follow
        CV_typ_t index[CV_ZEROLEN]; // array of type indices followed
        // by OEM defined data
    } lfOEM;

    #define OEM_ODI                 0x0010

    #define OEM_ODI_REC_BASELIST    0x0000


    //      type record describing using of a type server

    typedef struct lfTypeServer
    {
        unsigned short leaf; // LF_TYPESERVER
        unsigned long signature; // signature
        unsigned long age; // age of database used by this module
        unsigned char name[CV_ZEROLEN]; // length prefixed name of PDB
    } lfTypeServer;

    //      description of type records that can be referenced from
    //      type records referenced by symbols



    //      type record for skip record


    typedef struct lfSkip
    {
        unsigned short leaf; // LF_SKIP
        CV_typ_t type; // next valid index
        unsigned char data[CV_ZEROLEN]; // pad data
    } lfSkip;



    //      argument list leaf


    typedef struct lfArgList
    {
        unsigned short leaf; // LF_ARGLIST
        unsigned short count; // number of arguments
        CV_typ_t arg[CV_ZEROLEN]; // number of arguments
    } lfArgList;




    //      derived class list leaf


    typedef struct lfDerived
    {
        unsigned short leaf; // LF_DERIVED
        unsigned short count; // number of arguments
        CV_typ_t drvdcls[CV_ZEROLEN]; // type indices of derived classes
    } lfDerived;




    //      leaf for default arguments


    typedef struct lfDefArg
    {
        unsigned short leaf; // LF_DEFARG
        CV_typ_t type; // type of resulting expression
        unsigned char expr[CV_ZEROLEN]; // length prefixed expression string
    } lfDefArg;



    //      list leaf
    //      This list should no longer be used because the utilities cannot
    //      verify the contents of the list without knowing what type of list
    //      it is.  New specific leaf indices should be used instead.


    typedef struct lfList
    {
        unsigned short leaf; // LF_LIST
        char data[CV_ZEROLEN]; // data format specified by indexing type
    } lfList;




    //      field list leaf
    //      This is the header leaf for a complex list of class and structure
    //      subfields.


    typedef struct lfFieldList
    {
        unsigned short leaf; // LF_FIELDLIST
        char data[CV_ZEROLEN]; // field list sub lists
    } lfFieldList;



    //      type record for non-static methods and friends in overloaded method list

    typedef struct mlMethod
    {
        CV_fldattr_t attr; // method attribute
        CV_typ_t index; // index to type record for procedure
        unsigned long vbaseoff[CV_ZEROLEN]; 
            // offset in vfunctable if intro virtual
    } mlMethod;


    typedef struct lfMethodList
    {
        unsigned short leaf;
        unsigned char mList[CV_ZEROLEN]; // really a mlMethod type
    } lfMethodList;



    //      type record for LF_BITFIELD


    typedef struct lfBitfield
    {
        unsigned short leaf; // LF_BITFIELD
        CV_typ_t type; // type of bitfield
        unsigned char length;
        unsigned char position;
    } lfBitfield;




    //      type record for dimensioned array with constant bounds


    typedef struct lfDimCon
    {
        unsigned short leaf; // LF_DIMCONU or LF_DIMCONLU