cv.c

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

      *ofs += Mod.bseg->address ;
      If pefile.val IsFalse
       Then
        *seg = 0 ;
       Else
        *seg = PE_bss_seg+1 ;  
        *ofs -= imageBase.val ;
       EndIf
      break ;
     When 4:
      *ofs += Mod.constseg->address ;
      If pefile.val IsFalse
       Then
        *seg = 0 ;
       Else
        *ofs -= imageBase.val ;
        *seg = PE_code_seg+1 ;  
       EndIf
      break ;
     When 5:
      *ofs += Mod.stringseg->address ;
      If pefile.val IsFalse
       Then
        *seg = 0 ;
       Else
        *ofs -= imageBase.val ;
        *seg = PE_code_seg+1 ;  
       EndIf
      break ;
    EndCase
BeginCode
EndCode
#undef Mod

void cv_globalsyms_data(byte_ptr *globals, bit_32_ptr globallen)
BeginDeclarations
byte                                         align_copy[512];
bit_32                                       align_base ;
bit_32                                       align_len ;
byte_ptr                                     align_ptr ;
bit_32                                       blocklevel ;
bit_32                                       copy_to_global ;
byte_ptr                                     cp ;
bit_32                                       i ;
Generic_Element_ptr                          generic;
byte                                         global_copy[512] ;
bit_32                                       global_len ;
bit_32                                       global_max ;
byte_ptr                                     global_ptr ;
bit_32                                       length ;
module_ptr                                   mod ;
bit_32                                       global_base ;
bit_32                                       l;
LABELSYM32                                  *lab;
bit_32_ptr                                   nextptr_global ;
bit_32_ptr                                   nextptr_align ;
bit_32_ptr                                   oldptr_global ;
public_entry_ptr                             pub;
lseg_ptr                                     lseg ;
SEARCHSYM                                   *search_ptr_align ;
SEARCHSYM                                   *search_ptr_global ;
bit_32                                       symlen ;
byte_ptr                                     symptr ;
#define Mod                                (*mod)
#define Pub                                (*pub)
#define Lseg                               (*lseg)
#define Lab                                (*lab)
#define NEWTYPE(x) (x) = ((x) >= CV_FIRST_NONPRIM ? (x) + Mod.type_offset - CV_FIRST_NONPRIM : (x))
EndDeclarations
BeginCode
   blocklevel = 0 ;
   global_max = 65536 ;
   global_ptr = (byte_ptr) allocate_memory(global_max) ;
   search_ptr_global = global_ptr ;
   search_ptr_global->reclen = sizeof(SEARCHSYM) ;
   search_ptr_global->reclen = ((search_ptr_global->reclen + 3) And ~3) - 2 ;
   search_ptr_global->rectyp = S_SSEARCH ;
   global_len = search_ptr_global->reclen + 2 ;


   global_base = global_len -4 ; /* makes up for the 0002 in the obj file */

   nextptr_align = Null ;
   nextptr_global = Null ;

   For i = 0; i < n_modules; i++
    BeginFor
     mod = modules[i] ;
     lseg = Mod.debsymseg ;
     If lseg IsNull
      Then
       LoopIf(Mod.publics.first IsNull) ;

       Mod.align_len = 65536 ;
       Mod.align_data = (byte_ptr)allocate_memory(Mod.align_len) ;

       align_base = -4 ;
       align_len = 0 ;

       search_ptr_align = align_ptr = Mod.align_data ;
       search_ptr_align->reclen = sizeof(SEARCHSYM) ;
       search_ptr_align->reclen = ((search_ptr_align->reclen + 3) And ~3) - 2 ;
       search_ptr_align->rectyp = S_SSEARCH ;
       search_ptr_align->startsym = 0 ;
       search_ptr_align->seg = 0 ;
       align_len += search_ptr_align->reclen + 2 ;
       search_ptr_align = NULL ;

       align_base += align_len ;

       TraverseList(Mod.publics, generic)
        BeginTraverse
         pub = (public_entry_ptr)((byte_ptr)generic - PUB_OFFSET_MODPUBS) ;
         lab = (LABELSYM32 *)align_copy;
         Lab.reclen = sizeof(LABELSYM32) + (l = Pub.length) ;
         cp = Pub.symbol;
         If cp[0] Is '_'
          Then
           Lab.reclen--;
           l--;
           cp++;
          EndIf;
         If Lab.reclen % 4
          Then
           Lab.reclen = Lab.reclen + 4 - Lab.reclen % 4 ;
          EndIf
         Lab.reclen -= 2 ;
         Lab.rectyp = S_LABEL32 ;
         memset(&Lab.flags,0,sizeof(Lab.flags)) ;
         Lab.name[0] = l ;
         memcpy(Lab.name+1,cp, l) ;
         Lab.seg = Pub.Internal.segment_index ;
         Lab.off = Pub.Internal.offset ;
         GlobalAddress(mod,&Lab.off, &Lab.seg) ;
         length = Lab.reclen + 2 ;
         If global_len + length > global_max
          Then
           global_max += 65536 ;
           oldptr_global = global_ptr ;
           global_ptr = (byte_ptr) reallocate_memory(global_ptr, global_max) ;
           If nextptr_global IsNotNull
            Then
             nextptr_global = (bit_32_ptr)((bit_32)nextptr_global + (bit_32)global_ptr - (bit_32) oldptr_global) ;
            EndIf
           If search_ptr_global IsNotNull
            Then
             search_ptr_global = (bit_32_ptr)((bit_32)search_ptr_global + (bit_32)global_ptr - (bit_32) oldptr_global) ;
            EndIf
          EndIf
         memcpy(global_ptr + global_len, align_copy, length) ;
         global_len += length ;
         If align_len + length > Mod.align_len
          Then
           Mod.align_len += 65536 ;
           align_ptr = (byte_ptr) reallocate_memory(align_ptr, Mod.align_len) ;
          EndIf
         memcpy(align_ptr + align_len, align_copy, length) ;
         align_len += length ;
        EndTraverse
      Else
       Mod.align_len = Lseg.length ;
       Mod.align_data = (byte_ptr)allocate_memory(Mod.align_len + sizeof(SEARCHSYM)) ;

       symptr = Lseg.data + 4;
       symlen = Lseg.length -4;

       align_base = -4 ;
       align_len = 0 ;

       search_ptr_align = align_ptr = Mod.align_data ;
       search_ptr_align->reclen = sizeof(SEARCHSYM) ;
       search_ptr_align->reclen = ((search_ptr_align->reclen + 3) And ~3) - 2 ;
       search_ptr_align->rectyp = S_SSEARCH ;
       align_len += search_ptr_align->reclen + 2 ;

       align_base += align_len ;

       While symlen GreaterThan 0
        BeginWhile
         memcpy(align_copy,symptr,(*(bit_16_ptr)symptr) + 2) ;
         Using *(bit_16_ptr)(symptr+2)
          BeginCase
           When S_UDT:
            { 
              UDTSYM *p = align_copy ;
              NEWTYPE(p->typind) ;
            }
            memcpy(global_copy,align_copy , (*(bit_16 *)align_copy) + 2) ;
            copy_to_global = True ;
            break ;
           When S_BLOCK32:
            {
              BLOCKSYM32 *p = align_copy ;
              p->pParent += align_base ;
              p->pEnd += align_base ;
              GlobalAddress(mod,&p->off, &p->seg) ;
              If copy_to_global IsTrue
               Then
                memcpy(global_copy,symptr,(*(bit_16_ptr)symptr) + 2) ;
                p = global_copy ;
                GlobalAddress(mod,&p->off, &p->seg) ;
                p->pParent += global_len - align_len + global_base ;
                p->pEnd += global_len - align_len + global_base;
               EndIf
            }
            blocklevel++ ;
            break ;
           When S_REGISTER:
            {
              REGSYM *p = align_copy ;
              NEWTYPE(p->typind) ;
              memcpy(global_copy,align_copy , (*(bit_16 *)align_copy) + 2) ;
            }
            break ;
           When S_BPREL32:
            { 
              BPRELSYM32 *p = align_copy ;
              NEWTYPE(p->typind) ;
              memcpy(global_copy,align_copy , (*(bit_16 *)align_copy) + 2) ;
            }
            break ;
           When S_LDATA32:
            If blocklevel IsZero
             Then
              copy_to_global = False ;
             EndIf ;
            {
              DATASYM32 *p = align_copy ;
              NEWTYPE(p->typind) ;
              GlobalAddress(mod,&p->off, &p->seg) ;
              If copy_to_global IsTrue
               Then
                memcpy(global_copy,align_copy,(*(bit_16_ptr)symptr) + 2) ;
               EndIf
            }
            break ;
           When S_GDATA32:
            copy_to_global = True ;
            {
              DATASYM32 *p = align_copy ;
              NEWTYPE(p->typind) ;
              GlobalAddress(mod,&p->off, &p->seg) ;
              memcpy(global_copy,align_copy,(*(bit_16_ptr)symptr) + 2) ;
            }
            break ;
           When S_END:
            blocklevel-- ;
            memcpy(global_copy,symptr,(*(bit_16_ptr)symptr) + 2) ;
            break ;
           When S_ENDARG:
            memcpy(global_copy,symptr,(*(bit_16_ptr)symptr) + 2) ;
            break ;
           When S_LPROC32:
            copy_to_global = False ;
            If nextptr_align IsNotNull
             Then
              *nextptr_align = align_len;
              nextptr_align = Null ;
             EndIf
            {
              PROCSYM32 *p = align_copy ;
              NEWTYPE(p->typind) ;
              GlobalAddress(mod,&p->off, &p->seg) ;
              p->pEnd += align_base ;
              p->pNext = 0;
              nextptr_align = align_ptr + align_len + ((byte_ptr)&p->pNext - (byte_ptr)p) ;
              If search_ptr_align IsNotNull
               Then
                search_ptr_align->startsym = align_len ;
                search_ptr_align->seg = p->seg ;
                search_ptr_align = NULL ;
               EndIf
            }
            blocklevel++ ;
            break ;
           When S_GPROC32:
            copy_to_global = True ;
            If nextptr_align IsNotNull
             Then
              *nextptr_align = align_len;
              nextptr_align = Null ;
             EndIf
            If nextptr_global IsNotNull
             Then     
              *nextptr_global = global_len ;
              nextptr_global = Null ;
             EndIf
            {
              PROCSYM32 *p = align_copy ;
              NEWTYPE(p->typind) ;
              GlobalAddress(mod, &p->off, &p->seg) ;
              p->pEnd += align_base ;
              p->pNext = 0;
              nextptr_align = align_ptr + align_len + ((byte_ptr)&p->pNext - (byte_ptr)p);
              If search_ptr_align IsNotNull
               Then
                search_ptr_align->startsym = align_len ;
                search_ptr_align->seg = p->seg ;
                search_ptr_align = NULL ;
               EndIf
              memcpy(global_copy,symptr,(*(bit_16_ptr)symptr) + 2) ;
              p = global_copy ;
              NEWTYPE(p->typind) ;
              GlobalAddress(mod, &p->off, &p->seg) ;
              p->pEnd += global_len - align_len + global_base ;
              p->pNext = 0;
              nextptr_global = global_ptr + global_len + ((byte_ptr)&p->pNext - (byte_ptr)p);
              If search_ptr_global IsNotNull
               Then
                search_ptr_global->startsym = global_len ;
                search_ptr_global->seg = p->seg ;
                search_ptr_global = NULL ;