OpenCores
URL https://opencores.org/ocsvn/eco32/eco32/trunk

Subversion Repositories eco32

[/] [eco32/] [trunk/] [binutils/] [dof/] [dof.c] - Blame information for rev 15

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 7 hellwig 
/*
2 
 * dof.c -- dump object file
3 
 */
4 
 
5 
 
6 
#include <stdio.h>
7 
#include <stdlib.h>
8 
#include <string.h>
9 
#include <stdarg.h>
10 
 
11 
#include "../include/a.out.h"
12 
 
13 
 
14 
#define MSB     ((unsigned int) 1 << (sizeof(unsigned int) * 8 - 1))
15 
 
16 
 
17 
/**************************************************************/
18 
 
19 
 
20 
FILE *inFile;
21 
ExecHeader execHeader;
22 
char *segmentName[4] = { "ABS", "CODE", "DATA", "BSS" };
23 
char *methodName[5] = { "H16", "L16", "R16", "R26", "W32" };
24 
 
25 
 
26 
/**************************************************************/
27 
 
28 
 
29 
void error(char *fmt, ...) {
30 
  va_list ap;
31 
 
32 
  va_start(ap, fmt);
33 
  printf("Error: ");
34 
  vprintf(fmt, ap);
35 
  printf("\n");
36 
  va_end(ap);
37 
  exit(1);
38 
}
39 
 
40 
 
41 
/**************************************************************/
42 
 
43 
 
44 
unsigned int read4FromEco(unsigned char *p) {
45 
  return (unsigned int) p[0] << 24 |
46 
         (unsigned int) p[1] << 16 |
47 
         (unsigned int) p[2] <<  8 |
48 
         (unsigned int) p[3] <<  0;
49 
}
50 
 
51 
 
52 
void write4ToEco(unsigned char *p, unsigned int data) {
53 
  p[0] = data >> 24;
54 
  p[1] = data >> 16;
55 
  p[2] = data >>  8;
56 
  p[3] = data >>  0;
57 
}
58 
 
59 
 
60 
void conv4FromEcoToNative(unsigned char *p) {
61 
  unsigned int data;
62 
 
63 
  data = read4FromEco(p);
64 
  * (unsigned int *) p = data;
65 
}
66 
 
67 
 
68 
void conv4FromNativeToEco(unsigned char *p) {
69 
  unsigned int data;
70 
 
71 
  data = * (unsigned int *) p;
72 
  write4ToEco(p, data);
73 
}
74 
 
75 
 
76 
/**************************************************************/
77 
 
78 
 
79 
#define CODE_START      (sizeof(ExecHeader))
80 
#define DATA_START      (CODE_START + execHeader.csize)
81 
#define CRELOC_START    (DATA_START + execHeader.dsize)
82 
#define DRELOC_START    (CRELOC_START + execHeader.crsize)
83 
#define SYMTBL_START    (DRELOC_START + execHeader.drsize)
84 
#define STRING_START    (SYMTBL_START + execHeader.symsize)
85 
 
86 
 
87 
void dumpHeader(void) {
88 
  if (fseek(inFile, 0, SEEK_SET) < 0) {
89 
    error("cannot seek to exec header");
90 
  }
91 
  if (fread(&execHeader, sizeof(ExecHeader), 1, inFile) != 1) {
92 
    error("cannot read exec header");
93 
  }
94 
  conv4FromEcoToNative((unsigned char *) &execHeader.magic);
95 
  conv4FromEcoToNative((unsigned char *) &execHeader.csize);
96 
  conv4FromEcoToNative((unsigned char *) &execHeader.dsize);
97 
  conv4FromEcoToNative((unsigned char *) &execHeader.bsize);
98 
  conv4FromEcoToNative((unsigned char *) &execHeader.crsize);
99 
  conv4FromEcoToNative((unsigned char *) &execHeader.drsize);
100 
  conv4FromEcoToNative((unsigned char *) &execHeader.symsize);
101 
  conv4FromEcoToNative((unsigned char *) &execHeader.strsize);
102 
  if (execHeader.magic != EXEC_MAGIC) {
103 
    error("wrong magic number in exec header");
104 
  }
105 
  printf("Header\n");
106 
  printf("    size of code         : %8u bytes\n", execHeader.csize);
107 
  printf("    size of data         : %8u bytes\n", execHeader.dsize);
108 
  printf("    size of bss          : %8u bytes\n", execHeader.bsize);
109 
  printf("    size of code relocs  : %8u bytes\n", execHeader.crsize);
110 
  printf("    size of data relocs  : %8u bytes\n", execHeader.drsize);
111 
  printf("    size of symbol table : %8u bytes\n", execHeader.symsize);
112 
  printf("    size of string space : %8u bytes\n", execHeader.strsize);
113 
}
114 
 
115 
 
116 
void dumpBytes(unsigned int totalSize) {
117 
  unsigned int currSize;
118 
  unsigned char line[16];
119 
  int n, i;
120 
  unsigned char c;
121 
 
122 
  currSize = 0;
123 
  while (currSize < totalSize) {
124 
    if (totalSize - currSize >= 16) {
125 
      n = 16;
126 
    } else {
127 
      n = totalSize - currSize;
128 
    }
129 
    for (i = 0; i < n; i++) {
130 
      line[i] = fgetc(inFile);
131 
    }
132 
    printf("%08X:  ", currSize);
133 
    for (i = 0; i < 16; i++) {
134 
      if (i < n) {
135 
        c = line[i];
136 
        printf("%02X", c);
137 
      } else {
138 
        printf("  ");
139 
      }
140 
      printf(" ");
141 
    }
142 
    printf("  ");
143 
    for (i = 0; i < 16; i++) {
144 
      if (i < n) {
145 
        c = line[i];
146 
        if (c >= 32 && c <= 126) {
147 
          printf("%c", c);
148 
        } else {
149 
          printf(".");
150 
        }
151 
      } else {
152 
        printf(" ");
153 
      }
154 
    }
155 
    printf("\n");
156 
    currSize += n;
157 
  }
158 
}
159 
 
160 
 
161 
void dumpCode(void) {
162 
  if (fseek(inFile, CODE_START, SEEK_SET) < 0) {
163 
    error("cannot seek to code section");
164 
  }
165 
  printf("\nCode Segment\n");
166 
  dumpBytes(execHeader.csize);
167 
}
168 
 
169 
 
170 
void dumpData(void) {
171 
  if (fseek(inFile, DATA_START, SEEK_SET) < 0) {
172 
    error("cannot seek to data section");
173 
  }
174 
  printf("\nData Segment\n");
175 
  dumpBytes(execHeader.dsize);
176 
}
177 
 
178 
 
179 
void dumpRelocs(unsigned int totalSize) {
180 
  unsigned int currSize;
181 
  int n;
182 
  RelocRecord relRec;
183 
 
184 
  currSize = 0;
185 
  n = 0;
186 
  while (currSize < totalSize) {
187 
    if (fread(&relRec, sizeof(RelocRecord), 1, inFile) != 1) {
188 
      error("cannot read relocation record");
189 
    }
190 
    conv4FromEcoToNative((unsigned char *) &relRec.offset);
191 
    conv4FromEcoToNative((unsigned char *) &relRec.method);
192 
    conv4FromEcoToNative((unsigned char *) &relRec.value);
193 
    conv4FromEcoToNative((unsigned char *) &relRec.base);
194 
    printf("    %d:\n", n);
195 
    printf("        offset  = 0x%08X\n", relRec.offset);
196 
    if (relRec.method < 0 || relRec.method > 4) {
197 
      error("illegal relocation method");
198 
    }
199 
    printf("        method  = %s\n", methodName[relRec.method]);
200 
    printf("        value   = 0x%08X\n", relRec.value);
201 
    if (relRec.base & MSB) {
202 
      printf("        base    = symbol # %d\n", relRec.base & ~MSB);
203 
    } else {
204 
      if (relRec.base < 0 || relRec.base > 3) {
205 
        error("base contains an illegal segment number");
206 
      }
207 
      printf("        base    = %s\n", segmentName[relRec.base]);
208 
    }
209 
    currSize += sizeof(RelocRecord);
210 
    n++;
211 
  }
212 
}
213 
 
214 
 
215 
void dumpCodeRelocs(void) {
216 
  if (fseek(inFile, CRELOC_START, SEEK_SET) < 0) {
217 
    error("cannot seek to code relocation section");
218 
  }
219 
  printf("\nCode Relocation Records\n");
220 
  dumpRelocs(execHeader.crsize);
221 
}
222 
 
223 
 
224 
void dumpDataRelocs(void) {
225 
  if (fseek(inFile, DRELOC_START, SEEK_SET) < 0) {
226 
    error("cannot seek to data relocation section");
227 
  }
228 
  printf("\nData Relocation Records\n");
229 
  dumpRelocs(execHeader.drsize);
230 
}
231 
 
232 
 
233 
void dumpString(unsigned int offset) {
234 
  long pos;
235 
  int c;
236 
 
237 
  pos = ftell(inFile);
238 
  if (fseek(inFile, STRING_START + offset, SEEK_SET) < 0) {
239 
    error("cannot seek to string");
240 
  }
241 
  while (1) {
242 
    c = fgetc(inFile);
243 
    if (c == EOF) {
244 
      error("unexpected end of file");
245 
    }
246 
    if (c == 0) {
247 
      break;
248 
    }
249 
    fputc(c, stdout);
250 
  }
251 
  fseek(inFile, pos, SEEK_SET);
252 
}
253 
 
254 
 
255 
void dumpSymbolTable(void) {
256 
  unsigned int currSize;
257 
  int n;
258 
  SymbolRecord symRec;
259 
 
260 
  if (fseek(inFile, SYMTBL_START, SEEK_SET) < 0) {
261 
    error("cannot seek to symbol table section");
262 
  }
263 
  printf("\nSymbol Table Records\n");
264 
  currSize = 0;
265 
  n = 0;
266 
  while (currSize < execHeader.symsize) {
267 
    if (fread(&symRec, sizeof(SymbolRecord), 1, inFile) != 1) {
268 
      error("cannot read symbol record");
269 
    }
270 
    conv4FromEcoToNative((unsigned char *) &symRec.name);
271 
    conv4FromEcoToNative((unsigned char *) &symRec.type);
272 
    conv4FromEcoToNative((unsigned char *) &symRec.value);
273 
    printf("    %d:\n", n);
274 
    printf("        name    = ");
275 
    dumpString(symRec.name);
276 
    printf("\n");
277 
    if (symRec.type & MSB) {
278 
      printf("        --- undefined ---\n");
279 
    } else {
280 
      if (symRec.type < 0 || symRec.type > 3) {
281 
        error("type contains an illegal segment number");
282 
      }
283 
      printf("        segment = %s\n", segmentName[symRec.type]);
284 
      printf("        value   = 0x%08X\n", symRec.value);
285 
    }
286 
    currSize += sizeof(SymbolRecord);
287 
    n++;
288 
  }
289 
}
290 
 
291 
 
292 
/**************************************************************/
293 
 
294 
 
295 
void usage(char *myself) {
296 
  printf("Usage: %s\n", myself);
297 
  printf("         [-c]             dump code\n");
298 
  printf("         [-d]             dump data\n");
299 
  printf("         [-x]             dump code relocations\n");
300 
  printf("         [-y]             dump data relocations\n");
301 
  printf("         [-s]             dump symbol table\n");
302 
  printf("         [-a]             dump all\n");
303 
  printf("         file             object file to be dumped\n");
304 
  exit(1);
305 
}
306 
 
307 
 
308 
int main(int argc, char *argv[]) {
309 
  int i;
310 
  char *argp;
311 
  int optionCode;
312 
  int optionData;
313 
  int optionCodeRelocs;
314 
  int optionDataRelocs;
315 
  int optionSymbolTable;
316 
  char *inName;
317 
 
318 
  optionCode = 0;
319 
  optionData = 0;
320 
  optionCodeRelocs = 0;
321 
  optionDataRelocs = 0;
322 
  optionSymbolTable = 0;
323 
  inName = NULL;
324 
  for (i = 1; i < argc; i++) {
325 
    argp = argv[i];
326 
    if (*argp == '-') {
327 
      argp++;
328 
      switch (*argp) {
329 
        case 'c':
330 
          optionCode = 1;
331 
          break;
332 
        case 'd':
333 
          optionData = 1;
334 
          break;
335 
        case 'x':
336 
          optionCodeRelocs = 1;
337 
          break;
338 
        case 'y':
339 
          optionDataRelocs = 1;
340 
          break;
341 
        case 's':
342 
          optionSymbolTable = 1;
343 
          break;
344 
        case 'a':
345 
          optionCode = 1;
346 
          optionData = 1;
347 
          optionCodeRelocs = 1;
348 
          optionDataRelocs = 1;
349 
          optionSymbolTable = 1;
350 
          break;
351 
        default:
352 
          usage(argv[0]);
353 
      }
354 
    } else {
355 
      if (inName != NULL) {
356 
        usage(argv[0]);
357 
      }
358 
      inName = argp;
359 
    }
360 
  }
361 
  if (inName == NULL) {
362 
    usage(argv[0]);
363 
  }
364 
  inFile = fopen(inName, "r");
365 
  if (inFile == NULL) {
366 
    error("cannot open input file '%s'", inName);
367 
  }
368 
  dumpHeader();
369 
  if (optionCode) {
370 
    dumpCode();
371 
  }
372 
  if (optionData) {
373 
    dumpData();
374 
  }
375 
  if (optionCodeRelocs) {
376 
    dumpCodeRelocs();
377 
  }
378 
  if (optionDataRelocs) {
379 
    dumpDataRelocs();
380 
  }
381 
  if (optionSymbolTable) {
382 
    dumpSymbolTable();
383 
  }
384 
  fclose(inFile);
385 
  return 0;
386 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.