log.c

   1 /*
   2  * TODO TODO TODO TODO TODO TODO TODO
   3  *
   4  * move reg dump here to be more consistent
   5  *
   6  */
   7
   8 #include <stdio.h>
   9 #include <stdarg.h>
  10 #include <string.h>
  11 #include "disasm.h"
  12
  13
  14 /** ************* log functions ***********/
  15
  16 //strings
  17 #define LOG_ADDR_STR_MAX 8
  18 static char log_addr_str[LOG_ADDR_STR_MAX+1];
  19
  20 #define LOG_OPCODE_STR_MAX 10
  21 static char log_opcode_str[LOG_OPCODE_STR_MAX+1];
  22
  23 #define LOG_INSTR_NAME_STR_MAX 10
  24 static char log_instr_name_str[LOG_INSTR_NAME_STR_MAX+1];
  25
  26 #define LOG_INSTR_ARGS_STR_MAX 30
  27 static char log_instr_args_str[LOG_INSTR_ARGS_STR_MAX+1];
  28
  29 #define LOG_ACCESS_STR_MAX 80
  30 static char log_access_read_str[LOG_ACCESS_STR_MAX+1];
  31 static unsigned log_access_read_idx = 0;
  32 static char log_access_write_str[LOG_ACCESS_STR_MAX+1];
  33 static unsigned log_access_write_idx = 0;
  34
  35 #define LOG_COMMENT_STR_MAX 1000
  36 static char log_comment_str[LOG_COMMENT_STR_MAX+1];
  37 static unsigned log_comment_idx = 0;
  38
  39 //functions
  40 void log_addr(u16 addr)
  41 {
  42         snprintf(log_addr_str, LOG_ADDR_STR_MAX, "%04hx", addr);
  43 }
  44
  45 void log_opcode(struct opcode_word opcode)
  46 {
  47         snprintf(log_opcode_str, LOG_OPCODE_STR_MAX, "%06x", opcode.raw);
  48 }
  49
  50 void log_instr_name(const char *fmt, ...)
  51 {
  52         va_list args;
  53         va_start(args, fmt);
  54         vsnprintf(log_instr_name_str,
  55                 LOG_INSTR_NAME_STR_MAX,
  56                 fmt,
  57                 args
  58         );
  59         va_end(args);
  60 }
  61
  62 void log_instr_args(const char *fmt, ...)
  63 {
  64         va_list args;
  65         va_start(args, fmt);
  66         vsnprintf(log_instr_args_str,
  67                 LOG_INSTR_ARGS_STR_MAX,
  68                 fmt,
  69                 args
  70         );
  71         va_end(args);
  72 }
  73
  74 //TODO use trace
  75 void log_access_read_add(const char *fmt, ...)
  76 {
  77         if (log_access_read_idx < LOG_ACCESS_STR_MAX) {
  78                 va_list args;
  79                 va_start(args, fmt);
  80                 log_access_read_idx += vsnprintf(
  81                         &log_access_read_str[log_access_read_idx],
  82                         LOG_ACCESS_STR_MAX - log_access_read_idx,
  83                         fmt,
  84                         args
  85                 );
  86                 va_end(args);
  87         }
  88 }
  89
  90 void log_access_write_add(const char *fmt, ...)
  91 {
  92         if (log_access_write_idx < LOG_ACCESS_STR_MAX) {
  93                 va_list args;
  94                 va_start(args, fmt);
  95                 log_access_write_idx += vsnprintf(
  96                         &log_access_write_str[log_access_write_idx],
  97                         LOG_ACCESS_STR_MAX - log_access_write_idx,
  98                         fmt,
  99                         args
 100                 );
 101                 va_end(args);
 102         }
 103 }
 104
 105 void log_comment_add(const char *fmt, ...)
 106 {
 107         if (log_comment_idx < LOG_COMMENT_STR_MAX) {
 108                 va_list args;
 109                 va_start(args, fmt);
 110                 log_comment_idx += vsnprintf(
 111                         &log_comment_str[log_comment_idx],
 112                         LOG_COMMENT_STR_MAX - log_comment_idx,
 113                         fmt,
 114                         args
 115                 );
 116                 va_end(args);
 117         }
 118 }
 119
 120
 121 void log_comment_reg_bits(
 122         const char *caption,
 123         const char *reg_names[],
 124         u8 old,
 125         u8 new)
 126 {
 127         u8 diff = old ^ new;
 128
 129         if (diff) {
 130                 log_comment_add("       %s(%02hhx->%02hhx)\n", caption, old, new);
 131         } else {
 132                 log_comment_add("       %s(%02hhx)\n", caption, new);
 133         }
 134
 135         log_comment_add("       ");
 136         for(unsigned bit=0; bit<8; bit++) {
 137                 log_comment_add(" %1d:%s",
 138                         7-bit,
 139                         reg_names[7-bit]
 140                 );
 141         }
 142         log_comment_add("\n");
 143
 144
 145         log_comment_add("       ");
 146         for(unsigned bit=0; bit<8; bit++) {
 147                 if (diff & (1 << (7-bit))) {
 148                         log_comment_add(" %.*s%c->%c",
 149                                 strlen(reg_names[7-bit])-2,
 150                                 "                      ",
 151                                 old & (1<<(7-bit))?'1':'0',
 152                                 new & (1<<(7-bit))?'1':'0'
 153                         );
 154                 } else {
 155                         log_comment_add(" %.*s%c",
 156                                 strlen(reg_names[7-bit])+1,
 157                                 "                      ",
 158                                 new & (1<<(7-bit))?'1':'0'
 159                         );
 160                 }
 161         }
 162         log_comment_add("\n");
 163 }
 164
 165 ///main flush
 166
 167 void log_flush(unsigned flags)
 168 {
 169         //addr opbytes name+args comments
 170
 171         if (flags) {
 172                 printf("%4s:\t%s    %s %-*s\n",
 173                         log_addr_str,
 174                         log_opcode_str,
 175                         log_instr_name_str,
 176                         25-(int)strlen(log_instr_name_str),
 177                         log_instr_args_str
 178                 );
 179         } else {
 180                 //TODO split, no W, no R (don't do if trace log will be used)
 181                 printf("%4s:\t%s    %s %-*s ;R{%s} ;W{%s}\n",
 182                         log_addr_str,
 183                         log_opcode_str,
 184                         log_instr_name_str,
 185                         25-(int)strlen(log_instr_name_str),
 186                         log_instr_args_str,
 187                         log_access_read_str,
 188                         log_access_write_str
 189                 );
 190         }
 191
 192         if (strlen(log_comment_str)) {
 193 //              printf("\n%s\n", log_comment_str);
 194                 printf("%s", log_comment_str);
 195         }
 196
 197         log_addr_str[0] = '\0';
 198         log_opcode_str[0] = '\0';
 199         log_instr_name_str[0] = '\0';
 200         log_instr_args_str[0] = '\0';
 201         log_access_read_str[0] = '\0';
 202         log_access_write_str[0] = '\0';
 203         log_comment_str[0] = '\0';
 204
 205         log_access_read_idx = 0;
 206         log_access_write_idx = 0;
 207         log_comment_idx = 0;
 208 }
 209
 210 extern u8 read_mem(u16 addr, unsigned flags);
 211
 212 #define CHAR_PER_LINE 16
 213 void log_buf(char *name, u16 base, u16 len)
 214 {
 215         //TODO use log_comment buffer? problem with really long memdumps (limited buffer)
 216         printf("%s:\n", name);
 217
 218         for(unsigned off=0;off<len;off++){
 219                 if ((off%CHAR_PER_LINE) == 0) {
 220                         printf("%04hx: ", off);
 221                 }
 222
 223                 printf("%02hhx ", read_mem(base+off, 0));
 224
 225                 if ((off%CHAR_PER_LINE) == (CHAR_PER_LINE-1)) {
 226                         printf(" ");
 227                         u8 val;
 228                         for(unsigned charoff=0;charoff<CHAR_PER_LINE;charoff++){
 229                                 val = read_mem(base + charoff + (off/CHAR_PER_LINE)*CHAR_PER_LINE, 0);
 230
 231                                 printf("%c", ((val>=32)&&(val<=128))?val:'.');
 232                         }
 233                         printf("\n");
 234                 }
 235         }
 236 }