home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / trialva / ibmcppw / sdk / winh / ppc / kxppc.h < prev   
Encoding:
C/C++ Source or Header  |  1995-07-11  |  47.9 KB  |  1,311 lines
  1. //++ BUILD Version: 0003    // Increment this if a change has global effects //
  2. //*++
  3. //
  4. // Copyright (c) 1990-1993  IBM Corporation
  5. //
  6. // Module Name:
  7. //
  8. //  kxppc.h
  9. //
  10. // Abstract:
  11. //
  12. //  This module contains the nongenerated part of the PPC assembler
  13. //  header file. In general, it contains processor architecture constant
  14. //  information, however some assembler macros are also included.
  15. //
  16. // Author:
  17. //
  18. //  Chuck Bauman (chuck2) 03-Aug-1993
  19. //
  20. // Revision History:
  21. //
  22. //    Base on kxmips.h, NT product1 source (R3000 paths removed)
  23. //    Add procedure entry exit macros (Chuck Bauman)             10-Aug-1993
  24. //    Fixed # comments so C modules compile (Chuck Bauman)       13-Aug-1993
  25. //    Add exception entry codes and STK_SLACK_SPACE (Peter Johnston) 19-Aug-1993
  26. //    Optimizations for NESTED ENTRY/EXIT (Chuck Bauman)         27-Aug-1993
  27. //    New entry point linkage convention  (Chuck Bauman)         01-Sep-1993
  28. //    Added SPECIAL ENTRY/EXIT (Curt Fawcett)                    22-Sep-1993
  29. //    Deleted EXCEPTION_HANDLER and changed NESTED_ENTRY_EX
  30. //    and LEAF_ENTRY_EX to not append .scope to the Scope
  31. //    parameter (Tom Wood)                     02-Nov-1993
  32. //    Added definition for SPR #1, Fixed Point Exception
  33. //    register XER (Mark D. Johnson)                 11-Mar-1994
  34. //    Added in the macros that used to be in /private/ntos/
  35. //    crt32/h/ppcsects.h.  I then removed that file since
  36. //    we don't need it anymore. (Matt Holle)                     27-Apr-1994
  37. //
  38. //--*/
  39.  
  40. #ifndef _KXPPC_
  41. #define _KXPPC_
  42.  
  43. #ifndef _KXPPC_C_HEADER_
  44.  
  45. // =====================================================================
  46. // Begin code extracted from ppcsects.h
  47. // =====================================================================
  48.  
  49. //Purpose:
  50. //   This file defines sections for the C and C++ libs.
  51. //
  52. //   NOTE:  As needed, special "CRT" sections can be added into the existing
  53. //   init/term tables.  These will be for our use only -- users who put
  54. //   stuff in here do so at their own risk.
  55. //
  56. //Revision History:
  57. //   03-19-92  SKS   Loosely based on the 16-bit include file DEFSEGS.INC
  58. //   08-06-92  SKS   Changed these section names from X[ICPT]$[ACLUXZ] to
  59. //                   .CRT$X[ICPT][ACLUXZ] to avoid creating too many sections
  60. //                   Also, sections are no longer defined in groups.  That was
  61. //                   for use with OMF type objects where order of appearance
  62. //                   is important.  With COFF, sorting is done by section name.
  63. //   10-26-93  CDB   Based on MS defsects.inc
  64. //
  65. // beginSection - a macro for declaring and beginning a section
  66. //
  67. // endSection - a macro for ending a previously declared section
  68. //
  69. // *****
  70.  
  71. #define         beginSection(SectName) \
  72. .section        .CRT$##SectName, "drw2"
  73.  
  74. #define         endSection(SectName)
  75.  
  76. //  XIA  Begin C Initializer Sections
  77. //  XIC   Microsoft Reserved
  78. //  XIU   User
  79. //  XIZ  End C Initializer Sections
  80. //
  81. //  XCA  Begin C++ Constructor Sections
  82. //  XCC   Compiler (MS)
  83. //  XCL   Library
  84. //  XCU   User
  85. //  XCZ  End C++ Constructor Sections
  86. //
  87. //  XPA  Begin C Pre-Terminator Sections
  88. //  XPU   User
  89. //  XPX   Microsoft Reserved
  90. //  XPZ  End C Pre-Terminator Sections
  91. //
  92. //  XTA  Begin C Pre-Terminator Sections
  93. //  XTU   User
  94. //  XTX   Microsoft Reserved
  95. //  XTZ  End C Pre-Terminator Sections
  96.  
  97. // =====================================================================
  98. // End code extracted from ppcsects.h
  99. // =====================================================================
  100.  
  101. #endif // _KXPPC_C_HEADER_
  102.  
  103. //
  104. // Define soft reset vector address for nonhandled cache parity errors.
  105. //
  106.  
  107. #define SOFT_RESET_VECTOR 0xbfc00300    // default parity error routine address
  108.  
  109. //
  110. // Define low memory transfer vector address and TB index address (temporary).
  111. //
  112. #define TRANSFER_VECTOR (KSEG1_BASE + 0x400) // exception handler address
  113.  
  114. //
  115. // Maximum Bit number (32 bit implementation)
  116. //
  117. #define MAX_BITS  0x1f
  118.  
  119. //
  120. // Macro to generate a mask using the SPR bit definitions below
  121. //
  122. #define MASK_SPR(shift,mask)  (mask << (MAX_BITS-shift))
  123.  
  124. //
  125. // Define Machine State Register bit field offsets.
  126. //
  127. // MSR_POW   0x0d Power management enable         <13>
  128. // MSR_IMPL  0x0e Implementation dependent        <14>
  129. // MSR_ILE   0x0f Interrupt Little-Endian mode    <15>
  130. // MSR_EE    0x10 External interrupt Enable       <16>
  131. // MSR_PR    0x11 Problem state                   <17>
  132. // MSR_FP    0x12 Floating Point available        <18>
  133. // MSR_ME    0x13 Machine check Enable            <19>
  134. // MSR_FE0   0x14 Floating point Exception mode 0 <20>
  135. // MSR_SE    0x15 Single-step trace Enable        <21>
  136. // MSR_BE    0x16 Branch trace Enable             <22>
  137. // MSR_FE1   0x17 Floating point Exception mode 1 <23>
  138. // MSR_IP    0x19 Interrupt Prefix                <25>
  139. // MSR_IR    0x1a Instruction Relocate            <26>
  140. // MSR_DR    0x1b Data Relocate                   <27>
  141. // MSR_RI    0x1e Recoverable Interrupt           <30>
  142. // MSR_LE    0x1f Little-Endian execution mode    <31>
  143.  
  144. #define MSR_POW   0x0d
  145. #define MSR_IMPL  0x0e
  146. #define MSR_ILE   0x0f
  147. #define MSR_EE    0x10
  148. #define MSR_PR    0x11
  149. #define MSR_FP    0x12
  150. #define MSR_ME    0x13
  151. #define MSR_FE0   0x14
  152. #define MSR_SE    0x15
  153. #define MSR_BE    0x16
  154. #define MSR_FE1   0x17
  155. #define MSR_IP    0x19
  156. #define MSR_IR    0x1a
  157. #define MSR_DR    0x1b
  158. #define MSR_RI    0x1e
  159. #define MSR_LE    0x1f
  160.  
  161.  
  162. //
  163. // Define Processor Version Register (PVR) bit fields
  164. //
  165. //  PVR_Version  0x0  Processor Version  <0:15>
  166. //  PVR_Revision 0x10 Processor Revision <16:31>
  167. #define PVR_Version  0x0
  168. #define PVR_Revision 0x10
  169.  
  170. //
  171. // Fixed Point Exception Register is Special Purpose Reg no. 1
  172. //
  173.  
  174. #define    XER    0x1
  175.  
  176. //
  177. // Define Fixed Point Exception Register (XER) bit fields
  178. //
  179.  
  180. // XER_SO    0x0  Summary Overflow <0>
  181. // XER_OV    0x1  Overflow         <1>
  182. // XER_CA    0x2  Carry            <2>
  183. // XER_COMP  0x10 > Carry          <16:23>
  184. // XER_COUNT 0x19 Carry            <25:31>
  185.  
  186. #define XER_SO    0x0
  187. #define XER_OV    0x1
  188. #define XER_CA    0x2
  189. #define XER_COMP  0x10
  190. #define XER_COUNT 0x19
  191.  
  192.  
  193. //
  194. // Define Floating Point Status/Control Register (FPSCR) bit fields
  195. //
  196. // FPSCR_FX        0x0  Exception summary                          <0>
  197. // FPSCR_FEX       0x1  Enabled Exception summary                  <1>
  198. // FPSCR_VX        0x2  Invalid operation exception summary        <2>
  199. // FPSCR_OX        0x3  Overflow exception                         <3>
  200. // FPSCR_UX        0x4  Underflow exception                        <4>
  201. // FPSCR_ZX        0x5  Zero divide exception                      <5>
  202. // FPSCR_XX        0x6  Inexact exception                          <6>
  203. // FPSCR_VXSNAN    0x7  Invalid op exception (signalling NaN)      <7>
  204. // FPSCR_VXISI     0x8  Invalid op exception (infinity - infinity) <8>
  205. // FPSCR_VXIDI     0x9  Invalid op exception (infinity / infinity) <9>
  206. // FPSCR_VXZDZ     0x0a Invalid op exception (0 / 0)               <10>
  207. // FPSCR_VXIMZ     0x0b Invalid op exception (infinity * 0)        <11>
  208. // FPSCR_VXVC      0x0c Invalid op exception (compare)             <12>
  209. // FPSCR_FR        0x0d Fraction Rounded                           <13>
  210. // FPSCR_FI        0x0e Fraction Inexact                           <14>
  211. // FPSCR_C         0x0f Result Class descriptor                    <15>
  212. // FPSCR_FL        0x10 Result Less than or negative               <16>
  213. // FPSCR_FG        0x11 Result Greater than or positive            <17>
  214. // FPSCR_FE        0x12 Result Equal or zero                       <18>
  215. // FPSCR_FU        0x13 Result Unordered or NaN                    <19>
  216. // FPSCR_Res1      0x14 reserved                                   <20>
  217. // FPSCR_VXSOFT    0x15 Invalid op exception (software request)    <21>
  218. // FPSCR_VXSQRT    0x16 Invalid op exception (square root)         <22>
  219. // FPSCR_VXCVI     0x17 Invalid op exception (integer convert)     <23>
  220. // FPSCR_VE        0x18 Invalid operation exception Enable         <24>
  221. // FPSCR_OE        0x19 Overflow exception Enable                  <25>
  222. // FPSCR_UE        0x1a Underflow exception Enable                 <26>
  223. // FPSCR_ZE        0x1b Zero divide exception Enable               <27>
  224. // FPSCR_XE        0x1c Inexact exception Enable                   <28>
  225. // FPSCR_NI        0x1d Non-IEEE mode                              <29>
  226. // FPSCR_RN        0x1e Rounding control                        <30:31>
  227. #define FPSCR_FX        0x0
  228. #define FPSCR_FEX       0x1
  229. #define FPSCR_VX        0x2
  230. #define FPSCR_OX        0x3
  231. #define FPSCR_UX        0x4
  232. #define FPSCR_ZX        0x5
  233. #define FPSCR_XX        0x6
  234. #define FPSCR_VXSNAN    0x7
  235. #define FPSCR_VXISI     0x8
  236. #define FPSCR_VXIDI     0x9
  237. #define FPSCR_VXZDZ     0x0a
  238. #define FPSCR_VXIMZ     0x0b
  239. #define FPSCR_VXVC      0x0c
  240. #define FPSCR_FR        0x0d
  241. #define FPSCR_FI        0x0e
  242. #define FPSCR_C         0x0f
  243. #define FPSCR_FL        0x10
  244. #define FPSCR_FG        0x11
  245. #define FPSCR_FE        0x12
  246. #define FPSCR_FU        0x13
  247. #define FPSCR_Res1      0x14
  248. #define FPSCR_VXSOFT    0x15
  249. #define FPSCR_VXSQRT    0x16
  250. #define FPSCR_VXCVI     0x17
  251. #define FPSCR_VE        0x18
  252. #define FPSCR_OE        0x19
  253. #define FPSCR_UE        0x1a
  254. #define FPSCR_ZE        0x1b
  255. #define FPSCR_XE        0x1c
  256. #define FPSCR_NI        0x1d
  257. #define FPSCR_RN        0x1e
  258.  
  259.  
  260. //
  261. // Define exception codes.
  262. //
  263.  
  264. #define XCODE_INTERRUPT 0x0             // Interrupt
  265. #define XCODE_MODIFY 0x4                // TLB modify
  266. #define XCODE_READ_MISS 0x8             // TLB read miss
  267. #define XCODE_WRITE_MISS 0xc            // TLB write miss
  268. #define XCODE_READ_ADDRESS_ERROR 0x10   // Read alignment error
  269. #define XCODE_WRITE_ADDRESS_ERROR 0x14  // Write alignment error
  270. #define XCODE_INSTRUCTION_BUS_ERROR 0x18 // Instruction bus error
  271. #define XCODE_DATA_BUS_ERROR 0x1c       // Data bus error
  272. #define XCODE_SYSTEM_CALL 0x20          // System call
  273. #define XCODE_BREAKPOINT 0x24           // Breakpoint
  274. #define XCODE_ILLEGAL_INSTRUCTION 0x28  // Illegal instruction
  275. #define XCODE_COPROCESSOR_UNUSABLE 0x2c // Coprocessor unusable
  276. #define XCODE_INTEGER_OVERFLOW 0x30     // Arithmetic overflow
  277.  
  278. #define XCODE_TRAP 0x34                 // Trap instruction
  279. #define XCODE_VIRTUAL_INSTRUCTION 0x38  // Virtual instruction coherency
  280. #define XCODE_FLOATING_EXCEPTION 0x3c   // Floating point exception
  281. #define XCODE_WATCHPOINT 0x5c           // Watch point
  282. #define XCODE_PANIC 0x78                // Stack overflow (software)
  283. #define XCODE_VIRTUAL_DATA 0x7c         // Virtual data coherency
  284.  
  285. #define R4000_XCODE_MASK (0x1f << CAUSE_XCODE) // R4000 exception code mask
  286.  
  287. #define R4000_MISS_MASK (R4000_XCODE_MASK & \
  288.                         (~(XCODE_READ_MISS ^ XCODE_WRITE_MISS))) //
  289.  
  290. //
  291. // Define page mask values.
  292. //
  293.  
  294. #define PAGEMASK_4KB 0x0                // 4kb page
  295. #define PAGEMASK_16KB 0x3               // 16kb page
  296. #define PAGEMASK_64KB 0xf               // 64kb page
  297. #define PAGEMASK_256KB 0x3f             // 256kb page
  298. #define PAGEMASK_1MB 0xff               // 1mb page
  299. #define PAGEMASK_4MB 0x3ff              // 4mb page
  300. #define PAGEMASK_16MB 0xfff             // 16mb page
  301.  
  302. //
  303. // Define primary cache states.
  304. //
  305.  
  306. #define PRIMARY_CACHE_INVALID 0x0       // primary cache invalid
  307. #define PRIMARY_CACHE_SHARED 0x1        // primary cache shared (clean or dirty)
  308. #define PRIMARY_CACHE_CLEAN_EXCLUSIVE 0x2 // primary cache clean exclusive
  309. #define PRIMARY_CACHE_DIRTY_EXCLUSIVE 0x3 // primary cache dirty exclusive
  310.  
  311. //
  312. // Define cache instruction operation codes.
  313. //
  314.  
  315. #define INDEX_INVALIDATE_I 0x0          // invalidate primary instruction cache
  316. #define INDEX_WRITEBACK_INVALIDATE_D 0x1 // writeback/invalidate primary data cache
  317. #define INDEX_INVALIDATE_SI 0x2         // invalidate secondary instruction cache
  318. #define INDEX_WRITEBACK_INVALIDATE_SD 0x3 // writeback/invalidate secondary data cache
  319.  
  320. #define INDEX_LOAD_TAG_I 0x4            // load primary instruction tag indexed
  321. #define INDEX_LOAD_TAG_D 0x5            // load primary data tag indexed
  322. #define INDEX_LOAD_TAG_SI 0x6           // load secondary instruction tag indexed
  323. #define INDEX_LOAD_TAG_SD 0x7           // load secondary data tag indexed
  324.  
  325. #define INDEX_STORE_TAG_I 0x8           // store primary instruction tag indexed
  326. #define INDEX_STORE_TAG_D 0x9           // store primary data tag indexed
  327. #define INDEX_STORE_TAG_SI 0xa          // store secondary instruction tag indexed
  328. #define INDEX_STORE_TAG_SD 0xb          // store secondary data tag indexed
  329.  
  330. #define CREATE_DIRTY_EXCLUSIVE_D 0xd    // create dirty exclusive primary data cache
  331. #define CREATE_DIRTY_EXCLUSIVE_SD 0xf   // create dirty exclusive secondary data cache
  332.  
  333. #define HIT_INVALIDATE_I 0x10           // invalidate primary instruction cache
  334. #define HIT_INVALIDATE_D 0x11           // invalidate primary data cache
  335. #define HIT_INVALIDATE_SI 0x12          // invalidate secondary instruction cache
  336. #define HIT_INVALIDATE_SD 0x13          // invalidate secondary data cache
  337.  
  338. #define HIT_WRITEBACK_INVALIDATE_D 0x15 // writeback/invalidate primary data cache
  339. #define HIT_WRITEBACK_INVALIDATE_SD 0x17 // writeback/invalidate secondary data cache
  340.  
  341. #define HIT_WRITEBACK_D 0x19            // writeback primary data cache
  342. #define HIT_WRITEBACK_SD 0x1b           // writeback secondary data cache
  343.  
  344. #define HIT_SET_VIRTUAL_SI 0x1e         // hit set virtual secondary instruction cache
  345. #define HIT_SET_VIRTUAL_SD 0x1f         // hit set virtual secondary data cache
  346.  
  347. #ifndef _KXPPC_C_HEADER_
  348.  
  349. //
  350. // Define save and restore floating state macros.
  351. //
  352.  
  353. #define RESTORE_VOLATILE_FLOAT_STATE(_tf)   \
  354.         lfd     f.13, TrFpscr(_tf);         \
  355.         lfd     f.0,  TrFpr0(_tf);          \
  356.         lfd     f.1,  TrFpr1(_tf);          \
  357.         lfd     f.2,  TrFpr2(_tf);          \
  358.         lfd     f.3,  TrFpr3(_tf);          \
  359.         lfd     f.4,  TrFpr4(_tf);          \
  360.         lfd     f.5,  TrFpr5(_tf);          \
  361.         lfd     f.6,  TrFpr6(_tf);          \
  362.         lfd     f.7,  TrFpr7(_tf);          \
  363.         lfd     f.8,  TrFpr8(_tf);          \
  364.         mtfsf   0xff, f.13;                 \
  365.         lfd     f.9,  TrFpr9(_tf);          \
  366.         lfd     f.10, TrFpr10(_tf);         \
  367.         lfd     f.11, TrFpr11(_tf);         \
  368.         lfd     f.12, TrFpr12(_tf);         \
  369.         lfd     f.13, TrFpr13(_tf);
  370.  
  371. #define SAVE_VOLATILE_FLOAT_STATE(_tf)      \
  372.         stfd    f.0,  TrFpr0(_tf);          \
  373.         stfd    f.1,  TrFpr1(_tf);          \
  374.         stfd    f.2,  TrFpr2(_tf);          \
  375.         stfd    f.3,  TrFpr3(_tf);          \
  376.         stfd    f.4,  TrFpr4(_tf);          \
  377.         stfd    f.5,  TrFpr5(_tf);          \
  378.         mffs    f.0;                        \
  379.         stfd    f.6,  TrFpr6(_tf);          \
  380.         stfd    f.7,  TrFpr7(_tf);          \
  381.         stfd    f.8,  TrFpr8(_tf);          \
  382.         stfd    f.9,  TrFpr9(_tf);          \
  383.         stfd    f.10, TrFpr10(_tf);         \
  384.         stfd    f.11, TrFpr11(_tf);         \
  385.         stfd    f.12, TrFpr12(_tf);         \
  386.         stfd    f.13, TrFpr13(_tf);         \
  387.         stfd    f.0,  TrFpscr(_tf);
  388.  
  389. //#define RESTORE_NONVOLATILE_FLOAT_STATE
  390. //        ldc1    f20,ExFltF20(sp);
  391. //        jal     KiRestoreNonvolatileFloatState;
  392.  
  393. //#define SAVE_NONVOLATILE_FLOAT_STATE
  394. //        sdc1    f20,ExFltF20(sp);
  395. //        jal     KiSaveNonvolatileFloatState;
  396.  
  397. #endif // _KXPPC_C_HEADER_
  398.  
  399. //
  400. // Define TB and cache parameters.
  401. //
  402.  
  403. #define PCR_ENTRY 0                     // TB entry numbers (2) for the PCR
  404. #define PDR_ENTRY 2                     // TB entry number (1) for the PDR
  405. #define KSTACK_ENTRY 3                  // TB entry numbers (1) for kernel stack
  406. #define DMA_ENTRY 4                     // TB entry number (1) for DMA/InterruptSource
  407.  
  408. #define TB_ENTRY_SIZE (3 * 4)           // size of TB entry
  409. #define FIXED_BASE 0                    // base index of fixed TB entries
  410. #define FIXED_ENTRIES (DMA_ENTRY + 1)   // number of fixed TB entries
  411.  
  412. //
  413. // Define cache parameters
  414. //
  415.  
  416. #define DCACHE_SIZE 4 * 1024            // size of data cache in bytes
  417. #define ICACHE_SIZE 4 * 1024            // size of instruction cache in bytes
  418. #define MINIMUM_CACHE_SIZE 4 * 1024     // minimum size of cache
  419. #define MAXIMUM_CACHE_SIZE 128 * 1024   // maximum size fo cache
  420.  
  421. #ifndef _KXPPC_C_HEADER_
  422.  
  423. //
  424. // Define subtitle macro
  425. //
  426.  
  427. #define SBTTL(x)
  428.  
  429. //
  430. // Define global definition macros.
  431. //
  432.  
  433. //
  434. // Define load immediate macro for 32-bit values.
  435. //
  436. //      reg       - Register to load with the 32-bit immediate
  437. //      immediate - 32-bit immediate value
  438. //
  439. #define LWI(reg,immediate)                 \
  440.         lis     reg,immediate > 16         ;\
  441.         ori     reg,reg,immediate & 0xffff
  442.  
  443. #define END_REGION(Name)               \
  444.         .globl  Name                   ;\
  445. Name:
  446.  
  447. #define START_REGION(Name)             \
  448.         .globl  Name                   ;\
  449. Name:
  450.  
  451. //
  452. // Define trap frame generation macro.
  453. //
  454.  
  455. //#define GENERATE_TRAP_FRAME
  456. //        .set    noat;
  457. //        sw      AT,TrIntAt(s8);
  458. //        jal     KiGenerateTrapFrame;
  459. //        .set    at;
  460.  
  461. //
  462. // Define restore volatile integer state macro.
  463. //
  464.  
  465. //#define RESTORE_VOLATILE_INTEGER_STATE
  466. //        .set    noat;
  467. //        lw      AT,TrIntAt(s8);
  468. //        jal     KiRestoreVolatileIntegerState;
  469. //        .set    at;
  470.  
  471. //
  472. // Define save volatile integer state macro.
  473. //
  474.  
  475. //#define SAVE_VOLATILE_INTEGER_STATE
  476. //        .set    noat;
  477. //        sw      AT,TrIntAt(s8);
  478. //        jal     KiSaveVolatileIntegerState;
  479. //        .set    at;
  480.  
  481. //
  482. // Define macros used by procedure entry/exit macros
  483. //
  484.  
  485. //
  486. // Set register 12 to the GPR save location based on the number
  487. // of floating point registers to be saved.
  488. //
  489. #define __setFramemr(Fpr)       \
  490.         mr      r.12,r.sp
  491.  
  492. #define __setFramesubi(Fpr)     \
  493.         subi    r.12,r.sp,8*Fpr
  494.  
  495. //
  496. // Save the number of GPRs specified inline or by setting r.12 to the GPR
  497. // save location and branching to the appropriate millicode save procedure.
  498. //
  499. // Changed bla to bl in __savegpr4-__savegrp19          IBMCDB
  500. #define __savegpr0(op,Fpr)
  501. #define __savegpr1(op,Fpr)      \
  502.         stw     r.31,-(4+(8*Fpr))(r.sp)
  503. #define __savegpr2(op,Fpr)              \
  504.         stw     r.31,-(4+(8*Fpr))(r.sp) ;\
  505.         stw     r.30,-(8+(8*Fpr))(r.sp)
  506. #define __savegpr3(op,Fpr)              \
  507.         stw     r.31,-(4+(8*Fpr))(r.sp) ;\
  508.         stw     r.30,-(8+(8*Fpr))(r.sp) ;\
  509.         stw     r.29,-(12+(8*Fpr))(r.sp)
  510. #define __savegpr4(op,Fpr)      \
  511.         __setFrame##op(Fpr)     ;\
  512.         bl      .._savegpr_28
  513. #define __savegpr5(op,Fpr)      \
  514.         __setFrame##op(Fpr)     ;\
  515.         bl      .._savegpr_27
  516. #define __savegpr6(op,Fpr)      \
  517.         __setFrame##op(Fpr)     ;\
  518.         bl      .._savegpr_26
  519. #define __savegpr7(op,Fpr)      \
  520.         __setFrame##op(Fpr)     ;\
  521.         bl      .._savegpr_25
  522. #define __savegpr8(op,Fpr)      \
  523.         __setFrame##op(Fpr)     ;\
  524.         bl      .._savegpr_24
  525. #define __savegpr9(op,Fpr)      \
  526.         __setFrame##op(Fpr)     ;\
  527.         bl      .._savegpr_23
  528. #define __savegpr10(op,Fpr)     \
  529.         __setFrame##op(Fpr)     ;\
  530.         bl      .._savegpr_22
  531. #define __savegpr11(op,Fpr)     \
  532.         __setFrame##op(Fpr)     ;\
  533.         bl      .._savegpr_21
  534. #define __savegpr12(op,Fpr)     \
  535.         __setFrame##op(Fpr)     ;\
  536.         bl      .._savegpr_20
  537. #define __savegpr13(op,Fpr)     \
  538.         __setFrame##op(Fpr)     ;\
  539.         bl      .._savegpr_19
  540.  
  541.  
  542. #define __savegpr14(op,Fpr)     \
  543.         __setFrame##op(Fpr)     ;\
  544.         bl      .._savegpr_18
  545. #define __savegpr15(op,Fpr)     \
  546.         __setFrame##op(Fpr)     ;\
  547.         bl      .._savegpr_17
  548. #define __savegpr16(op,Fpr)     \
  549.         __setFrame##op(Fpr)     ;\
  550.         bl      .._savegpr_16
  551. #define __savegpr17(op,Fpr)     \
  552.         __setFrame##op(Fpr)     ;\
  553.         bl      .._savegpr_15
  554. #define __savegpr18(op,Fpr)     \
  555.         __setFrame##op(Fpr)     ;\
  556.         bl      .._savegpr_14
  557. #define __savegpr19(op,Fpr)     \
  558.         __setFrame##op(Fpr)     ;\
  559.         bl      .._savegpr_13
  560. //
  561. // Macros for removing the stack frame established through NESTED ENTRY.
  562. //
  563. #define __unsetFramemov(Fsize,Fpr)    \
  564.         addi    r.12,r.sp,Fsize  ;     \
  565.         mtlr    r.0              ;     \
  566.         mr      r.sp,r.12
  567.  
  568. #define __unsetFrameaddi(Fsize,Fpr)   \
  569.         addi    r.12,r.sp,(Fsize)-(8*Fpr)
  570.  
  571. #define __unsetFrameblr(Fsize,Fpr)    \
  572.         mtlr    r.0              ;     \
  573.         addi    r.sp,r.sp,Fsize  ;     \
  574.         blr
  575.  
  576. // Change __unsetFrameba to __unsetFrameb               IBMCDB
  577. #define __unsetFrameb(Fsize,Fpr)      \
  578.         addi    r.sp,r.sp,Fsize  ;     \
  579.         blr
  580.  
  581. // Change __unsetFramebla to __unsetFramebl             IBMCDB
  582. #define __unsetFramebl(Fsize,Fpr)
  583.  
  584. #define __unsetFramenop(Fsize,Fpr)
  585.  
  586. // Change __setLRba to __setLRb                         IBMCDB
  587. #define __setLRb(Fsize,Fpr)           \
  588.         mtlr    r.0
  589.  
  590. // Change __setLRbla to __setLRbl                       IBMCDB
  591. #define __setLRbl(Fsize,Fpr)
  592.  
  593.  
  594. //
  595. // Restore number of GPRs specified
  596. //      setr  - determines how to remove the stack frame (mov or addi)
  597. //              mov  - will cause __unsetFramemov to be used
  598. //              addi - will cause __unsetFrameaddi to be used
  599. //      opret - if set to blr will cause GPR restore to return to caller
  600. //              only used for 0 GPRs and 0 FPRs
  601. //      op    - specifies instruction to be used for the call to the
  602. //              restore millicode (ba, bla) - Changed to (b, bl)    IBMCDB
  603. //      Fsize - stack frame size
  604. //      Fpr   - number of FPRs to be restored
  605. //
  606. #define __restgpr0(setr,opret,op,Fsize,Fpr)       \
  607.         __unsetFrame##opret(Fsize,Fpr)
  608. #define __restgpr1(setr,opret,op,Fsize,Fpr)       \
  609.         __setLR##op(Fsize,Fpr)                    ;\
  610.         lwz     r.31,((Fsize)-(4+(8*Fpr)))(r.sp)  ;\
  611.         __unsetFrame##op(Fsize,Fpr)
  612. #define __restgpr2(setr,opret,op,Fsize,Fpr)       \
  613.         lwz     r.31,((Fsize)-(4+(8*Fpr)))(r.sp)  ;\
  614.         __setLR##op(Fsize,Fpr)                    ;\
  615.         lwz     r.30,((Fsize)-(8+(8*Fpr)))(r.sp)  ;\
  616.         __unsetFrame##op(Fsize,Fpr)
  617. #define __restgpr3(setr,opret,op,Fsize,Fpr)       \
  618.         lwz     r.31,((Fsize)-(4+(8*Fpr)))(r.sp)  ;\
  619.         __setLR##op(Fsize,Fpr)                    ;\
  620.         lwz     r.30,((Fsize)-(8+(8*Fpr)))(r.sp)  ;\
  621.         lwz     r.29,((Fsize)-(12+(8*Fpr)))(r.sp) ;\
  622.         __unsetFrame##op(Fsize,Fpr)
  623. #define __restgpr4(setr,opret,op,Fsize,Fpr)  \
  624.         __unsetFrame##setr(Fsize,Fpr)        ;\
  625.         op      .._restgpr_28
  626. #define __restgpr5(setr,opret,op,Fsize,Fpr)  \
  627.         __unsetFrame##setr(Fsize,Fpr)        ;\
  628.         op      .._restgpr_27
  629. #define __restgpr6(setr,opret,op,Fsize,Fpr)  \
  630.         __unsetFrame##setr(Fsize,Fpr)        ;\
  631.         op      .._restgpr_26
  632. #define __restgpr7(setr,opret,op,Fsize,Fpr)  \
  633.         __unsetFrame##setr(Fsize,Fpr)        ;\
  634.         op      .._restgpr_25
  635. #define __restgpr8(setr,opret,op,Fsize,Fpr)  \
  636.         __unsetFrame##setr(Fsize,Fpr)        ;\
  637.         op      .._restgpr_24
  638. #define __restgpr9(setr,opret,op,Fsize,Fpr)  \
  639.         __unsetFrame##setr(Fsize,Fpr)        ;\
  640.         op      .._restgpr_23
  641. #define __restgpr10(setr,opret,op,Fsize,Fpr) \
  642.         __unsetFrame##setr(Fsize,Fpr)        ;\
  643.         op      .._restgpr_22
  644. #define __restgpr11(setr,opret,op,Fsize,Fpr) \
  645.         __unsetFrame##setr(Fsize,Fpr)        ;\
  646.         op      .._restgpr_21
  647. #define __restgpr12(setr,opret,op,Fsize,Fpr) \
  648.         __unsetFrame##setr(Fsize,Fpr)        ;\
  649.         op      .._restgpr_20
  650. #define __restgpr13(setr,opret,op,Fsize,Fpr) \
  651.         __unsetFrame##setr(Fsize,Fpr)        ;\
  652.         op      .._restgpr_19
  653.  
  654.  
  655. #define __restgpr14(setr,opret,op,Fsize,Fpr) \
  656.         __unsetFrame##setr(Fsize,Fpr)        ;\
  657.         op      .._restgpr_18
  658. #define __restgpr15(setr,opret,op,Fsize,Fpr) \
  659.         __unsetFrame##setr(Fsize,Fpr)        ;\
  660.         op      .._restgpr_17
  661. #define __restgpr16(setr,opret,op,Fsize,Fpr) \
  662.         __unsetFrame##setr(Fsize,Fpr)        ;\
  663.         op      .._restgpr_16
  664. #define __restgpr17(setr,opret,op,Fsize,Fpr) \
  665.         __unsetFrame##setr(Fsize,Fpr)        ;\
  666.         op      .._restgpr_15
  667. #define __restgpr18(setr,opret,op,Fsize,Fpr) \
  668.         __unsetFrame##setr(Fsize,Fpr)        ;\
  669.         op      .._restgpr_14
  670. #define __restgpr19(setr,opret,op,Fsize,Fpr) \
  671.         __unsetFrame##setr(Fsize,Fpr)        ;\
  672.         op      .._restgpr_13
  673.  
  674. //
  675. // Set r.12 to GPR save location based on number of FPRs to save.
  676. //
  677. #define __setGPRFrm0(Fsize,Gpr,Fpr)          \
  678.         __savegpr##Gpr(mr,0)                 ;\
  679.         stwu    r.sp,-(Fsize)(r.sp)          ;\
  680.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  681. #define __setGPRFrm1(Fsize,Gpr,Fpr)          \
  682.         __savegpr##Gpr(subi,1)
  683. #define __setGPRFrm2(Fsize,Gpr,Fpr)          \
  684.         __savegpr##Gpr(subi,2)
  685. #define __setGPRFrm3(Fsize,Gpr,Fpr)          \
  686.         __savegpr##Gpr(subi,3)
  687. #define __setGPRFrm4(Fsize,Gpr,Fpr)          \
  688.         __savegpr##Gpr(subi,4)
  689. #define __setGPRFrm5(Fsize,Gpr,Fpr)          \
  690.         __savegpr##Gpr(subi,5)
  691. #define __setGPRFrm6(Fsize,Gpr,Fpr)          \
  692.         __savegpr##Gpr(subi,6)
  693. #define __setGPRFrm7(Fsize,Gpr,Fpr)          \
  694.         __savegpr##Gpr(subi,7)
  695. #define __setGPRFrm8(Fsize,Gpr,Fpr)          \
  696.         __savegpr##Gpr(subi,8)
  697. #define __setGPRFrm9(Fsize,Gpr,Fpr)          \
  698.         __savegpr##Gpr(subi,9)
  699. #define __setGPRFrm10(Fsize,Gpr,Fpr)         \
  700.         __savegpr##Gpr(subi,10)
  701. #define __setGPRFrm11(Fsize,Gpr,Fpr)         \
  702.         __savegpr##Gpr(subi,11)
  703. #define __setGPRFrm12(Fsize,Gpr,Fpr)         \
  704.         __savegpr##Gpr(subi,12)
  705. #define __setGPRFrm13(Fsize,Gpr,Fpr)         \
  706.         __savegpr##Gpr(subi,13)
  707.  
  708.  
  709. #define __setGPRFrm14(Fsize,Gpr,Fpr)         \
  710.         __savegpr##Gpr(subi,14)
  711. #define __setGPRFrm15(Fsize,Gpr,Fpr)         \
  712.         __savegpr##Gpr(subi,15)
  713. #define __setGPRFrm16(Fsize,Gpr,Fpr)         \
  714.         __savegpr##Gpr(subi,16)
  715. #define __setGPRFrm17(Fsize,Gpr,Fpr)         \
  716.         __savegpr##Gpr(subi,17)
  717. #define __setGPRFrm18(Fsize,Gpr,Fpr)         \
  718.         __savegpr##Gpr(subi,18)
  719.  
  720. //
  721. // Generate epilogue code for NESTED EXIT based on number of GPRs and FPRs
  722. // to be restored.
  723. //      Fsize - stack frame size
  724. //      Gpr   - number of GPRs to restore
  725. //      Fpr   - number of FPRs to restore
  726. //
  727. // Changed 3rd argument to __restgpr##Gpr in __unsetGPRFrm1 from ba to b      IBMCDB
  728. // Changed 3rd argument to __restgpr##Gpr in __unsetGPRFrm2-18 from bla to bl IBMCDB
  729. #define __unsetGPRFrm0(Fsize,Gpr,Fpr)           \
  730.         __restgpr##Gpr(mov,blr,b,Fsize,Fpr)
  731. #define __unsetGPRFrm1(Fsize,Gpr,Fpr)           \
  732.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  733.         mtlr    r.0                             ;\
  734.         lfd     f.31,((Fsize)-8)(r.sp)          ;\
  735.         addi    r.sp,r.sp,Fsize                 ;\
  736.         blr
  737. #define __unsetGPRFrm2(Fsize,Gpr,Fpr)           \
  738.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  739.         lfd     f.31,((Fsize)-8)(r.sp)          ;\
  740.         mtlr    r.0                             ;\
  741.         lfd     f.30,((Fsize)-16)(r.sp)         ;\
  742.         addi    r.sp,r.sp,Fsize                 ;\
  743.         blr
  744. #define __unsetGPRFrm3(Fsize,Gpr,Fpr)           \
  745.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  746.         lfd     f.31,((Fsize)-8)(r.sp)          ;\
  747.         mtlr    r.0                             ;\
  748.         lfd     f.30,((Fsize)-16)(r.sp)         ;\
  749.         lfd     f.29,((Fsize)-24)(r.sp)         ;\
  750.         addi    r.sp,r.sp,Fsize                 ;\
  751.         blr
  752. #define __unsetGPRFrm4(Fsize,Gpr,Fpr)           \
  753.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  754.         addi    r.sp,r.sp,Fsize                 ;\
  755.         mtlr    r.0                             ;\
  756.         __restfpr##Fpr
  757. #define __unsetGPRFrm5(Fsize,Gpr,Fpr)           \
  758.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  759.         addi    r.sp,r.sp,Fsize                 ;\
  760.         mtlr    r.0                             ;\
  761.         __restfpr##Fpr
  762. #define __unsetGPRFrm6(Fsize,Gpr,Fpr)           \
  763.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  764.         addi    r.sp,r.sp,Fsize                 ;\
  765.         mtlr    r.0                             ;\
  766.         __restfpr##Fpr
  767.  
  768.  
  769. #define __unsetGPRFrm7(Fsize,Gpr,Fpr)           \
  770.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  771.         addi    r.sp,r.sp,Fsize                 ;\
  772.         mtlr    r.0                             ;\
  773.         __restfpr##Fpr
  774. #define __unsetGPRFrm8(Fsize,Gpr,Fpr)           \
  775.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  776.         addi    r.sp,r.sp,Fsize                 ;\
  777.         mtlr    r.0                             ;\
  778.         __restfpr##Fpr
  779. #define __unsetGPRFrm9(Fsize,Gpr,Fpr)           \
  780.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  781.         addi    r.sp,r.sp,Fsize                 ;\
  782.         mtlr    r.0                             ;\
  783.         __restfpr##Fpr
  784. #define __unsetGPRFrm10(Fsize,Gpr,Fpr)          \
  785.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  786.         addi    r.sp,r.sp,Fsize                 ;\
  787.         mtlr    r.0                             ;\
  788.         __restfpr##Fpr
  789. #define __unsetGPRFrm11(Fsize,Gpr,Fpr)          \
  790.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  791.         addi    r.sp,r.sp,Fsize                 ;\
  792.         mtlr    r.0                             ;\
  793.         __restfpr##Fpr
  794. #define __unsetGPRFrm12(Fsize,Gpr,Fpr)          \
  795.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  796.         addi    r.sp,r.sp,Fsize                 ;\
  797.         mtlr    r.0                             ;\
  798.         __restfpr##Fpr
  799. #define __unsetGPRFrm13(Fsize,Gpr,Fpr)          \
  800.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  801.         addi    r.sp,r.sp,Fsize                 ;\
  802.         mtlr    r.0                             ;\
  803.         __restfpr##Fpr
  804. #define __unsetGPRFrm14(Fsize,Gpr,Fpr)          \
  805.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  806.         addi    r.sp,r.sp,Fsize                 ;\
  807.         mtlr    r.0                             ;\
  808.         __restfpr##Fpr
  809. #define __unsetGPRFrm15(Fsize,Gpr,Fpr)          \
  810.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  811.         addi    r.sp,r.sp,Fsize                 ;\
  812.         mtlr    r.0                             ;\
  813.         __restfpr##Fpr
  814. #define __unsetGPRFrm16(Fsize,Gpr,Fpr)          \
  815.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  816.         addi    r.sp,r.sp,Fsize                 ;\
  817.         mtlr    r.0                             ;\
  818.         __restfpr##Fpr
  819. #define __unsetGPRFrm17(Fsize,Gpr,Fpr)          \
  820.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  821.         addi    r.sp,r.sp,Fsize                 ;\
  822.         mtlr    r.0                             ;\
  823.         __restfpr##Fpr
  824. #define __unsetGPRFrm18(Fsize,Gpr,Fpr)          \
  825.         __restgpr##Gpr(addi,nop,bl,Fsize,Fpr)  ;\
  826.         addi    r.sp,r.sp,Fsize                 ;\
  827.         mtlr    r.0                             ;\
  828.         __restfpr##Fpr
  829.  
  830.  
  831. //
  832. // Save the number of FPRs specified inline or by branching to the appropriate
  833. // millicode procedure.
  834. //
  835. // Change bla to bl in __savefrp4-18            IBMCDB
  836. #define __savefpr0(Fsize,Gpr,Fpr)
  837. #define __savefpr1(Fsize,Gpr,Fpr)   \
  838.         stfd    f.31,-8(r.sp)       ;\
  839.         stwu    r.sp,-(Fsize)(r.sp) ;\
  840.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  841. #define __savefpr2(Fsize,Gpr,Fpr)   \
  842.         stfd    f.31,-8(r.sp)       ;\
  843.         stfd    f.30,-16(r.sp)      ;\
  844.         stwu    r.sp,-(Fsize)(r.sp) ;\
  845.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  846. #define __savefpr3(Fsize,Gpr,Fpr)   \
  847.         stfd    f.31,-8(r.sp)       ;\
  848.         stfd    f.30,-16(r.sp)      ;\
  849.         stfd    f.29,-24(r.sp)      ;\
  850.         stwu    r.sp,-(Fsize)(r.sp) ;\
  851.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  852. #define __savefpr4(Fsize,Gpr,Fpr)   \
  853.         bl      .._savefpr_28       ;   \
  854.         stwu    r.sp,-(Fsize)(r.sp) ;\
  855.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  856. #define __savefpr5(Fsize,Gpr,Fpr)   \
  857.         bl      .._savefpr_27       ;   \
  858.         stwu    r.sp,-(Fsize)(r.sp) ;\
  859.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  860. #define __savefpr6(Fsize,Gpr,Fpr)   \
  861.         bl      .._savefpr_26       ;   \
  862.         stwu    r.sp,-(Fsize)(r.sp) ;\
  863.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  864. #define __savefpr7(Fsize,Gpr,Fpr)   \
  865.         bl      .._savefpr_25       ;   \
  866.         stwu    r.sp,-(Fsize)(r.sp) ;\
  867.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  868. #define __savefpr8(Fsize,Gpr,Fpr)   \
  869.         bl      .._savefpr_24       ;   \
  870.         stwu    r.sp,-(Fsize)(r.sp) ;\
  871.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  872. #define __savefpr9(Fsize,Gpr,Fpr)   \
  873.         bl      .._savefpr_23       ;   \
  874.         stwu    r.sp,-(Fsize)(r.sp) ;\
  875.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  876. #define __savefpr10(Fsize,Gpr,Fpr)  \
  877.         bl      .._savefpr_22       ;   \
  878.         stwu    r.sp,-(Fsize)(r.sp) ;\
  879.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  880. #define __savefpr11(Fsize,Gpr,Fpr)  \
  881.         bl      .._savefpr_21       ;   \
  882.         stwu    r.sp,-(Fsize)(r.sp) ;\
  883.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  884. #define __savefpr12(Fsize,Gpr,Fpr)  \
  885.         bl      .._savefpr_20       ;   \
  886.         stwu    r.sp,-(Fsize)(r.sp) ;\
  887.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  888. #define __savefpr13(Fsize,Gpr,Fpr)  \
  889.         bl      .._savefpr_19       ;   \
  890.         stwu    r.sp,-(Fsize)(r.sp) ;\
  891.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  892. #define __savefpr14(Fsize,Gpr,Fpr)  \
  893.         bl      .._savefpr_18       ;   \
  894.         stwu    r.sp,-(Fsize)(r.sp) ;\
  895.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  896. #define __savefpr15(Fsize,Gpr,Fpr)  \
  897.         bl      .._savefpr_17       ;   \
  898.         stwu    r.sp,-(Fsize)(r.sp) ;\
  899.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  900. #define __savefpr16(Fsize,Gpr,Fpr)  \
  901.         bl      .._savefpr_16       ;   \
  902.         stwu    r.sp,-(Fsize)(r.sp) ;\
  903.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  904. #define __savefpr17(Fsize,Gpr,Fpr)  \
  905.         bl      .._savefpr_15       ;   \
  906.         stwu    r.sp,-(Fsize)(r.sp) ;\
  907.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  908. #define __savefpr18(Fsize,Gpr,Fpr)  \
  909.         bl      .._savefpr_14       ;   \
  910.         stwu    r.sp,-(Fsize)(r.sp) ;\
  911.         stw     r.0,(Fsize)-(4*(Gpr+1)+(8 * Fpr))(r.sp)
  912.  
  913.  
  914. //
  915. // Restore the number of FPRs specified inline or by branching to the
  916. // appropriate millicode procedure.
  917. //
  918. // Changed ba to b in __restfpr4-18             IBMCDB
  919. #define __restfpr0
  920. #define __restfpr4              \
  921.         b       .._restfpr_28
  922. #define __restfpr5              \
  923.         b       .._restfpr_27
  924. #define __restfpr6              \
  925.         b       .._restfpr_26
  926. #define __restfpr7              \
  927.         b       .._restfpr_25
  928. #define __restfpr8              \
  929.         b       .._restfpr_24
  930. #define __restfpr9              \
  931.         b       .._restfpr_23
  932. #define __restfpr10             \
  933.         b       .._restfpr_22
  934. #define __restfpr11             \
  935.         b       .._restfpr_21
  936. #define __restfpr12             \
  937.         b       .._restfpr_20
  938. #define __restfpr13             \
  939.         b       .._restfpr_19
  940. #define __restfpr14             \
  941.         b       .._restfpr_18
  942. #define __restfpr15             \
  943.         b       .._restfpr_17
  944. #define __restfpr16             \
  945.         b       .._restfpr_16
  946. #define __restfpr17             \
  947.         b       .._restfpr_15
  948. #define __restfpr18             \
  949.         b       .._restfpr_14
  950.  
  951. #endif // _KXPPC_C_HEADER_
  952.  
  953.  
  954. //**************************************************************************/
  955. //
  956. //      PPC Linkage support macros
  957. //
  958. //
  959. //**************************************************************************/
  960. //      Caller's stack frame is addressed via R1, which points to
  961. //      the stack frame header.  The 6 words following where R1 points
  962. //      comprise the header.  The area PRECEEDING R1 is where FPRs are saved,
  963. //      and the area preceeding that is where GPRs are saved.
  964. //
  965. //              |                                      |
  966. //              +--------------------------------------+
  967. //              |                                      |
  968. //              |                                      |
  969. //              |  Saved GPRs                          |
  970. //              |                                      |
  971. //              |                                      |
  972. //              |                                      |
  973. //              +--------------------------------------+
  974. //              |                                      |
  975. //              |                                      |
  976. //              |  Saved FPRs                          |
  977. //              |                                      |
  978. //              |                                      |
  979. //              |                                      |
  980. //   R1 ------> +------------------+-------------------+
  981. //              |  Back chain      |  Glue saved reg   |
  982. //              +------------------+-------------------+
  983. //              |  Glue saved rtoc |  Reserved         |
  984. //              +------------------+-------------------+
  985. //              |  Reserved        |  Reserved         |
  986. //              +------------------+-------------------+
  987. //              |  Parameter Wd 0  |  Parameter Wd 1   |
  988. //              +------------------+-------------------+
  989. //              |  Parameter Wd 2  |  Parameter Wd 3   |
  990. //              +------------------+-------------------+
  991. //              |  Parameter Wd 4  |  Parameter Wd 5   |
  992. //              +------------------+-------------------+
  993. //              |  Parameter Wd 6  |  Parameter Wd 7   |
  994. //              +------------------+-------------------+
  995. //              |  ...                                 |
  996. //
  997. //      Offsets to various elements of stack frame header
  998.  
  999. #define STK_RSP         0
  1000. #define STK_GSR         4
  1001. #define STK_GSRTOC      8
  1002.  
  1003. #define STK_HDR_SZ      24
  1004. #define STK_P0          STK_HDR_SZ
  1005. #define STK_P1          (STK_P0+4)
  1006. #define STK_P2          (STK_P0+8)
  1007. #define STK_P3          (STK_P0+12)
  1008. #define STK_P4          (STK_P0+16)
  1009. #define STK_P5          (STK_P0+20)
  1010. #define STK_P6          (STK_P0+24)
  1011. #define STK_P7          (STK_P0+28)
  1012. #define STK_MIN_FRAME   56
  1013. #define STK_SLACK_SPACE 232
  1014.  
  1015. #ifndef _KXPPC_C_HEADER_
  1016.  
  1017. //
  1018. // Define procedure entry/exit macros
  1019. //
  1020. // Name  - Name of the nested procedure entry
  1021. // Fsize - Stack frame size
  1022. // Gprs  - Number of general purpose registers to save
  1023. // Fprs  - Number of floating point registers to save
  1024. //
  1025.  
  1026. //
  1027. // For primary entry points (NESTED_ENTRY, LEAF_ENTRY), a function table
  1028. // entry (for debugging, exception handling) is built.
  1029. //
  1030. // For all entry points, a function descriptor is built.
  1031. //
  1032. //
  1033. // NESTED_ENTRY is used for routines that call other routines; a stack
  1034. // frame is acquired and registers are saved.
  1035. //
  1036. // LEAF_ENTRY is used for routines that do not call other routines; no stack
  1037. // frame is acquired and no registers are saved.
  1038. //
  1039. //
  1040. // NESTED_ENTRY_EX and LEAF_ENTRY_EX are used when an exception or termination
  1041. // handler is provided.
  1042. //
  1043. //
  1044. // NESTED_ENTRY always saves the LR register. Fsize must account for this.
  1045. // Fsize must be a multiple of 8 bytes.
  1046. // Minimum stack frame size is 64 bytes.
  1047. //
  1048. //
  1049. // The PROLOGUE_END macro must be coded in all routines that used NESTED_ENTRY
  1050. // or NESTED_ENTRY_EX, because the function table entry refers to the label
  1051. // that it generates.
  1052. //
  1053. // SPECIAL_ENTRY is a used for routines that function like a LEAF_ENTRY
  1054. // but require some prologue for exception handling. An example of this
  1055. // is a stack checking routine which must make a system call to get
  1056. // the TEB pointer. The efficiency of a LEAF_ENTRY is needed, but also
  1057. // parts of the NESTED_ENTRY are required for the system call.
  1058. //
  1059. // Just like the NESTED_ENTRY, SPECIAL_ENTRY requires the PROLOGUE_END
  1060. // macro.
  1061. //
  1062. // FN_TABLE, DUMMY_ENTRY, and DUMMY_EXIT are used to construct the "prologues"
  1063. // for low-level exception handling code.  These prologues are never executed,
  1064. // but are present to allow unwinding through the hand-written low-level
  1065. // assembly code.  See real0.s for examples.
  1066.  
  1067. //
  1068. // The following macros are provided for coding by assembly language programmers
  1069. //
  1070.  
  1071. #define NESTED_ENTRY(Name,Fsize,Gprs,Fprs)      \
  1072.         __fntabentry(Name,0,0)                  ;\
  1073.         __gendescriptor(Name)                   ;\
  1074.         __begintext(Name)                       ;\
  1075.         mflr    r.0                             ;\
  1076.         __setGPRFrm##Fprs(Fsize,Gprs,Fprs)      ;\
  1077.         __savefpr##Fprs(Fsize,Gprs,Fprs)
  1078.  
  1079. #define NESTED_ENTRY_EX(Name,Fsize,Gprs,Fprs,LangHandler,Scope) \
  1080.         __fntabentry(Name,LangHandler,Scope)    ;\
  1081.         __gendescriptor(Name)                   ;\
  1082.         __begintext(Name)                       ;\
  1083.         mflr    r.0                             ;\
  1084.         __setGPRFrm##Fprs(Fsize,Gprs,Fprs)      ;\
  1085.         __savefpr##Fprs(Fsize,Gprs,Fprs)
  1086.  
  1087. #define NESTED_ENTRY_S(Name,Fsize,Gprs,Fprs,Section) \
  1088.         __fntabentry(Name,0,0)                  ;\
  1089.         __gendescriptor(Name)                   ;\
  1090.         __begintext_S(Name,Section)             ;\
  1091.         mflr    r.0                             ;\
  1092.         __setGPRFrm##Fprs(Fsize,Gprs,Fprs)      ;\
  1093.         __savefpr##Fprs(Fsize,Gprs,Fprs)
  1094.  
  1095. #define NESTED_ENTRY_EX_S(Name,Fsize,Gprs,Fprs,LangHandler,Scope,Section) \
  1096.         __fntabentry(Name,LangHandler,Scope)    ;\
  1097.         __gendescriptor(Name)                   ;\
  1098.         __begintext_S(Name,Section)             ;\
  1099.         mflr    r.0                             ;\
  1100.         __setGPRFrm##Fprs(Fsize,Gprs,Fprs)      ;\
  1101.         __savefpr##Fprs(Fsize,Gprs,Fprs)
  1102.  
  1103. #define NESTED_EXIT(Name,Fsize,Gprs,Fprs)                    \
  1104. Name##.epi:                                                     \
  1105.         lwz     r.0,((Fsize)-(4*(Gprs+1)+(8*Fprs)))(r.sp)       ;\
  1106.         __unsetGPRFrm##Fprs(Fsize,Gprs,Fprs)                    ;\
  1107. Name##.end:
  1108.  
  1109. #define PROLOGUE_END(Name)      \
  1110. Name##.body:
  1111.  
  1112. #define ALTERNATE_ENTRY(Name)           \
  1113.         __gendescriptor(Name)           ;\
  1114.         __begintext(Name)
  1115.  
  1116. #define LEAF_ENTRY(Name)                \
  1117.         __gendescriptor(Name)           ;\
  1118.         __begintext(Name)               ;\
  1119. Name##.body:
  1120.  
  1121. #define LEAF_ENTRY_EX(Name,LangHandler,Scope) \
  1122.         __gendescriptor(Name)                 ;\
  1123.         __begintext(Name)                     ;\
  1124. Name##.body:
  1125.  
  1126. #define SPECIAL_ENTRY(Name)              \
  1127.         __fntabentry(Name,0,0)           ;\
  1128.         __gendescriptor(Name)            ;\
  1129.         __begintext(Name)
  1130.  
  1131. #define DUMMY_ENTRY(Name)               \
  1132.         __begintext(Name)
  1133.  
  1134. #define ALTERNATE_ENTRY_S(Name,Section) \
  1135.         __gendescriptor(Name)           ;\
  1136.         __begintext_S(Name,Section)
  1137.  
  1138. #define LEAF_ENTRY_S(Name,Section)      \
  1139.         __gendescriptor(Name)           ;\
  1140.         __begintext_S(Name,Section)     ;\
  1141. Name##.body:
  1142.  
  1143. #define LEAF_ENTRY_EX_S(Name,LangHandler,Scope,Section) \
  1144.         __gendescriptor(Name)                 ;\
  1145.         __begintext_S(Name,Section)           ;\
  1146. Name##.body:
  1147.  
  1148. #define SPECIAL_ENTRY_S(Name,Section)    \
  1149.         __fntabentry(Name,0,0)           ;\
  1150.         __gendescriptor(Name)            ;\
  1151.         __begintext_S(Name,Section)
  1152.  
  1153. #define DUMMY_ENTRY_S(Name,Section)     \
  1154.         __begintext_S(Name,Section)
  1155.  
  1156. #define LEAF_EXIT(Name)                 \
  1157.         blr                             ;\
  1158. Name##.end:
  1159.  
  1160. #define ALTERNATE_EXIT(Name)            \
  1161.         blr
  1162.  
  1163. #define SPECIAL_EXIT(Name)              \
  1164.         blr                             ;\
  1165. Name##.end:
  1166.  
  1167. #define DUMMY_EXIT(Name)                \
  1168. Name##.end:
  1169.  
  1170. #define FN_TABLE(Name,ExHandler,Data)   \
  1171.         __fntabentry(Name,ExHandler,Data)
  1172.  
  1173. //
  1174. // Define special section "names" for use with the NESTED/LEAF_ENTRY_S
  1175. // macros.   For the moment just define all possibilities as text.
  1176. //
  1177.  
  1178. #define _TEXT$normal    text
  1179. #define _TEXT$00        text
  1180. #define _TEXT$01        text
  1181.  
  1182.  
  1183. //
  1184. // Internal macros, used by the above (not for programmer use)
  1185. //
  1186.  
  1187. #define __gendescriptor(Name)                   \
  1188.         .reldata                                ;\
  1189.         .align  2                               ;\
  1190.         .globl  Name                            ;\
  1191. Name:                                           ;\
  1192.         .long   ..##Name, .toc
  1193.  
  1194. #define __fntabentry(Name,ExHandler,Data)       \
  1195.         .pdata                                  ;\
  1196.         .align  2                               ;\
  1197.         .long   ..##Name                        ;\
  1198.         .long   Name##.end                      ;\
  1199.         .long   ExHandler                       ;\
  1200.         .long   Data                            ;\
  1201.         .long   Name##.body
  1202.  
  1203. #define __begintext(Name)                       \
  1204.         .text                                   ;\
  1205.         .align  2                               ;\
  1206.         .globl  ..##Name                        ;\
  1207. ..##Name:
  1208.  
  1209. #define __begintext_S(Name,Section)             \
  1210.         .##Section                              ;\
  1211.         .align  2                               ;\
  1212.         .globl  ..##Name                        ;\
  1213. ..##Name:
  1214.  
  1215. //
  1216. // KIPCR(reg)
  1217. //
  1218. // Get address of KiPcr into reg
  1219. //
  1220.  
  1221. #define KIPCR(reg) li   reg, 0xffffd000
  1222.  
  1223.  
  1224. //
  1225. // DISABLE_INTERRUPTS(p0,s0)
  1226. //
  1227. // Clear EXTERNAL INTERRUPT ENABLE bit in Machine State Register
  1228. // (bit MSR:EE).
  1229. //
  1230. // Returns OLD value in p0
  1231. // Destroys s0 (actually, s0 contains new value)
  1232.  
  1233. #define DISABLE_INTERRUPTS(p0, s0)                                      ; \
  1234.         mfmsr   p0                                         ; \
  1235.         rlwinm  s0,p0,0,~MASK_SPR(MSR_EE,1)                ; \
  1236.         mtmsr   s0
  1237.  
  1238. #define ENABLE_INTERRUPTS(p0) mtmsr     p0
  1239.  
  1240. //
  1241. // RAISE_SOFTWARE_IRQL(p0, p1, s0)
  1242. //
  1243. // Raise Interrupt Request Level.
  1244. //      Parameters
  1245. //      p0      new irql
  1246. //      p1      pointer to byte to receive old irql
  1247. //      s0      scratch register (destroyed by this macro)
  1248. //
  1249. // LOWER_SOFTWARE_IRQL is done in a function rather than a macro.
  1250. //
  1251. // This macro should only be used to raise the IRQL if the interrupt
  1252. // mask does NOT need to be changed.
  1253. //
  1254.  
  1255. #define RAISE_SOFTWARE_IRQL(p0, p1, s0)         ;\
  1256.         lbz     s0, KiPcr+PcCurrentIrql(r.0)    ;\
  1257.         stb     p0, KiPcr+PcCurrentIrql(r.0)    ;\
  1258.         stb     s0, 0(p1)
  1259.  
  1260. //
  1261. // SOFTWARE_INTERRUPT(level, scratch)
  1262. //
  1263. // Set a flag indicating we need to process a software interrupt.
  1264. // This flag is checked when priority is lowered below dispatch level.
  1265. //
  1266. //      Parameters
  1267. //      level   is the priority of the interrupt  (either DISPATCH_LEVEL
  1268. //              or APC_LEVEL).
  1269. //      scratch is a register that will be destroyed by this macro.
  1270. //
  1271. // The flag is in fact a word in the PCR.  There are only two levels of
  1272. // software interrupt and we need to be able to set either one atomically.
  1273. // To accomplish this we store into a different byte for either of the
  1274. // interrupts. To indicate an APC_LEVEL interrupt store a non-zero value
  1275. // at pcr->SoftwareInterrupt + 0, DISPATCH_LEVEL store at the same address
  1276. // + 1.
  1277. //
  1278.  
  1279. #define SOFTWARE_INTERRUPT(level, scr)                                \
  1280.         li      scr, 1                                              ; \
  1281.         stb     scr, KiPcr+PcSoftwareInterrupt+level-APC_LEVEL(r.0)
  1282.  
  1283. #endif // _KXPPC_C_HEADER_
  1284.  
  1285.  
  1286. #ifndef _PPC601_
  1287. #define _PPC601_        601
  1288. #endif
  1289. #define PPC60X  _PPC601_
  1290.  
  1291. //
  1292. //  Exception entry reasons.  Passed to KiDispatchException from
  1293. //  exception entry routines.
  1294. //
  1295. #define ppc_machine_check       1
  1296. #define ppc_data_storage        2
  1297. #define ppc_instruction_storage 3
  1298. #define ppc_external            4
  1299. #define ppc_alignment           5
  1300. #define ppc_program             6
  1301. #define ppc_fp_unavailable      7
  1302. #define ppc_decrementer         8
  1303. #define ppc_direct_store_error  9
  1304. #define ppc_syscall             10
  1305. #define ppc_trace               11
  1306. #define ppc_fp_assist           12
  1307. #define ppc_run_mode            13
  1308. #define ppc_panic               256
  1309.  
  1310. #endif // _KXPPC_
  1311.