cvinfo.h

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

            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
    CV_typ_t        typ;            // type of index
    unsigned short  rank;           // number of dimensions
    unsigned char   dim[CV_ZEROLEN];  // array of dimension information with
                                    // either upper bounds or lower/upper bound
} lfDimCon;




//      type record for dimensioned array with variable bounds


typedef struct lfDimVar {
    unsigned short  leaf;           // LF_DIMVARU or LF_DIMVARLU
    CV_typ_t        typ;            // type of index
    unsigned short  rank;           // number of dimensions
    unsigned char   dim[CV_ZEROLEN];  // array of type indices for either
                                    // variable upper bound or variable
                                    // lower/upper bound.  The referenced
                                    // types must be LF_REFSYM or T_VOID
} lfDimVar;




//      type record for referenced symbol


typedef struct lfRefSym {
    unsigned short  leaf;           // LF_REFSYM
    unsigned char   Sym[1];         // copy of referenced symbol record
                                    // (including length)
} lfRefSym;





/**     the following are numeric leaves.  They are used to indicate the
 *      size of the following variable length data.  When the numeric
 *      data is a single byte less than 0x8000, then the data is output
 *      directly.  If the data is more the 0x8000 or is a negative value,
 *      then the data is preceeded by the proper index.
 */