symfile.c

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

#ifdef DWARF2
   ASSERT (0);
#endif
#ifdef DWARF2
   if( exec->fileStart == 0 ) {
       /* hack to indicate must be dwarf stuff */
       return Dwarf_SymLine2Addr(execname, srcfile, line, sym);
   }
#endif

   if (AssocTabLookup(exec->srcs, StripPath(srcfile), (ATHeader**)&src) != AT_OK) {
      SymReportError("no source file named \"", srcfile, "\"", NULL);
      return SYM_ERROR;
   }
   
   base = exec->fileStart + 
      BE2HO_4(exec->symHdr->cbLineOffset) + 
      src->pfd.cbLineOffset;
   pdr = (pPDR)(exec->fileStart + BE2HO_4(exec->symHdr->cbPdOffset)) + 
      src->pfd.ipdFirst;

   bestaddr = src->pfd.adr;
   
   for (p=0; p<src->pfd.cpd; p++, pdr++) {
      char *ptr, *end;
      int curline, curaddr, delta, num;

      if (line < BE2HO_4(pdr->lnLow)) {
         bestaddr = BE2HO_4(pdr->adr) + src->pfd.adr;
         break;
      } else if (line > BE2HO_4(pdr->lnHigh)) {
         if ((p+1) < src->pfd.cpd) {
            continue;
         } else {
            /* what do I do here? */
            line = BE2HO_4(pdr->lnHigh);
         }
      }
      
      curline = BE2HO_4(pdr->lnLow);
      curaddr = BE2HO_4(pdr->adr) +src->pfd.adr;
      
      ptr = base + BE2HO_4(pdr->cbLineOffset);

      if ((p+1) < src->pfd.cpd) {
         end = base + BE2HO_4(pdr[1].cbLineOffset);
      } else {
         end = base + src->pfd.cbLine;
      }
      
      while (ptr < end) {
         num = (*ptr & 0x0F) + 1;
         delta = *ptr >> 4;
         
         ptr++;
         
         if (delta >= 8) {
            delta -= 16;
         }
         
         if (delta == -8) {
            delta = (ptr[0] << 8) | ptr[1];
            if (delta >= 0x8000) {
               delta -= 0x10000;
            }
            ptr += 2;
         }
         
         curline += delta;

         if (curline < line) {
            bestaddr = curaddr + 4 * num;
         }

         curaddr += 4 * num;
      }

      break;
   }

   sym->global = 0;
   sym->isym = -1;
   sym->filenum = src->num;
   sym->name = NULL;
   sym->index = -1;
   sym->exec = exec;
   
   sym->type[1] = tAddr;
   sym->type[2] = tNil;
   sym->nextt = 1;
   
   sym->value = bestaddr;
   
   return SYM_OK;
}


/*
 *   SymTypeCast
 */

int SymTypeCast(char *execname, char *srcfile, int *types, char *name, Symb *sym)
{
   Symb tmp;
   int *tp;
   
#ifdef DWARF2
   Execfile *exec = NULL;

   ASSERT (exectab);

   if (!exectab) {
      exectab = AssocTabCreate();
   }

   if (AssocTabLookup(exectab, execname, (ATHeader**)&exec) != AT_OK) {
      SymReportError("no exec named \"", execname, "\"", NULL);
      return SYM_ERROR;
   }

   ASSERT (exec->fileStart==0);
   if( exec->fileStart == 0 ) {
       /* hack to indicate must be dwarf stuff */
       return Dwarf_SymTypeCast(execname, srcfile, types, name, sym);
   }
#endif

   sym->global = 0;
   sym->isym = -1;
   sym->filenum = -1;
   sym->name = NULL;
   sym->index = -1;
   sym->exec = NULL;

   sym->nextt = 1;
   tp = types;

   while (*tp != tNil) {
      sym->type[sym->nextt++] = *tp;
      tp++;
   }
   
   ASSERT(sym->nextt<MAX_TYPES);
   sym->type[sym->nextt] = tNil;

   if (name[0]) {

      sym->nextt--; /* OK because we are going to reset it anyway */

      if ((sym->type[sym->nextt] == tStruct)
          || (sym->type[sym->nextt] == tUnion)
          || (sym->type[sym->nextt] == tEnum)) {
         if (SymLookup(execname, srcfile, name, SYM_TAGS, &tmp) != SYM_OK) {
            return SYM_ERROR;
         }

      } else if (sym->type[sym->nextt] == tTypedef) {
         if (SymLookup(execname, srcfile, name, 0, &tmp) != SYM_OK) {
            return SYM_ERROR;
         }

      } else {
         ASSERT(0);
      }
      
      sym->exec = tmp.exec;
      sym->filenum = tmp.filenum;
      sym->rndx.rfd = tmp.filenum;
      sym->rndx.index = tmp.isym - BE2HO_4(tmp.exec->pfds[tmp.filenum].isymBase);
   }
   
   sym->nextt = 1;
   sym->value = 0;
   
   return SYM_OK;
}


/*
 *   FillIn
 *
 *     private function which fills in the fields of a symbol
 */

void FillIn(Symb *sym, Execfile *exec, int isym, int filenum)
{
   pFDR pfdPtr;
   FDR  frd;
   SYMR symr;
   uint index;
   if (filenum == -1) {
      sym->global = 1;
      sym->isym = isym;
      sym->filenum = BE2HO_2(exec->extrs[isym].ifd);
      sym->name = exec->fileStart + 
         BE2HO_4(exec->symHdr->cbSsExtOffset)
         + BE2HO_4(exec->extrs[isym].asym.iss);
      CopySYMR(&exec->extrs[isym].asym,&symr);
      
   } else {
      sym->global = 0;
      sym->isym = isym;
      sym->filenum = filenum;
      sym->name = exec->fileStart + 
         BE2HO_4(exec->symHdr->cbSsOffset)
         + BE2HO_4(exec->pfds[filenum].issBase) 
         + BE2HO_4(exec->syms[isym].iss);
      CopySYMR(&exec->syms[isym],&symr);
   }
   ASSERT( isym != 918659);


   pfdPtr = &(exec->pfds[sym->filenum]);
   CopyFDR(pfdPtr,&frd);

#ifdef notdef
   SIM_DEBUG(('t', "filling in symbol %s file %d isym %d global %d\n\r",
              sym->name, sym->filenum, sym->isym, sym->global));
   SIM_DEBUG(('t', "     file %s auxs %d\n\r", exec->fileStart
              + frd.issBase + exec->symHdr->cbSsOffset + frd.rss,
              frd.iauxBase));
#endif
   
   sym->exec = exec;
   sym->nextt = 1;
   sym->index = symr.index;
   ASSERT( sym->index != 0x18200000);

   index = sym->index  + frd.iauxBase;
   switch (symr.st) {
   case stProc:
   case stStaticProc: {
      sym->type[sym->nextt++] = tProc;
      if (sym->global) {
         pSYMR symrPtr = &exec->syms[symr.index + frd.isymBase];
         SYMR symr2;
         CopySYMR(symrPtr,&symr2);
         sym->index = symr2.index;
         ASSERT(  sym->index != 0x18200000);
      }
      if (sym->index != indexNil) {
         FillInBasicType(sym,sym->index + frd.iauxBase + 1, &symr);
      }
      break;
   }
   case stGlobal:
   case stStatic:
   case stMember: {
      if (sym->index != indexNil) {
         FillInBasicType(sym, index, &symr);
      }
      break;
   }
   case stTypedef: {
      sym->type[sym->nextt++] = tTypedefDef;
      if (sym->index != indexNil) {
         FillInBasicType(sym, index, &symr);
      }
      break;
   }
   case stIndirect: {
      pRNDXR x = &sym->exec->aux[index + 1].rndx;
      CopyRNDXR(x,&sym->rndx);
      sym->type[sym->nextt++] = tIndirect;
      sym->fip = BE2HO_4(sym->exec->aux[index + 2].isym);
   }
   case stLabel: {
      sym->type[sym->nextt++] = tLabel;
      break;
   }
   case stStruct: {
      sym->type[sym->nextt++] = tStructDef;
      break;
   }
   case stUnion: {
      sym->type[sym->nextt++] = tUnionDef;
      break;
   }
   case stEnum: {
      sym->type[sym->nextt++] = tEnumDef;
      break;
   }
   case stFile: {
      sym->type[sym->nextt++] = tFile;
      break;
   }
   case stEnd: {
      sym->type[sym->nextt++] = tEnd;
      break;
   }
   case stBlock: {
      sym->type[sym->nextt++] = tBlock;
      break;
   }
   case stRegReloc:
   case stParam:
   case stLocal:
   case stNil:
   default:
      break;
   }

   ASSERT(sym->nextt<MAX_TYPES);
   sym->type[sym->nextt] = tNil;
   sym->nextt = 1;
   sym->value = symr.value;
}

/* *********************************************
 * psym is a copy passed in the host order!!!
 * *********************************************/

void FillInBasicType(Symb *sym, int index, pSYMR psym)
{
   pTIR tirPtr;
   TIR tirCpy;

   int tq, i;
   uint sc =psym->sc;
   
   if (index == -1) {
      sym->type[sym->nextt++] = tNil;
      return;
   }
   
   if (sc == scAbs) {
      SIM_DEBUG(('t', "skipping symbol %s st %d sc %d\n\r", sym->name, psym->st, 
                 psym->sc));
      return;
   }

   if ((sc != scNil) && (sc != scText)
       && (sc != scBss) && (sc != scSBss)
       && (sc != scSData) && (sc != scInfo)
       && (sc != scData)) {
      printf("symbol %s st %d sc %d\n\r", sym->name, psym->st, sc);
      ASSERT(0);
   }
   
   tirPtr = &(sym->exec->aux[index].ti);
   CopyTIR(tirPtr,&tirCpy);
   ASSERT(!tirCpy.continued);
   ASSERT(!tirCpy.fBitfield);

   for (i=5; i>=0; i--) {
      switch (i) {
      case 0:
         tq = tirCpy.tq0;
         break;
      case 1:
         tq = tirCpy.tq1;
         break;
      case 2:
         tq = tirCpy.tq2;
         break;
      case 3:
         tq = tirCpy.tq3;
         break;
      case 4:
         tq = tirCpy.tq4;
         break;
      case 5:
         tq = tirCpy.tq5;
         break;
      default:
         ASSERT(0);
         tq = -1;
      }

      if (tq == tqNil) {
      } else if (tq == tqPtr) {
         sym->type[sym->nextt++] = tPtr;
      } else if (tq == tqArray) {
         sym->type[sym->nextt++] = tArray;
      } else if (tq == tqProc) {
         sym->type[sym->nextt++] = tPtr;
      } else if ((tq == tqVol) || (tq == tqConst)) {
         /* ignore */
      } else {
         ASSERT(0);
      }
   }

   if ((tirCpy.bt == btStruct)
       || (tirCpy.bt == btUnion)
       || (tirCpy.bt == btEnum)
       || (tirCpy.bt == btTypedef)) {
      pRNDXR x =&sym->exec->aux[index+1].rndx; 
      CopyRNDXR(x,&sym->rndx);
      sym->fip = BE2HO_4(sym->exec->aux[index+2].isym);
   }
   
   if ((tirCpy.bt >= btChar) && (tirCpy.bt <= btTypedef)) {
      sym->type[sym->nextt++] = (tirCpy.bt - btChar) + tChar;
   } else {
      sym->type[sym->nextt++] = tNil;
   }
}


/*
 *   SymLookup
 */

int SymLookup(char *execname, char *srcfile, char *symname, int flags, Symb *sym)
{
   Execfile *exec = NULL;
   Srcfile *src = NULL;
   Global *global = NULL;
   pFDR pfdPtr;
   FDR frd;
   int filenum;
   
   if (!exectab) {
      exectab = AssocTabCreate();
   }

   if (AssocTabLookup(exectab, execname, (ATHeader**)&exec) != AT_OK) {
      SymReportError("no exec named \"", execname, "\"", NULL);
      return SYM_ERROR;
   }

#ifdef DWARF2
   ASSERT (0);
#endif
#ifdef DWARF2
   if( exec->fileStart == 0 ) {
       /* hack to indicate must be dwarf stuff */
       return Dwarf_SymLookup(execname, srcfile, symname, flags, sym);
   }
#endif

   if (srcfile[0]) {
      if (AssocTabLookup(exec->srcs, StripPath(srcfile),
                         (ATHeader**)&src) != AT_OK) {
         SymReportError("no source file named \"", srcfile, "\"", NULL);
         return SYM_ERROR;
      }

      filenum = src->num;
      pfdPtr = src->pfdPtr;
      CopyFDR(pfdPtr,&frd);
      do {