yank.c

gdb是linux下的一个远程调试环境.能让你很方便地调试linux下的代码.

   char *filename;
   int   quietmode;
   INT32	sym;
   INT32	Section;
   INT32	mspace;
   {
   unsigned short  COFF_sections;
   INT32  flags;
   INT32  memory_space;
   INT32  address;
   INT32  byte_count;
   INT32  temp_byte_count;
   INT32	bytes_ret;

   struct  filehdr      COFF_header;
   struct  aouthdr      COFF_aout_header;
   struct  scnhdr      COFF_section_header;

    if (!quietmode) {
       fprintf(stderr, "loading %s\n", filename);
       if (io_config.echo_mode == (INT32) TRUE)
          fprintf(io_config.echo_file, "loading %s\n", filename);
    }

   /* Open the COFF input file (if we can) */
   if ((coff_in = fopen(filename, FILE_OPEN_FLAG)) == NULL) {
      warning (EMOPEN); return(FAILURE);
   };

   /* Read in COFF header information */
   if (fread((char *)&COFF_header, sizeof(struct filehdr), 1, coff_in) != 1) {
      fclose(coff_in); warning(EMHDR); return (FAILURE);
   };


   /* Is it an Am29000 COFF File? */
   if ((COFF_header.f_magic != 0x17a) && (COFF_header.f_magic != 0x7a01) &&
       (COFF_header.f_magic != 0x17b) && (COFF_header.f_magic != 0x7b01)) {
      fclose(coff_in); warning (EMMAGIC); return (FAILURE);
   }

   /* Get number of COFF sections */
   if ((COFF_header.f_magic != 0x17a) && (COFF_header.f_magic != 0x017b))
      convert16((BYTE *) &COFF_header.f_nscns);
   COFF_sections = (unsigned short) COFF_header.f_nscns;

   /* Read in COFF a.out header information (if we can) */
   if (COFF_header.f_opthdr > 0) {
      if (fread((char *)&COFF_aout_header, sizeof(struct aouthdr), 
						   1, coff_in) != 1) {
         fclose(coff_in); warning (EMAOUT); return (FAILURE);
      };
      /* Set entry point in INIT message */
      init_info.entry_point = COFF_aout_header.entry;
      if ((COFF_header.f_magic != 0x17a) && (COFF_header.f_magic != 0x017b)) {
         convert16((BYTE *) &COFF_header.f_opthdr);
         convert32((BYTE *) &init_info.entry_point);
      }
   }


   /*
   ** Process COFF section headers
   */

   /* Process all sections */
   while ((int) COFF_sections--) {

      fseek (coff_in, (long) (FILHSZ+(int)COFF_header.f_opthdr+
			      SCNHSZ*(COFF_header.f_nscns-COFF_sections-1)), 
			      FROM_BEGINNING);

      if (fread(&COFF_section_header, 1, SCNHSZ, coff_in) != SCNHSZ) {
          fclose(coff_in); warning (EMSCNHDR); return (FAILURE);
      }

      if ((COFF_header.f_magic != 0x17a) && (COFF_header.f_magic != 0x017b)) {
         convert32((BYTE *) &(COFF_section_header.s_paddr));
         convert32((BYTE *) &(COFF_section_header.s_scnptr));
         convert32((BYTE *) &(COFF_section_header.s_size));
         convert32((BYTE *) &(COFF_section_header.s_flags));
       }

      address = COFF_section_header.s_paddr;
      byte_count = COFF_section_header.s_size;
      flags = COFF_section_header.s_flags;

      /* Print downloading messages (if necessary) */
      if ((flags == (INT32) STYP_TEXT) || (flags == (INT32) (STYP_TEXT | STYP_ABS))) {
	 memory_space = I_MEM;
         init_info.text_start = MIN((ADDR32) address,
				    (ADDR32) init_info.text_start);
         init_info.text_end = MAX((ADDR32) (address + byte_count), 
				  (ADDR32) init_info.text_end);
      } else if ((flags == (INT32) STYP_DATA) || (flags == (INT32) (STYP_DATA | STYP_ABS)) ||
          (flags == (INT32) STYP_LIT) || (flags == (INT32) (STYP_LIT | STYP_ABS)) ||
          (flags == (INT32) STYP_BSS) || (flags == (INT32) (STYP_BSS | STYP_ABS))) {
	 memory_space = D_MEM;
         init_info.data_start = MIN((ADDR32) address,
				    (ADDR32) init_info.data_start);
         init_info.data_end = MAX((ADDR32) (address + byte_count),
				  (ADDR32)  init_info.data_end);
      } else {
	 print_ign_msg(quietmode, address, byte_count);
	 flags = (INT32) 0;
      }

      if ((flags == (INT32) STYP_BSS) || (flags == (INT32) (STYP_BSS | STYP_ABS))) {
      /* Clear BSS section */
   	if (flags & Section) {
           print_ld_msg(flags,quietmode,address,byte_count);
           if (Mini_fill ((INT32)  D_MEM,
                           (ADDR32) address,
                           (INT32)  (byte_count+3)/4,
			   4 /* fill zeroes */,
			   "\0\0\0") != SUCCESS)  {
	           (void) fclose(coff_in); warning(EMFILL); return(FAILURE);
	    };
           print_end_msg(flags,quietmode,address,byte_count);
	 }
      } else if (flags & Section) { /* not a BSS or COmment */
	 if (flags == (INT32) (flags & Section)) {
	   fseek (coff_in, COFF_section_header.s_scnptr, FROM_BEGINNING);
           while (byte_count > 0) {
             temp_byte_count = MIN((INT32) byte_count, (INT32) sizeof(buffer));
             if (fread((char *) buffer, (int) temp_byte_count, 1, coff_in) != 1) {
                fclose(coff_in); warning (EMSCN); return (FAILURE);
	     };
	     print_ld_msg(flags, quietmode,address, temp_byte_count);
             /* Write to 29K memory*/
	     if (Mini_write_req ((INT32)  memory_space,
                            (ADDR32) address,
                            (INT32)  (temp_byte_count+3)/4,
			    (INT16) 4, /* size */
			    &bytes_ret,
                            (BYTE *) buffer,
			    (INT32) FALSE) != SUCCESS) {
	            warning(EMWRITE); 
		    return(FAILURE);
	     }
             address = address + temp_byte_count;
             byte_count = byte_count - temp_byte_count;
           };
	   print_end_msg(flags, quietmode, COFF_section_header.s_paddr,
					 COFF_section_header.s_size);
	 };
      }
   }  /* end while */

   (void) fclose(coff_in);
   return (SUCCESS);

   }   /* end Mini_loadcoff() */


int
SetSections(string)
char	*string;
{
  int	i;

  if (string[0] != '-')
    return (-1);  /* not section options */

  Sections = STYP_ABS;
  for (i=1; string[i] != '\0'; i++) {
     switch (string[i]) {
       case	't':
       case	'T':
	 Sections = Sections | STYP_TEXT;
	 break;
       case	'd':
       case	'D':
	 Sections = Sections | STYP_DATA;
	 break;
       case	'b':
       case	'B':
	 Sections = Sections | STYP_BSS;
	 break;
       case	'l':
       case	'L':
	 Sections = Sections | STYP_LIT;
	 break;
       default:
         return (EMSYNTAX);
     }
  }
  return (0);
}

void
print_ld_msg(flags, mode, address, byte_count)
INT32	flags;
int	mode;
ADDR32	address;
INT32	byte_count;
{
   if (!mode) {
     if (flags & (INT32) STYP_BSS)
       fprintf(stderr, "Clearing ");
     else
       fprintf(stderr, "Loading ");

     if ((flags == (INT32) STYP_TEXT) || (flags == (INT32) (STYP_TEXT|STYP_ABS)))
       fprintf(stderr, "TEXT ");
     else if (flags & (INT32) STYP_DATA)
       fprintf(stderr, "DATA ");
     else if (flags & (INT32) STYP_LIT)
       fprintf(stderr, "LIT ");
     else if (flags & (INT32) STYP_BSS)
       fprintf(stderr, "BSS ");
     fprintf(stderr, "section from 0x%08lx to 0x%08lx\r", 
	       address, (ADDR32) (address+byte_count));
   }
}

void
print_ign_msg(mode, address, byte_count)
int	mode;
ADDR32	address;
INT32	byte_count;
{
  if (!mode) 
    fprintf(stderr, "Ignoring COMMENT section (%ld bytes) ...\n", byte_count);
}

void
print_end_msg(flags, mode,address,size)
INT32	flags;
int	mode;
ADDR32	address;
INT32	size;
{
   if (!mode) {
     if (flags & (INT32) STYP_BSS)
       fprintf(stderr, "Cleared  ");
     else
       fprintf(stderr, "Loaded  ");
     if (io_config.echo_mode == (INT32) TRUE) {
       if (flags & (INT32) STYP_BSS)
         fprintf(io_config.echo_file, "Cleared  ");
       else
         fprintf(io_config.echo_file, "Loaded  ");
     }

     if ((flags == (INT32) STYP_TEXT) || 
		     (flags == (INT32) (STYP_TEXT|STYP_ABS)))
       fprintf(stderr, "TEXT ");
     else if (flags & (INT32) STYP_DATA)
       fprintf(stderr, "DATA ");
     else if (flags & (INT32) STYP_LIT)
       fprintf(stderr, "LIT ");
     else if (flags & (INT32) STYP_BSS)
       fprintf(stderr, "BSS ");

     fprintf(stderr, "section from 0x%08lx to 0x%08lx\n", 
	       address, (ADDR32) (address+size));
     if (io_config.echo_mode == (INT32) TRUE) {
       if ((flags == (INT32) STYP_TEXT) || 
		     (flags == (INT32) (STYP_TEXT|STYP_ABS)))
         fprintf(io_config.echo_file, "TEXT ");
       else if (flags & (INT32) STYP_DATA)
         fprintf(io_config.echo_file, "DATA ");
       else if (flags & (INT32) STYP_LIT)
         fprintf(io_config.echo_file, "LIT ");
       else if (flags & (INT32) STYP_BSS)
         fprintf(io_config.echo_file, "BSS ");
  
       fprintf(io_config.echo_file, "section from 0x%08lx to 0x%08lx\n", 
	         address, (ADDR32) (address+size));
     }
   }
}