Mercurial > nand-ecoscentric
annotate packages/hal/sparclite/arch/current/src/icontext.c @ 6:d376b777e2ce ecos-sw-1999-05-14
Merge from eCos master repository on 1999-05-14-19:27:43-BST
| author | jlarmour |
|---|---|
| date | Fri, 14 May 1999 12:20:00 +0000 |
| parents | 443894e2e912 |
| children | ece80412419a |
| rev | line source |
|---|---|
| 2 | 1 /*============================================================================= |
| 2 // | |
| 3 // icontext.c | |
| 4 // | |
| 5 // SPARClite HAL context init function | |
| 6 // | |
| 7 //============================================================================= | |
| 8 //####COPYRIGHTBEGIN#### | |
| 9 // | |
| 10 // ------------------------------------------- | |
| 11 // The contents of this file are subject to the Cygnus eCos Public License | |
| 12 // Version 1.0 (the "License"); you may not use this file except in | |
| 13 // compliance with the License. You may obtain a copy of the License at | |
| 14 // http://sourceware.cygnus.com/ecos | |
| 15 // | |
| 16 // Software distributed under the License is distributed on an "AS IS" | |
| 17 // basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the | |
| 18 // License for the specific language governing rights and limitations under | |
| 19 // the License. | |
| 20 // | |
| 21 // The Original Code is eCos - Embedded Cygnus Operating System, released | |
| 22 // September 30, 1998. | |
| 23 // | |
| 24 // The Initial Developer of the Original Code is Cygnus. Portions created | |
| 25 // by Cygnus are Copyright (C) 1998,1999 Cygnus Solutions. All Rights Reserved. | |
| 26 // ------------------------------------------- | |
| 27 // | |
| 28 //####COPYRIGHTEND#### | |
| 29 //============================================================================= | |
| 30 //#####DESCRIPTIONBEGIN#### | |
| 31 // | |
| 32 // Author(s): hmt | |
| 33 // Contributors: hmt | |
| 34 // Date: 1998-12-14 | |
| 35 // Purpose: HAL context initialization function | |
| 36 // Description: Initialize a HAL context for SPARClite; this is in C and out | |
| 37 // of line because there is too much of it for a simple macro. | |
| 38 // | |
| 39 //####DESCRIPTIONEND#### | |
| 40 // | |
| 41 //===========================================================================*/ | |
| 42 | |
| 43 #include <pkgconf/hal.h> | |
| 44 | |
| 45 #include <cyg/hal/hal_arch.h> // HAL header | |
| 46 | |
| 47 #include <cyg/infra/cyg_type.h> | |
| 48 | |
| 49 #include <cyg/hal/vectors.h> // SAVE_REGS_SIZE, __WINSIZE, ... | |
| 50 | |
| 51 /*---------------------------------------------------------------------------*/ | |
| 52 | |
| 53 /* We lay out the stack in the manner that the PCS demands: | |
| 54 * frame pointer -----> [top of stack] | |
| 55 * Argument spill area (6 words) | |
| 56 * Return Arg pointer | |
| 57 * Initial saved register window (i[8], l[8]) | |
| 58 * for use by program when it starts | |
| 59 * [rest of] saved register object (various) | |
| 60 * stack pointer -----> saved register window (i[8], l[8]) | |
| 61 * to allow us to be interrupted. | |
| 62 * | |
| 63 * ie. frame pointer -> | |
| 64 * struct HAL_FrameStructure | |
| 65 * stack pointer -> struct HAL_SavedRegisters | |
| 66 * | |
| 67 * and when the context "resumes" sp is incremented by 40 * 4, the size of | |
| 68 * a _struct HAL_SavedRegisters_ which points it at the extant but unused | |
| 69 * _struct HAL_FrameStructure_ as the PCS requires. The frame pointer is | |
| 70 * left pointing off the top of stack. | |
| 71 * | |
| 72 * | |
| 73 * Thus the stack is the same if created from an already executing context: | |
| 74 * | |
| 75 * frame pointer -----> | |
| 76 * [temporaries and locals] | |
| 77 * [more arguments] | |
| 78 * Argument spill area (6 words) | |
| 79 * Return Arg pointer | |
| 80 * [sp at entry]------> Previous saved register window (i[8], l[8]) | |
| 81 * for use by program when it starts | |
| 82 * [rest of] saved register object (various) | |
| 83 * stack pointer -----> saved register window (i[8], l[8]) | |
| 84 * to allow us to be interrupted. | |
| 85 */ | |
| 86 | |
| 87 CYG_ADDRESS | |
| 88 hal_thread_init_context( CYG_WORD sparg, | |
| 89 CYG_WORD thread, | |
| 90 CYG_WORD entry, | |
| 91 CYG_WORD id ) | |
| 92 { | |
| 93 register CYG_WORD fp = sparg; | |
| 94 register CYG_WORD sp = 0; | |
| 95 register HAL_SavedRegisters *regs; | |
| 96 register HAL_FrameStructure *frame; | |
| 97 int i; | |
| 98 | |
| 99 if ( 0 == (id & 0xffff0000) ) | |
| 100 id <<= 16; | |
| 101 | |
|
6
d376b777e2ce
Merge from eCos master repository on 1999-05-14-19:27:43-BST
jlarmour
parents:
2
diff
changeset
|
102 fp &= ~15; // round down to double alignment |
| 2 | 103 |
| 104 frame = (HAL_FrameStructure *)( | |
| 105 fp - sizeof( HAL_FrameStructure ) ); | |
| 106 | |
| 107 regs = (HAL_SavedRegisters *)( | |
| 108 ((CYG_WORD)frame) - sizeof(HAL_SavedRegisters) ); | |
| 109 | |
| 110 sp = (CYG_WORD)regs; | |
| 111 | |
| 112 for ( i = 0; i < 6; i++ ) { | |
| 113 frame->spill_args[i] = id | 0xa0 | i; | |
| 114 } | |
| 115 frame->composite_return_ptr = 0; | |
| 116 | |
| 117 for ( i = 0; i < 8; i++ ) { | |
| 118 frame->li.i[i] = id | ( 56 + i ); | |
| 119 frame->li.l[i] = id | ( 48 + i ); | |
| 120 regs ->li.i[i] = id | ( 24 + i ); | |
| 121 regs ->li.l[i] = id | ( 16 + i ); | |
| 122 regs ->o[i] = id | ( 8 + i ); | |
| 123 regs ->g[i] = id | ( i ); | |
| 124 } | |
| 125 | |
| 126 // first terminate the linked list on the stack in the initial | |
| 127 // (already saved) register window: | |
| 128 frame->li.i[6] = regs->li.i[6] = (cyg_uint32)fp; // frame pointer | |
| 129 frame->li.i[7] = regs->li.i[7] = (cyg_uint32)0; // no ret addr here | |
| 130 | |
| 131 // and set up other saved regs as if called from just before | |
| 132 // the entry point: | |
| 133 regs->o[7] = (entry - 8); | |
| 134 regs->o[6] = sp; | |
| 135 | |
| 136 // this is the argument that the entry point is called with | |
| 137 regs->o[0] = thread; | |
| 138 | |
| 139 // this is the initial CWP; quite arbitrary really, the WIM is set up | |
| 140 // accordingly in hal_thread_load_context(). | |
| 141 | |
| 142 regs->g[0] = 7; | |
| 143 | |
| 144 return (CYG_ADDRESS)sp; | |
| 145 } | |
| 146 | |
| 147 // --------------------------------------------------------------------------- | |
| 148 | |
| 149 //#define THREAD_DEBUG_SERIAL_VERBOSE | |
| 150 | |
| 151 #ifdef THREAD_DEBUG_SERIAL_VERBOSE // NOT INCLUDED | |
| 152 | |
| 153 // This is unpleasant to try to debug, because these routines are called | |
| 154 // WHEN THE PROGRAM IS NOT RUNNING from the CygMon's GDB stubs - so you | |
| 155 // can't use any normal output: these little routines use the serial | |
| 156 // line directly, so are best used when debugging via Ethernet, so you | |
| 157 // just have a separate output stream to read. Nasty... | |
| 158 | |
| 159 #include <cyg/hal/hal_diag.h> | |
| 160 | |
| 161 #undef HAL_DIAG_WRITE_CHAR | |
| 162 #define HAL_DIAG_WRITE_CHAR(_c_) CYG_MACRO_START \ | |
| 163 SLEB_LED = (_c_); \ | |
| 164 HAL_DIAG_WRITE_CHAR_DIRECT( _c_ ); \ | |
| 165 CYG_MACRO_END | |
| 166 | |
| 167 static void swritec( char c ) | |
| 168 { | |
| 169 HAL_DIAG_WRITE_CHAR( c ); | |
| 170 } | |
| 171 | |
| 172 static void swrites( char *s ) | |
| 173 { | |
| 174 char c; | |
| 175 while ( 0 != (c = *s++) ) | |
| 176 HAL_DIAG_WRITE_CHAR( c ); | |
| 177 } | |
| 178 | |
| 179 static void swritex( cyg_uint32 x ) | |
| 180 { | |
| 181 int i; | |
| 182 swrites( "0x" ); | |
| 183 for ( i = 28; i >= 0; i-= 4 ) { | |
| 184 char c = "0123456789abcdef"[ 0xf & (x >> i) ]; | |
| 185 HAL_DIAG_WRITE_CHAR( c ); | |
| 186 } | |
| 187 } | |
| 188 | |
| 189 #define newline() swrites( "\n\r" ) | |
| 190 | |
| 191 static void x8( char *s, unsigned long *xp ) | |
| 192 { | |
| 193 int i; | |
| 194 for ( i = 0; i < 8; i++ ) { | |
| 195 swrites( s ); | |
| 196 swritec( '0' + i ); | |
| 197 swrites( " = " ); | |
| 198 swritex( xp[i] ); | |
| 199 if ( 3 == (i & 3) ) | |
| 200 newline(); | |
| 201 else | |
| 202 swrites( " " ); | |
| 203 } | |
| 204 } | |
| 205 | |
| 206 #endif // THREAD_DEBUG_SERIAL_VERBOSE ... NOT INCLUDED | |
| 207 | |
| 208 // --------------------------------------------------------------------------- | |
| 209 // Routines in icontext.c used here because they're quite large for | |
| 210 // the SPARClite (note param order); these are used in talking to GDB. | |
| 211 | |
| 212 enum regnames {G0 = 0, G1, G2, G3, G4, G5, G6, G7, | |
| 213 O0, O1, O2, O3, O4, O5, SP, O7, | |
| 214 L0, L1, L2, L3, L4, L5, L6, L7, | |
| 215 I0, I1, I2, I3, I4, I5, FP, I7, | |
| 216 | |
| 217 F0, F1, F2, F3, F4, F5, F6, F7, | |
| 218 F8, F9, F10, F11, F12, F13, F14, F15, | |
| 219 F16, F17, F18, F19, F20, F21, F22, F23, | |
| 220 F24, F25, F26, F27, F28, F29, F30, F31, | |
| 221 Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR}; | |
| 222 | |
| 223 typedef unsigned long target_register_t; | |
| 224 | |
| 225 void | |
| 226 cyg_hal_sparc_get_gdb_regs( void *gdb_regset, | |
| 227 HAL_SavedRegisters *eCos_regset ) | |
| 228 { | |
| 229 target_register_t *gdb = (target_register_t *)gdb_regset; | |
| 230 int reg; | |
| 231 cyg_uint32 scratch = 0; | |
| 232 cyg_uint32 *sptrap; | |
| 233 HAL_SavedWindow *trapli, *ctxli; | |
| 234 | |
| 235 if ( 0 == eCos_regset->g[0] || | |
| 236 0xc0 == (0xe0 & eCos_regset->g[0]) ) { | |
| 237 // Then it's an interrupt stack saved state: | |
| 238 // (either minimal, or a saved PSR with traps disabled) | |
| 239 // The saved register set is pretty minimal, so we have to grub | |
| 240 // around in the stack to find out some truth... | |
| 241 sptrap = (cyg_uint32 *)eCos_regset; // point to the IL save area for | |
| 242 sptrap -= 24; // the trap handler, for PC, NPC | |
| 243 trapli = (HAL_SavedWindow *)sptrap; // Get at those regs | |
| 244 | |
| 245 ctxli = (HAL_SavedWindow *)(trapli->i[6]); // (the frame pointer) | |
| 246 // and get at the interruptee's regs | |
| 247 | |
| 248 // Pick up interruptee's registers from all over the stack: | |
| 249 for ( reg = 0; reg < 8 ; reg++ ) { | |
| 250 gdb[ G0 + reg ] = eCos_regset->g[reg]; | |
| 251 gdb[ O0 + reg ] = trapli->i[reg]; | |
| 252 gdb[ L0 + reg ] = ctxli->l[reg]; | |
| 253 gdb[ I0 + reg ] = ctxli->i[reg]; | |
| 254 } | |
| 255 | |
| 256 // Clear out G0 which is always 0 (but abused in eCos_regset) | |
| 257 // and the FP regs which we do not have: | |
| 258 gdb[ G0 ] = 0; | |
| 259 for ( reg = F0; reg <= F31; reg++ ) | |
| 260 gdb[ reg ] = 0; | |
| 261 | |
| 262 // In the save context _of the trap handler_ registers are as follows: | |
| 263 // %l0 = psr (with this CWP/window-level in it) | |
| 264 // %l1 = pc | |
| 265 // %l2 = npc | |
| 266 // %l3 = vector number (1-15 for interrupts) | |
| 267 // %l4 = Y register preserved | |
| 268 gdb[ Y ] = trapli->l[4]; | |
| 269 | |
| 270 scratch = trapli->l[0]; // the PSR in the trap handler | |
| 271 scratch++; // back to interupted thread's window | |
| 272 scratch &=~ 0x38; // clear ET and any CWP overflow | |
| 273 gdb[ PSR ] = scratch; | |
| 274 gdb[ WIM ] = 1 << ((__WINBITS & (1 + scratch))); | |
| 275 | |
| 276 // Read _a_ TBR value and ignore the current trap details: | |
| 277 asm volatile ( "rd %%tbr, %0" : "=r"(scratch) : ); | |
| 278 gdb[ TBR ] = (scratch &~ 0xfff); | |
| 279 | |
| 280 gdb[ PC ] = trapli->l[1]; | |
| 281 gdb[ NPC ] = trapli->l[2]; | |
| 282 | |
| 283 gdb[ FPSR ] = 0; | |
| 284 gdb[ CPSR ] = 0; | |
| 285 | |
| 286 #ifdef THREAD_DEBUG_SERIAL_VERBOSE | |
| 287 newline(); | |
| 288 swrites( "-----------------------------------------------------" ); newline(); | |
| 289 swrites( "-------------- INTERRUPT STACK GET ------------------" ); newline(); | |
| 290 swrites( "eCos regset at " ); swritex( eCos_regset ); newline(); | |
| 291 swrites( " trapli " ); swritex( trapli ); newline(); | |
| 292 swrites( " ctxli " ); swritex( ctxli ); newline(); | |
| 293 x8( "global ", &(gdb[G0]) ); | |
| 294 x8( " in ", &(gdb[I0]) ); | |
| 295 x8( " local ", &(gdb[L0]) ); | |
| 296 x8( " out ", &(gdb[O0]) ); | |
| 297 swrites( "gdb PC = " ); swritex( gdb[ PC ] ); newline(); | |
| 298 swrites( "gdb NPC = " ); swritex( gdb[ NPC ] ); newline(); | |
| 299 swrites( "gdb PSR = " ); swritex( gdb[ PSR ] ); newline(); | |
| 300 #endif | |
| 301 | |
| 302 } | |
| 303 else { | |
| 304 // It's a synchronous context switch that led to this object. | |
| 305 // Pick up interruptee's registers from the saved context: | |
| 306 for ( reg = 0; reg < 8 ; reg++ ) { | |
| 307 #ifdef CYGDBG_HAL_COMMON_CONTEXT_SAVE_MINIMUM | |
| 308 gdb[ G0 + reg ] = 0; | |
| 309 gdb[ O0 + reg ] = 0; | |
| 310 #else | |
| 311 gdb[ G0 + reg ] = eCos_regset->g[reg]; | |
| 312 gdb[ O0 + reg ] = eCos_regset->o[reg]; | |
| 313 #endif | |
| 314 gdb[ L0 + reg ] = eCos_regset->li.l[reg]; | |
| 315 gdb[ I0 + reg ] = eCos_regset->li.i[reg]; | |
| 316 } | |
| 317 | |
| 318 #ifdef CYGDBG_HAL_COMMON_CONTEXT_SAVE_MINIMUM | |
| 319 // Set up the stack pointer by arithmetic and the return address | |
| 320 gdb[ SP ] = ((cyg_uint32)(eCos_regset)); | |
| 321 gdb[ O7 ] = eCos_regset->o[ 7 ]; | |
| 322 #else | |
| 323 // Clear out G0 which is always 0 (but abused in eCos_regset) | |
| 324 gdb[ G0 ] = 0; | |
| 325 #endif | |
| 326 // and clear the FP regs which we do not have: | |
| 327 for ( reg = F0; reg <= F31; reg++ ) | |
| 328 gdb[ reg ] = 0; | |
| 329 | |
| 330 gdb[ Y ] = 0; // it's not preserved. | |
| 331 | |
| 332 scratch = eCos_regset->g[ 0 ]; // the PSR in the saved context | |
| 333 gdb[ PSR ] = scratch; // return it verbatim. | |
| 334 gdb[ WIM ] = 1 << ((__WINBITS & (1 + scratch))); | |
| 335 | |
| 336 // Read _a_ TBR value and ignore the current trap details: | |
| 337 asm volatile ( "rd %%tbr, %0" : "=r"(scratch) : ); | |
| 338 gdb[ TBR ] = (scratch &~ 0xfff); | |
| 339 | |
| 340 gdb[ PC ] = eCos_regset->o[ 7 ]; // the return address | |
| 341 gdb[ NPC ] = 4 + gdb[ PC ]; | |
| 342 | |
| 343 gdb[ FPSR ] = 0; | |
| 344 gdb[ CPSR ] = 0; | |
| 345 | |
| 346 #ifdef THREAD_DEBUG_SERIAL_VERBOSE | |
| 347 newline(); | |
| 348 swrites( "-----------------------------------------------------" ); newline(); | |
| 349 swrites( "-------------- SYNCHRONOUS SWITCH GET----------------" ); newline(); | |
| 350 swrites( "eCos regset at " ); swritex( eCos_regset ); newline(); | |
| 351 x8( "global ", &(gdb[G0]) ); | |
| 352 x8( " in ", &(gdb[I0]) ); | |
| 353 x8( " local ", &(gdb[L0]) ); | |
| 354 x8( " out ", &(gdb[O0]) ); | |
| 355 swrites( "gdb PC = " ); swritex( gdb[ PC ] ); newline(); | |
| 356 swrites( "gdb NPC = " ); swritex( gdb[ NPC ] ); newline(); | |
| 357 swrites( "gdb PSR = " ); swritex( gdb[ PSR ] ); newline(); | |
| 358 #endif | |
| 359 } | |
| 360 | |
| 361 } | |
| 362 | |
| 363 // --------------------------------------------------------------------------- | |
| 364 | |
| 365 void | |
| 366 cyg_hal_sparc_set_gdb_regs( HAL_SavedRegisters *eCos_regset, | |
| 367 void *gdb_regset ) | |
| 368 { | |
| 369 target_register_t *gdb = (target_register_t *)gdb_regset; | |
| 370 int reg; | |
| 371 cyg_uint32 scratch = 0; | |
| 372 cyg_uint32 *sptrap; | |
| 373 HAL_SavedWindow *trapli, *ctxli; | |
| 374 | |
| 375 // Guess where the eCos register set really is: | |
| 376 if ( 0 == eCos_regset->g[0] || | |
| 377 0xc0 == (0xe0 & eCos_regset->g[0]) ) { | |
| 378 // Then it's an interrupt stack saved state: | |
| 379 // (either minimal, or a saved PSR with traps disabled) | |
| 380 // The saved register set is pretty minimal, so we have to grub | |
| 381 // around in the stack to find out some truth... | |
| 382 sptrap = (cyg_uint32 *)eCos_regset; // point to the IL save area for | |
| 383 sptrap -= 24; // the trap handler, for PC, NPC | |
| 384 trapli = (HAL_SavedWindow *)sptrap; // Get at those regs | |
| 385 | |
| 386 ctxli = (HAL_SavedWindow *)(trapli->i[6]); // (the frame pointer) | |
| 387 // and get at the interruptee's regs | |
| 388 | |
| 389 scratch = eCos_regset->g[0]; | |
| 390 | |
| 391 // Put back interruptee's registers all over the stack: | |
| 392 for ( reg = 0; reg < 8 ; reg++ ) { | |
| 393 eCos_regset->g[reg] = gdb[ G0 + reg ] ; | |
| 394 trapli->i[reg] = gdb[ O0 + reg ] ; | |
| 395 ctxli->l[reg] = gdb[ L0 + reg ] ; | |
| 396 ctxli->i[reg] = gdb[ I0 + reg ] ; | |
| 397 } | |
| 398 | |
| 399 // Put back the eCos G0 which is always 0 (but abused in eCos_regset) | |
| 400 eCos_regset->g[0] = scratch; | |
| 401 | |
| 402 // In the save context _of the trap handler_ registers are as follows: | |
| 403 // %l0 = psr (with this CWP/window-level in it) | |
| 404 // %l1 = pc | |
| 405 // %l2 = npc | |
| 406 // %l3 = vector number (1-15 for interrupts) | |
| 407 // %l4 = Y register preserved | |
| 408 trapli->l[4] = gdb[ Y ]; | |
| 409 | |
| 410 // I am *not* interfering with the saved PSR, nor the TBR nor WIM. | |
| 411 | |
| 412 // put back return PC and NPC | |
| 413 trapli->l[1] = gdb[ PC ] ; | |
| 414 trapli->l[2] = gdb[ NPC ]; | |
| 415 | |
| 416 #ifdef THREAD_DEBUG_SERIAL_VERBOSE | |
| 417 newline(); | |
| 418 swrites( "-----------------------------------------------------" ); newline(); | |
| 419 swrites( "-------------- INTERRUPT STACK SET ------------------" ); newline(); | |
| 420 swrites( "eCos regset at " ); swritex( eCos_regset ); newline(); | |
| 421 swrites( " trapli " ); swritex( trapli ); newline(); | |
| 422 swrites( " ctxli " ); swritex( ctxli ); newline(); | |
| 423 x8( "global ", &(gdb[G0]) ); | |
| 424 x8( " in ", &(gdb[I0]) ); | |
| 425 x8( " local ", &(gdb[L0]) ); | |
| 426 x8( " out ", &(gdb[O0]) ); | |
| 427 swrites( "gdb PC = " ); swritex( gdb[ PC ] ); newline(); | |
| 428 swrites( "gdb NPC = " ); swritex( gdb[ NPC ] ); newline(); | |
| 429 swrites( "gdb PSR = " ); swritex( gdb[ PSR ] ); newline(); | |
| 430 #endif | |
| 431 | |
| 432 } | |
| 433 else { | |
| 434 // It's a synchronous context switch that led to this object. | |
| 435 // Pick up interruptee's registers from the saved context: | |
| 436 | |
| 437 scratch = eCos_regset->g[0]; | |
| 438 | |
| 439 for ( reg = 0; reg < 8 ; reg++ ) { | |
| 440 eCos_regset->g[reg] = gdb[ G0 + reg ]; | |
| 441 eCos_regset->o[reg] = gdb[ O0 + reg ]; | |
| 442 eCos_regset->li.l[reg] = gdb[ L0 + reg ]; | |
| 443 eCos_regset->li.i[reg] = gdb[ I0 + reg ]; | |
| 444 } | |
| 445 | |
| 446 // Put back the eCos G0 which is always 0 (but abused in eCos_regset) | |
| 447 eCos_regset->g[0] = scratch; | |
| 448 | |
| 449 // I am *not* interfering with the saved PSR, nor the TBR nor WIM. | |
| 450 | |
| 451 // The PC is in o7, altering it via GDB's PC is not on. | |
| 452 // Setting the NPC in a voluntary context is meaningless. | |
| 453 | |
| 454 #ifdef THREAD_DEBUG_SERIAL_VERBOSE | |
| 455 newline(); | |
| 456 swrites( "-----------------------------------------------------" ); newline(); | |
| 457 swrites( "-------------- SYNCHRONOUS SWITCH SET ---------------" ); newline(); | |
| 458 swrites( "eCos regset at " ); swritex( eCos_regset ); newline(); | |
| 459 x8( "global ", &(gdb[G0]) ); | |
| 460 x8( " in ", &(gdb[I0]) ); | |
| 461 x8( " local ", &(gdb[L0]) ); | |
| 462 x8( " out ", &(gdb[O0]) ); | |
| 463 swrites( "gdb PC = " ); swritex( gdb[ PC ] ); newline(); | |
| 464 swrites( "gdb NPC = " ); swritex( gdb[ NPC ] ); newline(); | |
| 465 swrites( "gdb PSR = " ); swritex( gdb[ PSR ] ); newline(); | |
| 466 #endif | |
| 467 } | |
| 468 | |
| 469 } | |
| 470 | |
| 471 /*---------------------------------------------------------------------------*/ | |
| 472 // EOF icontext.c |