symfile.c

一个用在mips体系结构中的操作系统

         FillIn(sym, exec, frd.isymBase, filenum);

         if (frd.lang == langAssembler) {
            /* the structure of assembly files is all screwed up */
            flags |= SYM_RECURSE;
         }
         
         if (SymFind(sym, symname, flags) == SYM_OK) {
            return SYM_OK;
         }
         
         pfdPtr++;
         CopyFDR(pfdPtr,&frd);
         filenum++;
         
      } while (frd.fMerge);
   }

   /* search globals */
   if (flags & SYM_TAGS) {
      if (AssocTabLookup(exec->gStructs, symname, (ATHeader**)&global) != AT_OK) {
         SymReportError("couldn't find symbol \"", symname, "\"", NULL);
         return SYM_ERROR;
      }
      
      FillIn(sym, exec, global->isym, global->filenum);

   } else {
      if (AssocTabLookup(exec->globals, symname, (ATHeader**)&global) != AT_OK) {
         SymReportError("couldn't find symbol \"", symname, "\"", NULL);
         return SYM_ERROR;
      }
      
      FillIn(sym, exec, global->isym, -1);
   }
   
   return SYM_OK;
}


/*
 *   SymFind
 */

int SymFind(Symb *sym, char *name, int flags)
{
#ifdef DWARF2
   ASSERT (sym->index == DWARF_INDEX);
   if( sym->index == DWARF_INDEX ) {
       /* hack to indicate must be dwarf stuff */
       return Dwarf_SymFind(sym, name, flags);
   }
#endif

   if (SymIn(sym) != SYM_OK) {
      ASSERT(0);
      return SYM_ERROR;
   }
   
   while (sym->type[sym->nextt] != tEnd) {

      if (!strcmp(sym->name, name)) {

         if ((sym->type[sym->nextt] == tStructDef)
             || (sym->type[sym->nextt] == tUnionDef)
             || (sym->type[sym->nextt] == tEnumDef)) {

            if (flags & SYM_TAGS) {
               return SYM_OK;
            }
            
         } else if (!(flags & SYM_TAGS)) {
            return SYM_OK;
         }
      }

      /* we effectively ignore blocks */
      if ((sym->type[sym->nextt] == tBlock)
          || ((flags & SYM_RECURSE) && (sym->type[sym->nextt] == tProc))) {
         Symb in = *sym;

         if (SymFind(&in, name, flags) == SYM_OK) {
            *sym = in;
            return SYM_OK;
         }
      }
      
      if (SymNext(sym) != SYM_OK) {
         ASSERT(0);
         return SYM_ERROR;
      }
   }   

   SymReportError("couldn't find symbol \"", name, "\"", NULL);
   return SYM_ERROR;
}


/*
 *   SymNext
 */

int SymNext(Symb *sym)
{
   Execfile *exec = sym->exec;
   pFDR pfdPtr;
   FDR fdr;
   int isym = sym->isym;
   
#ifdef DWARF2
   ASSERT (sym->index == DWARF_INDEX);
   if( sym->index == DWARF_INDEX ) {
       /* hack to indicate must be dwarf stuff */
       return Dwarf_SymNext(sym);
   }
#endif

   pfdPtr = &(exec->pfds[sym->filenum]);
   CopyFDR(pfdPtr,&fdr);
   if (sym->type[sym->nextt] == tEnd) {
      SymReportError("internal error, next over end", NULL);
      return SYM_ERROR;
   }

   if (sym->global) {
      isym++;
      
   } else if (sym->type[sym->nextt] == tFile) {
      ASSERT(0);
      
   } else if (sym->type[sym->nextt] == tProc) {
      isym = fdr.isymBase + BE2HO_4(exec->aux[sym->index + fdr.iauxBase].isym);
      
   } else if ((sym->type[sym->nextt] == tStructDef)
              || (sym->type[sym->nextt] == tUnionDef)
              || (sym->type[sym->nextt] == tEnumDef)
              || (sym->type[sym->nextt] == tBlock)) {
      isym = fdr.isymBase + sym->index;
      
   } else {
      isym++;
   }

   FillIn(sym, exec, isym, (sym->global) ? -1 : sym->filenum);
   return SYM_OK;
}

/*
 *   SymIn
 */

int SymIn(Symb *sym)
{
   Execfile *exec = sym->exec;
   pFDR pfdPtr;
   int isym = sym->isym;

#ifdef DWARF2
   ASSERT (sym->index == DWARF_INDEX);
   if( sym->index == DWARF_INDEX ) {
       /* hack to indicate must be dwarf stuff */
       return Dwarf_SymIn(sym);
   }
#endif

   pfdPtr = &(exec->pfds[sym->filenum]);
   
   if (!SymIsHier(sym)) {
      SymReportError("internal error, in into non-hier", NULL);
      return SYM_ERROR;
   }

   if ((sym->type[sym->nextt] == tProc) && (sym->global)) {
      pSYMR symrPtr = &exec->extrs[sym->isym].asym;
      SYMR symr;
      CopySYMR(symrPtr,&symr);
      isym = BE2HO_4(pfdPtr->isymBase) + symr.index;
   } else {
      ASSERT(!sym->global);
   }
   
   isym++;

   FillIn(sym, exec, isym, sym->filenum);
   return SYM_OK;
}


/*
 *   SymSubType
 */

int SymSubtype(Symb *sym, int flags)
{
   Execfile *exec = sym->exec;
   int filenum;
   int st;
   int code;
   
#ifdef DWARF2
   ASSERT (sym->index == DWARF_INDEX);
   if( sym->index == DWARF_INDEX ) {
       /* hack to indicate must be dwarf stuff */
       return Dwarf_SymSubtype(sym, flags);
   }
#endif

  if (SymIsBasicType(sym)) {
      SymReportError("internal error, subtype of basic", NULL);
      return SYM_ERROR;

   } else if ((sym->type[sym->nextt] == tPtr) || (sym->type[sym->nextt] == tArray)) {
      sym->nextt++;
      ASSERT(SymIsVarType(sym));
      
   } else  {

      st = sym->type[sym->nextt];
      
      ASSERT((st == tStruct) || (st == tUnion) || (st == tEnum)
             || (st == tTypedef) || (st == tIndirect));
   
      if (sym->rndx.rfd == 4095) {
         int x = BE2HO_4(exec->pfds[sym->filenum].rfdBase);
         filenum = BE2HO_4(exec->fit[x + sym->fip]);
      } else {
         filenum = sym->rndx.rfd;
      }
      
      FillIn(sym, exec, sym->rndx.index 
             + BE2HO_4(exec->pfds[filenum].isymBase), filenum);

      /* ugliness to skip indirects */
      if (sym->type[sym->nextt] == tIndirect) {
         if (sym->rndx.index == 0) {
            SymReportError("definition not found in source file", NULL);
            return SYM_ERROR;
         }
         code = SymSubtype(sym, 0);
         ASSERT(code == SYM_OK);
      }
         
      if (st == tStruct) {
         ASSERT(sym->type[sym->nextt] == tStructDef);
         
      } else if (st == tUnion) {
         ASSERT(sym->type[sym->nextt] == tUnionDef);
         
      } else if (st == tEnum) {
         ASSERT(sym->type[sym->nextt] == tEnumDef);
         
      } else if (st == tTypedef) {
         ASSERT(sym->type[sym->nextt] == tTypedefDef);
         sym->nextt++;
         ASSERT(SymIsVarType(sym));

         if (flags & SYM_RESOLVE) {
            return SymSubtype(sym, flags);
         }

      } else if (st == tIndirect) {
         ASSERT((sym->type[sym->nextt] == tStructDef)
                || (sym->type[sym->nextt] == tUnionDef));

      } else {
         ASSERT(0);
      }
   }

   return SYM_OK;
}


/*
 *   SymType
 */

int SymType(Symb *sym, int flags)
{
   Symb tmp;
   
#ifdef DWARF2
   ASSERT (sym->index == DWARF_INDEX);
   if( sym->index == DWARF_INDEX ) {
      /* hack to indicate must be dwarf stuff */
      return Dwarf_SymType(sym, flags);
   }
#endif

   if ((sym->type[(sym)->nextt] != tTypedef) || !(flags & SYM_RESOLVE)) {
      return sym->type[(sym)->nextt];
   }

   tmp = *sym;
   SymSubtype(&tmp, 0);
   return SymType(&tmp, flags);
}


/*
 *   SymSize
 */

Reg_s SymSize(Symb *sym)
{
#ifdef DWARF2
   ASSERT (sym->index == DWARF_INDEX);
   if( sym->index == DWARF_INDEX ) {
       /* hack to indicate must be dwarf stuff */
       return Dwarf_SymSize(sym);
   }
#endif

   switch (SymType(sym, SYM_RESOLVE)) {
   case tChar:
   case tUChar:
      return 1;
   case tShort:
   case tUShort:
      return 2;
   case tInt:
   case tUInt:
   case tLong:
   case tULong:
   case tPtr:
      return 4;
   case tFloat:
      return sizeof(float);
   case tDouble:
      return sizeof(double);
   case tLabel:
   case tAddr:
      return 4;
   case tProc: {
      pFDR pfd = &sym->exec->pfds[sym->filenum];
      int isym = BE2HO_4(sym->exec->aux[sym->index + BE2HO_4(pfd->iauxBase)].isym) + 
         BE2HO_4(pfd->isymBase) - 1;
      return BE2HO_4(sym->exec->syms[isym].value);
   }
   case tArray:
      /* XXX fix */
      return 4;
   case tStruct:
   case tUnion:
   case tEnum: {
      Symb tmp = *sym;
      if (SymSubtype(&tmp, SYM_RESOLVE) != SYM_OK) {
         ASSERT(0);
      }
      return tmp.value;
   }
   case tStructDef:
   case tUnionDef:
   case tEnumDef:
      return sym->value;
   default:
      ASSERT(0);
      break;
   }

   /* never reached - for compiler */
   ASSERT(0);
   return 0;
}


/*
 *   SymMakeAddr
 *
 *     This is not an rpc because we have all the info
 *     we need locally.
 */

int SymMakeAddr(Symb *sym)
{
#ifdef DWARF2
   ASSERT (sym->index == DWARF_INDEX);
   if( sym->index == DWARF_INDEX ) {
       /* hack to indicate must be dwarf stuff */
       return Dwarf_SymMakeAddr(sym);
   }
#endif
   ASSERT(sym->nextt > 0);
   sym->nextt--;
   sym->type[sym->nextt] = tAddr;

   return SYM_OK;
}


static void CopySYMR(pSYMR mapped,pSYMR copy)
{
   int i;
   char * mptr = (char*)mapped;
   char * cptr = (char*)copy;
   for (i=0;i<sizeof(SYMR);i+=4) {
      uint *mp = (uint*)(mptr+i);
      uint *cp = (uint*)(cptr+i);
      *cp = BE2HO_4(*mp);
   }
}

static void CopyFDR(pFDR mapped,pFDR copy)
{
   int i;
   char * mptr = (char*)mapped;
   char * cptr = (char*)copy;
   for (i=0;i<sizeof(FDR);i+=4) {
      uint *mp = (uint*)(mptr+i);
      uint *cp = (uint*)(cptr+i);
      *cp = BE2HO_4(*mp);
   }
   copy->ipdFirst = BE2HO_2(mapped->ipdFirst);
   copy->cpd      = BE2HO_2(mapped->cpd);
}

static void CopyTIR(pTIR mapped,pTIR copy)
{
   int i;
   char * mptr = (char*)mapped;
   char * cptr = (char*)copy;
   for (i=0;i<sizeof(TIR);i+=4) {
      uint *mp = (uint*)(mptr+i);
      uint *cp = (uint*)(cptr+i);
      *cp = BE2HO_4(*mp);
   }
}


static void CopyRNDXR(pRNDXR mapped, pRNDXR copy)
{
   int i;
   char * mptr = (char*)mapped;
   char * cptr = (char*)copy;
   for (i=0;i<sizeof(RNDXR);i+=4) {
      uint *mp = (uint*)(mptr+i);
      uint *cp = (uint*)(cptr+i);
      *cp = BE2HO_4(*mp);
   }
}