URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [utils/] [amd-udi/] [montip/] [mtip.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


static char _[] = "@(#)mtip.c   2.14 92/01/13 18:04:36, AMD.";
/******************************************************************************
 * Copyright 1991 Advanced Micro Devices, Inc.
 *
 * This software is the property of Advanced Micro Devices, Inc  (AMD)  which
 * specifically  grants the user the right to modify, use and distribute this
 * software provided this notice is not removed or altered.  All other rights
 * are reserved by AMD.
 *
 * AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
 * SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
 * DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
 * USE OF THIS SOFTWARE.
 *
 * So that all may benefit from your experience, please report  any  problems
 * or  suggestions about this software to the 29K Technical Support Center at
 * 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131  in  the  UK,  or
 * 0031-11-1129 in Japan, toll free.  The direct dial number is 512-462-4118.
 *
 * Advanced Micro Devices, Inc.
 * 29K Support Products
 * Mail Stop 573
 * 5900 E. Ben White Blvd.
 * Austin, TX 78741
 * 800-292-9263
 *****************************************************************************
 *      Engineers: MINIMON DEVELOPMENT TEAM MEMBERS, AMD.
 */
 
#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include "messages.h"
#include "coff.h"
#include "memspcs.h"
#include "mtip.h"
#include "macros.h"
 
/* TIP Breakpoint table */
typedef unsigned int    BreakIdType;
 
static struct break_table {
  BreakIdType           id;
  INT32         space;
  ADDR32        offset;
  INT32         count;
  INT32         type;
  ADDR32        BreakInst;      /* actual instruction */
  struct break_table *next;
};
 
struct break_table  *bp_table=NULL;
 
#define BUFFER_SIZE     1024
 
static BYTE     buffer[BUFFER_SIZE];
 
int     Mini_core_load PARAMS((char *corefile, INT32 space,
                               INT32 sects, int syms));
void    add_to_bp_table PARAMS((BreakIdType *id, INT32 space,
                        ADDR32 offset, INT32 count, INT32 type, ADDR32 inst));
int     get_from_bp_table PARAMS((BreakIdType id, INT32 *space,
                                 ADDR32 *offset, INT32 *count,
                                 INT32 *type, ADDR32 *inst));
int     remove_from_bp_table PARAMS((BreakIdType id));
int     is_breakpt_at PARAMS((INT32 space, ADDR32 offset));
 
/*
** Breakpoint code
*/
 
void
add_to_bp_table(id, space, offset, count, type, inst)
BreakIdType     *id;
INT32   space;
ADDR32  offset;
INT32   count;
INT32   type;
ADDR32  inst;
{
  static BreakIdType    current_break_id=1;
  struct break_table    *temp, *temp2;
 
  if (bp_table == NULL) { /* first element */
    bp_table = (struct break_table *) malloc (sizeof(struct break_table));
    bp_table->id = current_break_id;
    bp_table->offset = offset;
    bp_table->space = space;
    bp_table->count = count;
    bp_table->type = type;
    bp_table->BreakInst = inst;
    bp_table->next = NULL;
  } else {
    temp2 = bp_table;
    temp = (struct break_table *) malloc (sizeof(struct break_table));
    temp->id = current_break_id;
    temp->offset = offset;
    temp->space = space;
    temp->count = count;
    temp->type = type;
    temp->BreakInst = inst;
    temp->next = NULL;
    while (temp2->next != NULL)
      temp2 = temp2->next;
    temp2->next = temp;
  };
  *id = current_break_id;
  current_break_id++;
}
 
int
get_from_bp_table(id, space, offset, count, type, inst)
BreakIdType     id;
INT32   *space;
ADDR32  *offset;
INT32   *count;
INT32   *type;
ADDR32  *inst;
{
  struct break_table  *temp;
 
  temp = bp_table;
 
  while (temp != NULL) {
    if (temp->id == id) {
       *offset = temp->offset;
       *space = temp->space;
       *count = temp->count;
       *type = temp->type;
       *inst = temp->BreakInst;
       return(0);
    } else {
      temp = temp->next;
    };
  }
  return(-1);
}
 
int
remove_from_bp_table(id)
BreakIdType     id;
{
  struct  break_table   *temp, *temp2;
 
  if (bp_table == NULL)
     return (-1);
  else {
    temp = bp_table;
    if (temp->id == id) { /* head of list */
       bp_table = bp_table->next;
       (void) free (temp);
       return (0); /* success */
    } else {
       while (temp->next != NULL) {
          if (temp->next->id == id) {
             temp2 = temp->next;
             temp->next = temp->next->next;
             (void) free (temp2);
             return (0); /* success */
          } else {
            temp = temp->next;
          }
       };
    }
  };
  return (-1);  /* failed */
}
 
int
is_breakpt_at(space, offset)
INT32   space;
ADDR32  offset;
{
  struct break_table  *temp;
 
  temp = bp_table;
 
  while (temp != NULL) {
    if ((temp->space == space) && (temp->offset == offset)) {
       return(1); /* TRUE */
    } else {
      temp = temp->next;
    };
  }
  return(0); /* FALSE */
}
 
/*
** Miscellaneous functions.
*/
 
int
Mini_core_load(filename, space, sects, syms)
char *filename;
INT32   space;
INT32   sects;
int     syms;
  {
 
   FILE  *coff_in;
   INT32  COFF_sections;
   INT32  i;
   int    read_count;
   int    section_type;
   int    host_endian;
   INT32  flags;
   INT32  memory_space;
   INT32  address;
   INT32  byte_count;
   INT32        write_count;
   INT32  temp_byte_count;
   INT16  temp_magic;
   INT16  temp_sections;
 
   struct  filehdr      COFF_header;
   struct  aouthdr      COFF_aout_header;
   struct  scnhdr      *COFF_section_header;
   struct  scnhdr      *temp_COFF_section_header;
 
   /* Open the COFF input file (if we can) */
   coff_in = fopen(filename, FILE_OPEN_FLAG);
   if (coff_in == NULL) {
      /* warning (EMOPEN);  */
      return(-1);
   }
 
   /*
   ** Process COFF header(s)
   */
 
   /* Read in COFF header information */
   read_count = fread((char *)&COFF_header,
                      sizeof(struct filehdr),
                      1, coff_in);
 
   /* Did we get it all? */
   if (read_count != 1) {
      fclose(coff_in);
      /* warning(EMHDR); */
      return (-1);
      }
 
   /* Is it an Am29000 COFF File? */
   temp_magic = COFF_header.f_magic;
   tip_convert16((BYTE *) &temp_magic);
   if (COFF_header.f_magic == SIPFBOMAGIC) {
      host_endian = TRUE;
      }
   else
   if (temp_magic == SIPFBOMAGIC) {
      host_endian = FALSE;
      }
   else
      {
      fclose(coff_in);
      /* warning (EMMAGIC); */
      return (-1);
      }
 
   /* Get number of COFF sections */
   temp_sections = COFF_header.f_nscns;
   if (host_endian == FALSE)
      tip_convert16((BYTE *) &temp_sections);
   COFF_sections = (INT32) temp_sections;
 
   /* Read in COFF a.out header information (if we can) */
   if (COFF_header.f_opthdr > 0) {
      read_count = fread((char *)&COFF_aout_header,
                         sizeof(struct aouthdr),
                         1, coff_in);
 
      /* Did we get it all? */
      if (read_count != 1) {
         fclose(coff_in);
         /* warning (EMAOUT); */
         return (-1);
         }
 
      }
 
   /*
   ** Process COFF section headers
   */
 
   /* Allocate space for section headers */
   (char *)COFF_section_header = (char *)
       malloc((unsigned) (COFF_sections * sizeof(struct scnhdr)));
 
   if (COFF_section_header == NULL) {
      fclose(coff_in);
      /* warning (EMALLOC); */
      return (-1);
      }
 
   /* Save the pointer to the malloc'ed data, so
   ** we can free it later. */
   temp_COFF_section_header = COFF_section_header;
 
   read_count = fread((char *)COFF_section_header,
                      sizeof(struct scnhdr),
                      (int) COFF_sections, coff_in);
 
   /* Did we get it all? */
   if (read_count != (int) COFF_sections) {
      fclose(coff_in);
      /*  warning (EMSCNHDR); */
      return (-1);
      }
 
 
   /* Process all sections */
   for (i=0; i<COFF_sections; i=i+1) {
 
      address = COFF_section_header->s_paddr;
      byte_count = COFF_section_header->s_size;
      flags = COFF_section_header->s_flags;
 
      if (host_endian == FALSE) {
         tip_convert32((BYTE *) &address);
         tip_convert32((BYTE *) &byte_count);
         tip_convert32((BYTE *) &flags);
         }
 
      /* Print downloading messages (if necessary) */
      if ((flags == STYP_TEXT) ||
          (flags == (STYP_TEXT | STYP_ABS))) {
         section_type = TEXT_SECTION;
         memory_space = I_MEM;
         }
      else
      if ((flags == STYP_DATA) ||
          (flags == (STYP_DATA | STYP_ABS))) {
         section_type = DATA_SECTION;
         memory_space = D_MEM;
         }
      else
      if ((flags == STYP_LIT) ||
          (flags == (STYP_LIT | STYP_ABS))) {
         section_type = LIT_SECTION;
         memory_space = D_MEM;
         }
      else
      if ((flags == STYP_BSS) ||
          (flags == (STYP_BSS | STYP_ABS))) {
         section_type = BSS_SECTION;
         memory_space = D_MEM;
         }
      else {
         section_type = UNKNOWN_SECTION;
      }
 
      /* Clear BSS sections in 29K data memory */
      if (section_type == BSS_SECTION) {
         (void) memset ((char *) buffer, (int) '\0', sizeof(buffer));
         while (byte_count > 0) {
           write_count = (byte_count < (INT32) sizeof(buffer)) ?
                                byte_count : (INT32) sizeof (buffer);
           if(Mini_write_memory ((INT32) memory_space,
                              (ADDR32) address,
                              (INT32) write_count,
                              (BYTE *) buffer) != SUCCESS) {
                (void) fclose(coff_in);
                return(-1);
           }
           address = address + write_count;
           byte_count = byte_count - write_count;
         }
       } else
 
      /* Else send data to the target */
      while (byte_count > 0) {
 
         temp_byte_count = MIN(byte_count, (INT32) sizeof(buffer));
 
         read_count = fread((char *) buffer,
                            (int) temp_byte_count,
                            1, coff_in);
 
         /* Did we get it all? */
         if (read_count != 1) {
            fclose(coff_in);
            /* warning (EMSCN); */
            return (-1);
            }
 
         /* Write to 29K memory*/
         if (section_type != UNKNOWN_SECTION) {
           if (Mini_write_memory ((INT32)  memory_space,
                                (ADDR32) address,
                                (INT32)  temp_byte_count,
                                (BYTE *) buffer) != SUCCESS) {
             /* warning(EMWRITE); */
             (void) fclose(coff_in);
             return(-1);
           };
         }
 
         address = address + temp_byte_count;
 
         byte_count = byte_count - temp_byte_count;
 
         }  /* end while */
 
      COFF_section_header++;
 
   }  /* end for loop */
 
   (void) free((char *)temp_COFF_section_header);
   (void) fclose(coff_in);
 
   return (0);
 
   }   /* end Mini_loadcoff() */
 

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [utils/] [amd-udi/] [montip/] [mtip.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	106	markom	`static char _[] = "@(#)mtip.c 2.14 92/01/13 18:04:36, AMD.";`
2			`/******************************************************************************`
3			`* Copyright 1991 Advanced Micro Devices, Inc.`
4			`*`
5			`* This software is the property of Advanced Micro Devices, Inc (AMD) which`
6			`* specifically grants the user the right to modify, use and distribute this`
7			`* software provided this notice is not removed or altered. All other rights`
8			`* are reserved by AMD.`
9			`*`
10			`* AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS`
11			`* SOFTWARE. IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL`
12			`* DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR`
13			`* USE OF THIS SOFTWARE.`
14			`*`
15			`* So that all may benefit from your experience, please report any problems`
16			`* or suggestions about this software to the 29K Technical Support Center at`
17			`* 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131 in the UK, or`
18			`* 0031-11-1129 in Japan, toll free. The direct dial number is 512-462-4118.`
19			`*`
20			`* Advanced Micro Devices, Inc.`
21			`* 29K Support Products`
22			`* Mail Stop 573`
23			`* 5900 E. Ben White Blvd.`
24			`* Austin, TX 78741`
25			`* 800-292-9263`
26			`*****************************************************************************`
27			`* Engineers: MINIMON DEVELOPMENT TEAM MEMBERS, AMD.`
28			`*/`
29
30			`#include <stdio.h>`
31			`#include <string.h>`
32			`#include <malloc.h>`
33			`#include "messages.h"`
34			`#include "coff.h"`
35			`#include "memspcs.h"`
36			`#include "mtip.h"`
37			`#include "macros.h"`
38
39			`/* TIP Breakpoint table */`
40			`typedef unsigned int BreakIdType;`
41
42			`static struct break_table {`
43			`BreakIdType id;`
44			`INT32 space;`
45			`ADDR32 offset;`
46			`INT32 count;`
47			`INT32 type;`
48			`ADDR32 BreakInst; /* actual instruction */`
49			`struct break_table *next;`
50			`};`
51
52			`struct break_table *bp_table=NULL;`
53
54			`#define BUFFER_SIZE 1024`
55
56			`static BYTE buffer[BUFFER_SIZE];`
57
58			`int Mini_core_load PARAMS((char *corefile, INT32 space,`
59			`INT32 sects, int syms));`
60			`void add_to_bp_table PARAMS((BreakIdType *id, INT32 space,`
61			`ADDR32 offset, INT32 count, INT32 type, ADDR32 inst));`
62			`int get_from_bp_table PARAMS((BreakIdType id, INT32 *space,`
63			`ADDR32 offset, INT32 count,`
64			`INT32 type, ADDR32 inst));`
65			`int remove_from_bp_table PARAMS((BreakIdType id));`
66			`int is_breakpt_at PARAMS((INT32 space, ADDR32 offset));`
67
68			`/*`
69			`** Breakpoint code`
70			`*/`
71
72			`void`
73			`add_to_bp_table(id, space, offset, count, type, inst)`
74			`BreakIdType *id;`
75			`INT32 space;`
76			`ADDR32 offset;`
77			`INT32 count;`
78			`INT32 type;`
79			`ADDR32 inst;`
80			`{`
81			`static BreakIdType current_break_id=1;`
82			`struct break_table temp, temp2;`
83
84			`if (bp_table == NULL) { /* first element */`
85			`bp_table = (struct break_table *) malloc (sizeof(struct break_table));`
86			`bp_table->id = current_break_id;`
87			`bp_table->offset = offset;`
88			`bp_table->space = space;`
89			`bp_table->count = count;`
90			`bp_table->type = type;`
91			`bp_table->BreakInst = inst;`
92			`bp_table->next = NULL;`
93			`} else {`
94			`temp2 = bp_table;`
95			`temp = (struct break_table *) malloc (sizeof(struct break_table));`
96			`temp->id = current_break_id;`
97			`temp->offset = offset;`
98			`temp->space = space;`
99			`temp->count = count;`
100			`temp->type = type;`
101			`temp->BreakInst = inst;`
102			`temp->next = NULL;`
103			`while (temp2->next != NULL)`
104			`temp2 = temp2->next;`
105			`temp2->next = temp;`
106			`};`
107			`*id = current_break_id;`
108			`current_break_id++;`
109			`}`
110
111			`int`
112			`get_from_bp_table(id, space, offset, count, type, inst)`
113			`BreakIdType id;`
114			`INT32 *space;`
115			`ADDR32 *offset;`
116			`INT32 *count;`
117			`INT32 *type;`
118			`ADDR32 *inst;`
119			`{`
120			`struct break_table *temp;`
121
122			`temp = bp_table;`
123
124			`while (temp != NULL) {`
125			`if (temp->id == id) {`
126			`*offset = temp->offset;`
127			`*space = temp->space;`
128			`*count = temp->count;`
129			`*type = temp->type;`
130			`*inst = temp->BreakInst;`
131			`return(0);`
132			`} else {`
133			`temp = temp->next;`
134			`};`
135			`}`
136			`return(-1);`
137			`}`
138
139			`int`
140			`remove_from_bp_table(id)`
141			`BreakIdType id;`
142			`{`
143			`struct break_table temp, temp2;`
144
145			`if (bp_table == NULL)`
146			`return (-1);`
147			`else {`
148			`temp = bp_table;`
149			`if (temp->id == id) { /* head of list */`
150			`bp_table = bp_table->next;`
151			`(void) free (temp);`
152			`return (0); /* success */`
153			`} else {`
154			`while (temp->next != NULL) {`
155			`if (temp->next->id == id) {`
156			`temp2 = temp->next;`
157			`temp->next = temp->next->next;`
158			`(void) free (temp2);`
159			`return (0); /* success */`
160			`} else {`
161			`temp = temp->next;`
162			`}`
163			`};`
164			`}`
165			`};`
166			`return (-1); /* failed */`
167			`}`
168
169			`int`
170			`is_breakpt_at(space, offset)`
171			`INT32 space;`
172			`ADDR32 offset;`
173			`{`
174			`struct break_table *temp;`
175
176			`temp = bp_table;`
177
178			`while (temp != NULL) {`
179			`if ((temp->space == space) && (temp->offset == offset)) {`
180			`return(1); /* TRUE */`
181			`} else {`
182			`temp = temp->next;`
183			`};`
184			`}`
185			`return(0); /* FALSE */`
186			`}`
187
188			`/*`
189			`** Miscellaneous functions.`
190			`*/`
191
192			`int`
193			`Mini_core_load(filename, space, sects, syms)`
194			`char *filename;`
195			`INT32 space;`
196			`INT32 sects;`
197			`int syms;`
198			`{`
199
200			`FILE *coff_in;`
201			`INT32 COFF_sections;`
202			`INT32 i;`
203			`int read_count;`
204			`int section_type;`
205			`int host_endian;`
206			`INT32 flags;`
207			`INT32 memory_space;`
208			`INT32 address;`
209			`INT32 byte_count;`
210			`INT32 write_count;`
211			`INT32 temp_byte_count;`
212			`INT16 temp_magic;`
213			`INT16 temp_sections;`
214
215			`struct filehdr COFF_header;`
216			`struct aouthdr COFF_aout_header;`
217			`struct scnhdr *COFF_section_header;`
218			`struct scnhdr *temp_COFF_section_header;`
219
220			`/* Open the COFF input file (if we can) */`
221			`coff_in = fopen(filename, FILE_OPEN_FLAG);`
222			`if (coff_in == NULL) {`
223			`/* warning (EMOPEN); */`
224			`return(-1);`
225			`}`
226
227			`/*`
228			`** Process COFF header(s)`
229			`*/`
230
231			`/* Read in COFF header information */`
232			`read_count = fread((char *)&COFF_header,`
233			`sizeof(struct filehdr),`
234			`1, coff_in);`
235
236			`/* Did we get it all? */`
237			`if (read_count != 1) {`
238			`fclose(coff_in);`
239			`/* warning(EMHDR); */`
240			`return (-1);`
241			`}`
242
243			`/* Is it an Am29000 COFF File? */`
244			`temp_magic = COFF_header.f_magic;`
245			`tip_convert16((BYTE *) &temp_magic);`
246			`if (COFF_header.f_magic == SIPFBOMAGIC) {`
247			`host_endian = TRUE;`
248			`}`
249			`else`
250			`if (temp_magic == SIPFBOMAGIC) {`
251			`host_endian = FALSE;`
252			`}`
253			`else`
254			`{`
255			`fclose(coff_in);`
256			`/* warning (EMMAGIC); */`
257			`return (-1);`
258			`}`
259
260			`/* Get number of COFF sections */`
261			`temp_sections = COFF_header.f_nscns;`
262			`if (host_endian == FALSE)`
263			`tip_convert16((BYTE *) &temp_sections);`
264			`COFF_sections = (INT32) temp_sections;`
265
266			`/* Read in COFF a.out header information (if we can) */`
267			`if (COFF_header.f_opthdr > 0) {`
268			`read_count = fread((char *)&COFF_aout_header,`
269			`sizeof(struct aouthdr),`
270			`1, coff_in);`
271
272			`/* Did we get it all? */`
273			`if (read_count != 1) {`
274			`fclose(coff_in);`
275			`/* warning (EMAOUT); */`
276			`return (-1);`
277			`}`
278
279			`}`
280
281			`/*`
282			`** Process COFF section headers`
283			`*/`
284
285			`/* Allocate space for section headers */`
286			`(char )COFF_section_header = (char )`
287			`malloc((unsigned) (COFF_sections * sizeof(struct scnhdr)));`
288
289			`if (COFF_section_header == NULL) {`
290			`fclose(coff_in);`
291			`/* warning (EMALLOC); */`
292			`return (-1);`
293			`}`
294
295			`/* Save the pointer to the malloc'ed data, so`
296			`** we can free it later. */`
297			`temp_COFF_section_header = COFF_section_header;`
298
299			`read_count = fread((char *)COFF_section_header,`
300			`sizeof(struct scnhdr),`
301			`(int) COFF_sections, coff_in);`
302
303			`/* Did we get it all? */`
304			`if (read_count != (int) COFF_sections) {`
305			`fclose(coff_in);`
306			`/* warning (EMSCNHDR); */`
307			`return (-1);`
308			`}`
309
310
311			`/* Process all sections */`
312			`for (i=0; i<COFF_sections; i=i+1) {`
313
314			`address = COFF_section_header->s_paddr;`
315			`byte_count = COFF_section_header->s_size;`
316			`flags = COFF_section_header->s_flags;`
317
318			`if (host_endian == FALSE) {`
319			`tip_convert32((BYTE *) &address);`
320			`tip_convert32((BYTE *) &byte_count);`
321			`tip_convert32((BYTE *) &flags);`
322			`}`
323
324			`/* Print downloading messages (if necessary) */`
325			`if ((flags == STYP_TEXT) \|\|`
326			`(flags == (STYP_TEXT \| STYP_ABS))) {`
327			`section_type = TEXT_SECTION;`
328			`memory_space = I_MEM;`
329			`}`
330			`else`
331			`if ((flags == STYP_DATA) \|\|`
332			`(flags == (STYP_DATA \| STYP_ABS))) {`
333			`section_type = DATA_SECTION;`
334			`memory_space = D_MEM;`
335			`}`
336			`else`
337			`if ((flags == STYP_LIT) \|\|`
338			`(flags == (STYP_LIT \| STYP_ABS))) {`
339			`section_type = LIT_SECTION;`
340			`memory_space = D_MEM;`
341			`}`
342			`else`
343			`if ((flags == STYP_BSS) \|\|`
344			`(flags == (STYP_BSS \| STYP_ABS))) {`
345			`section_type = BSS_SECTION;`
346			`memory_space = D_MEM;`
347			`}`
348			`else {`
349			`section_type = UNKNOWN_SECTION;`
350			`}`
351
352			`/* Clear BSS sections in 29K data memory */`
353			`if (section_type == BSS_SECTION) {`
354			`(void) memset ((char *) buffer, (int) '\0', sizeof(buffer));`
355			`while (byte_count > 0) {`
356			`write_count = (byte_count < (INT32) sizeof(buffer)) ?`
357			`byte_count : (INT32) sizeof (buffer);`
358			`if(Mini_write_memory ((INT32) memory_space,`
359			`(ADDR32) address,`
360			`(INT32) write_count,`
361			`(BYTE *) buffer) != SUCCESS) {`
362			`(void) fclose(coff_in);`
363			`return(-1);`
364			`}`
365			`address = address + write_count;`
366			`byte_count = byte_count - write_count;`
367			`}`
368			`} else`
369
370			`/* Else send data to the target */`
371			`while (byte_count > 0) {`
372
373			`temp_byte_count = MIN(byte_count, (INT32) sizeof(buffer));`
374
375			`read_count = fread((char *) buffer,`
376			`(int) temp_byte_count,`
377			`1, coff_in);`
378
379			`/* Did we get it all? */`
380			`if (read_count != 1) {`
381			`fclose(coff_in);`
382			`/* warning (EMSCN); */`
383			`return (-1);`
384			`}`
385
386			`/* Write to 29K memory*/`
387			`if (section_type != UNKNOWN_SECTION) {`
388			`if (Mini_write_memory ((INT32) memory_space,`
389			`(ADDR32) address,`
390			`(INT32) temp_byte_count,`
391			`(BYTE *) buffer) != SUCCESS) {`
392			`/* warning(EMWRITE); */`
393			`(void) fclose(coff_in);`
394			`return(-1);`
395			`};`
396			`}`
397
398			`address = address + temp_byte_count;`
399
400			`byte_count = byte_count - temp_byte_count;`
401
402			`} /* end while */`
403
404			`COFF_section_header++;`
405
406			`} /* end for loop */`
407
408			`(void) free((char *)temp_COFF_section_header);`
409			`(void) fclose(coff_in);`
410
411			`return (0);`
412
413			`} /* end Mini_loadcoff() */`
414