asm-offsets.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342
  1. /*
  2. * offset.c: Calculate pt_regs and task_struct offsets.
  3. *
  4. * Copyright (C) 1996 David S. Miller
  5. * Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 Ralf Baechle
  6. * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
  7. *
  8. * Kevin Kissell, kevink@mips.com and Carsten Langgaard, carstenl@mips.com
  9. * Copyright (C) 2000 MIPS Technologies, Inc.
  10. */
  11. #include <linux/compat.h>
  12. #include <linux/types.h>
  13. #include <linux/sched.h>
  14. #include <linux/mm.h>
  15. #include <linux/interrupt.h>
  16. #include <linux/kbuild.h>
  17. #include <linux/suspend.h>
  18. #include <asm/ptrace.h>
  19. #include <asm/processor.h>
  20. void output_ptreg_defines(void)
  21. {
  22. COMMENT("MIPS pt_regs offsets.");
  23. OFFSET(PT_R0, pt_regs, regs[0]);
  24. OFFSET(PT_R1, pt_regs, regs[1]);
  25. OFFSET(PT_R2, pt_regs, regs[2]);
  26. OFFSET(PT_R3, pt_regs, regs[3]);
  27. OFFSET(PT_R4, pt_regs, regs[4]);
  28. OFFSET(PT_R5, pt_regs, regs[5]);
  29. OFFSET(PT_R6, pt_regs, regs[6]);
  30. OFFSET(PT_R7, pt_regs, regs[7]);
  31. OFFSET(PT_R8, pt_regs, regs[8]);
  32. OFFSET(PT_R9, pt_regs, regs[9]);
  33. OFFSET(PT_R10, pt_regs, regs[10]);
  34. OFFSET(PT_R11, pt_regs, regs[11]);
  35. OFFSET(PT_R12, pt_regs, regs[12]);
  36. OFFSET(PT_R13, pt_regs, regs[13]);
  37. OFFSET(PT_R14, pt_regs, regs[14]);
  38. OFFSET(PT_R15, pt_regs, regs[15]);
  39. OFFSET(PT_R16, pt_regs, regs[16]);
  40. OFFSET(PT_R17, pt_regs, regs[17]);
  41. OFFSET(PT_R18, pt_regs, regs[18]);
  42. OFFSET(PT_R19, pt_regs, regs[19]);
  43. OFFSET(PT_R20, pt_regs, regs[20]);
  44. OFFSET(PT_R21, pt_regs, regs[21]);
  45. OFFSET(PT_R22, pt_regs, regs[22]);
  46. OFFSET(PT_R23, pt_regs, regs[23]);
  47. OFFSET(PT_R24, pt_regs, regs[24]);
  48. OFFSET(PT_R25, pt_regs, regs[25]);
  49. OFFSET(PT_R26, pt_regs, regs[26]);
  50. OFFSET(PT_R27, pt_regs, regs[27]);
  51. OFFSET(PT_R28, pt_regs, regs[28]);
  52. OFFSET(PT_R29, pt_regs, regs[29]);
  53. OFFSET(PT_R30, pt_regs, regs[30]);
  54. OFFSET(PT_R31, pt_regs, regs[31]);
  55. OFFSET(PT_LO, pt_regs, lo);
  56. OFFSET(PT_HI, pt_regs, hi);
  57. #ifdef CONFIG_CPU_HAS_SMARTMIPS
  58. OFFSET(PT_ACX, pt_regs, acx);
  59. #endif
  60. OFFSET(PT_EPC, pt_regs, cp0_epc);
  61. OFFSET(PT_BVADDR, pt_regs, cp0_badvaddr);
  62. OFFSET(PT_STATUS, pt_regs, cp0_status);
  63. OFFSET(PT_CAUSE, pt_regs, cp0_cause);
  64. #ifdef CONFIG_MIPS_MT_SMTC
  65. OFFSET(PT_TCSTATUS, pt_regs, cp0_tcstatus);
  66. #endif /* CONFIG_MIPS_MT_SMTC */
  67. #ifdef CONFIG_CPU_CAVIUM_OCTEON
  68. OFFSET(PT_MPL, pt_regs, mpl);
  69. OFFSET(PT_MTP, pt_regs, mtp);
  70. #endif /* CONFIG_CPU_CAVIUM_OCTEON */
  71. DEFINE(PT_SIZE, sizeof(struct pt_regs));
  72. BLANK();
  73. }
  74. void output_task_defines(void)
  75. {
  76. COMMENT("MIPS task_struct offsets.");
  77. OFFSET(TASK_STATE, task_struct, state);
  78. OFFSET(TASK_THREAD_INFO, task_struct, stack);
  79. OFFSET(TASK_FLAGS, task_struct, flags);
  80. OFFSET(TASK_MM, task_struct, mm);
  81. OFFSET(TASK_PID, task_struct, pid);
  82. DEFINE(TASK_STRUCT_SIZE, sizeof(struct task_struct));
  83. BLANK();
  84. }
  85. void output_thread_info_defines(void)
  86. {
  87. COMMENT("MIPS thread_info offsets.");
  88. OFFSET(TI_TASK, thread_info, task);
  89. OFFSET(TI_EXEC_DOMAIN, thread_info, exec_domain);
  90. OFFSET(TI_FLAGS, thread_info, flags);
  91. OFFSET(TI_TP_VALUE, thread_info, tp_value);
  92. OFFSET(TI_CPU, thread_info, cpu);
  93. OFFSET(TI_PRE_COUNT, thread_info, preempt_count);
  94. OFFSET(TI_ADDR_LIMIT, thread_info, addr_limit);
  95. OFFSET(TI_RESTART_BLOCK, thread_info, restart_block);
  96. OFFSET(TI_REGS, thread_info, regs);
  97. DEFINE(_THREAD_SIZE, THREAD_SIZE);
  98. DEFINE(_THREAD_MASK, THREAD_MASK);
  99. BLANK();
  100. }
  101. void output_thread_defines(void)
  102. {
  103. COMMENT("MIPS specific thread_struct offsets.");
  104. OFFSET(THREAD_REG16, task_struct, thread.reg16);
  105. OFFSET(THREAD_REG17, task_struct, thread.reg17);
  106. OFFSET(THREAD_REG18, task_struct, thread.reg18);
  107. OFFSET(THREAD_REG19, task_struct, thread.reg19);
  108. OFFSET(THREAD_REG20, task_struct, thread.reg20);
  109. OFFSET(THREAD_REG21, task_struct, thread.reg21);
  110. OFFSET(THREAD_REG22, task_struct, thread.reg22);
  111. OFFSET(THREAD_REG23, task_struct, thread.reg23);
  112. OFFSET(THREAD_REG29, task_struct, thread.reg29);
  113. OFFSET(THREAD_REG30, task_struct, thread.reg30);
  114. OFFSET(THREAD_REG31, task_struct, thread.reg31);
  115. OFFSET(THREAD_STATUS, task_struct,
  116. thread.cp0_status);
  117. OFFSET(THREAD_FPU, task_struct, thread.fpu);
  118. OFFSET(THREAD_BVADDR, task_struct, \
  119. thread.cp0_badvaddr);
  120. OFFSET(THREAD_BUADDR, task_struct, \
  121. thread.cp0_baduaddr);
  122. OFFSET(THREAD_ECODE, task_struct, \
  123. thread.error_code);
  124. OFFSET(THREAD_TRAMP, task_struct, \
  125. thread.irix_trampoline);
  126. OFFSET(THREAD_OLDCTX, task_struct, \
  127. thread.irix_oldctx);
  128. BLANK();
  129. }
  130. void output_thread_fpu_defines(void)
  131. {
  132. OFFSET(THREAD_FPR0, task_struct, thread.fpu.fpr[0]);
  133. OFFSET(THREAD_FPR1, task_struct, thread.fpu.fpr[1]);
  134. OFFSET(THREAD_FPR2, task_struct, thread.fpu.fpr[2]);
  135. OFFSET(THREAD_FPR3, task_struct, thread.fpu.fpr[3]);
  136. OFFSET(THREAD_FPR4, task_struct, thread.fpu.fpr[4]);
  137. OFFSET(THREAD_FPR5, task_struct, thread.fpu.fpr[5]);
  138. OFFSET(THREAD_FPR6, task_struct, thread.fpu.fpr[6]);
  139. OFFSET(THREAD_FPR7, task_struct, thread.fpu.fpr[7]);
  140. OFFSET(THREAD_FPR8, task_struct, thread.fpu.fpr[8]);
  141. OFFSET(THREAD_FPR9, task_struct, thread.fpu.fpr[9]);
  142. OFFSET(THREAD_FPR10, task_struct, thread.fpu.fpr[10]);
  143. OFFSET(THREAD_FPR11, task_struct, thread.fpu.fpr[11]);
  144. OFFSET(THREAD_FPR12, task_struct, thread.fpu.fpr[12]);
  145. OFFSET(THREAD_FPR13, task_struct, thread.fpu.fpr[13]);
  146. OFFSET(THREAD_FPR14, task_struct, thread.fpu.fpr[14]);
  147. OFFSET(THREAD_FPR15, task_struct, thread.fpu.fpr[15]);
  148. OFFSET(THREAD_FPR16, task_struct, thread.fpu.fpr[16]);
  149. OFFSET(THREAD_FPR17, task_struct, thread.fpu.fpr[17]);
  150. OFFSET(THREAD_FPR18, task_struct, thread.fpu.fpr[18]);
  151. OFFSET(THREAD_FPR19, task_struct, thread.fpu.fpr[19]);
  152. OFFSET(THREAD_FPR20, task_struct, thread.fpu.fpr[20]);
  153. OFFSET(THREAD_FPR21, task_struct, thread.fpu.fpr[21]);
  154. OFFSET(THREAD_FPR22, task_struct, thread.fpu.fpr[22]);
  155. OFFSET(THREAD_FPR23, task_struct, thread.fpu.fpr[23]);
  156. OFFSET(THREAD_FPR24, task_struct, thread.fpu.fpr[24]);
  157. OFFSET(THREAD_FPR25, task_struct, thread.fpu.fpr[25]);
  158. OFFSET(THREAD_FPR26, task_struct, thread.fpu.fpr[26]);
  159. OFFSET(THREAD_FPR27, task_struct, thread.fpu.fpr[27]);
  160. OFFSET(THREAD_FPR28, task_struct, thread.fpu.fpr[28]);
  161. OFFSET(THREAD_FPR29, task_struct, thread.fpu.fpr[29]);
  162. OFFSET(THREAD_FPR30, task_struct, thread.fpu.fpr[30]);
  163. OFFSET(THREAD_FPR31, task_struct, thread.fpu.fpr[31]);
  164. OFFSET(THREAD_FCR31, task_struct, thread.fpu.fcr31);
  165. BLANK();
  166. }
  167. void output_mm_defines(void)
  168. {
  169. COMMENT("Size of struct page");
  170. DEFINE(STRUCT_PAGE_SIZE, sizeof(struct page));
  171. BLANK();
  172. COMMENT("Linux mm_struct offsets.");
  173. OFFSET(MM_USERS, mm_struct, mm_users);
  174. OFFSET(MM_PGD, mm_struct, pgd);
  175. OFFSET(MM_CONTEXT, mm_struct, context);
  176. BLANK();
  177. DEFINE(_PGD_T_SIZE, sizeof(pgd_t));
  178. DEFINE(_PMD_T_SIZE, sizeof(pmd_t));
  179. DEFINE(_PTE_T_SIZE, sizeof(pte_t));
  180. BLANK();
  181. DEFINE(_PGD_T_LOG2, PGD_T_LOG2);
  182. #ifndef __PAGETABLE_PMD_FOLDED
  183. DEFINE(_PMD_T_LOG2, PMD_T_LOG2);
  184. #endif
  185. DEFINE(_PTE_T_LOG2, PTE_T_LOG2);
  186. BLANK();
  187. DEFINE(_PGD_ORDER, PGD_ORDER);
  188. #ifndef __PAGETABLE_PMD_FOLDED
  189. DEFINE(_PMD_ORDER, PMD_ORDER);
  190. #endif
  191. DEFINE(_PTE_ORDER, PTE_ORDER);
  192. BLANK();
  193. DEFINE(_PMD_SHIFT, PMD_SHIFT);
  194. DEFINE(_PGDIR_SHIFT, PGDIR_SHIFT);
  195. BLANK();
  196. DEFINE(_PTRS_PER_PGD, PTRS_PER_PGD);
  197. DEFINE(_PTRS_PER_PMD, PTRS_PER_PMD);
  198. DEFINE(_PTRS_PER_PTE, PTRS_PER_PTE);
  199. BLANK();
  200. }
  201. #ifdef CONFIG_32BIT
  202. void output_sc_defines(void)
  203. {
  204. COMMENT("Linux sigcontext offsets.");
  205. OFFSET(SC_REGS, sigcontext, sc_regs);
  206. OFFSET(SC_FPREGS, sigcontext, sc_fpregs);
  207. OFFSET(SC_ACX, sigcontext, sc_acx);
  208. OFFSET(SC_MDHI, sigcontext, sc_mdhi);
  209. OFFSET(SC_MDLO, sigcontext, sc_mdlo);
  210. OFFSET(SC_PC, sigcontext, sc_pc);
  211. OFFSET(SC_FPC_CSR, sigcontext, sc_fpc_csr);
  212. OFFSET(SC_FPC_EIR, sigcontext, sc_fpc_eir);
  213. OFFSET(SC_HI1, sigcontext, sc_hi1);
  214. OFFSET(SC_LO1, sigcontext, sc_lo1);
  215. OFFSET(SC_HI2, sigcontext, sc_hi2);
  216. OFFSET(SC_LO2, sigcontext, sc_lo2);
  217. OFFSET(SC_HI3, sigcontext, sc_hi3);
  218. OFFSET(SC_LO3, sigcontext, sc_lo3);
  219. BLANK();
  220. }
  221. #endif
  222. #ifdef CONFIG_64BIT
  223. void output_sc_defines(void)
  224. {
  225. COMMENT("Linux sigcontext offsets.");
  226. OFFSET(SC_REGS, sigcontext, sc_regs);
  227. OFFSET(SC_FPREGS, sigcontext, sc_fpregs);
  228. OFFSET(SC_MDHI, sigcontext, sc_mdhi);
  229. OFFSET(SC_MDLO, sigcontext, sc_mdlo);
  230. OFFSET(SC_PC, sigcontext, sc_pc);
  231. OFFSET(SC_FPC_CSR, sigcontext, sc_fpc_csr);
  232. BLANK();
  233. }
  234. #endif
  235. #ifdef CONFIG_MIPS32_COMPAT
  236. void output_sc32_defines(void)
  237. {
  238. COMMENT("Linux 32-bit sigcontext offsets.");
  239. OFFSET(SC32_FPREGS, sigcontext32, sc_fpregs);
  240. OFFSET(SC32_FPC_CSR, sigcontext32, sc_fpc_csr);
  241. OFFSET(SC32_FPC_EIR, sigcontext32, sc_fpc_eir);
  242. BLANK();
  243. }
  244. #endif
  245. void output_signal_defined(void)
  246. {
  247. COMMENT("Linux signal numbers.");
  248. DEFINE(_SIGHUP, SIGHUP);
  249. DEFINE(_SIGINT, SIGINT);
  250. DEFINE(_SIGQUIT, SIGQUIT);
  251. DEFINE(_SIGILL, SIGILL);
  252. DEFINE(_SIGTRAP, SIGTRAP);
  253. DEFINE(_SIGIOT, SIGIOT);
  254. DEFINE(_SIGABRT, SIGABRT);
  255. DEFINE(_SIGEMT, SIGEMT);
  256. DEFINE(_SIGFPE, SIGFPE);
  257. DEFINE(_SIGKILL, SIGKILL);
  258. DEFINE(_SIGBUS, SIGBUS);
  259. DEFINE(_SIGSEGV, SIGSEGV);
  260. DEFINE(_SIGSYS, SIGSYS);
  261. DEFINE(_SIGPIPE, SIGPIPE);
  262. DEFINE(_SIGALRM, SIGALRM);
  263. DEFINE(_SIGTERM, SIGTERM);
  264. DEFINE(_SIGUSR1, SIGUSR1);
  265. DEFINE(_SIGUSR2, SIGUSR2);
  266. DEFINE(_SIGCHLD, SIGCHLD);
  267. DEFINE(_SIGPWR, SIGPWR);
  268. DEFINE(_SIGWINCH, SIGWINCH);
  269. DEFINE(_SIGURG, SIGURG);
  270. DEFINE(_SIGIO, SIGIO);
  271. DEFINE(_SIGSTOP, SIGSTOP);
  272. DEFINE(_SIGTSTP, SIGTSTP);
  273. DEFINE(_SIGCONT, SIGCONT);
  274. DEFINE(_SIGTTIN, SIGTTIN);
  275. DEFINE(_SIGTTOU, SIGTTOU);
  276. DEFINE(_SIGVTALRM, SIGVTALRM);
  277. DEFINE(_SIGPROF, SIGPROF);
  278. DEFINE(_SIGXCPU, SIGXCPU);
  279. DEFINE(_SIGXFSZ, SIGXFSZ);
  280. BLANK();
  281. }
  282. void output_irq_cpustat_t_defines(void)
  283. {
  284. COMMENT("Linux irq_cpustat_t offsets.");
  285. DEFINE(IC_SOFTIRQ_PENDING,
  286. offsetof(irq_cpustat_t, __softirq_pending));
  287. DEFINE(IC_IRQ_CPUSTAT_T, sizeof(irq_cpustat_t));
  288. BLANK();
  289. }
  290. #ifdef CONFIG_CPU_CAVIUM_OCTEON
  291. void output_octeon_cop2_state_defines(void)
  292. {
  293. COMMENT("Octeon specific octeon_cop2_state offsets.");
  294. OFFSET(OCTEON_CP2_CRC_IV, octeon_cop2_state, cop2_crc_iv);
  295. OFFSET(OCTEON_CP2_CRC_LENGTH, octeon_cop2_state, cop2_crc_length);
  296. OFFSET(OCTEON_CP2_CRC_POLY, octeon_cop2_state, cop2_crc_poly);
  297. OFFSET(OCTEON_CP2_LLM_DAT, octeon_cop2_state, cop2_llm_dat);
  298. OFFSET(OCTEON_CP2_3DES_IV, octeon_cop2_state, cop2_3des_iv);
  299. OFFSET(OCTEON_CP2_3DES_KEY, octeon_cop2_state, cop2_3des_key);
  300. OFFSET(OCTEON_CP2_3DES_RESULT, octeon_cop2_state, cop2_3des_result);
  301. OFFSET(OCTEON_CP2_AES_INP0, octeon_cop2_state, cop2_aes_inp0);
  302. OFFSET(OCTEON_CP2_AES_IV, octeon_cop2_state, cop2_aes_iv);
  303. OFFSET(OCTEON_CP2_AES_KEY, octeon_cop2_state, cop2_aes_key);
  304. OFFSET(OCTEON_CP2_AES_KEYLEN, octeon_cop2_state, cop2_aes_keylen);
  305. OFFSET(OCTEON_CP2_AES_RESULT, octeon_cop2_state, cop2_aes_result);
  306. OFFSET(OCTEON_CP2_GFM_MULT, octeon_cop2_state, cop2_gfm_mult);
  307. OFFSET(OCTEON_CP2_GFM_POLY, octeon_cop2_state, cop2_gfm_poly);
  308. OFFSET(OCTEON_CP2_GFM_RESULT, octeon_cop2_state, cop2_gfm_result);
  309. OFFSET(OCTEON_CP2_HSH_DATW, octeon_cop2_state, cop2_hsh_datw);
  310. OFFSET(OCTEON_CP2_HSH_IVW, octeon_cop2_state, cop2_hsh_ivw);
  311. OFFSET(THREAD_CP2, task_struct, thread.cp2);
  312. OFFSET(THREAD_CVMSEG, task_struct, thread.cvmseg.cvmseg);
  313. BLANK();
  314. }
  315. #endif
  316. #ifdef CONFIG_HIBERNATION
  317. void output_pbe_defines(void)
  318. {
  319. COMMENT(" Linux struct pbe offsets. ");
  320. OFFSET(PBE_ADDRESS, pbe, address);
  321. OFFSET(PBE_ORIG_ADDRESS, pbe, orig_address);
  322. OFFSET(PBE_NEXT, pbe, next);
  323. DEFINE(PBE_SIZE, sizeof(struct pbe));
  324. BLANK();
  325. }
  326. #endif