自学教程：C++ DEFINE函数代码示例

void board_read_group(const char *cmd){	char buf[16];	snprintf(buf, sizeof(buf), "EGROUP%c", *cmd);	choose_board_t cbrd;	memset(&cbrd, 0, sizeof(cbrd));	cbrd.prefix = sysconf_str(buf);	cbrd.newflag = DEFINE(DEF_NEWPOST);	cbrd.parent = -1;	choose_board(&cbrd);}

void output_ptreg_defines(void){	COMMENT("MIPS pt_regs offsets.");	OFFSET(PT_R0, pt_regs, regs[0]);	OFFSET(PT_R1, pt_regs, regs[1]);	OFFSET(PT_R2, pt_regs, regs[2]);	OFFSET(PT_R3, pt_regs, regs[3]);	OFFSET(PT_R4, pt_regs, regs[4]);	OFFSET(PT_R5, pt_regs, regs[5]);	OFFSET(PT_R6, pt_regs, regs[6]);	OFFSET(PT_R7, pt_regs, regs[7]);	OFFSET(PT_R8, pt_regs, regs[8]);	OFFSET(PT_R9, pt_regs, regs[9]);	OFFSET(PT_R10, pt_regs, regs[10]);	OFFSET(PT_R11, pt_regs, regs[11]);	OFFSET(PT_R12, pt_regs, regs[12]);	OFFSET(PT_R13, pt_regs, regs[13]);	OFFSET(PT_R14, pt_regs, regs[14]);	OFFSET(PT_R15, pt_regs, regs[15]);	OFFSET(PT_R16, pt_regs, regs[16]);	OFFSET(PT_R17, pt_regs, regs[17]);	OFFSET(PT_R18, pt_regs, regs[18]);	OFFSET(PT_R19, pt_regs, regs[19]);	OFFSET(PT_R20, pt_regs, regs[20]);	OFFSET(PT_R21, pt_regs, regs[21]);	OFFSET(PT_R22, pt_regs, regs[22]);	OFFSET(PT_R23, pt_regs, regs[23]);	OFFSET(PT_R24, pt_regs, regs[24]);	OFFSET(PT_R25, pt_regs, regs[25]);	OFFSET(PT_R26, pt_regs, regs[26]);	OFFSET(PT_R27, pt_regs, regs[27]);	OFFSET(PT_R28, pt_regs, regs[28]);	OFFSET(PT_R29, pt_regs, regs[29]);	OFFSET(PT_R30, pt_regs, regs[30]);	OFFSET(PT_R31, pt_regs, regs[31]);	OFFSET(PT_LO, pt_regs, lo);	OFFSET(PT_HI, pt_regs, hi);#ifdef CONFIG_CPU_HAS_SMARTMIPS	OFFSET(PT_ACX, pt_regs, acx);#endif	OFFSET(PT_EPC, pt_regs, cp0_epc);	OFFSET(PT_BVADDR, pt_regs, cp0_badvaddr);	OFFSET(PT_STATUS, pt_regs, cp0_status);	OFFSET(PT_CAUSE, pt_regs, cp0_cause);#ifdef CONFIG_CPU_CAVIUM_OCTEON	OFFSET(PT_MPL, pt_regs, mpl);	OFFSET(PT_MTP, pt_regs, mtp);#endif /* CONFIG_CPU_CAVIUM_OCTEON */	DEFINE(PT_SIZE, sizeof(struct pt_regs));	BLANK();}

static voidinit_dbg(void){    l_debug_mode = 0;    DEFINE("%debug-macro-compiler", MAKE_INT(DBG_COMPILER));    DEFINE("%debug-macro-matcher", MAKE_INT(DBG_MATCHER));    DEFINE("%debug-macro-transcriptor", MAKE_INT(DBG_TRANSCRIPTOR));    DEFINE("%debug-macro-funcall", MAKE_INT(DBG_FUNCALL));    DEFINE("%debug-macro-pvar", MAKE_INT(DBG_PVAR));    DEFINE("%debug-macro-return", MAKE_INT(DBG_RETURN));    DEFINE("%debug-macro-unwrap", MAKE_INT(DBG_UNWRAP));    DEFINE("%debug-macro-expander", MAKE_INT(DBG_EXPANDER));    scm_register_funcs(dbg_funcs);}

intmain(void){    // Memory layout values    DEFINE(CYGMEM_REGION_sdram, CYGMEM_REGION_sdram);    DEFINE(CYGMEM_REGION_sdram_SIZE, CYGMEM_REGION_sdram_SIZE);    DEFINE(CYGMEM_REGION_devs, CYGMEM_REGION_devs);    DEFINE(CYGMEM_REGION_devs_SIZE, CYGMEM_REGION_devs_SIZE);    DEFINE(CYGMEM_REGION_sram, CYGMEM_REGION_sram);    DEFINE(CYGMEM_REGION_sram_SIZE, CYGMEM_REGION_sram_SIZE);    DEFINE(CYGMEM_REGION_flash, CYGMEM_REGION_flash);    DEFINE(CYGMEM_REGION_flash_SIZE, CYGMEM_REGION_flash_SIZE);        return 0;}

void output_task_defines(void){	COMMENT("MIPS task_struct offsets.");	OFFSET(TASK_STATE, task_struct, state);	OFFSET(TASK_THREAD_INFO, task_struct, stack);	OFFSET(TASK_FLAGS, task_struct, flags);	OFFSET(TASK_MM, task_struct, mm);	OFFSET(TASK_PID, task_struct, pid);#if defined(CONFIG_CC_STACKPROTECTOR)	OFFSET(TASK_STACK_CANARY, task_struct, stack_canary);#endif	DEFINE(TASK_STRUCT_SIZE, sizeof(struct task_struct));	BLANK();}

//PROCESSLINE Functionvoid PROCESSLINE(){	int i;        for(i=0;i<namcount;i++) //till the total no. of macros        	if(!strcmp(opcode,mynamtab[i].name))	//if opcode matches in the NAMTAB                {                	EXPAND();return;		//then expand                }                {                         if(!strcmp(opcode,"MACRO"))	//if "MACRO" keyword is encountered		                DEFINE();		//then define                        else fprintf(expanded,"%s",line);	//otherwise copy it into the expanded file                }}//end processline

void asm_offsets(void){	OFFSET(TASK_THREAD_INFO, task_struct, stack);	OFFSET(THREAD_PC, task_struct, thread.pc);	OFFSET(THREAD_SP, task_struct, thread.sp);#ifdef CONFIG_FRAME_POINTER	OFFSET(THREAD_FP, task_struct, thread.fp);#endif /* CONFIG_FRAME_POINTER */	OFFSET(TI_FLAGS, thread_info, flags);	DEFINE(PT_SIZE, sizeof(struct pt_regs));	OFFSET(PT_ZERO, pt_regs, zero);	OFFSET(PT_RA, pt_regs, ra);	OFFSET(PT_FP, pt_regs, s[0]);	OFFSET(PT_S0, pt_regs, s[0]);	OFFSET(PT_S1, pt_regs, s[1]);	OFFSET(PT_S2, pt_regs, s[2]);	OFFSET(PT_S3, pt_regs, s[3]);	OFFSET(PT_S4, pt_regs, s[4]);	OFFSET(PT_S5, pt_regs, s[5]);	OFFSET(PT_S6, pt_regs, s[6]);	OFFSET(PT_S7, pt_regs, s[7]);	OFFSET(PT_S8, pt_regs, s[8]);	OFFSET(PT_S9, pt_regs, s[9]);	OFFSET(PT_S10, pt_regs, s[10]);	OFFSET(PT_S11, pt_regs, s[11]);	OFFSET(PT_SP, pt_regs, sp);	OFFSET(PT_TP, pt_regs, tp);	OFFSET(PT_V0, pt_regs, v[0]);	OFFSET(PT_V1, pt_regs, v[1]);	OFFSET(PT_A0, pt_regs, a[0]);	OFFSET(PT_A1, pt_regs, a[1]);	OFFSET(PT_A2, pt_regs, a[2]);	OFFSET(PT_A3, pt_regs, a[3]);	OFFSET(PT_A4, pt_regs, a[4]);	OFFSET(PT_A5, pt_regs, a[5]);	OFFSET(PT_A6, pt_regs, a[6]);	OFFSET(PT_A7, pt_regs, a[7]);	OFFSET(PT_A8, pt_regs, a[8]);	OFFSET(PT_A9, pt_regs, a[9]);	OFFSET(PT_A10, pt_regs, a[10]);	OFFSET(PT_A11, pt_regs, a[11]);	OFFSET(PT_A12, pt_regs, a[12]);	OFFSET(PT_A13, pt_regs, a[13]);	OFFSET(PT_STATUS, pt_regs, status);	OFFSET(PT_EPC, pt_regs, epc);	OFFSET(PT_BADVADDR, pt_regs, badvaddr);	OFFSET(PT_CAUSE, pt_regs, cause);}

static int load_pager(void){	int pager = 0;	if (DEFINE(DEF_FRIENDCALL)) {		pager |= FRIEND_PAGER;	}	if (currentuser.flags[0] & PAGER_FLAG) {		pager |= ALL_PAGER;		pager |= FRIEND_PAGER;	}	if (DEFINE(DEF_FRIENDMSG)) {		pager |= FRIENDMSG_PAGER;	}	if (DEFINE(DEF_ALLMSG)) {		pager |= ALLMSG_PAGER;		pager |= FRIENDMSG_PAGER;	}	if (DEFINE(DEF_LOGOFFMSG)) {		pager |= LOGOFFMSG_PAGER;	}	return pager;}

int foo(void){    DEFINE(AOFF_task_thread, offsetof(struct task_struct, thread));    BLANK();    /* XXX This is the stuff for sclow.S, kill it. */    DEFINE(AOFF_task_pid, offsetof(struct task_struct, pid));    DEFINE(AOFF_task_uid, offsetof(struct task_struct, uid));    DEFINE(AOFF_task_gid, offsetof(struct task_struct, gid));    DEFINE(AOFF_task_euid, offsetof(struct task_struct, euid));    DEFINE(AOFF_task_egid, offsetof(struct task_struct, egid));    /* DEFINE(THREAD_INFO, offsetof(struct task_struct, stack)); */    DEFINE(ASIZ_task_uid,    sizeof(current->uid));    DEFINE(ASIZ_task_gid,    sizeof(current->gid));    DEFINE(ASIZ_task_euid,    sizeof(current->euid));    DEFINE(ASIZ_task_egid,    sizeof(current->egid));    BLANK();    DEFINE(AOFF_thread_fork_kpsr,            offsetof(struct thread_struct, fork_kpsr));    BLANK();    DEFINE(AOFF_mm_context, offsetof(struct mm_struct, context));    /* DEFINE(NUM_USER_SEGMENTS, TASK_SIZE>>28); */    return 0;}

static voidprepare (void){  /* Flags. */  MUSCLE_INSERT_BOOL ("debug_flag", debug_flag);  MUSCLE_INSERT_BOOL ("defines_flag", defines_flag);  MUSCLE_INSERT_BOOL ("error_verbose_flag", error_verbose);  MUSCLE_INSERT_BOOL ("locations_flag", locations_flag);  MUSCLE_INSERT_BOOL ("pure_flag", pure_parser);  MUSCLE_INSERT_BOOL ("synclines_flag", !no_lines_flag);  /* File names.  */  MUSCLE_INSERT_STRING ("prefix", spec_name_prefix ? spec_name_prefix : "yy");#define DEFINE(Name) MUSCLE_INSERT_STRING (#Name, Name ? Name : "")  DEFINE (dir_prefix);  DEFINE (parser_file_name);  DEFINE (spec_defines_file);  DEFINE (spec_file_prefix);  DEFINE (spec_graph_file);  DEFINE (spec_name_prefix);  DEFINE (spec_outfile);  DEFINE (spec_verbose_file);#undef DEFINE  /* User Code.  */  obstack_1grow (&pre_prologue_obstack, 0);  obstack_1grow (&post_prologue_obstack, 0);  muscle_insert ("pre_prologue", obstack_finish (&pre_prologue_obstack));  muscle_insert ("post_prologue", obstack_finish (&post_prologue_obstack));  /* Find the right skeleton file.  */  if (!skeleton)    {      if (glr_parser || nondeterministic_parser)	skeleton = "glr.c";      else	skeleton = "yacc.c";    }  /* About the skeletons. */  {    char const *pkgdatadir = getenv ("BISON_PKGDATADIR");    MUSCLE_INSERT_STRING ("pkgdatadir", pkgdatadir ? pkgdatadir : PKGDATADIR);    MUSCLE_INSERT_C_STRING ("skeleton", skeleton);  }}

void common(void) {	BLANK();	OFFSET(TI_flags, thread_info, flags);	OFFSET(TI_status, thread_info, status);	OFFSET(TI_addr_limit, thread_info, addr_limit);	OFFSET(TI_preempt_count, thread_info, preempt_count);	OFFSET(TI_preempt_lazy_count, thread_info, preempt_lazy_count);	BLANK();	OFFSET(crypto_tfm_ctx_offset, crypto_tfm, __crt_ctx);	BLANK();	OFFSET(pbe_address, pbe, address);	OFFSET(pbe_orig_address, pbe, orig_address);	OFFSET(pbe_next, pbe, next);#ifdef CONFIG_PARAVIRT	BLANK();	OFFSET(PARAVIRT_enabled, pv_info, paravirt_enabled);	OFFSET(PARAVIRT_PATCH_pv_cpu_ops, paravirt_patch_template, pv_cpu_ops);	OFFSET(PARAVIRT_PATCH_pv_irq_ops, paravirt_patch_template, pv_irq_ops);	OFFSET(PV_IRQ_irq_disable, pv_irq_ops, irq_disable);	OFFSET(PV_IRQ_irq_enable, pv_irq_ops, irq_enable);	OFFSET(PV_CPU_iret, pv_cpu_ops, iret);	OFFSET(PV_CPU_irq_enable_sysexit, pv_cpu_ops, irq_enable_sysexit);	OFFSET(PV_CPU_read_cr0, pv_cpu_ops, read_cr0);	OFFSET(PV_MMU_read_cr2, pv_mmu_ops, read_cr2);#endif#ifdef CONFIG_XEN	BLANK();	OFFSET(XEN_vcpu_info_mask, vcpu_info, evtchn_upcall_mask);	OFFSET(XEN_vcpu_info_pending, vcpu_info, evtchn_upcall_pending);#endif	BLANK();	OFFSET(BP_scratch, boot_params, scratch);	OFFSET(BP_loadflags, boot_params, hdr.loadflags);	OFFSET(BP_hardware_subarch, boot_params, hdr.hardware_subarch);	OFFSET(BP_version, boot_params, hdr.version);	OFFSET(BP_kernel_alignment, boot_params, hdr.kernel_alignment);	OFFSET(BP_pref_address, boot_params, hdr.pref_address);	OFFSET(BP_code32_start, boot_params, hdr.code32_start);	BLANK();	DEFINE(PTREGS_SIZE, sizeof(struct pt_regs));}

void output_ptreg_defines(void){	COMMENT("MIPS pt_regs offsets.");	OFFSET(PT_R0, pt_regs, regs[0]);	OFFSET(PT_R1, pt_regs, regs[1]);	OFFSET(PT_R2, pt_regs, regs[2]);	OFFSET(PT_R3, pt_regs, regs[3]);	OFFSET(PT_R4, pt_regs, regs[4]);	OFFSET(PT_R5, pt_regs, regs[5]);	OFFSET(PT_R6, pt_regs, regs[6]);	OFFSET(PT_R7, pt_regs, regs[7]);	OFFSET(PT_R8, pt_regs, regs[8]);	OFFSET(PT_R9, pt_regs, regs[9]);	OFFSET(PT_R10, pt_regs, regs[10]);	OFFSET(PT_R11, pt_regs, regs[11]);	OFFSET(PT_R12, pt_regs, regs[12]);	OFFSET(PT_R13, pt_regs, regs[13]);	OFFSET(PT_R14, pt_regs, regs[14]);	OFFSET(PT_R15, pt_regs, regs[15]);	OFFSET(PT_R16, pt_regs, regs[16]);	OFFSET(PT_R17, pt_regs, regs[17]);	OFFSET(PT_R18, pt_regs, regs[18]);	OFFSET(PT_R19, pt_regs, regs[19]);	OFFSET(PT_R20, pt_regs, regs[20]);	OFFSET(PT_R21, pt_regs, regs[21]);	OFFSET(PT_R22, pt_regs, regs[22]);	OFFSET(PT_R23, pt_regs, regs[23]);	OFFSET(PT_R24, pt_regs, regs[24]);	OFFSET(PT_R25, pt_regs, regs[25]);	OFFSET(PT_R26, pt_regs, regs[26]);	OFFSET(PT_R27, pt_regs, regs[27]);	OFFSET(PT_R28, pt_regs, regs[28]);	OFFSET(PT_R29, pt_regs, regs[29]);	OFFSET(PT_R30, pt_regs, regs[30]);	OFFSET(PT_R31, pt_regs, regs[31]);	OFFSET(PT_LO, pt_regs, lo);	OFFSET(PT_HI, pt_regs, hi);	OFFSET(PT_EPC, pt_regs, cp0_epc);	OFFSET(PT_BVADDR, pt_regs, cp0_badvaddr);	OFFSET(PT_STATUS, pt_regs, cp0_status);	OFFSET(PT_CAUSE, pt_regs, cp0_cause);	DEFINE(PT_SIZE, sizeof(struct pt_regs));	BLANK();}

int main(void){	OFFSET(S_X0, pt_regs, regs[0]);	OFFSET(S_X1, pt_regs, regs[1]);	OFFSET(S_X2, pt_regs, regs[2]);	OFFSET(S_X3, pt_regs, regs[3]);	OFFSET(S_X4, pt_regs, regs[4]);	OFFSET(S_X5, pt_regs, regs[5]);	OFFSET(S_X6, pt_regs, regs[6]);	OFFSET(S_X7, pt_regs, regs[7]);	OFFSET(S_LR, pt_regs, regs[30]);	OFFSET(S_SP, pt_regs, sp);	OFFSET(S_PC, pt_regs, pc);	OFFSET(S_PSTATE, pt_regs, pstate);	OFFSET(S_ORIG_X0, pt_regs, orig_x0);	OFFSET(S_SYSCALLNO, pt_regs, syscallno);	DEFINE(S_FRAME_SIZE, sizeof(struct pt_regs));	return 0;}

int main(void){    DEFINE(TSK_ACTIVE_MM,		offsetof(struct task_struct, active_mm));    BLANK();    DEFINE(VMA_VM_MM,		offsetof(struct vm_area_struct, vm_mm));    DEFINE(VMA_VM_FLAGS,		offsetof(struct vm_area_struct, vm_flags));    BLANK();    DEFINE(VM_EXEC,	       	VM_EXEC);    BLANK();    BLANK();    DEFINE(PAGE_PRESENT,		_PAGE_PRESENT);    DEFINE(PAGE_READONLY,		_PAGE_READONLY);    DEFINE(PAGE_NOT_USER,		_PAGE_NOT_USER);    DEFINE(PAGE_OLD,		_PAGE_OLD);    DEFINE(PAGE_CLEAN,		_PAGE_CLEAN);    BLANK();    DEFINE(PAGE_SZ,	       	PAGE_SIZE);    BLANK();    DEFINE(SYS_ERROR0,		0x9f0000);    return 0;}

static int choose_board_read(choose_t *cp){	choose_board_t *cbrd = cp->data;	board_data_t *ptr = cbrd->brds + cp->cur;	if (ptr->flag & BOARD_DIR_FLAG) {		int parent = cbrd->parent;		const char *prefix = cbrd->prefix;		bool recursive = cbrd->recursive;		bool goodbrd = cbrd->goodbrd;		int cur = cp->cur;		cbrd->parent = ptr->pos;		cbrd->prefix = NULL;		cbrd->recursive = true;		cbrd->goodbrd = (ptr->flag & BOARD_CUSTOM_FLAG) ? true : false;		choose_board(cbrd);		cbrd->parent = parent;		cbrd->prefix = prefix;		cbrd->recursive = recursive;		cbrd->goodbrd = goodbrd;		cp->cur = cur;	} else {		brc_initial(currentuser.userid, ptr->name);		changeboard(&currbp, currboard, ptr->name);		memcpy(currBM, ptr->BM, BM_LEN - 1);		char buf[STRLEN];		if (DEFINE(DEF_FIRSTNEW)) {			setbdir(buf, currboard);			int tmp = unread_position(buf, ptr);			int page = tmp - t_lines / 2;			getkeep(buf, page > 1 ? page : 1, tmp + 1);		}		board_read();		brc_zapbuf(cbrd->zapbuf + ptr->pos);		ptr->total = -1;		currBM[0] = '/0';	}	return FULLUPDATE;}

int main(void){		DEFINE(TASK_STATE, offsetof(struct task_struct, state));	DEFINE(TASK_FLAGS, offsetof(struct task_struct, flags));	DEFINE(TASK_PTRACE, offsetof(struct task_struct, ptrace));	DEFINE(TASK_BLOCKED, offsetof(struct task_struct, blocked));	DEFINE(TASK_THREAD, offsetof(struct task_struct, thread));	DEFINE(TASK_THREAD_INFO, offsetof(struct task_struct, stack));	DEFINE(TASK_MM, offsetof(struct task_struct, mm));	DEFINE(TASK_ACTIVE_MM, offsetof(struct task_struct, active_mm));		DEFINE(CPUSTAT_SOFTIRQ_PENDING, offsetof(irq_cpustat_t, __softirq_pending));		DEFINE(THREAD_KSP, offsetof(struct thread_struct, ksp));	DEFINE(THREAD_USP, offsetof(struct thread_struct, usp));	DEFINE(THREAD_CCR, offsetof(struct thread_struct, ccr));		DEFINE(LER0,  offsetof(struct pt_regs, er0)      - sizeof(long));	DEFINE(LER1,  offsetof(struct pt_regs, er1)      - sizeof(long));	DEFINE(LER2,  offsetof(struct pt_regs, er2)      - sizeof(long));	DEFINE(LER3,  offsetof(struct pt_regs, er3)      - sizeof(long));	DEFINE(LER4,  offsetof(struct pt_regs, er4)      - sizeof(long));	DEFINE(LER5,  offsetof(struct pt_regs, er5)      - sizeof(long));	DEFINE(LER6,  offsetof(struct pt_regs, er6)      - sizeof(long));	DEFINE(LORIG, offsetof(struct pt_regs, orig_er0) - sizeof(long));	DEFINE(LCCR,  offsetof(struct pt_regs, ccr)      - sizeof(long));	DEFINE(LVEC,  offsetof(struct pt_regs, vector)   - sizeof(long));#if defined(__H8300S__)	DEFINE(LEXR,  offsetof(struct pt_regs, exr)      - sizeof(long));#endif	DEFINE(LRET,  offsetof(struct pt_regs, pc)       - sizeof(long));	DEFINE(PT_PTRACED, PT_PTRACED);	return 0;}

int main(void){	DEFINE(GENERATED_GD_RELOC_OFF, offsetof(gd_t, reloc_off));	DEFINE(GENERATED_SC520_PAR0, offsetof(struct sc520_mmcr, par[0]));	DEFINE(GENERATED_SC520_PAR1, offsetof(struct sc520_mmcr, par[1]));	DEFINE(GENERATED_SC520_PAR2, offsetof(struct sc520_mmcr, par[2]));	DEFINE(GENERATED_SC520_PAR3, offsetof(struct sc520_mmcr, par[3]));	DEFINE(GENERATED_SC520_PAR4, offsetof(struct sc520_mmcr, par[4]));	DEFINE(GENERATED_SC520_PAR5, offsetof(struct sc520_mmcr, par[5]));	DEFINE(GENERATED_SC520_PAR6, offsetof(struct sc520_mmcr, par[6]));	DEFINE(GENERATED_SC520_PAR7, offsetof(struct sc520_mmcr, par[7]));	DEFINE(GENERATED_SC520_PAR8, offsetof(struct sc520_mmcr, par[8]));	DEFINE(GENERATED_SC520_PAR9, offsetof(struct sc520_mmcr, par[9]));	DEFINE(GENERATED_SC520_PAR10, offsetof(struct sc520_mmcr, par[10]));	DEFINE(GENERATED_SC520_PAR11, offsetof(struct sc520_mmcr, par[11]));	DEFINE(GENERATED_SC520_PAR12, offsetof(struct sc520_mmcr, par[12]));	DEFINE(GENERATED_SC520_PAR13, offsetof(struct sc520_mmcr, par[13]));	DEFINE(GENERATED_SC520_PAR14, offsetof(struct sc520_mmcr, par[14]));	DEFINE(GENERATED_SC520_PAR15, offsetof(struct sc520_mmcr, par[15]));	return 0;}

static void user_login(void){	char fname[STRLEN];	// SYSOP gets all permission bits when login.	if (strcmp(currentuser.userid, "SYSOP") == 0) {		currentuser.userlevel = ~0;		substitut_record(PASSFILE, &currentuser, sizeof(currentuser),				usernum);	}	fromhost[sizeof(fromhost) - 1] = 0; //added by iamfat 2004.01.05 to avoid overflow	log_usies("ENTER", fromhost, &currentuser);	SpecialID(currentuser.userid, fromhost, sizeof(fromhost));	u_enter();	report("Enter", currentuser.userid);#ifdef USE_NOTEPAD	notepad_init();	if (strcmp(currentuser.userid, "guest") != 0) {		if (DEFINE(DEF_NOTEPAD)) {			int noteln;			if (lastnote> currentuser.notedate)			currentuser.noteline = 0;			noteln = countln("etc/notepad");			if (currentuser.noteline == 0) {				shownotepad();			} else if ((noteln - currentuser.noteline)> 0) {				screen_move(0, 0);				ansimore2("etc/notepad", NA, 0, noteln - currentuser.noteline + 1);				terminal_getchar();				screen_clear();			}			currentuser.noteline = noteln;			write_defnotepad();		}	}#endif	if (show_statshm("etc/hotspot", 0)) {		screen_flush();		pressanykey();	}	if ((vote_flag(NULL, '/0', 2 /* 检查读过新的Welcome 没 */) == 0)) {		if (dashf("Welcome")) {			ansimore("Welcome", YEA);			vote_flag(NULL, 'R', 2 /* 写入读过新的Welcome */);		}	} else {		ansimore("Welcome2", YEA);	}	show_statshm("0Announce/bbslist/day", 1);	screen_flush();	screen_move_clear(-2);	if (currentuser.numlogins < 1) {		currentuser.numlogins = 0;		//% prints("/033[1;36m☆ 这是您第 /033[33m1/033[36m 次拜访本站，请记住今天吧。/n");		prints("/033[1;36m/xa1/xee /xd5/xe2/xca/xc7/xc4/xfa/xb5/xda /033[33m1/033[36m /xb4/xce/xb0/xdd/xb7/xc3/xb1/xbe/xd5/xbe/xa3/xac/xc7/xeb/xbc/xc7/xd7/xa1/xbd/xf1/xcc/xec/xb0/xc9/xa1/xa3/n");		//% prints("☆ 您第一次连入本站的时间为 /033[33m%s/033[m ", format_time(time(NULL), TIME_FORMAT_ZH));		prints("/xa1/xee /xc4/xfa/xb5/xda/xd2/xbb/xb4/xce/xc1/xac/xc8/xeb/xb1/xbe/xd5/xbe/xb5/xc4/xca/xb1/xbc/xe4/xce/xaa /033[33m%s/033[m ", format_time(fb_time(), TIME_FORMAT_ZH));	} else {		prints(				//% "/033[1;36m☆ 这是您第 /033[33m%d/033[36m 次拜访本站，上次您是从 /033[33m%s/033[36m 连往本站。/n",				"/033[1;36m/xa1/xee /xd5/xe2/xca/xc7/xc4/xfa/xb5/xda /033[33m%d/033[36m /xb4/xce/xb0/xdd/xb7/xc3/xb1/xbe/xd5/xbe/xa3/xac/xc9/xcf/xb4/xce/xc4/xfa/xca/xc7/xb4/xd3 /033[33m%s/033[36m /xc1/xac/xcd/xf9/xb1/xbe/xd5/xbe/xa1/xa3/n",				currentuser.numlogins + 1, currentuser.lasthost);		//% prints("☆ 上次连线时间为 /033[33m%s/033[m ", format_time(currentuser.lastlogin, TIME_FORMAT_ZH));		prints("/xa1/xee /xc9/xcf/xb4/xce/xc1/xac/xcf/xdf/xca/xb1/xbc/xe4/xce/xaa /033[33m%s/033[m ", format_time(currentuser.lastlogin, TIME_FORMAT_ZH));	}	terminal_getchar();	setuserfile(fname, BADLOGINFILE);	if (ansimore(fname, NA) != -1) {		//% if (askyn("您要删除以上密码输入错误的记录吗", NA, NA) == YEA)		if (askyn("/xc4/xfa/xd2/xaa/xc9/xbe/xb3/xfd/xd2/xd4/xc9/xcf/xc3/xdc/xc2/xeb/xca/xe4/xc8/xeb/xb4/xed/xce/xf3/xb5/xc4/xbc/xc7/xc2/xbc/xc2/xf0", NA, NA) == YEA)			unlink(fname);	}	set_safe_record();	tui_check_uinfo(&currentuser);	strlcpy(currentuser.lasthost, fromhost, sizeof(currentuser.lasthost));	if (login_start_time - currentuser.lastlogin >= 20 * 60			|| !strcmp(currentuser.userid, "guest")			|| currentuser.numlogins < 100) {		currentuser.numlogins++;	}	session_basic_info_t *res = get_my_sessions();	update_user_stay(&currentuser, true, session_basic_info_count(res) > 1);	session_basic_info_clear(res);#ifdef ALLOWGAME	if (currentuser.money> 1000000) {		currentuser.nummedals += currentuser.money / 10000;		currentuser.money %= 1000000;	}	if ((signed int) (currentuser.money - currentuser.bet) < -4990			&& currentuser.numlogins < 10 && currentuser.numposts < 10			&& currentuser.nummedals == 0)//.........这里部分代码省略.........

void start_client(void){	extern char currmaildir[];	initialize_mdb();#ifndef ENABLE_SSH	initialize_db();#endif	initialize_convert_env();	system_init();	if (setjmp(byebye)) {		system_abort();	}	strlcpy(BoardName, BBSNAME, sizeof(BoardName));	if (login_query() == -1) {		terminal_flush();		sleep(3);		exit(1);	}#ifndef ENABLE_SSH	screen_negotiate_size();#endif // ENABLE_SSH	screen_init(0);	user_login();	setmdir(currmaildir, currentuser.userid);	RMSG = NA;	screen_clear();	editor_restore();#ifdef TALK_LOG	tlog_recover();#endif	if (strcmp(currentuser.userid, "guest")) {		if (check_maxmail())			pressanykey();		screen_move(9, 0);		screen_clrtobot();		if (!DEFINE(DEF_NOLOGINSEND))			if (session_visible())				login_msg();		screen_clear();		set_numofsig();	}	active_board_init(false);	fill_date();	if (DEFINE(DEF_LOGFRIEND)			&& session_count_online_followed(!HAS_PERM(PERM_SEECLOAK)) > 0)		show_online_followings();	menu_load("menu.img");	while (1) {		if (DEFINE(DEF_NORMALSCR))			menu_loop("TOPMENU");		else			menu_loop("TOPMENU2");		Goodbye();	}}

int main(void){	/* thread struct on stack */	DEFINE(THREAD_SHIFT, THREAD_SHIFT);	DEFINE(THREAD_SIZE, THREAD_SIZE);	DEFINE(TI_FLAGS, offsetof(struct thread_info, flags));	DEFINE(TI_PREEMPT, offsetof(struct thread_info, preempt_count));	DEFINE(TI_SC_NOERR, offsetof(struct thread_info, syscall_noerror));	/* task_struct->thread */	DEFINE(THREAD, offsetof(struct task_struct, thread));	DEFINE(PT_REGS, offsetof(struct thread_struct, regs));	DEFINE(THREAD_FPEXC_MODE, offsetof(struct thread_struct, fpexc_mode));	DEFINE(THREAD_FPR0, offsetof(struct thread_struct, fpr[0]));	DEFINE(THREAD_FPSCR, offsetof(struct thread_struct, fpscr));	DEFINE(KSP, offsetof(struct thread_struct, ksp));	DEFINE(KSP_VSID, offsetof(struct thread_struct, ksp_vsid));#ifdef CONFIG_ALTIVEC	DEFINE(THREAD_VR0, offsetof(struct thread_struct, vr[0]));	DEFINE(THREAD_VRSAVE, offsetof(struct thread_struct, vrsave));	DEFINE(THREAD_VSCR, offsetof(struct thread_struct, vscr));	DEFINE(THREAD_USED_VR, offsetof(struct thread_struct, used_vr));#endif /* CONFIG_ALTIVEC */	DEFINE(MM, offsetof(struct task_struct, mm));	DEFINE(AUDITCONTEXT, offsetof(struct task_struct, audit_context));	/* naca */        DEFINE(PACA, offsetof(struct naca_struct, paca));	DEFINE(DCACHEL1LINESIZE, offsetof(struct systemcfg, dCacheL1LineSize));        DEFINE(DCACHEL1LOGLINESIZE, offsetof(struct naca_struct, dCacheL1LogLineSize));        DEFINE(DCACHEL1LINESPERPAGE, offsetof(struct naca_struct, dCacheL1LinesPerPage));        DEFINE(ICACHEL1LINESIZE, offsetof(struct systemcfg, iCacheL1LineSize));        DEFINE(ICACHEL1LOGLINESIZE, offsetof(struct naca_struct, iCacheL1LogLineSize));        DEFINE(ICACHEL1LINESPERPAGE, offsetof(struct naca_struct, iCacheL1LinesPerPage));	DEFINE(PLATFORM, offsetof(struct systemcfg, platform));	/* paca */        DEFINE(PACA_SIZE, sizeof(struct paca_struct));        DEFINE(PACAPACAINDEX, offsetof(struct paca_struct, paca_index));        DEFINE(PACAPROCSTART, offsetof(struct paca_struct, cpu_start));        DEFINE(PACAKSAVE, offsetof(struct paca_struct, kstack));	DEFINE(PACACURRENT, offsetof(struct paca_struct, __current));        DEFINE(PACASAVEDMSR, offsetof(struct paca_struct, saved_msr));        DEFINE(PACASTABREAL, offsetof(struct paca_struct, stab_real));        DEFINE(PACASTABVIRT, offsetof(struct paca_struct, stab_addr));	DEFINE(PACASTABRR, offsetof(struct paca_struct, stab_rr));        DEFINE(PACAR1, offsetof(struct paca_struct, saved_r1));	DEFINE(PACATOC, offsetof(struct paca_struct, kernel_toc));	DEFINE(PACAPROCENABLED, offsetof(struct paca_struct, proc_enabled));	DEFINE(PACASLBCACHE, offsetof(struct paca_struct, slb_cache));	DEFINE(PACASLBCACHEPTR, offsetof(struct paca_struct, slb_cache_ptr));	DEFINE(PACACONTEXTID, offsetof(struct paca_struct, context.id));#ifdef CONFIG_HUGETLB_PAGE	DEFINE(PACAHTLBSEGS, offsetof(struct paca_struct, context.htlb_segs));#endif /* CONFIG_HUGETLB_PAGE */	DEFINE(PACADEFAULTDECR, offsetof(struct paca_struct, default_decr));        DEFINE(PACA_EXGEN, offsetof(struct paca_struct, exgen));        DEFINE(PACA_EXMC, offsetof(struct paca_struct, exmc));        DEFINE(PACA_EXSLB, offsetof(struct paca_struct, exslb));        DEFINE(PACA_EXDSI, offsetof(struct paca_struct, exdsi));        DEFINE(PACAEMERGSP, offsetof(struct paca_struct, emergency_sp));	DEFINE(PACALPPACA, offsetof(struct paca_struct, lppaca));        DEFINE(LPPACASRR0, offsetof(struct ItLpPaca, xSavedSrr0));        DEFINE(LPPACASRR1, offsetof(struct ItLpPaca, xSavedSrr1));	DEFINE(LPPACAANYINT, offsetof(struct ItLpPaca, xIntDword.xAnyInt));	DEFINE(LPPACADECRINT, offsetof(struct ItLpPaca, xIntDword.xFields.xDecrInt));	/* SLB shadow buffer */	DEFINE(SLBSHADOW_STACKVSID,	       offsetof(struct slb_shadow, save_area[SLB_NUM_BOLTED - 1].vsid));	DEFINE(SLBSHADOW_STACKESID,	       offsetof(struct slb_shadow, save_area[SLB_NUM_BOLTED - 1].esid));	/* RTAS */	DEFINE(RTASBASE, offsetof(struct rtas_t, base));	DEFINE(RTASENTRY, offsetof(struct rtas_t, entry));	/* Interrupt register frame */	DEFINE(STACK_FRAME_OVERHEAD, STACK_FRAME_OVERHEAD);	DEFINE(SWITCH_FRAME_SIZE, STACK_FRAME_OVERHEAD + sizeof(struct pt_regs));	/* 288 = # of volatile regs, int & fp, for leaf routines */	/* which do not stack a frame.  See the PPC64 ABI.       */	DEFINE(INT_FRAME_SIZE, STACK_FRAME_OVERHEAD + sizeof(struct pt_regs) + 288);	/* Create extra stack space for SRR0 and SRR1 when calling prom/rtas. */	DEFINE(PROM_FRAME_SIZE, STACK_FRAME_OVERHEAD + sizeof(struct pt_regs) + 16);	DEFINE(RTAS_FRAME_SIZE, STACK_FRAME_OVERHEAD + sizeof(struct pt_regs) + 16);	DEFINE(GPR0, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[0]));	DEFINE(GPR1, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[1]));	DEFINE(GPR2, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[2]));	DEFINE(GPR3, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[3]));	DEFINE(GPR4, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[4]));	DEFINE(GPR5, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[5]));	DEFINE(GPR6, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[6]));	DEFINE(GPR7, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[7]));	DEFINE(GPR8, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[8]));	DEFINE(GPR9, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[9]));	DEFINE(GPR10, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[10]));//.........这里部分代码省略.........

int main(void){#ifdef CONFIG_PARAVIRT	OFFSET(PV_CPU_usergs_sysret64, pv_cpu_ops, usergs_sysret64);	OFFSET(PV_CPU_swapgs, pv_cpu_ops, swapgs);#ifdef CONFIG_DEBUG_ENTRY	OFFSET(PV_IRQ_save_fl, pv_irq_ops, save_fl);#endif	BLANK();#endif#if defined(CONFIG_KVM_GUEST) && defined(CONFIG_PARAVIRT_SPINLOCKS)	OFFSET(KVM_STEAL_TIME_preempted, kvm_steal_time, preempted);	BLANK();#endif#define ENTRY(entry) OFFSET(pt_regs_ ## entry, pt_regs, entry)	ENTRY(bx);	ENTRY(cx);	ENTRY(dx);	ENTRY(sp);	ENTRY(bp);	ENTRY(si);	ENTRY(di);	ENTRY(r8);	ENTRY(r9);	ENTRY(r10);	ENTRY(r11);	ENTRY(r12);	ENTRY(r13);	ENTRY(r14);	ENTRY(r15);	ENTRY(flags);	BLANK();#undef ENTRY#define ENTRY(entry) OFFSET(saved_context_ ## entry, saved_context, entry)	ENTRY(cr0);	ENTRY(cr2);	ENTRY(cr3);	ENTRY(cr4);	ENTRY(cr8);	ENTRY(gdt_desc);	BLANK();#undef ENTRY	OFFSET(TSS_ist, tss_struct, x86_tss.ist);	OFFSET(TSS_sp0, tss_struct, x86_tss.sp0);	OFFSET(TSS_sp1, tss_struct, x86_tss.sp1);	BLANK();#ifdef CONFIG_CC_STACKPROTECTOR	DEFINE(stack_canary_offset, offsetof(union irq_stack_union, stack_canary));	BLANK();#endif	DEFINE(__NR_syscall_max, sizeof(syscalls_64) - 1);	DEFINE(NR_syscalls, sizeof(syscalls_64));	DEFINE(__NR_syscall_compat_max, sizeof(syscalls_ia32) - 1);	DEFINE(IA32_NR_syscalls, sizeof(syscalls_ia32));	return 0;}

int main(void){	/* offsets into the task struct */	DEFINE(TASK_STATE, offsetof(struct task_struct, state));	DEFINE(TASK_FLAGS, offsetof(struct task_struct, flags));	DEFINE(TASK_PTRACE, offsetof(struct task_struct, ptrace));	DEFINE(TASK_BLOCKED, offsetof(struct task_struct, blocked));	DEFINE(TASK_THREAD, offsetof(struct task_struct, thread));	DEFINE(TASK_THREAD_INFO, offsetof(struct task_struct, stack));	DEFINE(TASK_MM, offsetof(struct task_struct, mm));	DEFINE(TASK_ACTIVE_MM, offsetof(struct task_struct, active_mm));	DEFINE(TASK_SIGPENDING, offsetof(struct task_struct, pending));	/* offsets into the irq_cpustat_t struct */	DEFINE(CPUSTAT_SOFTIRQ_PENDING,	       offsetof(irq_cpustat_t, __softirq_pending));	/* offsets into the thread struct */	DEFINE(THREAD_KSP, offsetof(struct thread_struct, ksp));	DEFINE(THREAD_USP, offsetof(struct thread_struct, usp));	DEFINE(THREAD_SR, offsetof(struct thread_struct, seqstat));	DEFINE(PT_SR, offsetof(struct thread_struct, seqstat));	DEFINE(THREAD_ESP0, offsetof(struct thread_struct, esp0));	DEFINE(THREAD_PC, offsetof(struct thread_struct, pc));	DEFINE(KERNEL_STACK_SIZE, THREAD_SIZE);	/* offsets into the pt_regs */	DEFINE(PT_ORIG_P0, offsetof(struct pt_regs, orig_p0));	DEFINE(PT_ORIG_PC, offsetof(struct pt_regs, orig_pc));	DEFINE(PT_R0, offsetof(struct pt_regs, r0));	DEFINE(PT_R1, offsetof(struct pt_regs, r1));	DEFINE(PT_R2, offsetof(struct pt_regs, r2));	DEFINE(PT_R3, offsetof(struct pt_regs, r3));	DEFINE(PT_R4, offsetof(struct pt_regs, r4));	DEFINE(PT_R5, offsetof(struct pt_regs, r5));	DEFINE(PT_R6, offsetof(struct pt_regs, r6));	DEFINE(PT_R7, offsetof(struct pt_regs, r7));	DEFINE(PT_P0, offsetof(struct pt_regs, p0));	DEFINE(PT_P1, offsetof(struct pt_regs, p1));	DEFINE(PT_P2, offsetof(struct pt_regs, p2));	DEFINE(PT_P3, offsetof(struct pt_regs, p3));	DEFINE(PT_P4, offsetof(struct pt_regs, p4));	DEFINE(PT_P5, offsetof(struct pt_regs, p5));	DEFINE(PT_FP, offsetof(struct pt_regs, fp));	DEFINE(PT_USP, offsetof(struct pt_regs, usp));	DEFINE(PT_I0, offsetof(struct pt_regs, i0));	DEFINE(PT_I1, offsetof(struct pt_regs, i1));	DEFINE(PT_I2, offsetof(struct pt_regs, i2));	DEFINE(PT_I3, offsetof(struct pt_regs, i3));	DEFINE(PT_M0, offsetof(struct pt_regs, m0));	DEFINE(PT_M1, offsetof(struct pt_regs, m1));	DEFINE(PT_M2, offsetof(struct pt_regs, m2));	DEFINE(PT_M3, offsetof(struct pt_regs, m3));	DEFINE(PT_L0, offsetof(struct pt_regs, l0));	DEFINE(PT_L1, offsetof(struct pt_regs, l1));	DEFINE(PT_L2, offsetof(struct pt_regs, l2));	DEFINE(PT_L3, offsetof(struct pt_regs, l3));	DEFINE(PT_B0, offsetof(struct pt_regs, b0));	DEFINE(PT_B1, offsetof(struct pt_regs, b1));	DEFINE(PT_B2, offsetof(struct pt_regs, b2));	DEFINE(PT_B3, offsetof(struct pt_regs, b3));	DEFINE(PT_A0X, offsetof(struct pt_regs, a0x));	DEFINE(PT_A0W, offsetof(struct pt_regs, a0w));	DEFINE(PT_A1X, offsetof(struct pt_regs, a1x));	DEFINE(PT_A1W, offsetof(struct pt_regs, a1w));	DEFINE(PT_LC0, offsetof(struct pt_regs, lc0));	DEFINE(PT_LC1, offsetof(struct pt_regs, lc1));	DEFINE(PT_LT0, offsetof(struct pt_regs, lt0));	DEFINE(PT_LT1, offsetof(struct pt_regs, lt1));	DEFINE(PT_LB0, offsetof(struct pt_regs, lb0));	DEFINE(PT_LB1, offsetof(struct pt_regs, lb1));	DEFINE(PT_ASTAT, offsetof(struct pt_regs, astat));	DEFINE(PT_RESERVED, offsetof(struct pt_regs, reserved));	DEFINE(PT_RETS, offsetof(struct pt_regs, rets));	DEFINE(PT_PC, offsetof(struct pt_regs, pc));	DEFINE(PT_RETX, offsetof(struct pt_regs, retx));	DEFINE(PT_RETN, offsetof(struct pt_regs, retn));	DEFINE(PT_RETE, offsetof(struct pt_regs, rete));	DEFINE(PT_SEQSTAT, offsetof(struct pt_regs, seqstat));	DEFINE(PT_SYSCFG, offsetof(struct pt_regs, syscfg));	DEFINE(PT_IPEND, offsetof(struct pt_regs, ipend));	DEFINE(SIZEOF_PTREGS, sizeof(struct pt_regs));	DEFINE(PT_TEXT_ADDR, sizeof(struct pt_regs));        /* Needed by gdb */	DEFINE(PT_TEXT_END_ADDR, 4 + sizeof(struct pt_regs));/* Needed by gdb */	DEFINE(PT_DATA_ADDR, 8 + sizeof(struct pt_regs));    /* Needed by gdb */	DEFINE(PT_FDPIC_EXEC, 12 + sizeof(struct pt_regs));  /* Needed by gdb */	DEFINE(PT_FDPIC_INTERP, 16 + sizeof(struct pt_regs));/* Needed by gdb */	/* signal defines */	DEFINE(SIGSEGV, SIGSEGV);	DEFINE(SIGTRAP, SIGTRAP);	return 0;}

int main (void){	/* offsets into the task struct */	DEFINE (TASK_STATE, offsetof (struct task_struct, state));	DEFINE (TASK_FLAGS, offsetof (struct task_struct, flags));	DEFINE (TASK_PTRACE, offsetof (struct task_struct, ptrace));	DEFINE (TASK_BLOCKED, offsetof (struct task_struct, blocked));	DEFINE (TASK_THREAD, offsetof (struct task_struct, thread));	DEFINE (TASK_THREAD_INFO, offsetof (struct task_struct, thread_info));	DEFINE (TASK_MM, offsetof (struct task_struct, mm));	DEFINE (TASK_ACTIVE_MM, offsetof (struct task_struct, active_mm));	DEFINE (TASK_PID, offsetof (struct task_struct, pid));	/* offsets into the kernel_stat struct */	DEFINE (STAT_IRQ, offsetof (struct kernel_stat, irqs));	/* signal defines */	DEFINE (SIGSEGV, SIGSEGV);	DEFINE (SEGV_MAPERR, SEGV_MAPERR);	DEFINE (SIGTRAP, SIGTRAP);	DEFINE (SIGCHLD, SIGCHLD);	DEFINE (SIGILL, SIGILL);	DEFINE (TRAP_TRACE, TRAP_TRACE);	/* ptrace flag bits */	DEFINE (PT_PTRACED, PT_PTRACED);	DEFINE (PT_DTRACE, PT_DTRACE);	/* error values */	DEFINE (ENOSYS, ENOSYS);	/* clone flag bits */	DEFINE (CLONE_VFORK, CLONE_VFORK);	DEFINE (CLONE_VM, CLONE_VM);	return 0;}

void output_kvm_defines(void){	COMMENT(" KVM/MIPS Specfic offsets. ");	DEFINE(VCPU_ARCH_SIZE, sizeof(struct kvm_vcpu_arch));	OFFSET(VCPU_RUN, kvm_vcpu, run);	OFFSET(VCPU_HOST_ARCH, kvm_vcpu, arch);	OFFSET(VCPU_HOST_EBASE, kvm_vcpu_arch, host_ebase);	OFFSET(VCPU_GUEST_EBASE, kvm_vcpu_arch, guest_ebase);	OFFSET(VCPU_HOST_STACK, kvm_vcpu_arch, host_stack);	OFFSET(VCPU_HOST_GP, kvm_vcpu_arch, host_gp);	OFFSET(VCPU_HOST_CP0_BADVADDR, kvm_vcpu_arch, host_cp0_badvaddr);	OFFSET(VCPU_HOST_CP0_CAUSE, kvm_vcpu_arch, host_cp0_cause);	OFFSET(VCPU_HOST_EPC, kvm_vcpu_arch, host_cp0_epc);	OFFSET(VCPU_HOST_ENTRYHI, kvm_vcpu_arch, host_cp0_entryhi);	OFFSET(VCPU_GUEST_INST, kvm_vcpu_arch, guest_inst);	OFFSET(VCPU_R0, kvm_vcpu_arch, gprs[0]);	OFFSET(VCPU_R1, kvm_vcpu_arch, gprs[1]);	OFFSET(VCPU_R2, kvm_vcpu_arch, gprs[2]);	OFFSET(VCPU_R3, kvm_vcpu_arch, gprs[3]);	OFFSET(VCPU_R4, kvm_vcpu_arch, gprs[4]);	OFFSET(VCPU_R5, kvm_vcpu_arch, gprs[5]);	OFFSET(VCPU_R6, kvm_vcpu_arch, gprs[6]);	OFFSET(VCPU_R7, kvm_vcpu_arch, gprs[7]);	OFFSET(VCPU_R8, kvm_vcpu_arch, gprs[8]);	OFFSET(VCPU_R9, kvm_vcpu_arch, gprs[9]);	OFFSET(VCPU_R10, kvm_vcpu_arch, gprs[10]);	OFFSET(VCPU_R11, kvm_vcpu_arch, gprs[11]);	OFFSET(VCPU_R12, kvm_vcpu_arch, gprs[12]);	OFFSET(VCPU_R13, kvm_vcpu_arch, gprs[13]);	OFFSET(VCPU_R14, kvm_vcpu_arch, gprs[14]);	OFFSET(VCPU_R15, kvm_vcpu_arch, gprs[15]);	OFFSET(VCPU_R16, kvm_vcpu_arch, gprs[16]);	OFFSET(VCPU_R17, kvm_vcpu_arch, gprs[17]);	OFFSET(VCPU_R18, kvm_vcpu_arch, gprs[18]);	OFFSET(VCPU_R19, kvm_vcpu_arch, gprs[19]);	OFFSET(VCPU_R20, kvm_vcpu_arch, gprs[20]);	OFFSET(VCPU_R21, kvm_vcpu_arch, gprs[21]);	OFFSET(VCPU_R22, kvm_vcpu_arch, gprs[22]);	OFFSET(VCPU_R23, kvm_vcpu_arch, gprs[23]);	OFFSET(VCPU_R24, kvm_vcpu_arch, gprs[24]);	OFFSET(VCPU_R25, kvm_vcpu_arch, gprs[25]);	OFFSET(VCPU_R26, kvm_vcpu_arch, gprs[26]);	OFFSET(VCPU_R27, kvm_vcpu_arch, gprs[27]);	OFFSET(VCPU_R28, kvm_vcpu_arch, gprs[28]);	OFFSET(VCPU_R29, kvm_vcpu_arch, gprs[29]);	OFFSET(VCPU_R30, kvm_vcpu_arch, gprs[30]);	OFFSET(VCPU_R31, kvm_vcpu_arch, gprs[31]);	OFFSET(VCPU_LO, kvm_vcpu_arch, lo);	OFFSET(VCPU_HI, kvm_vcpu_arch, hi);	OFFSET(VCPU_PC, kvm_vcpu_arch, pc);	OFFSET(VCPU_COP0, kvm_vcpu_arch, cop0);	OFFSET(VCPU_GUEST_KERNEL_ASID, kvm_vcpu_arch, guest_kernel_asid);	OFFSET(VCPU_GUEST_USER_ASID, kvm_vcpu_arch, guest_user_asid);	OFFSET(COP0_TLB_HI, mips_coproc, reg[MIPS_CP0_TLB_HI][0]);	OFFSET(COP0_STATUS, mips_coproc, reg[MIPS_CP0_STATUS][0]);	BLANK();}

void output_mm_defines(void){	COMMENT("Size of struct page");	DEFINE(STRUCT_PAGE_SIZE, sizeof(struct page));	BLANK();	COMMENT("Linux mm_struct offsets.");	OFFSET(MM_USERS, mm_struct, mm_users);	OFFSET(MM_PGD, mm_struct, pgd);	OFFSET(MM_CONTEXT, mm_struct, context);	BLANK();	DEFINE(_PGD_T_SIZE, sizeof(pgd_t));	DEFINE(_PMD_T_SIZE, sizeof(pmd_t));	DEFINE(_PTE_T_SIZE, sizeof(pte_t));	BLANK();	DEFINE(_PGD_T_LOG2, PGD_T_LOG2);#ifndef __PAGETABLE_PMD_FOLDED	DEFINE(_PMD_T_LOG2, PMD_T_LOG2);#endif	DEFINE(_PTE_T_LOG2, PTE_T_LOG2);	BLANK();	DEFINE(_PGD_ORDER, PGD_ORDER);#ifndef __PAGETABLE_PMD_FOLDED	DEFINE(_PMD_ORDER, PMD_ORDER);#endif	DEFINE(_PTE_ORDER, PTE_ORDER);	BLANK();	DEFINE(_PMD_SHIFT, PMD_SHIFT);	DEFINE(_PGDIR_SHIFT, PGDIR_SHIFT);	BLANK();	DEFINE(_PTRS_PER_PGD, PTRS_PER_PGD);	DEFINE(_PTRS_PER_PMD, PTRS_PER_PMD);	DEFINE(_PTRS_PER_PTE, PTRS_PER_PTE);	BLANK();	DEFINE(_PAGE_SHIFT, PAGE_SHIFT);	DEFINE(_PAGE_SIZE, PAGE_SIZE);	BLANK();}

int main(void){	DEFINE(TSK_ACTIVE_MM,	offsetof(struct task_struct, active_mm));	BLANK();	DEFINE(TI_FLAGS,	offsetof(struct thread_info, flags));	DEFINE(TI_PREEMPT,	offsetof(struct thread_info, preempt_count));	DEFINE(TI_ADDR_LIMIT,	offsetof(struct thread_info, addr_limit));	DEFINE(TI_TASK,		offsetof(struct thread_info, task));	DEFINE(TI_EXEC_DOMAIN,	offsetof(struct thread_info, exec_domain));	DEFINE(TI_CPU,		offsetof(struct thread_info, cpu));	DEFINE(TI_CPU_SAVE,	offsetof(struct thread_info, cpu_context));	DEFINE(TI_USED_CP,	offsetof(struct thread_info, used_cp));#ifdef CONFIG_UNICORE_FPU_F64	DEFINE(TI_FPSTATE,	offsetof(struct thread_info, fpstate));#endif	BLANK();	DEFINE(S_R0,		offsetof(struct pt_regs, UCreg_00));	DEFINE(S_R1,		offsetof(struct pt_regs, UCreg_01));	DEFINE(S_R2,		offsetof(struct pt_regs, UCreg_02));	DEFINE(S_R3,		offsetof(struct pt_regs, UCreg_03));	DEFINE(S_R4,		offsetof(struct pt_regs, UCreg_04));	DEFINE(S_R5,		offsetof(struct pt_regs, UCreg_05));	DEFINE(S_R6,		offsetof(struct pt_regs, UCreg_06));	DEFINE(S_R7,		offsetof(struct pt_regs, UCreg_07));	DEFINE(S_R8,		offsetof(struct pt_regs, UCreg_08));	DEFINE(S_R9,		offsetof(struct pt_regs, UCreg_09));	DEFINE(S_R10,		offsetof(struct pt_regs, UCreg_10));	DEFINE(S_R11,		offsetof(struct pt_regs, UCreg_11));	DEFINE(S_R12,		offsetof(struct pt_regs, UCreg_12));	DEFINE(S_R13,		offsetof(struct pt_regs, UCreg_13));	DEFINE(S_R14,		offsetof(struct pt_regs, UCreg_14));	DEFINE(S_R15,		offsetof(struct pt_regs, UCreg_15));	DEFINE(S_R16,		offsetof(struct pt_regs, UCreg_16));	DEFINE(S_R17,		offsetof(struct pt_regs, UCreg_17));	DEFINE(S_R18,		offsetof(struct pt_regs, UCreg_18));	DEFINE(S_R19,		offsetof(struct pt_regs, UCreg_19));	DEFINE(S_R20,		offsetof(struct pt_regs, UCreg_20));	DEFINE(S_R21,		offsetof(struct pt_regs, UCreg_21));	DEFINE(S_R22,		offsetof(struct pt_regs, UCreg_22));	DEFINE(S_R23,		offsetof(struct pt_regs, UCreg_23));	DEFINE(S_R24,		offsetof(struct pt_regs, UCreg_24));	DEFINE(S_R25,		offsetof(struct pt_regs, UCreg_25));	DEFINE(S_R26,		offsetof(struct pt_regs, UCreg_26));	DEFINE(S_FP,		offsetof(struct pt_regs, UCreg_fp));	DEFINE(S_IP,		offsetof(struct pt_regs, UCreg_ip));	DEFINE(S_SP,		offsetof(struct pt_regs, UCreg_sp));	DEFINE(S_LR,		offsetof(struct pt_regs, UCreg_lr));	DEFINE(S_PC,		offsetof(struct pt_regs, UCreg_pc));	DEFINE(S_PSR,		offsetof(struct pt_regs, UCreg_asr));	DEFINE(S_OLD_R0,	offsetof(struct pt_regs, UCreg_ORIG_00));	DEFINE(S_FRAME_SIZE,	sizeof(struct pt_regs));	BLANK();	DEFINE(VMA_VM_MM,	offsetof(struct vm_area_struct, vm_mm));	DEFINE(VMA_VM_FLAGS,	offsetof(struct vm_area_struct, vm_flags));	BLANK();	DEFINE(VM_EXEC,		VM_EXEC);	BLANK();	DEFINE(PAGE_SZ,		PAGE_SIZE);	BLANK();	DEFINE(SYS_ERROR0,	0x9f0000);	BLANK();	DEFINE(PBE_ADDRESS,		offsetof(struct pbe, address));	DEFINE(PBE_ORIN_ADDRESS,	offsetof(struct pbe, orig_address));	DEFINE(PBE_NEXT,		offsetof(struct pbe, next));	DEFINE(SWSUSP_CPU,		offsetof(struct swsusp_arch_regs, /							cpu_context));#ifdef	CONFIG_UNICORE_FPU_F64	DEFINE(SWSUSP_FPSTATE,		offsetof(struct swsusp_arch_regs, /							fpstate));#endif	BLANK();	DEFINE(DMA_BIDIRECTIONAL,	DMA_BIDIRECTIONAL);	DEFINE(DMA_TO_DEVICE,		DMA_TO_DEVICE);	DEFINE(DMA_FROM_DEVICE,		DMA_FROM_DEVICE);	return 0;}

void output_signal_defined(void){	COMMENT("Linux signal numbers.");	DEFINE(_SIGHUP, SIGHUP);	DEFINE(_SIGINT, SIGINT);	DEFINE(_SIGQUIT, SIGQUIT);	DEFINE(_SIGILL, SIGILL);	DEFINE(_SIGTRAP, SIGTRAP);	DEFINE(_SIGIOT, SIGIOT);	DEFINE(_SIGABRT, SIGABRT);	DEFINE(_SIGFPE, SIGFPE);	DEFINE(_SIGKILL, SIGKILL);	DEFINE(_SIGBUS, SIGBUS);	DEFINE(_SIGSEGV, SIGSEGV);	DEFINE(_SIGSYS, SIGSYS);	DEFINE(_SIGPIPE, SIGPIPE);	DEFINE(_SIGALRM, SIGALRM);	DEFINE(_SIGTERM, SIGTERM);	DEFINE(_SIGUSR1, SIGUSR1);	DEFINE(_SIGUSR2, SIGUSR2);	DEFINE(_SIGCHLD, SIGCHLD);	DEFINE(_SIGPWR, SIGPWR);	DEFINE(_SIGWINCH, SIGWINCH);	DEFINE(_SIGURG, SIGURG);	DEFINE(_SIGIO, SIGIO);	DEFINE(_SIGSTOP, SIGSTOP);	DEFINE(_SIGTSTP, SIGTSTP);	DEFINE(_SIGCONT, SIGCONT);	DEFINE(_SIGTTIN, SIGTTIN);	DEFINE(_SIGTTOU, SIGTTOU);	DEFINE(_SIGVTALRM, SIGVTALRM);	DEFINE(_SIGPROF, SIGPROF);	DEFINE(_SIGXCPU, SIGXCPU);	DEFINE(_SIGXFSZ, SIGXFSZ);	BLANK();}

int main(void){	DEFINE(GENERATED_IPQ_RESERVE_SIZE, sizeof(ipq_mem_reserve_t));	return 0;}

int main(void){	/* struct pt_regs */	DEFINE(PT_PC, offsetof (struct pt_regs, pc));	DEFINE(PT_PS, offsetof (struct pt_regs, ps));	DEFINE(PT_DEPC, offsetof (struct pt_regs, depc));	DEFINE(PT_EXCCAUSE, offsetof (struct pt_regs, exccause));	DEFINE(PT_EXCVADDR, offsetof (struct pt_regs, excvaddr));	DEFINE(PT_DEBUGCAUSE, offsetof (struct pt_regs, debugcause));	DEFINE(PT_WMASK, offsetof (struct pt_regs, wmask));	DEFINE(PT_LBEG, offsetof (struct pt_regs, lbeg));	DEFINE(PT_LEND, offsetof (struct pt_regs, lend));	DEFINE(PT_LCOUNT, offsetof (struct pt_regs, lcount));	DEFINE(PT_SAR, offsetof (struct pt_regs, sar));	DEFINE(PT_ICOUNTLEVEL, offsetof (struct pt_regs, icountlevel));	DEFINE(PT_SYSCALL, offsetof (struct pt_regs, syscall));	DEFINE(PT_AREG, offsetof (struct pt_regs, areg[0]));	DEFINE(PT_AREG0, offsetof (struct pt_regs, areg[0]));	DEFINE(PT_AREG1, offsetof (struct pt_regs, areg[1]));	DEFINE(PT_AREG2, offsetof (struct pt_regs, areg[2]));	DEFINE(PT_AREG3, offsetof (struct pt_regs, areg[3]));	DEFINE(PT_AREG4, offsetof (struct pt_regs, areg[4]));	DEFINE(PT_AREG5, offsetof (struct pt_regs, areg[5]));	DEFINE(PT_AREG6, offsetof (struct pt_regs, areg[6]));	DEFINE(PT_AREG7, offsetof (struct pt_regs, areg[7]));	DEFINE(PT_AREG8, offsetof (struct pt_regs, areg[8]));	DEFINE(PT_AREG9, offsetof (struct pt_regs, areg[9]));	DEFINE(PT_AREG10, offsetof (struct pt_regs, areg[10]));	DEFINE(PT_AREG11, offsetof (struct pt_regs, areg[11]));	DEFINE(PT_AREG12, offsetof (struct pt_regs, areg[12]));	DEFINE(PT_AREG13, offsetof (struct pt_regs, areg[13]));	DEFINE(PT_AREG14, offsetof (struct pt_regs, areg[14]));	DEFINE(PT_AREG15, offsetof (struct pt_regs, areg[15]));	DEFINE(PT_WINDOWBASE, offsetof (struct pt_regs, windowbase));	DEFINE(PT_WINDOWSTART, offsetof(struct pt_regs, windowstart));	DEFINE(PT_SIZE, sizeof(struct pt_regs));	DEFINE(PT_AREG_END, offsetof (struct pt_regs, areg[XCHAL_NUM_AREGS]));	DEFINE(PT_USER_SIZE, offsetof(struct pt_regs, areg[XCHAL_NUM_AREGS]));	DEFINE(PT_XTREGS_OPT, offsetof(struct pt_regs, xtregs_opt));	DEFINE(XTREGS_OPT_SIZE, sizeof(xtregs_opt_t));	/* struct task_struct */	DEFINE(TASK_PTRACE, offsetof (struct task_struct, ptrace));	DEFINE(TASK_MM, offsetof (struct task_struct, mm));	DEFINE(TASK_ACTIVE_MM, offsetof (struct task_struct, active_mm));	DEFINE(TASK_PID, offsetof (struct task_struct, pid));	DEFINE(TASK_THREAD, offsetof (struct task_struct, thread));	DEFINE(TASK_THREAD_INFO, offsetof (struct task_struct, stack));	DEFINE(TASK_STRUCT_SIZE, sizeof (struct task_struct));	/* struct thread_info (offset from start_struct) */	DEFINE(THREAD_RA, offsetof (struct task_struct, thread.ra));	DEFINE(THREAD_SP, offsetof (struct task_struct, thread.sp));	DEFINE(THREAD_CPENABLE, offsetof (struct thread_info, cpenable));#if XTENSA_HAVE_COPROCESSORS	DEFINE(THREAD_XTREGS_CP0, offsetof (struct thread_info, xtregs_cp));	DEFINE(THREAD_XTREGS_CP1, offsetof (struct thread_info, xtregs_cp));	DEFINE(THREAD_XTREGS_CP2, offsetof (struct thread_info, xtregs_cp));	DEFINE(THREAD_XTREGS_CP3, offsetof (struct thread_info, xtregs_cp));	DEFINE(THREAD_XTREGS_CP4, offsetof (struct thread_info, xtregs_cp));	DEFINE(THREAD_XTREGS_CP5, offsetof (struct thread_info, xtregs_cp));	DEFINE(THREAD_XTREGS_CP6, offsetof (struct thread_info, xtregs_cp));	DEFINE(THREAD_XTREGS_CP7, offsetof (struct thread_info, xtregs_cp));#endif	DEFINE(THREAD_XTREGS_USER, offsetof (struct thread_info, xtregs_user));	DEFINE(XTREGS_USER_SIZE, sizeof(xtregs_user_t));	DEFINE(THREAD_CURRENT_DS, offsetof (struct task_struct, thread.current_ds));	/* struct mm_struct */	DEFINE(MM_USERS, offsetof(struct mm_struct, mm_users));	DEFINE(MM_PGD, offsetof (struct mm_struct, pgd));	DEFINE(MM_CONTEXT, offsetof (struct mm_struct, context));	/* struct page */	DEFINE(PAGE_FLAGS, offsetof(struct page, flags));	/* constants */	DEFINE(_CLONE_VM, CLONE_VM);	DEFINE(_CLONE_UNTRACED, CLONE_UNTRACED);	DEFINE(PG_ARCH_1, PG_arch_1);	return 0;}

void foo(void){	DEFINE(IA64_TASK_SIZE, sizeof (struct task_struct));	DEFINE(IA64_THREAD_INFO_SIZE, sizeof (struct thread_info));	DEFINE(IA64_PT_REGS_SIZE, sizeof (struct pt_regs));	DEFINE(IA64_SWITCH_STACK_SIZE, sizeof (struct switch_stack));	DEFINE(IA64_SIGINFO_SIZE, sizeof (struct siginfo));	DEFINE(IA64_CPU_SIZE, sizeof (struct cpuinfo_ia64));	DEFINE(SIGFRAME_SIZE, sizeof (struct sigframe));	DEFINE(UNW_FRAME_INFO_SIZE, sizeof (struct unw_frame_info));	BLANK();	DEFINE(TI_FLAGS, offsetof(struct thread_info, flags));	DEFINE(TI_PRE_COUNT, offsetof(struct thread_info, preempt_count));	BLANK();	DEFINE(IA64_TASK_BLOCKED_OFFSET,offsetof (struct task_struct, blocked));	DEFINE(IA64_TASK_CLEAR_CHILD_TID_OFFSET,offsetof (struct task_struct, clear_child_tid));	DEFINE(IA64_TASK_GROUP_LEADER_OFFSET, offsetof (struct task_struct, group_leader));	DEFINE(IA64_TASK_PENDING_OFFSET,offsetof (struct task_struct, pending));	DEFINE(IA64_TASK_PID_OFFSET, offsetof (struct task_struct, pid));	DEFINE(IA64_TASK_REAL_PARENT_OFFSET, offsetof (struct task_struct, real_parent));	DEFINE(IA64_TASK_SIGHAND_OFFSET,offsetof (struct task_struct, sighand));	DEFINE(IA64_TASK_SIGNAL_OFFSET,offsetof (struct task_struct, signal));	DEFINE(IA64_TASK_TGID_OFFSET, offsetof (struct task_struct, tgid));	DEFINE(IA64_TASK_THREAD_KSP_OFFSET, offsetof (struct task_struct, thread.ksp));	DEFINE(IA64_TASK_THREAD_ON_USTACK_OFFSET, offsetof (struct task_struct, thread.on_ustack));	BLANK();	DEFINE(IA64_SIGHAND_SIGLOCK_OFFSET,offsetof (struct sighand_struct, siglock));	BLANK();	DEFINE(IA64_SIGNAL_GROUP_STOP_COUNT_OFFSET,offsetof (struct signal_struct,							     group_stop_count));	DEFINE(IA64_SIGNAL_SHARED_PENDING_OFFSET,offsetof (struct signal_struct, shared_pending));	BLANK();	DEFINE(IA64_PT_REGS_B6_OFFSET, offsetof (struct pt_regs, b6));	DEFINE(IA64_PT_REGS_B7_OFFSET, offsetof (struct pt_regs, b7));	DEFINE(IA64_PT_REGS_AR_CSD_OFFSET, offsetof (struct pt_regs, ar_csd));	DEFINE(IA64_PT_REGS_AR_SSD_OFFSET, offsetof (struct pt_regs, ar_ssd));	DEFINE(IA64_PT_REGS_R8_OFFSET, offsetof (struct pt_regs, r8));	DEFINE(IA64_PT_REGS_R9_OFFSET, offsetof (struct pt_regs, r9));	DEFINE(IA64_PT_REGS_R10_OFFSET, offsetof (struct pt_regs, r10));	DEFINE(IA64_PT_REGS_R11_OFFSET, offsetof (struct pt_regs, r11));	DEFINE(IA64_PT_REGS_CR_IPSR_OFFSET, offsetof (struct pt_regs, cr_ipsr));	DEFINE(IA64_PT_REGS_CR_IIP_OFFSET, offsetof (struct pt_regs, cr_iip));	DEFINE(IA64_PT_REGS_CR_IFS_OFFSET, offsetof (struct pt_regs, cr_ifs));	DEFINE(IA64_PT_REGS_AR_UNAT_OFFSET, offsetof (struct pt_regs, ar_unat));	DEFINE(IA64_PT_REGS_AR_PFS_OFFSET, offsetof (struct pt_regs, ar_pfs));	DEFINE(IA64_PT_REGS_AR_RSC_OFFSET, offsetof (struct pt_regs, ar_rsc));	DEFINE(IA64_PT_REGS_AR_RNAT_OFFSET, offsetof (struct pt_regs, ar_rnat));	DEFINE(IA64_PT_REGS_AR_BSPSTORE_OFFSET, offsetof (struct pt_regs, ar_bspstore));	DEFINE(IA64_PT_REGS_PR_OFFSET, offsetof (struct pt_regs, pr));	DEFINE(IA64_PT_REGS_B0_OFFSET, offsetof (struct pt_regs, b0));	DEFINE(IA64_PT_REGS_LOADRS_OFFSET, offsetof (struct pt_regs, loadrs));	DEFINE(IA64_PT_REGS_R1_OFFSET, offsetof (struct pt_regs, r1));	DEFINE(IA64_PT_REGS_R12_OFFSET, offsetof (struct pt_regs, r12));	DEFINE(IA64_PT_REGS_R13_OFFSET, offsetof (struct pt_regs, r13));	DEFINE(IA64_PT_REGS_AR_FPSR_OFFSET, offsetof (struct pt_regs, ar_fpsr));	DEFINE(IA64_PT_REGS_R15_OFFSET, offsetof (struct pt_regs, r15));	DEFINE(IA64_PT_REGS_R14_OFFSET, offsetof (struct pt_regs, r14));	DEFINE(IA64_PT_REGS_R2_OFFSET, offsetof (struct pt_regs, r2));	DEFINE(IA64_PT_REGS_R3_OFFSET, offsetof (struct pt_regs, r3));	DEFINE(IA64_PT_REGS_R16_OFFSET, offsetof (struct pt_regs, r16));	DEFINE(IA64_PT_REGS_R17_OFFSET, offsetof (struct pt_regs, r17));	DEFINE(IA64_PT_REGS_R18_OFFSET, offsetof (struct pt_regs, r18));	DEFINE(IA64_PT_REGS_R19_OFFSET, offsetof (struct pt_regs, r19));	DEFINE(IA64_PT_REGS_R20_OFFSET, offsetof (struct pt_regs, r20));	DEFINE(IA64_PT_REGS_R21_OFFSET, offsetof (struct pt_regs, r21));	DEFINE(IA64_PT_REGS_R22_OFFSET, offsetof (struct pt_regs, r22));	DEFINE(IA64_PT_REGS_R23_OFFSET, offsetof (struct pt_regs, r23));	DEFINE(IA64_PT_REGS_R24_OFFSET, offsetof (struct pt_regs, r24));	DEFINE(IA64_PT_REGS_R25_OFFSET, offsetof (struct pt_regs, r25));	DEFINE(IA64_PT_REGS_R26_OFFSET, offsetof (struct pt_regs, r26));	DEFINE(IA64_PT_REGS_R27_OFFSET, offsetof (struct pt_regs, r27));	DEFINE(IA64_PT_REGS_R28_OFFSET, offsetof (struct pt_regs, r28));	DEFINE(IA64_PT_REGS_R29_OFFSET, offsetof (struct pt_regs, r29));	DEFINE(IA64_PT_REGS_R30_OFFSET, offsetof (struct pt_regs, r30));	DEFINE(IA64_PT_REGS_R31_OFFSET, offsetof (struct pt_regs, r31));	DEFINE(IA64_PT_REGS_AR_CCV_OFFSET, offsetof (struct pt_regs, ar_ccv));	DEFINE(IA64_PT_REGS_F6_OFFSET, offsetof (struct pt_regs, f6));	DEFINE(IA64_PT_REGS_F7_OFFSET, offsetof (struct pt_regs, f7));	DEFINE(IA64_PT_REGS_F8_OFFSET, offsetof (struct pt_regs, f8));	DEFINE(IA64_PT_REGS_F9_OFFSET, offsetof (struct pt_regs, f9));	DEFINE(IA64_PT_REGS_F10_OFFSET, offsetof (struct pt_regs, f10));	DEFINE(IA64_PT_REGS_F11_OFFSET, offsetof (struct pt_regs, f11));	BLANK();	DEFINE(IA64_SWITCH_STACK_CALLER_UNAT_OFFSET, offsetof (struct switch_stack, caller_unat));	DEFINE(IA64_SWITCH_STACK_AR_FPSR_OFFSET, offsetof (struct switch_stack, ar_fpsr));	DEFINE(IA64_SWITCH_STACK_F2_OFFSET, offsetof (struct switch_stack, f2));	DEFINE(IA64_SWITCH_STACK_F3_OFFSET, offsetof (struct switch_stack, f3));//.........这里部分代码省略.........