cvinfo.h

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

    CV_PTR_HUGE         = 0x02, // huge pointer
    CV_PTR_BASE_SEG     = 0x03, // based on segment
    CV_PTR_BASE_VAL     = 0x04, // based on value of base
    CV_PTR_BASE_SEGVAL  = 0x05, // based on segment value of base
    CV_PTR_BASE_ADDR    = 0x06, // based on address of base
    CV_PTR_BASE_SEGADDR = 0x07, // based on segment address of base
    CV_PTR_BASE_TYPE    = 0x08, // based on type
    CV_PTR_BASE_SELF    = 0x09, // based on self
    CV_PTR_NEAR32       = 0x0a, // 16:32 near pointer
    CV_PTR_FAR32        = 0x0b, // 16:32 far pointer
    CV_PTR_UNUSEDPTR    = 0x0c  // first unused pointer type
} CV_ptrtype_e;





//      Mode enum for pointers
//      Pointers can have one of the following modes


typedef enum CV_ptrmode_e {
    CV_PTR_MODE_PTR     = 0x00, // "normal" pointer
    CV_PTR_MODE_REF     = 0x01, // reference
    CV_PTR_MODE_PMEM    = 0x02, // pointer to data member
    CV_PTR_MODE_PMFUNC  = 0x03, // pointer to member function
    CV_PTR_MODE_RESERVED= 0x04  // first unused pointer mode
} CV_ptrmode_e;




//      Enumeration for function call type


typedef enum CV_call_e {
    CV_CALL_NEAR_C      = 0x00, // near right to left push, caller pops stack
    CV_CALL_FAR_C       = 0x01, // far right to left push, caller pops stack
    CV_CALL_NEAR_PASCAL = 0x02, // near left to right push, callee pops stack
    CV_CALL_FAR_PASCAL  = 0x03, // far left to right push, callee pops stack
    CV_CALL_NEAR_FAST   = 0x04, // near left to right push with regs, callee pops stack
    CV_CALL_FAR_FAST    = 0x05, // far left to right push with regs, callee pops stack
    CV_CALL_SKIPPED     = 0x06, // skipped (unused) call index
    CV_CALL_NEAR_STD    = 0x07, // near standard call
    CV_CALL_FAR_STD     = 0x08, // far standard call
    CV_CALL_NEAR_SYS    = 0x09, // near sys call
    CV_CALL_FAR_SYS     = 0x0a, // far sys call
    CV_CALL_THISCALL    = 0x0b, // this call (this passed in register)
    CV_CALL_MIPSCALL    = 0x0c, // Mips call
    CV_CALL_GENERIC     = 0x0d, // Generic call sequence
    CV_CALL_ALPHACALL   = 0x0e, // Alpha call
    CV_CALL_PPCCALL     = 0x0f, // PPC call
    CV_CALL_RESERVED    = 0x10  // first unused call enumeration
} CV_call_e;




//      Values for the access protection of class attributes


typedef enum CV_access_e {
    CV_private   = 1,
    CV_protected = 2,
    CV_public    = 3
} CV_access_e;



//      enumeration for method properties

typedef enum CV_methodprop_e {
    CV_MTvanilla    = 0x00,
    CV_MTvirtual    = 0x01,
    CV_MTstatic     = 0x02,
    CV_MTfriend     = 0x03,
    CV_MTintro      = 0x04,
    CV_MTpurevirt   = 0x05,
    CV_MTpureintro  = 0x06
} CV_methodprop_e;




//      enumeration for virtual shape table entries

typedef enum CV_VTS_desc_e {
    CV_VTS_near     = 0x00,
    CV_VTS_far      = 0x01,
    CV_VTS_thin     = 0x02,
    CV_VTS_outer    = 0x03,
    CV_VTS_meta     = 0x04,
    CV_VTS_near32   = 0x05,
    CV_VTS_far32    = 0x06,
    CV_VTS_unused   = 0x07
} CV_VTS_desc_e;




//      enumeration for LF_LABEL address modes

typedef enum CV_LABEL_TYPE_e {
    CV_LABEL_NEAR = 0,          // near return
    CV_LABEL_FAR  = 4           // far return
} CV_LABEL_TYPE_e;



//      enumeration for LF_MODIFIER values


typedef struct CV_modifier_t {
    unsigned short  MOD_const       :1;
    unsigned short  MOD_volatile    :1;
    unsigned short  MOD_unaligned   :1;
    unsigned short  MOD_unused      :13;
} CV_modifier_t;


//      bit field structure describing class/struct/union/enum properties

typedef struct CV_prop_t {
    unsigned short  packed      :1;     // true if structure is packed
    unsigned short  ctor        :1;     // true if constructors or destructors present
    unsigned short  ovlops      :1;     // true if overloaded operators present
    unsigned short  isnested    :1;     // true if this is a nested class
    unsigned short  cnested     :1;     // true if this class contains nested types
    unsigned short  opassign    :1;     // true if overloaded assignment (=)
    unsigned short  opcast      :1;     // true if casting methods
    unsigned short  fwdref      :1;     // true if forward reference (incomplete defn)
    unsigned short  scoped      :1;     // scoped definition
    unsigned short  reserved    :7;
} CV_prop_t;




//      class field attribute

typedef struct CV_fldattr_t {
    unsigned short  access      :2;     // access protection CV_access_t
    unsigned short  mprop       :3;     // method properties CV_methodprop_t
    unsigned short  pseudo      :1;     // compiler generated fcn and does not exist
    unsigned short  noinherit   :1;     // true if class cannot be inherited
    unsigned short  noconstruct :1;     // true if class cannot be constructed
    unsigned short  unused      :8;     // unused
} CV_fldattr_t;



//      Structures to access to the type records


typedef struct TYPTYPE {
    unsigned short  len;
    unsigned short  leaf;
    unsigned char   data[CV_ZEROLEN];
} TYPTYPE;                      // general types record


//__INLINE char *NextType (char * pType) {
//    return (pType + ((TYPTYPE *)pType)->len + sizeof(unsigned short));
//}

typedef enum CV_PMEMBER {
    CV_PDM16_NONVIRT        = 0x00, // 16:16 data no virtual fcn or base
    CV_PDM16_VFCN           = 0x01, // 16:16 data with virtual functions
    CV_PDM16_VBASE          = 0x02, // 16:16 data with virtual bases
    CV_PDM32_NVVFCN         = 0x03, // 16:32 data w/wo virtual functions
    CV_PDM32_VBASE          = 0x04, // 16:32 data with virtual bases

    CV_PMF16_NEARNVSA       = 0x05, // 16:16 near method nonvirtual single address point
    CV_PMF16_NEARNVMA       = 0x06, // 16:16 near method nonvirtual multiple address points
    CV_PMF16_NEARVBASE      = 0x07, // 16:16 near method virtual bases
    CV_PMF16_FARNVSA        = 0x08, // 16:16 far method nonvirtual single address point
    CV_PMF16_FARNVMA        = 0x09, // 16:16 far method nonvirtual multiple address points
    CV_PMF16_FARVBASE       = 0x0a, // 16:16 far method virtual bases

    CV_PMF32_NVSA           = 0x0b, // 16:32 method nonvirtual single address point
    CV_PMF32_NVMA           = 0x0c, // 16:32 method nonvirtual multiple address point
    CV_PMF32_VBASE          = 0x0d  // 16:32 method virtual bases
} CV_PMEMBER;



//      memory representation of pointer to member.  These representations are
//      indexed by the enumeration above in the LF_POINTER record




//      representation of a 16:16 pointer to data for a class with no
//      virtual functions or virtual bases


struct CV_PDMR16_NONVIRT {
    CV_off16_t      mdisp;          // displacement to data (NULL = -1)
};




//      representation of a 16:16 pointer to data for a class with virtual
//      functions


struct CV_PMDR16_VFCN {
    CV_off16_t      mdisp;          // displacement to data ( NULL = 0)
};




//      representation of a 16:16 pointer to data for a class with
//      virtual bases


struct CV_PDMR16_VBASE {
    CV_off16_t      mdisp;          // displacement to data
    CV_off16_t      pdisp;          // this pointer displacement to vbptr
    CV_off16_t      vdisp;          // displacement within vbase table
                                    // NULL = (,,0xffff)
};




//      representation of a 16:32 near pointer to data for a class with
//      or without virtual functions and no virtual bases


struct CV_PDMR32_NVVFCN {
    CV_off32_t      mdisp;          // displacement to data (NULL = 0x80000000)
};




//      representation of a 16:32 near pointer to data for a class
//      with virtual bases


struct CV_PDMR32_VBASE {
    CV_off32_t      mdisp;          // displacement to data
    CV_off32_t      pdisp;          // this pointer displacement
    CV_off32_t      vdisp;          // vbase table displacement
                                    // NULL = (,,0xffffffff)
};




//      representation of a 16:16 pointer to near member function for a
//      class with no virtual functions or bases and a single address point


struct CV_PMFR16_NEARNVSA {
    CV_uoff16_t     off;            // near address of function (NULL = 0)
};



//      representation of a 16:16 near pointer to member functions of a
//      class with no virtual bases and multiple address points


struct CV_PMFR16_NEARNVMA {
    CV_uoff16_t     off;            // offset of function (NULL = 0,x)
    signed short    disp;
};




//      representation of a 16:16 near pointer to member function of a
//      class with virtual bases


struct CV_PMFR16_NEARVBASE {
    CV_uoff16_t     off;            // offset of function (NULL = 0,x,x,x)
    CV_off16_t      mdisp;          // displacement to data
    CV_off16_t      pdisp;          // this pointer displacement
    CV_off16_t      vdisp;          // vbase table displacement
};




//      representation of a 16:16 pointer to far member function for a
//      class with no virtual bases and a single address point


struct CV_PMFR16_FARNVSA {
    CV_uoff16_t     off;            // offset of function (NULL = 0:0)
    unsigned short  seg;            // segment of function
};




//      representation of a 16:16 far pointer to member functions of a
//      class with no virtual bases and multiple address points


struct CV_PMFR16_FARNVMA {
    CV_uoff16_t     off;            // offset of function (NULL = 0:0,x)
    unsigned short  seg;
    signed short    disp;
};




//      representation of a 16:16 far pointer to member function of a
//      class with virtual bases


struct CV_PMFR16_FARVBASE {
    CV_uoff16_t     off;            // offset of function (NULL = 0:0,x,x,x)
    unsigned short  seg;
    CV_off16_t      mdisp;          // displacement to data
    CV_off16_t      pdisp;          // this pointer displacement
    CV_off16_t      vdisp;          // vbase table displacement

};




//      representation of a 16:32 near pointer to member function for a
//      class with no virtual bases and a single address point


struct CV_PMFR32_NVSA {
    CV_uoff32_t      off;            // near address of function (NULL = 0L)
};




//      representation of a 16:32 near pointer to member function for a
//      class with no virtual bases and multiple address points


struct CV_PMFR32_NVMA {
    CV_uoff32_t     off;            // near address of function (NULL = 0L,x)
    CV_off32_t      disp;
};




//      representation of a 16:32 near pointer to member function for a
//      class with virtual bases


struct CV_PMFR32_VBASE {
    CV_uoff32_t     off;            // near address of function (NULL = 0L,x,x,x)
    CV_off32_t      mdisp;          // displacement to data
    CV_off32_t      pdisp;          // this pointer displacement
    CV_off32_t      vdisp;          // vbase table displacement
};





//      Easy leaf - used for generic casting to reference leaf field
//      of a subfield of a complex list

typedef struct lfEasy {
    unsigned short  leaf;           // LF_...
} lfEasy;


/**     The following type records are basically variant records of the
 *      above structure.  The "unsigned short leaf" of the above structure and
 *      the "unsigned short leaf" of the following type definitions are the same
 *      symbol.  When the OMF record is locked via the MHOMFLock API
 *      call, the address of the "unsigned short leaf" is returned
 */


//      Type record for LF_MODIFIER


typedef struct lfModifier {
    unsigned short  leaf;           // LF_MODIFIER
    CV_typ_t        type;           // modified type
    CV_modifier_t   attr;           // modifier attribute modifier_t
} lfModifier;




//      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)