241 lines
11 KiB
C
241 lines
11 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Generate definitions needed by assembly language modules.
|
|
* This code generates raw asm output which is post-processed to extract
|
|
* and format the required data.
|
|
*/
|
|
|
|
#define GENERATING_ASM_OFFSETS /* asm/smp.h */
|
|
#include <linux/stddef.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/kbuild.h>
|
|
#include <linux/suspend.h>
|
|
|
|
#include <asm/suspend.h>
|
|
#include <asm/kvm.h>
|
|
|
|
#include "traps.c"
|
|
#include "signal.c"
|
|
|
|
void foo(void)
|
|
{
|
|
DEFINE(ASM_THREAD_SIZE, THREAD_SIZE);
|
|
DEFINE(TI_FLAGS, offsetof(struct thread_info, flags));
|
|
BLANK();
|
|
|
|
DEFINE(TASK_BLOCKED, offsetof(struct task_struct, blocked));
|
|
DEFINE(TASK_CRED, offsetof(struct task_struct, cred));
|
|
DEFINE(TASK_REAL_PARENT, offsetof(struct task_struct, real_parent));
|
|
DEFINE(TASK_GROUP_LEADER, offsetof(struct task_struct, group_leader));
|
|
DEFINE(TASK_TGID, offsetof(struct task_struct, tgid));
|
|
DEFINE(TASK_STACK, offsetof(struct task_struct, stack));
|
|
#ifdef CONFIG_SMP
|
|
DEFINE(TASK_CPU, offsetof(struct task_struct, thread_info.cpu));
|
|
#endif
|
|
BLANK();
|
|
|
|
OFFSET(PSTATE_REGS, processor_state, regs);
|
|
OFFSET(PSTATE_FPREGS, processor_state, fpregs);
|
|
OFFSET(PSTATE_FPCR, processor_state, fpcr);
|
|
OFFSET(PSTATE_KTP, processor_state, ktp);
|
|
#ifdef CONFIG_HIBERNATION
|
|
OFFSET(PSTATE_SP, processor_state, sp);
|
|
#endif
|
|
OFFSET(PBE_ADDR, pbe, address);
|
|
OFFSET(PBE_ORIG_ADDR, pbe, orig_address);
|
|
OFFSET(PBE_NEXT, pbe, next);
|
|
OFFSET(CALLEE_R9, callee_saved_regs, r9);
|
|
OFFSET(CALLEE_R10, callee_saved_regs, r10);
|
|
OFFSET(CALLEE_R11, callee_saved_regs, r11);
|
|
OFFSET(CALLEE_R12, callee_saved_regs, r12);
|
|
OFFSET(CALLEE_R13, callee_saved_regs, r13);
|
|
OFFSET(CALLEE_R14, callee_saved_regs, r14);
|
|
OFFSET(CALLEE_R15, callee_saved_regs, r15);
|
|
OFFSET(CALLEE_RA, callee_saved_regs, ra);
|
|
OFFSET(CALLEE_F2, callee_saved_fpregs, f2);
|
|
OFFSET(CALLEE_F3, callee_saved_fpregs, f3);
|
|
OFFSET(CALLEE_F4, callee_saved_fpregs, f4);
|
|
OFFSET(CALLEE_F5, callee_saved_fpregs, f5);
|
|
OFFSET(CALLEE_F6, callee_saved_fpregs, f6);
|
|
OFFSET(CALLEE_F7, callee_saved_fpregs, f7);
|
|
OFFSET(CALLEE_F8, callee_saved_fpregs, f8);
|
|
OFFSET(CALLEE_F9, callee_saved_fpregs, f9);
|
|
BLANK();
|
|
DEFINE(CRED_UID, offsetof(struct cred, uid));
|
|
DEFINE(CRED_EUID, offsetof(struct cred, euid));
|
|
DEFINE(CRED_GID, offsetof(struct cred, gid));
|
|
DEFINE(CRED_EGID, offsetof(struct cred, egid));
|
|
BLANK();
|
|
|
|
DEFINE(PT_REGS_SIZE, sizeof(struct pt_regs));
|
|
DEFINE(PT_REGS_R0, offsetof(struct pt_regs, regs[0]));
|
|
DEFINE(PT_REGS_R1, offsetof(struct pt_regs, regs[1]));
|
|
DEFINE(PT_REGS_R2, offsetof(struct pt_regs, regs[2]));
|
|
DEFINE(PT_REGS_R3, offsetof(struct pt_regs, regs[3]));
|
|
DEFINE(PT_REGS_R4, offsetof(struct pt_regs, regs[4]));
|
|
DEFINE(PT_REGS_R5, offsetof(struct pt_regs, regs[5]));
|
|
DEFINE(PT_REGS_R6, offsetof(struct pt_regs, regs[6]));
|
|
DEFINE(PT_REGS_R7, offsetof(struct pt_regs, regs[7]));
|
|
DEFINE(PT_REGS_R8, offsetof(struct pt_regs, regs[8]));
|
|
DEFINE(PT_REGS_R9, offsetof(struct pt_regs, regs[9]));
|
|
DEFINE(PT_REGS_R10, offsetof(struct pt_regs, regs[10]));
|
|
DEFINE(PT_REGS_R11, offsetof(struct pt_regs, regs[11]));
|
|
DEFINE(PT_REGS_R12, offsetof(struct pt_regs, regs[12]));
|
|
DEFINE(PT_REGS_R13, offsetof(struct pt_regs, regs[13]));
|
|
DEFINE(PT_REGS_R14, offsetof(struct pt_regs, regs[14]));
|
|
DEFINE(PT_REGS_R15, offsetof(struct pt_regs, regs[15]));
|
|
DEFINE(PT_REGS_R16, offsetof(struct pt_regs, regs[16]));
|
|
DEFINE(PT_REGS_R17, offsetof(struct pt_regs, regs[17]));
|
|
DEFINE(PT_REGS_R18, offsetof(struct pt_regs, regs[18]));
|
|
DEFINE(PT_REGS_R19, offsetof(struct pt_regs, regs[19]));
|
|
DEFINE(PT_REGS_R20, offsetof(struct pt_regs, regs[20]));
|
|
DEFINE(PT_REGS_R21, offsetof(struct pt_regs, regs[21]));
|
|
DEFINE(PT_REGS_R22, offsetof(struct pt_regs, regs[22]));
|
|
DEFINE(PT_REGS_R23, offsetof(struct pt_regs, regs[23]));
|
|
DEFINE(PT_REGS_R24, offsetof(struct pt_regs, regs[24]));
|
|
DEFINE(PT_REGS_R25, offsetof(struct pt_regs, regs[25]));
|
|
DEFINE(PT_REGS_R26, offsetof(struct pt_regs, regs[26]));
|
|
DEFINE(PT_REGS_R27, offsetof(struct pt_regs, regs[27]));
|
|
DEFINE(PT_REGS_R28, offsetof(struct pt_regs, regs[28]));
|
|
DEFINE(PT_REGS_GP, offsetof(struct pt_regs, regs[29]));
|
|
DEFINE(PT_REGS_SP, offsetof(struct pt_regs, regs[30]));
|
|
DEFINE(PT_REGS_PC, offsetof(struct pt_regs, pc));
|
|
DEFINE(PT_REGS_PS, offsetof(struct pt_regs, ps));
|
|
DEFINE(PT_REGS_ORIG_R0, offsetof(struct pt_regs, orig_r0));
|
|
DEFINE(PT_REGS_ORIG_R19, offsetof(struct pt_regs, orig_r19));
|
|
DEFINE(PT_REGS_HM_PS, offsetof(struct pt_regs, hm_ps));
|
|
DEFINE(PT_REGS_HM_PC, offsetof(struct pt_regs, hm_pc));
|
|
DEFINE(PT_REGS_HM_GP, offsetof(struct pt_regs, hm_gp));
|
|
DEFINE(PT_REGS_HM_R16, offsetof(struct pt_regs, hm_r16));
|
|
DEFINE(PT_REGS_HM_R17, offsetof(struct pt_regs, hm_r17));
|
|
DEFINE(PT_REGS_HM_R18, offsetof(struct pt_regs, hm_r18));
|
|
BLANK();
|
|
|
|
DEFINE(KVM_REGS_SIZE, sizeof(struct kvm_regs));
|
|
DEFINE(KVM_REGS_R0, offsetof(struct kvm_regs, r0));
|
|
DEFINE(KVM_REGS_R1, offsetof(struct kvm_regs, r1));
|
|
DEFINE(KVM_REGS_R2, offsetof(struct kvm_regs, r2));
|
|
DEFINE(KVM_REGS_R3, offsetof(struct kvm_regs, r3));
|
|
DEFINE(KVM_REGS_R4, offsetof(struct kvm_regs, r4));
|
|
DEFINE(KVM_REGS_R5, offsetof(struct kvm_regs, r5));
|
|
DEFINE(KVM_REGS_R6, offsetof(struct kvm_regs, r6));
|
|
DEFINE(KVM_REGS_R7, offsetof(struct kvm_regs, r7));
|
|
DEFINE(KVM_REGS_R8, offsetof(struct kvm_regs, r8));
|
|
DEFINE(KVM_REGS_R9, offsetof(struct kvm_regs, r9));
|
|
DEFINE(KVM_REGS_R10, offsetof(struct kvm_regs, r10));
|
|
DEFINE(KVM_REGS_R11, offsetof(struct kvm_regs, r11));
|
|
DEFINE(KVM_REGS_R12, offsetof(struct kvm_regs, r12));
|
|
DEFINE(KVM_REGS_R13, offsetof(struct kvm_regs, r13));
|
|
DEFINE(KVM_REGS_R14, offsetof(struct kvm_regs, r14));
|
|
DEFINE(KVM_REGS_R15, offsetof(struct kvm_regs, r15));
|
|
DEFINE(KVM_REGS_R19, offsetof(struct kvm_regs, r19));
|
|
DEFINE(KVM_REGS_R20, offsetof(struct kvm_regs, r20));
|
|
DEFINE(KVM_REGS_R21, offsetof(struct kvm_regs, r21));
|
|
DEFINE(KVM_REGS_R22, offsetof(struct kvm_regs, r22));
|
|
DEFINE(KVM_REGS_R23, offsetof(struct kvm_regs, r23));
|
|
DEFINE(KVM_REGS_R24, offsetof(struct kvm_regs, r24));
|
|
DEFINE(KVM_REGS_R25, offsetof(struct kvm_regs, r25));
|
|
DEFINE(KVM_REGS_R26, offsetof(struct kvm_regs, r26));
|
|
DEFINE(KVM_REGS_R27, offsetof(struct kvm_regs, r27));
|
|
DEFINE(KVM_REGS_R28, offsetof(struct kvm_regs, r28));
|
|
DEFINE(KVM_REGS_FPCR, offsetof(struct kvm_regs, fpcr));
|
|
DEFINE(KVM_REGS_F0, offsetof(struct kvm_regs, fp[0 * 4]));
|
|
DEFINE(KVM_REGS_F1, offsetof(struct kvm_regs, fp[1 * 4]));
|
|
DEFINE(KVM_REGS_F2, offsetof(struct kvm_regs, fp[2 * 4]));
|
|
DEFINE(KVM_REGS_F3, offsetof(struct kvm_regs, fp[3 * 4]));
|
|
DEFINE(KVM_REGS_F4, offsetof(struct kvm_regs, fp[4 * 4]));
|
|
DEFINE(KVM_REGS_F5, offsetof(struct kvm_regs, fp[5 * 4]));
|
|
DEFINE(KVM_REGS_F6, offsetof(struct kvm_regs, fp[6 * 4]));
|
|
DEFINE(KVM_REGS_F7, offsetof(struct kvm_regs, fp[7 * 4]));
|
|
DEFINE(KVM_REGS_F8, offsetof(struct kvm_regs, fp[8 * 4]));
|
|
DEFINE(KVM_REGS_F9, offsetof(struct kvm_regs, fp[9 * 4]));
|
|
DEFINE(KVM_REGS_F10, offsetof(struct kvm_regs, fp[10 * 4]));
|
|
DEFINE(KVM_REGS_F11, offsetof(struct kvm_regs, fp[11 * 4]));
|
|
DEFINE(KVM_REGS_F12, offsetof(struct kvm_regs, fp[12 * 4]));
|
|
DEFINE(KVM_REGS_F13, offsetof(struct kvm_regs, fp[13 * 4]));
|
|
DEFINE(KVM_REGS_F14, offsetof(struct kvm_regs, fp[14 * 4]));
|
|
DEFINE(KVM_REGS_F15, offsetof(struct kvm_regs, fp[15 * 4]));
|
|
DEFINE(KVM_REGS_F16, offsetof(struct kvm_regs, fp[16 * 4]));
|
|
DEFINE(KVM_REGS_F17, offsetof(struct kvm_regs, fp[17 * 4]));
|
|
DEFINE(KVM_REGS_F18, offsetof(struct kvm_regs, fp[18 * 4]));
|
|
DEFINE(KVM_REGS_F19, offsetof(struct kvm_regs, fp[19 * 4]));
|
|
DEFINE(KVM_REGS_F20, offsetof(struct kvm_regs, fp[20 * 4]));
|
|
DEFINE(KVM_REGS_F21, offsetof(struct kvm_regs, fp[21 * 4]));
|
|
DEFINE(KVM_REGS_F22, offsetof(struct kvm_regs, fp[22 * 4]));
|
|
DEFINE(KVM_REGS_F23, offsetof(struct kvm_regs, fp[23 * 4]));
|
|
DEFINE(KVM_REGS_F24, offsetof(struct kvm_regs, fp[24 * 4]));
|
|
DEFINE(KVM_REGS_F25, offsetof(struct kvm_regs, fp[25 * 4]));
|
|
DEFINE(KVM_REGS_F26, offsetof(struct kvm_regs, fp[26 * 4]));
|
|
DEFINE(KVM_REGS_F27, offsetof(struct kvm_regs, fp[27 * 4]));
|
|
DEFINE(KVM_REGS_F28, offsetof(struct kvm_regs, fp[28 * 4]));
|
|
DEFINE(KVM_REGS_F29, offsetof(struct kvm_regs, fp[29 * 4]));
|
|
DEFINE(KVM_REGS_F30, offsetof(struct kvm_regs, fp[30 * 4]));
|
|
DEFINE(KVM_REGS_PS, offsetof(struct kvm_regs, ps));
|
|
DEFINE(KVM_REGS_PC, offsetof(struct kvm_regs, pc));
|
|
DEFINE(KVM_REGS_GP, offsetof(struct kvm_regs, gp));
|
|
DEFINE(KVM_REGS_R16, offsetof(struct kvm_regs, r16));
|
|
DEFINE(KVM_REGS_R17, offsetof(struct kvm_regs, r17));
|
|
DEFINE(KVM_REGS_R18, offsetof(struct kvm_regs, r18));
|
|
BLANK();
|
|
|
|
DEFINE(VCPU_RET_SIZE, sizeof(struct vcpu_run_ret_stack));
|
|
DEFINE(VCPU_RET_RA, offsetof(struct vcpu_run_ret_stack, ra));
|
|
DEFINE(VCPU_RET_R0, offsetof(struct vcpu_run_ret_stack, r0));
|
|
BLANK();
|
|
|
|
DEFINE(HOST_INT_SIZE, sizeof(struct host_int_args));
|
|
DEFINE(HOST_INT_R18, offsetof(struct host_int_args, r18));
|
|
DEFINE(HOST_INT_R17, offsetof(struct host_int_args, r17));
|
|
DEFINE(HOST_INT_R16, offsetof(struct host_int_args, r16));
|
|
BLANK();
|
|
|
|
OFFSET(TASK_THREAD, task_struct, thread);
|
|
OFFSET(TASK_THREAD_F0, task_struct, thread.fpstate.fp[0]);
|
|
OFFSET(TASK_THREAD_F1, task_struct, thread.fpstate.fp[1]);
|
|
OFFSET(TASK_THREAD_F2, task_struct, thread.fpstate.fp[2]);
|
|
OFFSET(TASK_THREAD_F3, task_struct, thread.fpstate.fp[3]);
|
|
OFFSET(TASK_THREAD_F4, task_struct, thread.fpstate.fp[4]);
|
|
OFFSET(TASK_THREAD_F5, task_struct, thread.fpstate.fp[5]);
|
|
OFFSET(TASK_THREAD_F6, task_struct, thread.fpstate.fp[6]);
|
|
OFFSET(TASK_THREAD_F7, task_struct, thread.fpstate.fp[7]);
|
|
OFFSET(TASK_THREAD_F8, task_struct, thread.fpstate.fp[8]);
|
|
OFFSET(TASK_THREAD_F9, task_struct, thread.fpstate.fp[9]);
|
|
OFFSET(TASK_THREAD_F10, task_struct, thread.fpstate.fp[10]);
|
|
OFFSET(TASK_THREAD_F11, task_struct, thread.fpstate.fp[11]);
|
|
OFFSET(TASK_THREAD_F12, task_struct, thread.fpstate.fp[12]);
|
|
OFFSET(TASK_THREAD_F13, task_struct, thread.fpstate.fp[13]);
|
|
OFFSET(TASK_THREAD_F14, task_struct, thread.fpstate.fp[14]);
|
|
OFFSET(TASK_THREAD_F15, task_struct, thread.fpstate.fp[15]);
|
|
OFFSET(TASK_THREAD_F16, task_struct, thread.fpstate.fp[16]);
|
|
OFFSET(TASK_THREAD_F17, task_struct, thread.fpstate.fp[17]);
|
|
OFFSET(TASK_THREAD_F18, task_struct, thread.fpstate.fp[18]);
|
|
OFFSET(TASK_THREAD_F19, task_struct, thread.fpstate.fp[19]);
|
|
OFFSET(TASK_THREAD_F20, task_struct, thread.fpstate.fp[20]);
|
|
OFFSET(TASK_THREAD_F21, task_struct, thread.fpstate.fp[21]);
|
|
OFFSET(TASK_THREAD_F22, task_struct, thread.fpstate.fp[22]);
|
|
OFFSET(TASK_THREAD_F23, task_struct, thread.fpstate.fp[23]);
|
|
OFFSET(TASK_THREAD_F24, task_struct, thread.fpstate.fp[24]);
|
|
OFFSET(TASK_THREAD_F25, task_struct, thread.fpstate.fp[25]);
|
|
OFFSET(TASK_THREAD_F26, task_struct, thread.fpstate.fp[26]);
|
|
OFFSET(TASK_THREAD_F27, task_struct, thread.fpstate.fp[27]);
|
|
OFFSET(TASK_THREAD_F28, task_struct, thread.fpstate.fp[28]);
|
|
OFFSET(TASK_THREAD_F29, task_struct, thread.fpstate.fp[29]);
|
|
OFFSET(TASK_THREAD_F30, task_struct, thread.fpstate.fp[30]);
|
|
OFFSET(TASK_THREAD_FPCR, task_struct, thread.fpstate.fpcr);
|
|
BLANK();
|
|
OFFSET(TASK_THREAD_RA, task_struct, thread.ra);
|
|
OFFSET(TASK_THREAD_SP, task_struct, thread.sp);
|
|
OFFSET(TASK_THREAD_S0, task_struct, thread.s[0]);
|
|
OFFSET(TASK_THREAD_S1, task_struct, thread.s[1]);
|
|
OFFSET(TASK_THREAD_S2, task_struct, thread.s[2]);
|
|
OFFSET(TASK_THREAD_S3, task_struct, thread.s[3]);
|
|
OFFSET(TASK_THREAD_S4, task_struct, thread.s[4]);
|
|
OFFSET(TASK_THREAD_S5, task_struct, thread.s[5]);
|
|
OFFSET(TASK_THREAD_S6, task_struct, thread.s[6]);
|
|
BLANK();
|
|
DEFINE(ASM_THREAD_SIZE, THREAD_SIZE);
|
|
BLANK();
|
|
DEFINE(RT_SIGFRAME_SIZE, sizeof(struct rt_sigframe));
|
|
OFFSET(RT_SIGFRAME_MCTX, rt_sigframe, uc.uc_mcontext);
|
|
}
|