sys64738
/
mspdebug
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
mspdebug/formats/coff.c

405 lines
8.7 KiB
C
Raw Blame History

/* MSPDebug - debugging tool for MSP430 MCUs
* Copyright (C) 2009, 2010 Daniel Beer
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <string.h>
#include "coff.h"
#include "util.h"
#include "output.h"
struct coff_header {
uint16_t version;
int sec_count;
uint32_t timestamp;
int stab_start;
int stab_count;
int opt_bytes;
uint16_t flags;
uint16_t target_id;
};
/* Header sizes */
#define FILE_HEADER_SIZE 22
#define OPT_HEADER_SIZE 28
#define SHDR_SIZE 48
#define STAB_ENTRY_SIZE 18
/* Bits in the flags field */
#define F_RELFLG 0x0001
#define F_EXEC 0x0002
#define F_LSYMS 0x0008
#define F_LITTLE 0x0100
#define F_BIG 0x0200
#define F_SYMMERGE 0x1000
/* Section header flags */
#define STYP_REG 0x00000000
#define STYP_DSECT 0x00000001
#define STYP_NOLOAD 0x00000002
#define STYP_GROUP 0x00000004
#define STYP_PAD 0x00000008
#define STYP_COPY 0x00000010
#define STYP_TEXT 0x00000020
#define STYP_DATA 0x00000040
#define STYP_BSS 0x00000080
#define STYP_BLOCK 0x00001000
#define STYP_PASS 0x00002000
#define STYP_CLINK 0x00004000
#define STYP_VECTOR 0x00008000
#define STYP_PADDED 0x00010000
/* Symbol storage classes */
#define C_NULL 0
#define C_AUTO 1
#define C_EXT 2
#define C_STAT 3
#define C_REG 4
#define C_EXTREF 5
#define C_LABEL 6
#define C_ULABEL 7
#define C_MOS 8
#define C_ARG 9
#define C_STRTAG 10
#define C_MOU 11
#define C_UNTAG 12
#define C_TPDEF 13
#define C_USTATIC 14
#define C_ENTAG 15
#define C_MOE 16
#define C_REGPARM 17
#define C_FIELD 18
#define C_UEXT 19
#define C_STATLAB 20
#define C_EXTLAB 21
#define C_VARARG 22
#define C_BLOCK 100
#define C_FCN 101
#define C_EOS 102
#define C_FILE 103
#define C_LINE 104
/* MSP430 magic number */
#define MSP430_MAGIC 0x00a0
static int read_block(FILE *in, int offset, int size, void *buf)
{
int len;
if (size < 0) {
printc_err("coff: invalid size: %d\n", size);
return -1;
}
if (fseek(in, offset, SEEK_SET) < 0) {
printc_err("coff: can't seek to offset %d: %s\n",
offset, last_error());
return -1;
}
len = fread(buf, 1, size, in);
if (len < 0) {
printc_err("coff: can't read %d bytes from "
"offset %d: %s\n",
size, offset, last_error());
return -1;
}
if (len < size) {
printc_err("coff: can't read %d bytes from "
"offset %d: short read\n",
size, offset);
return -1;
}
return 0;
}
static void parse_header(const uint8_t *data, struct coff_header *hdr)
{
hdr->version = LE_WORD(data, 0);
hdr->sec_count = LE_WORD(data, 2);
hdr->timestamp = LE_LONG(data, 4);
hdr->stab_start = LE_LONG(data, 8);
hdr->stab_count = LE_LONG(data, 12);
hdr->opt_bytes = LE_WORD(data, 16);
hdr->flags = LE_WORD(data, 18);
hdr->target_id = LE_WORD(data, 20);
}
static int read_header(FILE *in, struct coff_header *hdr)
{
uint8_t hdr_data[FILE_HEADER_SIZE];
if (read_block(in, 0, FILE_HEADER_SIZE, hdr_data) < 0) {
printc_err("coff: failed to extract COFF header\n");
return -1;
}
parse_header(hdr_data, hdr);
return 0;
}
int coff_check(FILE *in)
{
uint8_t data[FILE_HEADER_SIZE];
rewind(in);
if (fread(data, 1, FILE_HEADER_SIZE, in) != FILE_HEADER_SIZE)
return 0;
return data[20] == 0xa0 && !data[21];
}
static int read_sechdrs(FILE *in, const struct coff_header *hdr,
uint8_t **ret_tab)
{
uint8_t *table;
int alloc_size = SHDR_SIZE * hdr->sec_count;
if (!hdr->sec_count) {
*ret_tab = NULL;
return 0;
}
table = malloc(alloc_size);
if (!table) {
pr_error("coff: can't allocate memory for section headers");
return -1;
}
if (read_block(in, hdr->opt_bytes + FILE_HEADER_SIZE,
SHDR_SIZE * hdr->sec_count, table) < 0) {
printc_err("coff: can't read section headers\n");
free(table);
return -1;
}
*ret_tab = table;
return hdr->sec_count;
}
static int load_section(FILE *in, uint32_t addr, uint32_t offset,
uint32_t size,
binfile_imgcb_t cb, void *user_data)
{
struct binfile_chunk ch = {0};
uint8_t *section;
if (!size)
return 0;
section = malloc(size);
if (!section) {
printc_err("coff: couldn't allocate memory for "
"section at 0x%x: %s\n", offset, last_error());
return -1;
}
if (read_block(in, offset, size, section) < 0) {
printc_err("coff: couldn't read section at 0x%x\n",
offset);
free(section);
return -1;
}
ch.addr = addr;
ch.len = size;
ch.data = section;
if (cb(user_data, &ch) < 0) {
free(section);
return -1;
}
free(section);
return 0;
}
int coff_extract(FILE *in, binfile_imgcb_t cb, void *user_data)
{
struct coff_header hdr;
uint8_t *shdrs;
int ret = 0;
int i;
if (read_header(in, &hdr) < 0)
return -1;
if (read_sechdrs(in, &hdr, &shdrs) < 0)
return -1;
for (i = 0; i < hdr.sec_count; i++) {
uint8_t *header = shdrs + SHDR_SIZE * i;
uint32_t flags = LE_LONG(header, 40);
if (((flags & STYP_TEXT) || (flags & STYP_DATA)) &&
!(flags & STYP_NOLOAD)) {
uint32_t addr = LE_LONG(header, 8);
uint32_t offset = LE_LONG(header, 20);
uint32_t size = LE_LONG(header, 16);
if (load_section(in, addr, offset, size,
cb, user_data) < 0) {
printc_err("coff: error while loading "
"section %d\n", i);
ret = -1;
break;
}
}
}
if (shdrs)
free(shdrs);
return ret;
}
static int read_strtab(FILE *in, const struct coff_header *hdr,
char **ret_tab)
{
char *strtab;
int file_size;
int alloc_size;
int strtab_len;
int strtab_start = hdr->stab_count * STAB_ENTRY_SIZE + hdr->stab_start;
if (fseek(in, 0, SEEK_END) < 0) {
printc_err("coff: can't seek to end\n");
return -1;
}
file_size = ftell(in);
strtab_len = file_size - strtab_start;
if (strtab_len < 0) {
printc_err("coff: invalid string table size\n");
return -1;
}
if (!strtab_len) {
*ret_tab = NULL;
return 0;
}
alloc_size = strtab_len + 1;
strtab = malloc(alloc_size);
if (!strtab) {
pr_error("coff: can't allocate memory for string table");
return -1;
}
if (read_block(in, strtab_start, strtab_len, strtab) < 0) {
printc_err("coff: failed to read string table\n");
free(strtab);
return -1;
}
strtab[strtab_len] = 0;
*ret_tab = strtab;
return strtab_len;
}
static int read_symtab(FILE *in, const struct coff_header *hdr,
uint8_t **ret_tab)
{
uint8_t *table;
int alloc_size = STAB_ENTRY_SIZE * hdr->stab_count;
if (!hdr->stab_count) {
*ret_tab = NULL;
return 0;
}
table = malloc(alloc_size);
if (!table) {
pr_error("coff: failed to allocate memory for symbol table");
return -1;
}
if (read_block(in, hdr->stab_start,
STAB_ENTRY_SIZE * hdr->stab_count, table) < 0) {
printc_err("coff: failed to read symbol table\n");
free(table);
return -1;
}
*ret_tab = table;
return hdr->stab_count;
}
int coff_syms(FILE *in)
{
struct coff_header hdr;
char *strtab;
uint8_t *symtab;
int strtab_len;
int i;
int ret = 0;
if (read_header(in, &hdr) < 0)
return -1;
strtab_len = read_strtab(in, &hdr, &strtab);
if (strtab_len < 0)
return -1;
if (read_symtab(in, &hdr, &symtab) < 0) {
if (strtab)
free(strtab);
return -1;
}
for (i = 0; i < hdr.stab_count; i++) {
uint8_t *entry = symtab + i * STAB_ENTRY_SIZE;
uint32_t value = LE_LONG(entry, 8);
int storage_class = entry[16];
char namebuf[9];
const char *name = NULL;
if (LE_LONG(entry, 0)) {
memcpy(namebuf, entry, 8);
namebuf[8] = 0;
name = namebuf;
} else {
uint32_t offset = LE_LONG(entry, 4);
if (offset >= 4 && offset < strtab_len)
name = strtab + offset;
}
if (name &&
(storage_class == C_EXT || storage_class == C_LABEL) &&
stab_set(name, value) < 0) {
printc_err("coff: failed to insert symbol\n");
ret = -1;
break;
}
/* Skip auxiliary entries */
i += entry[17];
}
if (symtab)
free(symtab);
if (strtab)
free(strtab);
return ret;
}
Reference in New Issue View Git Blame Copy Permalink