Thread: Help with Debugging Code

Hello,

I have these two items that are not compiling incorrectly...

Code:

enum trace_item_type {
	ti_NOP=0,
	ti_RTYPE,
	ti_ITYPE,
	ti_LOAD,
	ti_STORE,
	ti_BRANCH,
	ti_JTYPE,
	ti_SPECIAL,
	ti_JRTYPE
};

struct trace_item {
uint8_t type;
uint8_t sReg_a;
uint8_t sReg_b;
uint8_t dReg;
uint32_t PC;
uint32_t Addr;
};

Everytime I compile it i get the error of this:
mytrace.h: line 14: Parse Error, expecting `'}''

'struct trace_item { uint8_t'

aborting compile


I checked my syntax and everything seems to be right unless i'm missing something?

Thanks,
husslela2

I'm still now getting the error:

Code:

mytrace.h: line 15: Parse Error, expecting `'}''

'struct trace_item { u_int8_t'

aborting compile

Here is my header file:

Code:

#include <sys/types.h>

enum trace_item_type {

                ti_NOP,

                ti_RTYPE,

                ti_ITYPE,

                ti_LOAD,

                ti_STORE,

                ti_BRANCH,

                ti_JTYPE,

                ti_SPECIAL,

                ti_JRTYPE

};

 

struct trace_item {

u_int8_t type;

u_int8_t sReg_a;

u_int8_t sReg_b;

u_int8_t dReg;

u_int32_t PC;

u_int32_t Addr;

};

Miracle C compiler...do you recommend a better one?

i had that miracle C thing at one time, i remember the editor was awful, used for about one hour, i cant comment on the compiler, there are a few good free IDEs (integrated development environment) i got code:blocks, its great, download it, it's the most fun you can have with your clothes on

okay i downloaded code blocks.

Here is the code I have to work with now, I have to count branches with the input of a trace file...

however I am getting a lot of errors, and would like some direction for debugging.

here is the code:

Code:

#include <stdio.h>

#include <mytrace.h>

#include <sys/types.h>

 

#define TRACE_BUFSIZE 1024*1024

 

static FILE *trace_fd;

static int trace_buf_ptr;

static int trace_buf_end;

static struct trace_item *trace_buf;

 

void trace_init()

{

  trace_buf = malloc(sizeof(struct trace_item) * TRACE_BUFSIZE);

 

  if (!trace_buf) {

    fprintf(stdout, "** trace_buf not allocated\n");

    exit(-1);

  }

 

  trace_buf_ptr = 0;

  trace_buf_end = 0;

}

 

void trace_uninit()

{

  free(trace_buf);

  fclose(trace_fd);

}

 

int trace_get_item(struct trace_item **item)

{

  int n_items;

 

  if (trace_buf_ptr == trace_buf_end) {

    // get new data

    n_items = fread(trace_buf, sizeof(struct trace_item), TRACE_BUFSIZE, trace_fd);

    if (!n_items) return 0;

 

    trace_buf_ptr = 0;

    trace_buf_end = n_items;

  }

 

  *item = &trace_buf[trace_buf_ptr];

  trace_buf_ptr++;

 

  return 1;

}

 

int main(int argc, char **argv)

{

  struct trace_item *tr_entry;

  size_t size;

  char *trace_file_name;

  int trace_view_on = 0;

  

  unsigned char t_type = 0;

  unsigned char t_sReg_a= 0;

  unsigned char t_sReg_b= 0;

  unsigned char t_dReg= 0;

  unsigned int t_PC = 0;

  unsigned int t_Addr = 0;

 

  unsigned int n_items = 0;

  unsigned int n_nop = 0;

  unsigned int n_rtype = 0;

  unsigned int n_itype = 0;

  unsigned int n_load = 0;

  unsigned int n_store = 0;

  unsigned int n_branch = 0;

  unsigned int n_jtype = 0;

  unsigned int n_jrtype = 0;

  unsigned int n_special = 0;

  unsigned int n_unknown = 0;

  unsigned int n_mem_inst = 0;

  unsigned int n_cont_inst = 0;

 

  if (argc == 1) {

    fprintf(stdout, "\nUSAGE: tv <trace_file> <switch - any character>\n");

    fprintf(stdout, "\n(switch) to turn on or off individual item view.\n\n");

    exit(0);

  }

    

  trace_file_name = argv[1];

  trace_view_on = (argc == 3);

 

  fprintf(stdout, "\n ** opening file %s\n", trace_file_name);

 

  trace_fd = fopen(trace_file_name, "rb");

 

  if (!trace_fd) {

    fprintf(stdout, "\ntrace file %s not opened.\n\n", trace_file_name);

    exit(0);

  }

 

  trace_init();

 

  while(1) {

    size = trace_get_item(&tr_entry);

   

    if (!size) {

      printf("+ total # items : %u\n", n_items);

      printf("+ # nop: %u\n", n_nop);

      printf("+ # rtype: %u\n", n_rtype);

      printf("+ # itype: %u\n", n_itype);

      printf("+ # load: %u\n", n_load);

      printf("+ # store: %u\n", n_store);

      printf("+ # branch: %u\n", n_branch);

      printf("+ # jtype: %u\n", n_jtype);

      printf("+ # jrtype: %u\n", n_jrtype);

      printf("+ # special: %u\n", n_special);

      printf("+ # unknown: %u\n", n_unknown);

      printf("+ # Avg mem instr: %4.2f\n", (double)n_mem_inst/(double)n_items);

      printf("+ # Avg control instr: %4.2f\n", (double)n_cont_inst/(double)n_items);

      break;

    }

    else{

      n_items++;

      t_type = tr_entry->type;

      t_sReg_a = tr_entry->sReg_a;

      t_sReg_b = tr_entry->sReg_b;

      t_dReg = tr_entry->dReg;

      t_PC = tr_entry->PC;

      t_Addr = tr_entry->Addr;

    }  

 

    switch(tr_entry->type) {

 

      case ti_NOP:

        if (trace_view_on){

          printf("[item %d] entry NOP: (PC: %x) (sReg_a: %d) (sReg_b: %d) (dReg: %d) (addr: %x)\n", n_items, tr_entry->PC, tr_entry->sReg_a, tr_entry->sReg_b, tr_entry->dReg, tr_entry->Addr);

        }

 

        n_nop++;

        break;

 

      case ti_RTYPE:

        if (trace_view_on){

          printf("[item %d] entry RTYPE: (PC: %x) (sReg_a: %d) (sReg_b: %d) (dReg: %d) (addr: %x)\n", n_items, tr_entry->PC, tr_entry->sReg_a, tr_entry->sReg_b, tr_entry->dReg, tr_entry->Addr);

        }

 

        n_rtype++;

        break;

 

     case ti_ITYPE:

        if (trace_view_on){

          printf("[item %d] entry ITYPE: (PC: %x) (sReg_a: %d) (sReg_b: %d) (dReg: %d) (addr: %x)\n", n_items, tr_entry->PC, tr_entry->sReg_a, tr_entry->sReg_b, tr_entry->dReg, tr_entry->Addr);

        }

 

        n_itype++;

        break;

                

     case ti_LOAD:

        if (trace_view_on){

          printf("[item %d] entry LOAD: (PC: %x) (sReg_a: %d) (sReg_b: %d) (dReg: %d) (addr: %x)\n", n_items,  tr_entry->PC, tr_entry->sReg_a, tr_entry->sReg_b, tr_entry->dReg, tr_entry->Addr);

        }

 

        n_load++; n_mem_inst++;

        break;

 

     case ti_STORE:

        if (trace_view_on){

          printf("[item %d] entry STORE: (PC: %x) (sReg_a: %d) (sReg_b: %d) (dReg: %d) (addr: %x)\n", n_items, tr_entry->PC, tr_entry->sReg_a, tr_entry->sReg_b, tr_entry->dReg, tr_entry->Addr);

        }

 

        n_store++; n_mem_inst++;

        break;

 

     case ti_BRANCH:

        if (trace_view_on){

          printf("[item %d] entry BRANCH: (PC: %x) (sReg_a: %d) (sReg_b: %d) (dReg: %d) (addr: %x)\n", n_items, tr_entry->PC, tr_entry->sReg_a, tr_entry->sReg_b, tr_entry->dReg, tr_entry->Addr);

        }

        n_branch++; n_cont_inst++;

        break;

 

     case ti_JTYPE:

        if (trace_view_on){

          printf("[item %d] entry JTYPE: (PC: %x) (sReg_a: %d) (sReg_b: %d) (dReg: %d) (addr: %x)\n", n_items, tr_entry->PC, tr_entry->sReg_a, tr_entry->sReg_b, tr_entry->dReg, tr_entry->Addr);

        }

 

        n_jtype++; n_cont_inst++;

        break;

 

     case ti_SPECIAL:

        if (trace_view_on){

          printf("[item %d] entry SPECIAL: (PC: %x) (sReg_a: %d) (sReg_b: %d) (dReg: %d) (addr: %x)\n", n_items, tr_entry->PC, tr_entry->sReg_a, tr_entry->sReg_b, tr_entry->dReg, tr_entry->Addr);

        }

 

        n_special++; n_cont_inst++;

        break;

 

     case ti_JRTYPE:

        if (trace_view_on){

          printf("[item %d] entry JRTYPE: (PC: %x) (sReg_a: %d) (sReg_b: %d) (dReg: %d) (addr: %x)\n", n_items, tr_entry->PC, tr_entry->sReg_a, tr_entry->sReg_b, tr_entry->dReg, tr_entry->Addr);

        }

 

        n_jrtype++; n_cont_inst++;

        break;

 

      default:

                n_unknown++;

                break;

    }

  }

 

  trace_uninit();

 

  exit(0);

}

Here is the header:

Code:

#include <sys/types.h>

enum trace_item_type

{

                ti_NOP,

                ti_RTYPE,

                ti_ITYPE,

                ti_LOAD,

                ti_STORE,

                ti_BRANCH,

                ti_JTYPE,

                ti_SPECIAL,

                ti_JRTYPE

};

 

struct trace_item

{

u_int8_t type;

u_int8_t sReg_a;

u_int8_t sReg_b;

u_int8_t dReg;

u_int32_t PC;

u_int32_t Addr;

};

Originally Posted by husslela2

okay i downloaded code blocks.

Here is the code I have to work with now, I have to count branches with the input of a trace file...

however I am getting a lot of errors, and would like some direction for debugging.

The fun part about error messages is that the error messages tell you what the errors are. So your direction for debugging is to read the error messages, and fix the errors they tell you about.

(Granted, if you get a lot of errors, some of them may be "spurious" or relate to the same missing character, etc.)

I am not very good at C code...and this is all I have to work with...

For example, I have an error on line #133 saying Error: invalid use of undefined type `struct trace_item`. I don't know how to start debugging that..

Line 133? Line 133 of the posted code (assuming you don't have all those blank lines in between every single line) is

Code:

n_nop++;

So first I guess is to figure out which line is line 133.

So you need to include the header file that defines that type, then. Is that what mytrace.h is supposed to be? Your header files go in "quotes", not <angle brackets>. (Your probably also then getting an error for that line, along the lines of "file not found".)