gdb/sparc-stub.c - Issue 11969036: Merge GDB 7.5.1

Side by Side Diff: gdb/sparc-stub.c

Issue 11969036: Merge GDB 7.5.1 (Closed) Base URL: http://git.chromium.org/native_client/nacl-gdb.git@master

Patch Set: Created 7 years, 11 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 /****************************************************************************

2

3 THIS SOFTWARE IS NOT COPYRIGHTED

4

5 HP offers the following for use in the public domain. HP makes no

6 warranty with regard to the software or it's performance and the

7 user accepts the software "AS IS" with all faults.

8

9 HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD

10 TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES

11 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

12

13 ****************************************************************************/

14

15 /****************************************************************************

16 * Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $

17 *

18 * Module name: remcom.c $

19 * Revision: 1.34 $

20 * Date: 91/03/09 12:29:49 $

21 * Contributor: Lake Stevens Instrument Division$

22 *

23 * Description: low level support for gdb debugger. $

24 *

25 * Considerations: only works on target hardware $

26 *

27 * Written by: Glenn Engel $

28 * ModuleState: Experimental $

29 *

30 * NOTES: See Below $

31 *

32 * Modified for SPARC by Stu Grossman, Cygnus Support.

33 *

34 * This code has been extensively tested on the Fujitsu SPARClite demo board.

35 *

36 * To enable debugger support, two things need to happen. One, a

37 * call to set_debug_traps() is necessary in order to allow any breakpoints

38 * or error conditions to be properly intercepted and reported to gdb.

39 * Two, a breakpoint needs to be generated to begin communication. This

40 * is most easily accomplished by a call to breakpoint(). Breakpoint()

41 * simulates a breakpoint by executing a trap #1.

42 *

43 *************

44 *

45 * The following gdb commands are supported:

46 *

47 * command function Return value

48 *

49 * g return the value of the CPU registers hex data or ENN

50 * G set the value of the CPU registers OK or ENN

51 *

52 * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN

53 * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN

54 *

55 * c Resume at current address SNN ( signal NN)

56 * cAA..AA Continue at address AA..AA SNN

57 *

58 * s Step one instruction SNN

59 * sAA..AA Step one instruction from AA..AA SNN

60 *

61 * k kill

62 *

63 * ? What was the last sigval ? SNN (signal NN)

64 *

65 * All commands and responses are sent with a packet which includes a

66 * checksum. A packet consists of

67 *

68 * $<packet info>#<checksum>.

69 *

70 * where

71 * <packet info> :: <characters representing the command or response>

72 * <checksum> :: < two hex digits computed as modulo 256 sum of <packetinfo>>

73 *

74 * When a packet is received, it is first acknowledged with either '+' or '-'.

75 * '+' indicates a successful transfer. '-' indicates a failed transfer.

76 *

77 * Example:

78 *

79 * Host: Reply:

80 * $m0,10#2a +$00010203040506070809101112131415#42

81 *

82 ****************************************************************************/

83

84 #include <string.h>

85 #include <signal.h>

86

87 /************************************************************************

88 *

89 * external low-level support routines

90 */

91

92 extern void putDebugChar(); /* write a single character */

93 extern int getDebugChar(); /* read and return a single char */

94

95 /************************************************************************/

96 /* BUFMAX defines the maximum number of characters in inbound/outbound buffers*/

97 /* at least NUMREGBYTES2 are needed for register packets /

98 #define BUFMAX 2048

99

100 static int initialized = 0; /* !0 means we've been initialized */

101

102 static void set_mem_fault_trap();

103

104 static const char hexchars[]="0123456789abcdef";

105

106 #define NUMREGS 72

107

108 /* Number of bytes of registers. */

109 #define NUMREGBYTES (NUMREGS * 4)

110 enum regnames {G0, G1, G2, G3, G4, G5, G6, G7,

111 O0, O1, O2, O3, O4, O5, SP, O7,

112 L0, L1, L2, L3, L4, L5, L6, L7,

113 I0, I1, I2, I3, I4, I5, FP, I7,

114

115 F0, F1, F2, F3, F4, F5, F6, F7,

116 F8, F9, F10, F11, F12, F13, F14, F15,

117 F16, F17, F18, F19, F20, F21, F22, F23,

118 F24, F25, F26, F27, F28, F29, F30, F31,

119 Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR };

120

121 /************************* ASSEMBLY CODE MACROS ***********************/

122 /* */

123

124 extern void trap_low();

125

126 asm("

127 .reserve trapstack, 1000 * 4, \"bss\", 8

128

129 .data

130 .align 4

131

132 in_trap_handler:

133 .word 0

134

135 .text

136 .align 4

137

138 ! This function is called when any SPARC trap (except window overflow or

139 ! underflow) occurs. It makes sure that the invalid register window is still

140 ! available before jumping into C code. It will also restore the world if you

141 ! return from handle_exception.

142

143 .globl _trap_low

144 _trap_low:

145 mov %psr, %l0

146 mov %wim, %l3

147

148 srl %l3, %l0, %l4 ! wim >> cwp

149 cmp %l4, 1

150 bne window_fine ! Branch if not in the invalid window

151 nop

152

153 ! Handle window overflow

154

155 mov %g1, %l4 ! Save g1, we use it to hold the wim

156 srl %l3, 1, %g1 ! Rotate wim right

157 tst %g1

158 bg good_wim ! Branch if new wim is non-zero

159 nop

160

161 ! At this point, we need to bring a 1 into the high order bit of the wim.

162 ! Since we don't want to make any assumptions about the number of register

163 ! windows, we figure it out dynamically so as to setup the wim correctly.

164

165 not %g1 ! Fill g1 with ones

166 mov %g1, %wim ! Fill the wim with ones

167 nop

168 nop

169 nop

170 mov %wim, %g1 ! Read back the wim

171 inc %g1 ! Now g1 has 1 just to left of wim

172 srl %g1, 1, %g1 ! Now put 1 at top of wim

173 mov %g0, %wim ! Clear wim so that subsequent save

174 nop ! won't trap

175 nop

176 nop

177

178 good_wim:

179 save %g0, %g0, %g0 ! Slip into next window

180 mov %g1, %wim ! Install the new wim

181

182 std %l0, [%sp + 0 * 4] ! save L & I registers

183 std %l2, [%sp + 2 * 4]

184 std %l4, [%sp + 4 * 4]

185 std %l6, [%sp + 6 * 4]

186

187 std %i0, [%sp + 8 * 4]

188 std %i2, [%sp + 10 * 4]

189 std %i4, [%sp + 12 * 4]

190 std %i6, [%sp + 14 * 4]

191

192 restore ! Go back to trap window.

193 mov %l4, %g1 ! Restore %g1

194

195 window_fine:

196 sethi %hi(in_trap_handler), %l4

197 ld [%lo(in_trap_handler) + %l4], %l5

198 tst %l5

199 bg recursive_trap

200 inc %l5

201

202 set trapstack+1000*4, %sp ! Switch to trap stack

203

204 recursive_trap:

205 st %l5, [%lo(in_trap_handler) + %l4]

206 sub %sp,(16+1+6+1+72)*4,%sp ! Make room for input & locals

207 ! + hidden arg + arg spill

208 ! + doubleword alignment

209 ! + registers[72] local var

210

211 std %g0, [%sp + (24 + 0) * 4] ! registers[Gx]

212 std %g2, [%sp + (24 + 2) * 4]

213 std %g4, [%sp + (24 + 4) * 4]

214 std %g6, [%sp + (24 + 6) * 4]

215

216 std %i0, [%sp + (24 + 8) * 4] ! registers[Ox]

217 std %i2, [%sp + (24 + 10) * 4]

218 std %i4, [%sp + (24 + 12) * 4]

219 std %i6, [%sp + (24 + 14) * 4]

220 ! F0->F31 not implemented

221 mov %y, %l4

222 mov %tbr, %l5

223 st %l4, [%sp + (24 + 64) * 4] ! Y

224 st %l0, [%sp + (24 + 65) * 4] ! PSR

225 st %l3, [%sp + (24 + 66) * 4] ! WIM

226 st %l5, [%sp + (24 + 67) * 4] ! TBR

227 st %l1, [%sp + (24 + 68) * 4] ! PC

228 st %l2, [%sp + (24 + 69) * 4] ! NPC

229

230 ! CPSR and FPSR not impl

231

232 or %l0, 0xf20, %l4

233 mov %l4, %psr ! Turn on traps, disable interrupts

234

235 call _handle_exception

236 add %sp, 24 * 4, %o0 ! Pass address of registers

237

238 ! Reload all of the registers that aren't on the stack

239

240 ld [%sp + (24 + 1) * 4], %g1 ! registers[Gx]

241 ldd [%sp + (24 + 2) * 4], %g2

242 ldd [%sp + (24 + 4) * 4], %g4

243 ldd [%sp + (24 + 6) * 4], %g6

244

245 ldd [%sp + (24 + 8) * 4], %i0 ! registers[Ox]

246 ldd [%sp + (24 + 10) * 4], %i2

247 ldd [%sp + (24 + 12) * 4], %i4

248 ldd [%sp + (24 + 14) * 4], %i6

249

250 ldd [%sp + (24 + 64) * 4], %l0 ! Y & PSR

251 ldd [%sp + (24 + 68) * 4], %l2 ! PC & NPC

252

253 restore ! Ensure that previous window is valid

254 save %g0, %g0, %g0 ! by causing a window_underflow trap

255

256 mov %l0, %y

257 mov %l1, %psr ! Make sure that traps are disabled

258 ! for rett

259

260 sethi %hi(in_trap_handler), %l4

261 ld [%lo(in_trap_handler) + %l4], %l5

262 dec %l5

263 st %l5, [%lo(in_trap_handler) + %l4]

264

265 jmpl %l2, %g0 ! Restore old PC

266 rett %l3 ! Restore old nPC

267 ");

268

269 /* Convert ch from a hex digit to an int */

270

271 static int

272 hex (unsigned char ch)

273 {

274 if (ch >= 'a' && ch <= 'f')

275 return ch-'a'+10;

276 if (ch >= '0' && ch <= '9')

277 return ch-'0';

278 if (ch >= 'A' && ch <= 'F')

279 return ch-'A'+10;

280 return -1;

281 }

282

283 static char remcomInBuffer[BUFMAX];

284 static char remcomOutBuffer[BUFMAX];

285

286 /* scan for the sequence $<data>#<checksum> */

287

288 unsigned char *

289 getpacket (void)

290 {

291 unsigned char *buffer = &remcomInBuffer[0];

292 unsigned char checksum;

293 unsigned char xmitcsum;

294 int count;

295 char ch;

296

297 while (1)

298 {

299 /* wait around for the start character, ignore all other characters */

300 while ((ch = getDebugChar ()) != '$')

301 ;

302

303 retry:

304 checksum = 0;

305 xmitcsum = -1;

306 count = 0;

307

308 /* now, read until a # or end of buffer is found */

309 while (count < BUFMAX - 1)

310 {

311 ch = getDebugChar ();

312 if (ch == '$')

313 goto retry;

314 if (ch == '#')

315 break;

316 checksum = checksum + ch;

317 buffer[count] = ch;

318 count = count + 1;

319 }

320 buffer[count] = 0;

321

322 if (ch == '#')

323 {

324 ch = getDebugChar ();

325 xmitcsum = hex (ch) << 4;

326 ch = getDebugChar ();

327 xmitcsum += hex (ch);

328

329 if (checksum != xmitcsum)

330 {

331 putDebugChar ('-'); /* failed checksum */

332 }

333 else

334 {

335 putDebugChar ('+'); /* successful transfer */

336

337 /* if a sequence char is present, reply the sequence ID */

338 if (buffer[2] == ':')

339 {

340 putDebugChar (buffer[0]);

341 putDebugChar (buffer[1]);

342

343 return &buffer[3];

344 }

345

346 return &buffer[0];

347 }

348 }

349 }

350 }

351

352 /* send the packet in buffer. */

353

354 static void

355 putpacket (unsigned char *buffer)

356 {

357 unsigned char checksum;

358 int count;

359 unsigned char ch;

360

361 /* $<packet info>#<checksum>. */

362 do

363 {

364 putDebugChar('$');

365 checksum = 0;

366 count = 0;

367

368 while (ch = buffer[count])

369 {

370 putDebugChar(ch);

371 checksum += ch;

372 count += 1;

373 }

374

375 putDebugChar('#');

376 putDebugChar(hexchars[checksum >> 4]);

377 putDebugChar(hexchars[checksum & 0xf]);

378

379 }

380 while (getDebugChar() != '+');

381 }

382

383 /* Indicate to caller of mem2hex or hex2mem that there has been an

384 error. */

385 static volatile int mem_err = 0;

386

387 /* Convert the memory pointed to by mem into hex, placing result in buf.

388 * Return a pointer to the last char put in buf (null), in case of mem fault,

389 * return 0.

390 * If MAY_FAULT is non-zero, then we will handle memory faults by returning

391 * a 0, else treat a fault like any other fault in the stub.

392 */

393

394 static unsigned char *

395 mem2hex (unsigned char mem, unsigned char buf, int count, int may_fault)

396 {

397 unsigned char ch;

398

399 set_mem_fault_trap(may_fault);

400

401 while (count-- > 0)

402 {

403 ch = *mem++;

404 if (mem_err)

405 return 0;

406 *buf++ = hexchars[ch >> 4];

407 *buf++ = hexchars[ch & 0xf];

408 }

409

410 *buf = 0;

411

412 set_mem_fault_trap(0);

413

414 return buf;

415 }

416

417 /* convert the hex array pointed to by buf into binary to be placed in mem

418 * return a pointer to the character AFTER the last byte written */

419

420 static char *

421 hex2mem (unsigned char buf, unsigned char mem, int count, int may_fault)

422 {

423 int i;

424 unsigned char ch;

425

426 set_mem_fault_trap(may_fault);

427

428 for (i=0; i<count; i++)

429 {

430 ch = hex(*buf++) << 4;

431 ch \|= hex(*buf++);

432 *mem++ = ch;

433 if (mem_err)

434 return 0;

435 }

436

437 set_mem_fault_trap(0);

438

439 return mem;

440 }

441

442 /* This table contains the mapping between SPARC hardware trap types, and

443 signals, which are primarily what GDB understands. It also indicates

444 which hardware traps we need to commandeer when initializing the stub. */

445

446 static struct hard_trap_info

447 {

448 unsigned char tt; /* Trap type code for SPARClite */

449 unsigned char signo; /* Signal that we map this trap into */

450 } hard_trap_info[] = {

451 {1, SIGSEGV}, /* instruction access error */

452 {2, SIGILL}, /* privileged instruction */

453 {3, SIGILL}, /* illegal instruction */

454 {4, SIGEMT}, /* fp disabled */

455 {36, SIGEMT}, /* cp disabled */

456 {7, SIGBUS}, /* mem address not aligned */

457 {9, SIGSEGV}, /* data access exception */

458 {10, SIGEMT}, /* tag overflow */

459 {128+1, SIGTRAP}, /* ta 1 - normal breakpoint instruction */

460 {0, 0} /* Must be last */

461 };

462

463 /* Set up exception handlers for tracing and breakpoints */

464

465 void

466 set_debug_traps (void)

467 {

468 struct hard_trap_info *ht;

469

470 for (ht = hard_trap_info; ht->tt && ht->signo; ht++)

471 exceptionHandler(ht->tt, trap_low);

472

473 initialized = 1;

474 }

475

476 asm ("

477 ! Trap handler for memory errors. This just sets mem_err to be non-zero. It

478 ! assumes that %l1 is non-zero. This should be safe, as it is doubtful that

479 ! 0 would ever contain code that could mem fault. This routine will skip

480 ! past the faulting instruction after setting mem_err.

481

482 .text

483 .align 4

484

485 _fltr_set_mem_err:

486 sethi %hi(_mem_err), %l0

487 st %l1, [%l0 + %lo(_mem_err)]

488 jmpl %l2, %g0

489 rett %l2+4

490 ");

491

492 static void

493 set_mem_fault_trap (int enable)

494 {

495 extern void fltr_set_mem_err();

496 mem_err = 0;

497

498 if (enable)

499 exceptionHandler(9, fltr_set_mem_err);

500 else

501 exceptionHandler(9, trap_low);

502 }

503

504 /* Convert the SPARC hardware trap type code to a unix signal number. */

505

506 static int

507 computeSignal (int tt)

508 {

509 struct hard_trap_info *ht;

510

511 for (ht = hard_trap_info; ht->tt && ht->signo; ht++)

512 if (ht->tt == tt)

513 return ht->signo;

514

515 return SIGHUP; /* default for things we don't know about */

516 }

517

518 /*

519 * While we find nice hex chars, build an int.

520 * Return number of chars processed.

521 */

522

523 static int

524 hexToInt(char *ptr, int intValue)

525 {

526 int numChars = 0;

527 int hexValue;

528

529 *intValue = 0;

530

531 while (**ptr)

532 {

533 hexValue = hex(**ptr);

534 if (hexValue < 0)

535 break;

536

537 intValue = (intValue << 4) \| hexValue;

538 numChars ++;

539

540 (*ptr)++;

541 }

542

543 return (numChars);

544 }

545

546 /*

547 * This function does all command procesing for interfacing to gdb. It

548 * returns 1 if you should skip the instruction at the trap address, 0

549 * otherwise.

550 */

551

552 extern void breakinst();

553

554 static void

555 handle_exception (unsigned long *registers)

556 {

557 int tt; /* Trap type */

558 int sigval;

559 int addr;

560 int length;

561 char *ptr;

562 unsigned long *sp;

563

564 /* First, we must force all of the windows to be spilled out */

565

566 asm(" save %sp, -64, %sp

567 save %sp, -64, %sp

568 save %sp, -64, %sp

569 save %sp, -64, %sp

570 save %sp, -64, %sp

571 save %sp, -64, %sp

572 save %sp, -64, %sp

573 save %sp, -64, %sp

574 restore

575 restore

576 restore

577 restore

578 restore

579 restore

580 restore

581 restore

582 ");

583

584 if (registers[PC] == (unsigned long)breakinst)

585 {

586 registers[PC] = registers[NPC];

587 registers[NPC] += 4;

588 }

589

590 sp = (unsigned long *)registers[SP];

591

592 tt = (registers[TBR] >> 4) & 0xff;

593

594 /* reply to host that an exception has occurred */

595 sigval = computeSignal(tt);

596 ptr = remcomOutBuffer;

597

598 *ptr++ = 'T';

599 *ptr++ = hexchars[sigval >> 4];

600 *ptr++ = hexchars[sigval & 0xf];

601

602 *ptr++ = hexchars[PC >> 4];

603 *ptr++ = hexchars[PC & 0xf];

604 *ptr++ = ':';

605 ptr = mem2hex((char *)&registers[PC], ptr, 4, 0);

606 *ptr++ = ';';

607

608 *ptr++ = hexchars[FP >> 4];

609 *ptr++ = hexchars[FP & 0xf];

610 *ptr++ = ':';

611 ptr = mem2hex(sp + 8 + 6, ptr, 4, 0); /* FP */

612 *ptr++ = ';';

613

614 *ptr++ = hexchars[SP >> 4];

615 *ptr++ = hexchars[SP & 0xf];

616 *ptr++ = ':';

617 ptr = mem2hex((char *)&sp, ptr, 4, 0);

618 *ptr++ = ';';

619

620 *ptr++ = hexchars[NPC >> 4];

621 *ptr++ = hexchars[NPC & 0xf];

622 *ptr++ = ':';

623 ptr = mem2hex((char *)&registers[NPC], ptr, 4, 0);

624 *ptr++ = ';';

625

626 *ptr++ = hexchars[O7 >> 4];

627 *ptr++ = hexchars[O7 & 0xf];

628 *ptr++ = ':';

629 ptr = mem2hex((char *)&registers[O7], ptr, 4, 0);

630 *ptr++ = ';';

631

632 *ptr++ = 0;

633

634 putpacket(remcomOutBuffer);

635

636 while (1)

637 {

638 remcomOutBuffer[0] = 0;

639

640 ptr = getpacket();

641 switch (*ptr++)

642 {

643 case '?':

644 remcomOutBuffer[0] = 'S';

645 remcomOutBuffer[1] = hexchars[sigval >> 4];

646 remcomOutBuffer[2] = hexchars[sigval & 0xf];

647 remcomOutBuffer[3] = 0;

648 break;

649

650 case 'd': /* toggle debug flag */

651 break;

652

653 case 'g': /* return the value of the CPU registers */

654 {

655 ptr = remcomOutBuffer;

656 ptr = mem2hex((char )registers, ptr, 16 4, 0); /* G & O regs */

657 ptr = mem2hex(sp + 0, ptr, 16 * 4, 0); /* L & I regs */

658 memset(ptr, '0', 32 * 8); /* Floating point */

659 mem2hex((char *)&registers[Y],

660 ptr + 32 * 4 * 2,

661 8 * 4,

662 0); /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */

663 }

664 break;

665

666 case 'G': /* set the value of the CPU registers - return OK */

667 {

668 unsigned long *newsp, psr;

669

670 psr = registers[PSR];

671

672 hex2mem(ptr, (char )registers, 16 4, 0); /* G & O regs */

673 hex2mem(ptr + 16 * 4 * 2, sp + 0, 16 * 4, 0); /* L & I regs */

674 hex2mem(ptr + 64 * 4 * 2, (char *)&registers[Y],

675 8 * 4, 0); /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */

676

677 /* See if the stack pointer has moved. If so, then copy the saved

678 locals and ins to the new location. This keeps the window

679 overflow and underflow routines happy. */

680

681 newsp = (unsigned long *)registers[SP];

682 if (sp != newsp)

683 sp = memcpy(newsp, sp, 16 * 4);

684

685 /* Don't allow CWP to be modified. */

686

687 if (psr != registers[PSR])

688 registers[PSR] = (psr & 0x1f) \| (registers[PSR] & ~0x1f);

689

690 strcpy(remcomOutBuffer,"OK");

691 }

692 break;

693

694 case 'm': /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */

695 /* Try to read %x,%x. */

696

697 if (hexToInt(&ptr, &addr)

698 && *ptr++ == ','

699 && hexToInt(&ptr, &length))

700 {

701 if (mem2hex((char *)addr, remcomOutBuffer, length, 1))

702 break;

703

704 strcpy (remcomOutBuffer, "E03");

705 }

706 else

707 strcpy(remcomOutBuffer,"E01");

708 break;

709

710 case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK * /

711 /* Try to read '%x,%x:'. */

712

713 if (hexToInt(&ptr, &addr)

714 && *ptr++ == ','

715 && hexToInt(&ptr, &length)

716 && *ptr++ == ':')

717 {

718 if (hex2mem(ptr, (char *)addr, length, 1))

719 strcpy(remcomOutBuffer, "OK");

720 else

721 strcpy(remcomOutBuffer, "E03");

722 }

723 else

724 strcpy(remcomOutBuffer, "E02");

725 break;

726

727 case 'c': /* cAA..AA Continue at address AA..AA(optional) */

728 /* try to read optional parameter, pc unchanged if no parm */

729

730 if (hexToInt(&ptr, &addr))

731 {

732 registers[PC] = addr;

733 registers[NPC] = addr + 4;

734 }

735

736 /* Need to flush the instruction cache here, as we may have deposited a

737 breakpoint, and the icache probably has no way of knowing that a data ref to

738 some location may have changed something that is in the instruction cache.

739 */

740

741 flush_i_cache();

742 return;

743

744 /* kill the program */

745 case 'k' : /* do nothing */

746 break;

747 #if 0

748 case 't': /* Test feature */

749 asm (" std %f30,[%sp]");

750 break;

751 #endif

752 case 'r': /* Reset */

753 asm ("call 0

754 nop ");

755 break;

756 } /* switch */

757

758 /* reply to the request */

759 putpacket(remcomOutBuffer);

760 }

761 }

762

763 /* This function will generate a breakpoint exception. It is used at the

764 beginning of a program to sync up with a debugger and can be used

765 otherwise as a quick means to stop program execution and "break" into

766 the debugger. */

767

768 void

769 breakpoint (void)

770 {

771 if (!initialized)

772 return;

773

774 asm(" .globl _breakinst

775

776 _breakinst: ta 1

777 ");

778 }

OLD	NEW

« no previous file with comments | « gdb/sparc-sol2-tdep.c ('k') | gdb/sparc-tdep.h » ('j') | no next file with comments »