git.libre-soc.org Git - binutils-gdb.git/blob

1 /* mem.c --- memory for M32C simulator.

4 Contributed by Red Hat, Inc.

6 This file is part of the GNU simulators.

8 This program is free software; you can redistribute it and/or modify

9 it under the terms of the GNU General Public License as published by

10 the Free Software Foundation; either version 3 of the License, or

11 (at your option) any later version.

13 This program is distributed in the hope that it will be useful,

14 but WITHOUT ANY WARRANTY; without even the implied warranty of

15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

16 GNU General Public License for more details.

18 You should have received a copy of the GNU General Public License

19 along with this program. If not, see <http://www.gnu.org/licenses/>. */

22 #include "config.h"

23 #include <stdio.h>

24 #include <stdlib.h>

25 #include <string.h>

26 #include <ctype.h>

27 #include <sys/time.h>

28 #include <sys/types.h>

29 #include <unistd.h>

30 #ifdef HAVE_SYS_SELECT_H

31 #include <sys/select.h>

32 #endif

33 #ifdef HAVE_TERMIOS_H

34 #include <termios.h>

35 #endif

37 #include "mem.h"

38 #include "cpu.h"

39 #include "syscalls.h"

40 #include "misc.h"

41 #ifdef TIMER_A

42 #include "int.h"

43 #include "timer_a.h"

44 #endif

46 #define L1_BITS (10)

47 #define L2_BITS (10)

48 #define OFF_BITS (12)

50 #define L1_LEN (1 << L1_BITS)

51 #define L2_LEN (1 << L2_BITS)

52 #define OFF_LEN (1 << OFF_BITS)

54 static unsigned char **pt[L1_LEN];

56 #ifdef HAVE_TERMIOS_H

57 int m32c_console_ifd = 0;

58 #endif

59 int m32c_console_ofd = 1;

60 #ifdef HAVE_TERMIOS_H

61 int m32c_use_raw_console = 0;

62 #endif

64 #ifdef TIMER_A

65 Timer_A timer_a;

66 #endif

68 /* [ get=0/put=1 ][ byte size ] */

69 static unsigned int mem_counters[2][5];

71 #define COUNT(isput,bytes) \

72 if (verbose && enable_counting) mem_counters[isput][bytes]++

74 void

75 init_mem (void)

76 {

77 int i, j;

79 for (i = 0; i < L1_LEN; i++)

80 if (pt[i])

81 {

82 for (j = 0; j < L2_LEN; j++)

83 if (pt[i][j])

84 free (pt[i][j]);

85 free (pt[i]);

86 }

87 memset (pt, 0, sizeof (pt));

88 memset (mem_counters, 0, sizeof (mem_counters));

89 }

91 static unsigned char *

92 mem_ptr (int address)

93 {

94 static int recursing = 0;

95 int pt1 = (address >> (L2_BITS + OFF_BITS)) & ((1 << L1_BITS) - 1);

96 int pt2 = (address >> OFF_BITS) & ((1 << L2_BITS) - 1);

97 int pto = address & ((1 << OFF_BITS) - 1);

99 if (address == 0 && !recursing)

100 {

101 recursing = 1;

102 put_reg (pc, m32c_opcode_pc);

103 printf ("NULL pointer dereference at pc=0x%x\n", get_reg (pc));

104 step_result = M32C_MAKE_HIT_BREAK ();

105 #if 0

106 /* This code can be re-enabled to help diagnose NULL pointer

107 bugs that aren't debuggable in GDB. */

108 m32c_dump_all_registers ();

109 exit (1);

110 #endif

111 }

112

113 if (pt[pt1] == 0)

114 pt[pt1] = (unsigned char **) calloc (L2_LEN, sizeof (char **));

115 if (pt[pt1][pt2] == 0)

116 {

117 pt[pt1][pt2] = (unsigned char *) malloc (OFF_LEN);

118 memset (pt[pt1][pt2], 0, OFF_LEN);

119 }

120

121 return pt[pt1][pt2] + pto;

122 }

123

124 static void

125 used (int rstart, int i, int j)

126 {

127 int rend = i << (L2_BITS + OFF_BITS);

128 rend += j << OFF_BITS;

129 if (rstart == 0xe0000 && rend == 0xe1000)

130 return;

131 printf ("mem: %08x - %08x (%dk bytes)\n", rstart, rend - 1,

132 (rend - rstart) / 1024);

133 }

134

135 static char *

136 mcs (int isput, int bytes)

137 {

138 return comma (mem_counters[isput][bytes]);

139 }

140

141 void

142 mem_usage_stats (void)

143 {

144 int i, j;

145 int rstart = 0;

146 int pending = 0;

147

148 for (i = 0; i < L1_LEN; i++)

149 if (pt[i])

150 {

151 for (j = 0; j < L2_LEN; j++)

152 if (pt[i][j])

153 {

154 if (!pending)

155 {

156 pending = 1;

157 rstart = (i << (L2_BITS + OFF_BITS)) + (j << OFF_BITS);

158 }

159 }

160 else if (pending)

161 {

162 pending = 0;

163 used (rstart, i, j);

164 }

165 }

166 else

167 {

168 if (pending)

169 {

170 pending = 0;

171 used (rstart, i, 0);

172 }

173 }

174 /* mem foo: 123456789012 123456789012 123456789012 123456789012

175 123456789012 */

176 printf (" byte short pointer long"

177 " fetch\n");

178 printf ("mem get: %12s %12s %12s %12s %12s\n", mcs (0, 1), mcs (0, 2),

179 mcs (0, 3), mcs (0, 4), mcs (0, 0));

180 printf ("mem put: %12s %12s %12s %12s\n", mcs (1, 1), mcs (1, 2),

181 mcs (1, 3), mcs (1, 4));

182 }

183

184 static int tpr = 0;

185 static void

186 s (int address, char *dir)

187 {

188 if (tpr == 0)

189 printf ("MEM[%0*x] %s", membus_mask == 0xfffff ? 5 : 6, address, dir);

190 tpr++;

191 }

192

193 #define S(d) if (trace) s(address, d)

194 static void

195 e (void)

196 {

197 if (!trace)

198 return;

199 tpr--;

200 if (tpr == 0)

201 printf ("\n");

202 }

203

204 #define E() if (trace) e()

205

206 extern int m32c_disassemble;

207

208 static void

209 mem_put_byte (int address, unsigned char value)

210 {

211 unsigned char *m;

212 address &= membus_mask;

213 m = mem_ptr (address);

214 if (trace)

215 printf (" %02x", value);

216 *m = value;

217 switch (address)

218 {

219 case 0x00e1:

220 {

221 static int old_led = -1;

222 static char *led_on[] =

223 { "\033[31m O ", "\033[32m O ", "\033[34m O " };

224 static char *led_off[] = { "\033[0m · ", "\033[0m · ", "\033[0m · " };

225 int i;

226 if (old_led != value)

227 {

228 fputs (" ", stdout);

229 for (i = 0; i < 3; i++)

230 if (value & (1 << i))

231 fputs (led_off[i], stdout);

232 else

233 fputs (led_on[i], stdout);

234 fputs ("\033[0m\r", stdout);

235 fflush (stdout);

236 old_led = value;

237 }

238 }

239 break;

240 #ifdef TIMER_A

241 /* M32C Timer A */

242 case 0x346: /* TA0low */

243 timer_a.count = (timer_a.count & 0xff00) | value;

244 timer_a.reload = timer_a.count;

245 break;

246 case 0x347: /* TA0high */

247 timer_a.count = (timer_a.count & 0x00ff) | (value << 8);

248 timer_a.reload = timer_a.count;

249 break;

250 case 0x340: /* TABSR */

251 timer_a.bsr = value;

252 break;

253 case 0x356: /* TA0MR */

254 timer_a.mode = value;

255 break;

256 case 0x35f: /* TCSPR */

257 timer_a.tcspr = value;

258 break;

259 case 0x006c: /* TA0IC */

260 timer_a.ic = value;

261 break;

262

263 /* R8C Timer RA */

264 case 0x100: /* TRACR */

265 timer_a.bsr = value;

266 break;

267 case 0x102: /* TRAMR */

268 timer_a.mode = value;

269 break;

270 case 0x104: /* TRA */

271 timer_a.count = value;

272 timer_a.reload = value;

273 break;

274 case 0x103: /* TRAPRE */

275 timer_a.tcspr = value;

276 break;

277 case 0x0056: /* TA0IC */

278 timer_a.ic = value;

279 break;

280 #endif

281

282 case 0x2ea: /* m32c uart1tx */

283 case 0x3aa: /* m16c uart1tx */

284 {

285 static int pending_exit = 0;

286 if (value == 0)

287 {

288 if (pending_exit)

289 {

290 step_result = M32C_MAKE_EXITED (value);

291 return;

292 }

293 pending_exit = 1;

294 }

295 else

296 {

297 write (m32c_console_ofd, &value, 1);

298 }

299 }

300 break;

301

302 case 0x400:

303 m32c_syscall (value);

304 break;

305

306 case 0x401:

307 putchar (value);

308 break;

309

310 case 0x402:

311 printf ("SimTrace: %06lx %02x\n", regs.r_pc, value);

312 break;

313

314 case 0x403:

315 printf ("SimTrap: %06lx %02x\n", regs.r_pc, value);

316 abort ();

317 }

318 }

319

320 void

321 mem_put_qi (int address, unsigned char value)

322 {

323 S ("<=");

324 mem_put_byte (address, value & 0xff);

325 E ();

326 COUNT (1, 1);

327 }

328

329 void

330 mem_put_hi (int address, unsigned short value)

331 {

332 if (address == 0x402)

333 {

334 printf ("SimTrace: %06lx %04x\n", regs.r_pc, value);

335 return;

336 }

337 S ("<=");

338 mem_put_byte (address, value & 0xff);

339 mem_put_byte (address + 1, value >> 8);

340 E ();

341 COUNT (1, 2);

342 }

343

344 void

345 mem_put_psi (int address, unsigned long value)

346 {

347 S ("<=");

348 mem_put_byte (address, value & 0xff);

349 mem_put_byte (address + 1, (value >> 8) & 0xff);

350 mem_put_byte (address + 2, value >> 16);

351 E ();

352 COUNT (1, 3);

353 }

354

355 void

356 mem_put_si (int address, unsigned long value)

357 {

358 S ("<=");

359 mem_put_byte (address, value & 0xff);

360 mem_put_byte (address + 1, (value >> 8) & 0xff);

361 mem_put_byte (address + 2, (value >> 16) & 0xff);

362 mem_put_byte (address + 3, (value >> 24) & 0xff);

363 E ();

364 COUNT (1, 4);

365 }

366

367 void

368 mem_put_blk (int address, const void *bufptr, int nbytes)

369 {

370 S ("<=");

371 if (enable_counting)

372 mem_counters[1][1] += nbytes;

373 while (nbytes--)

374 mem_put_byte (address++, *(const unsigned char *) bufptr++);

375 E ();

376 }

377

378 unsigned char

379 mem_get_pc (void)

380 {

381 unsigned char *m = mem_ptr (regs.r_pc & membus_mask);

382 COUNT (0, 0);

383 return *m;

384 }

385

386 #ifdef HAVE_TERMIOS_H

387 static int console_raw = 0;

388 static struct termios oattr;

389

390 static int

391 stdin_ready (void)

392 {

393 fd_set ifd;

394 int n;

395 struct timeval t;

396

397 t.tv_sec = 0;

398 t.tv_usec = 0;

399 FD_ZERO (&ifd);

400 FD_SET (m32c_console_ifd, &ifd);

401 n = select (1, &ifd, 0, 0, &t);

402 return n > 0;

403 }

404

405 void

406 m32c_sim_restore_console (void)

407 {

408 if (console_raw)

409 tcsetattr (m32c_console_ifd, TCSANOW, &oattr);

410 console_raw = 0;

411 }

412 #endif

413

414 static unsigned char

415 mem_get_byte (int address)

416 {

417 unsigned char *m;

418 address &= membus_mask;

419 m = mem_ptr (address);

420 switch (address)

421 {

422 #ifdef HAVE_TERMIOS_H

423 case 0x2ed: /* m32c uart1c1 */

424 case 0x3ad: /* m16c uart1c1 */

425

426 if (!console_raw && m32c_use_raw_console)

427 {

428 struct termios attr;

429 tcgetattr (m32c_console_ifd, &attr);

430 tcgetattr (m32c_console_ifd, &oattr);

431 /* We want each key to be sent as the user presses them. */

432 attr.c_lflag &= ~(ICANON | ECHO | ECHOE);

433 tcsetattr (m32c_console_ifd, TCSANOW, &attr);

434 console_raw = 1;

435 atexit (m32c_sim_restore_console);

436 }

437

438 if (stdin_ready ())

439 return 0x02; /* tx empty and rx full */

440 else

441 return 0x0a; /* transmitter empty */

442

443 case 0x2ee: /* m32c uart1 rx */

444 {

445 char c;

446 read (m32c_console_ifd, &c, 1);

447 if (m32c_console_ifd == 0 && c == 3) /* Ctrl-C */

448 {

449 printf ("Ctrl-C!\n");

450 exit (0);

451 }

452

453 if (m32c_console_ifd != 1)

454 {

455 if (isgraph (c))

456 printf ("\033[31m%c\033[0m", c);

457 else

458 printf ("\033[31m%02x\033[0m", c);

459 }

460 return c;

461 }

462 #endif

463

464 #ifdef TIMER_A

465 case 0x346: /* TA0low */

466 return timer_a.count & 0xff;

467 case 0x347: /* TA0high */

468 return (timer_a.count >> 8) & 0xff;

469 case 0x104: /* TRA */

470 return timer_a.count;

471 #endif

472

473 default:

474 /* In case both cases above are not included. */

475 ;

476 }

477

478 S ("=>");

479 if (trace)

480 printf (" %02x", *m);

481 E ();

482 return *m;

483 }

484

485 unsigned char

486 mem_get_qi (int address)

487 {

488 unsigned char rv;

489 S ("=>");

490 rv = mem_get_byte (address);

491 COUNT (0, 1);

492 E ();

493 return rv;

494 }

495

496 unsigned short

497 mem_get_hi (int address)

498 {

499 unsigned short rv;

500 S ("=>");

501 rv = mem_get_byte (address);

502 rv |= mem_get_byte (address + 1) * 256;

503 COUNT (0, 2);

504 E ();

505 return rv;

506 }

507

508 unsigned long

509 mem_get_psi (int address)

510 {

511 unsigned long rv;

512 S ("=>");

513 rv = mem_get_byte (address);

514 rv |= mem_get_byte (address + 1) * 256;

515 rv |= mem_get_byte (address + 2) * 65536;

516 COUNT (0, 3);

517 E ();

518 return rv;

519 }

520

521 unsigned long

522 mem_get_si (int address)

523 {

524 unsigned long rv;

525 S ("=>");

526 rv = mem_get_byte (address);

527 rv |= mem_get_byte (address + 1) << 8;

528 rv |= mem_get_byte (address + 2) << 16;

529 rv |= mem_get_byte (address + 3) << 24;

530 COUNT (0, 4);

531 E ();

532 return rv;

533 }

534

535 void

536 mem_get_blk (int address, void *bufptr, int nbytes)

537 {

538 S ("=>");

539 if (enable_counting)

540 mem_counters[0][1] += nbytes;

541 while (nbytes--)

542 *(char *) bufptr++ = mem_get_byte (address++);

543 E ();

544 }

545

546 int

547 sign_ext (int v, int bits)

548 {

549 if (bits < 32)

550 {

551 v &= (1 << bits) - 1;

552 if (v & (1 << (bits - 1)))

553 v -= (1 << bits);

554 }

555 return v;

556 }

557

558 #if TIMER_A

559 void

560 update_timer_a (void)

561 {

562 if (timer_a.bsr & 1)

563 {

564 timer_a.prescale--;

565 if (timer_a.prescale < 0)

566 {

567 if (A24)

568 {

569 switch (timer_a.mode & 0xc0)

570 {

571 case 0x00:

572 timer_a.prescale = 0;

573 break;

574 case 0x40:

575 timer_a.prescale = 8;

576 break;

577 case 0x80:

578 timer_a.prescale = timer_a.tcspr & 0x0f;

579 break;

580 case 0xc0:

581 timer_a.prescale = 32;

582 break;

583 }

584 }

585 else

586 {

587 timer_a.prescale = timer_a.tcspr;

588 }

589 timer_a.count--;

590 if (timer_a.count < 0)

591 {

592 timer_a.count = timer_a.reload;

593 if (timer_a.ic & 7)

594 {

595 if (A24)

596 mem_put_qi (0x6c, timer_a.ic | 0x08);

597 else

598 mem_put_qi (0x56, timer_a.ic | 0x08);

599 }

600 }

601 }

602 }

603

604 if (regs.r_flags & FLAGBIT_I /* interrupts enabled */

605 && timer_a.ic & 0x08 /* timer A interrupt triggered */

606 && (timer_a.ic & 0x07) > ((regs.r_flags >> 12) & 0x07))

607 {

608 if (A24)

609 trigger_peripheral_interrupt (12, 0x06c);

610 else

611 trigger_peripheral_interrupt (22, 0x056);

612 }

613 }

614 #endif