1 /* mem.c --- memory for M32C simulator. 2 3 Copyright (C) 2005, 2007, 2008, 2009, 2010, 2011 4 Free Software Foundation, Inc. 5 Contributed by Red Hat, Inc. 6 7 This file is part of the GNU simulators. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 23 #include "config.h" 24 #include <stdio.h> 25 #include <stdlib.h> 26 #include <string.h> 27 #include <ctype.h> 28 #include <sys/time.h> 29 #include <sys/types.h> 30 #include <unistd.h> 31 #ifdef HAVE_SYS_SELECT_H 32 #include <sys/select.h> 33 #endif 34 #ifdef HAVE_TERMIOS_H 35 #include <termios.h> 36 #endif 37 38 #include "mem.h" 39 #include "cpu.h" 40 #include "syscalls.h" 41 #include "misc.h" 42 #ifdef TIMER_A 43 #include "int.h" 44 #include "timer_a.h" 45 #endif 46 47 #define L1_BITS (10) 48 #define L2_BITS (10) 49 #define OFF_BITS (12) 50 51 #define L1_LEN (1 << L1_BITS) 52 #define L2_LEN (1 << L2_BITS) 53 #define OFF_LEN (1 << OFF_BITS) 54 55 static unsigned char **pt[L1_LEN]; 56 57 #ifdef HAVE_TERMIOS_H 58 int m32c_console_ifd = 0; 59 #endif 60 int m32c_console_ofd = 1; 61 #ifdef HAVE_TERMIOS_H 62 int m32c_use_raw_console = 0; 63 #endif 64 65 #ifdef TIMER_A 66 Timer_A timer_a; 67 #endif 68 69 /* [ get=0/put=1 ][ byte size ] */ 70 static unsigned int mem_counters[2][5]; 71 72 #define COUNT(isput,bytes) \ 73 if (verbose && enable_counting) mem_counters[isput][bytes]++ 74 75 void 76 init_mem (void) 77 { 78 int i, j; 79 80 for (i = 0; i < L1_LEN; i++) 81 if (pt[i]) 82 { 83 for (j = 0; j < L2_LEN; j++) 84 if (pt[i][j]) 85 free (pt[i][j]); 86 free (pt[i]); 87 } 88 memset (pt, 0, sizeof (pt)); 89 memset (mem_counters, 0, sizeof (mem_counters)); 90 } 91 92 static unsigned char * 93 mem_ptr (address) 94 { 95 static int recursing = 0; 96 int pt1 = (address >> (L2_BITS + OFF_BITS)) & ((1 << L1_BITS) - 1); 97 int pt2 = (address >> OFF_BITS) & ((1 << L2_BITS) - 1); 98 int pto = address & ((1 << OFF_BITS) - 1); 99 100 if (address == 0 && !recursing) 101 { 102 recursing = 1; 103 put_reg (pc, m32c_opcode_pc); 104 printf ("NULL pointer dereference at pc=0x%x\n", get_reg (pc)); 105 step_result = M32C_MAKE_HIT_BREAK (); 106 #if 0 107 /* This code can be re-enabled to help diagnose NULL pointer 108 bugs that aren't debuggable in GDB. */ 109 m32c_dump_all_registers (); 110 exit (1); 111 #endif 112 } 113 114 if (pt[pt1] == 0) 115 pt[pt1] = (unsigned char **) calloc (L2_LEN, sizeof (char **)); 116 if (pt[pt1][pt2] == 0) 117 { 118 pt[pt1][pt2] = (unsigned char *) malloc (OFF_LEN); 119 memset (pt[pt1][pt2], 0, OFF_LEN); 120 } 121 122 return pt[pt1][pt2] + pto; 123 } 124 125 static void 126 used (int rstart, int i, int j) 127 { 128 int rend = i << (L2_BITS + OFF_BITS); 129 rend += j << OFF_BITS; 130 if (rstart == 0xe0000 && rend == 0xe1000) 131 return; 132 printf ("mem: %08x - %08x (%dk bytes)\n", rstart, rend - 1, 133 (rend - rstart) / 1024); 134 } 135 136 static char * 137 mcs (int isput, int bytes) 138 { 139 return comma (mem_counters[isput][bytes]); 140 } 141 142 void 143 mem_usage_stats () 144 { 145 int i, j; 146 int rstart = 0; 147 int pending = 0; 148 149 for (i = 0; i < L1_LEN; i++) 150 if (pt[i]) 151 { 152 for (j = 0; j < L2_LEN; j++) 153 if (pt[i][j]) 154 { 155 if (!pending) 156 { 157 pending = 1; 158 rstart = (i << (L2_BITS + OFF_BITS)) + (j << OFF_BITS); 159 } 160 } 161 else if (pending) 162 { 163 pending = 0; 164 used (rstart, i, j); 165 } 166 } 167 else 168 { 169 if (pending) 170 { 171 pending = 0; 172 used (rstart, i, 0); 173 } 174 } 175 /* mem foo: 123456789012 123456789012 123456789012 123456789012 176 123456789012 */ 177 printf (" byte short pointer long" 178 " fetch\n"); 179 printf ("mem get: %12s %12s %12s %12s %12s\n", mcs (0, 1), mcs (0, 2), 180 mcs (0, 3), mcs (0, 4), mcs (0, 0)); 181 printf ("mem put: %12s %12s %12s %12s\n", mcs (1, 1), mcs (1, 2), 182 mcs (1, 3), mcs (1, 4)); 183 } 184 185 static int tpr = 0; 186 static void 187 s (int address, char *dir) 188 { 189 if (tpr == 0) 190 printf ("MEM[%0*x] %s", membus_mask == 0xfffff ? 5 : 6, address, dir); 191 tpr++; 192 } 193 194 #define S(d) if (trace) s(address, d) 195 static void 196 e () 197 { 198 if (!trace) 199 return; 200 tpr--; 201 if (tpr == 0) 202 printf ("\n"); 203 } 204 205 #define E() if (trace) e() 206 207 extern int m32c_disassemble; 208 209 void 210 mem_put_byte (int address, unsigned char value) 211 { 212 unsigned char *m; 213 address &= membus_mask; 214 m = mem_ptr (address); 215 if (trace) 216 printf (" %02x", value); 217 *m = value; 218 switch (address) 219 { 220 case 0x00e1: 221 { 222 static int old_led = -1; 223 static char *led_on[] = 224 { "\033[31m O ", "\033[32m O ", "\033[34m O " }; 225 static char *led_off[] = { "\033[0m � ", "\033[0m � ", "\033[0m � " }; 226 int i; 227 if (old_led != value) 228 { 229 fputs (" ", stdout); 230 for (i = 0; i < 3; i++) 231 if (value & (1 << i)) 232 fputs (led_off[i], stdout); 233 else 234 fputs (led_on[i], stdout); 235 fputs ("\033[0m\r", stdout); 236 fflush (stdout); 237 old_led = value; 238 } 239 } 240 break; 241 #ifdef TIMER_A 242 /* M32C Timer A */ 243 case 0x346: /* TA0low */ 244 timer_a.count = (timer_a.count & 0xff00) | value; 245 timer_a.reload = timer_a.count; 246 break; 247 case 0x347: /* TA0high */ 248 timer_a.count = (timer_a.count & 0x00ff) | (value << 8); 249 timer_a.reload = timer_a.count; 250 break; 251 case 0x340: /* TABSR */ 252 timer_a.bsr = value; 253 break; 254 case 0x356: /* TA0MR */ 255 timer_a.mode = value; 256 break; 257 case 0x35f: /* TCSPR */ 258 timer_a.tcspr = value; 259 break; 260 case 0x006c: /* TA0IC */ 261 timer_a.ic = value; 262 break; 263 264 /* R8C Timer RA */ 265 case 0x100: /* TRACR */ 266 timer_a.bsr = value; 267 break; 268 case 0x102: /* TRAMR */ 269 timer_a.mode = value; 270 break; 271 case 0x104: /* TRA */ 272 timer_a.count = value; 273 timer_a.reload = value; 274 break; 275 case 0x103: /* TRAPRE */ 276 timer_a.tcspr = value; 277 break; 278 case 0x0056: /* TA0IC */ 279 timer_a.ic = value; 280 break; 281 #endif 282 283 case 0x2ea: /* m32c uart1tx */ 284 case 0x3aa: /* m16c uart1tx */ 285 { 286 static int pending_exit = 0; 287 if (value == 0) 288 { 289 if (pending_exit) 290 { 291 step_result = M32C_MAKE_EXITED (value); 292 return; 293 } 294 pending_exit = 1; 295 } 296 else 297 { 298 write (m32c_console_ofd, &value, 1); 299 } 300 } 301 break; 302 303 case 0x400: 304 m32c_syscall (value); 305 break; 306 307 case 0x401: 308 putchar (value); 309 break; 310 311 case 0x402: 312 printf ("SimTrace: %06lx %02x\n", regs.r_pc, value); 313 break; 314 315 case 0x403: 316 printf ("SimTrap: %06lx %02x\n", regs.r_pc, value); 317 abort (); 318 } 319 } 320 321 void 322 mem_put_qi (int address, unsigned char value) 323 { 324 S ("<="); 325 mem_put_byte (address, value & 0xff); 326 E (); 327 COUNT (1, 1); 328 } 329 330 void 331 mem_put_hi (int address, unsigned short value) 332 { 333 if (address == 0x402) 334 { 335 printf ("SimTrace: %06lx %04x\n", regs.r_pc, value); 336 return; 337 } 338 S ("<="); 339 mem_put_byte (address, value & 0xff); 340 mem_put_byte (address + 1, value >> 8); 341 E (); 342 COUNT (1, 2); 343 } 344 345 void 346 mem_put_psi (int address, unsigned long value) 347 { 348 S ("<="); 349 mem_put_byte (address, value & 0xff); 350 mem_put_byte (address + 1, (value >> 8) & 0xff); 351 mem_put_byte (address + 2, value >> 16); 352 E (); 353 COUNT (1, 3); 354 } 355 356 void 357 mem_put_si (int address, unsigned long value) 358 { 359 S ("<="); 360 mem_put_byte (address, value & 0xff); 361 mem_put_byte (address + 1, (value >> 8) & 0xff); 362 mem_put_byte (address + 2, (value >> 16) & 0xff); 363 mem_put_byte (address + 3, (value >> 24) & 0xff); 364 E (); 365 COUNT (1, 4); 366 } 367 368 void 369 mem_put_blk (int address, const void *bufptr, int nbytes) 370 { 371 S ("<="); 372 if (enable_counting) 373 mem_counters[1][1] += nbytes; 374 while (nbytes--) 375 mem_put_byte (address++, *(const unsigned char *) bufptr++); 376 E (); 377 } 378 379 unsigned char 380 mem_get_pc () 381 { 382 unsigned char *m = mem_ptr (regs.r_pc & membus_mask); 383 COUNT (0, 0); 384 return *m; 385 } 386 387 #ifdef HAVE_TERMIOS_H 388 static int console_raw = 0; 389 static struct termios oattr; 390 391 static int 392 stdin_ready () 393 { 394 fd_set ifd; 395 int n; 396 struct timeval t; 397 398 t.tv_sec = 0; 399 t.tv_usec = 0; 400 FD_ZERO (&ifd); 401 FD_SET (m32c_console_ifd, &ifd); 402 n = select (1, &ifd, 0, 0, &t); 403 return n > 0; 404 } 405 406 void 407 m32c_sim_restore_console () 408 { 409 if (console_raw) 410 tcsetattr (m32c_console_ifd, TCSANOW, &oattr); 411 console_raw = 0; 412 } 413 #endif 414 415 static unsigned char 416 mem_get_byte (int address) 417 { 418 unsigned char *m; 419 address &= membus_mask; 420 m = mem_ptr (address); 421 switch (address) 422 { 423 #ifdef HAVE_TERMIOS_H 424 case 0x2ed: /* m32c uart1c1 */ 425 case 0x3ad: /* m16c uart1c1 */ 426 427 if (!console_raw && m32c_use_raw_console) 428 { 429 struct termios attr; 430 tcgetattr (m32c_console_ifd, &attr); 431 tcgetattr (m32c_console_ifd, &oattr); 432 /* We want each key to be sent as the user presses them. */ 433 attr.c_lflag &= ~(ICANON | ECHO | ECHOE); 434 tcsetattr (m32c_console_ifd, TCSANOW, &attr); 435 console_raw = 1; 436 atexit (m32c_sim_restore_console); 437 } 438 439 if (stdin_ready ()) 440 return 0x02; /* tx empty and rx full */ 441 else 442 return 0x0a; /* transmitter empty */ 443 444 case 0x2ee: /* m32c uart1 rx */ 445 { 446 char c; 447 read (m32c_console_ifd, &c, 1); 448 if (m32c_console_ifd == 0 && c == 3) /* Ctrl-C */ 449 { 450 printf ("Ctrl-C!\n"); 451 exit (0); 452 } 453 454 if (m32c_console_ifd != 1) 455 { 456 if (isgraph (c)) 457 printf ("\033[31m%c\033[0m", c); 458 else 459 printf ("\033[31m%02x\033[0m", c); 460 } 461 return c; 462 } 463 #endif 464 465 #ifdef TIMER_A 466 case 0x346: /* TA0low */ 467 return timer_a.count & 0xff; 468 case 0x347: /* TA0high */ 469 return (timer_a.count >> 8) & 0xff; 470 case 0x104: /* TRA */ 471 return timer_a.count; 472 #endif 473 474 default: 475 /* In case both cases above are not included. */ 476 ; 477 } 478 479 S ("=>"); 480 if (trace) 481 printf (" %02x", *m); 482 E (); 483 return *m; 484 } 485 486 unsigned char 487 mem_get_qi (int address) 488 { 489 unsigned char rv; 490 S ("=>"); 491 rv = mem_get_byte (address); 492 COUNT (0, 1); 493 E (); 494 return rv; 495 } 496 497 unsigned short 498 mem_get_hi (int address) 499 { 500 unsigned short rv; 501 S ("=>"); 502 rv = mem_get_byte (address); 503 rv |= mem_get_byte (address + 1) * 256; 504 COUNT (0, 2); 505 E (); 506 return rv; 507 } 508 509 unsigned long 510 mem_get_psi (int address) 511 { 512 unsigned long rv; 513 S ("=>"); 514 rv = mem_get_byte (address); 515 rv |= mem_get_byte (address + 1) * 256; 516 rv |= mem_get_byte (address + 2) * 65536; 517 COUNT (0, 3); 518 E (); 519 return rv; 520 } 521 522 unsigned long 523 mem_get_si (int address) 524 { 525 unsigned long rv; 526 S ("=>"); 527 rv = mem_get_byte (address); 528 rv |= mem_get_byte (address + 1) << 8; 529 rv |= mem_get_byte (address + 2) << 16; 530 rv |= mem_get_byte (address + 3) << 24; 531 COUNT (0, 4); 532 E (); 533 return rv; 534 } 535 536 void 537 mem_get_blk (int address, void *bufptr, int nbytes) 538 { 539 S ("=>"); 540 if (enable_counting) 541 mem_counters[0][1] += nbytes; 542 while (nbytes--) 543 *(char *) bufptr++ = mem_get_byte (address++); 544 E (); 545 } 546 547 int 548 sign_ext (int v, int bits) 549 { 550 if (bits < 32) 551 { 552 v &= (1 << bits) - 1; 553 if (v & (1 << (bits - 1))) 554 v -= (1 << bits); 555 } 556 return v; 557 } 558 559 #if TIMER_A 560 void 561 update_timer_a () 562 { 563 if (timer_a.bsr & 1) 564 { 565 timer_a.prescale--; 566 if (timer_a.prescale < 0) 567 { 568 if (A24) 569 { 570 switch (timer_a.mode & 0xc0) 571 { 572 case 0x00: 573 timer_a.prescale = 0; 574 break; 575 case 0x40: 576 timer_a.prescale = 8; 577 break; 578 case 0x80: 579 timer_a.prescale = timer_a.tcspr & 0x0f; 580 break; 581 case 0xc0: 582 timer_a.prescale = 32; 583 break; 584 } 585 } 586 else 587 { 588 timer_a.prescale = timer_a.tcspr; 589 } 590 timer_a.count--; 591 if (timer_a.count < 0) 592 { 593 timer_a.count = timer_a.reload; 594 if (timer_a.ic & 7) 595 { 596 if (A24) 597 mem_put_qi (0x6c, timer_a.ic | 0x08); 598 else 599 mem_put_qi (0x56, timer_a.ic | 0x08); 600 } 601 } 602 } 603 } 604 605 if (regs.r_flags & FLAGBIT_I /* interrupts enabled */ 606 && timer_a.ic & 0x08 /* timer A interrupt triggered */ 607 && (timer_a.ic & 0x07) > ((regs.r_flags >> 12) & 0x07)) 608 { 609 if (A24) 610 trigger_peripheral_interrupt (12, 0x06c); 611 else 612 trigger_peripheral_interrupt (22, 0x056); 613 } 614 } 615 #endif 616