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

static CORE_ADDRvax_store_arguments (struct regcache *regcache, int nargs,		     struct value **args, CORE_ADDR sp){  struct gdbarch *gdbarch = get_regcache_arch (regcache);  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);  gdb_byte buf[4];  int count = 0;  int i;  /* We create an argument list on the stack, and make the argument     pointer to it.  */  /* Push arguments in reverse order.  */  for (i = nargs - 1; i >= 0; i--)    {      int len = TYPE_LENGTH (value_enclosing_type (args[i]));      sp -= (len + 3) & ~3;      count += (len + 3) / 4;      write_memory (sp, value_contents_all (args[i]), len);    }  /* Push argument count.  */  sp -= 4;  store_unsigned_integer (buf, 4, byte_order, count);  write_memory (sp, buf, 4);  /* Update the argument pointer.  */  store_unsigned_integer (buf, 4, byte_order, sp);  regcache_cooked_write (regcache, VAX_AP_REGNUM, buf);  return sp;}

static CORE_ADDRm68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,		      struct regcache *regcache, CORE_ADDR bp_addr, int nargs,		      struct value **args, CORE_ADDR sp, int struct_return,		      CORE_ADDR struct_addr){  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);  gdb_byte buf[4];  int i;  /* Push arguments in reverse order.  */  for (i = nargs - 1; i >= 0; i--)    {      struct type *value_type = value_enclosing_type (args[i]);      int len = TYPE_LENGTH (value_type);      int container_len = (len + 3) & ~3;      int offset;      /* Non-scalars bigger than 4 bytes are left aligned, others are	 right aligned.  */      if ((TYPE_CODE (value_type) == TYPE_CODE_STRUCT	   || TYPE_CODE (value_type) == TYPE_CODE_UNION	   || TYPE_CODE (value_type) == TYPE_CODE_ARRAY)	  && len > 4)	offset = 0;      else	offset = container_len - len;      sp -= container_len;      write_memory (sp + offset, value_contents_all (args[i]), len);    }  /* Store struct value address.  */  if (struct_return)    {      store_unsigned_integer (buf, 4, byte_order, struct_addr);      regcache_cooked_write (regcache, tdep->struct_value_regnum, buf);    }  /* Store return address.  */  sp -= 4;  store_unsigned_integer (buf, 4, byte_order, bp_addr);  write_memory (sp, buf, 4);  /* Finally, update the stack pointer...  */  store_unsigned_integer (buf, 4, byte_order, sp);  regcache_cooked_write (regcache, M68K_SP_REGNUM, buf);  /* ...and fake a frame pointer.  */  regcache_cooked_write (regcache, M68K_FP_REGNUM, buf);  /* DWARF2/GCC uses the stack address *before* the function call as a     frame's CFA.  */  return sp + 8;}

static void snrom_wram_open(usb_dev_handle *handle){	uint8_t t[5];	t[0] = 0x80;	write_memory(handle, REQUEST_CPU_WRITE_6502, INDEX_IMPLIED, 0x8000, 1, t);	t[0] = 0, t[1] = 0, t[2] = 0, t[3] = 1, t[4] = 0;	write_memory(handle, REQUEST_CPU_WRITE_6502, INDEX_IMPLIED, 0x8000, sizeof(t), t);	t[0] = 0, t[1] = 0, t[2] = 0, t[3] = 0, t[4] = 0;	write_memory(handle, REQUEST_CPU_WRITE_6502, INDEX_IMPLIED, 0xe000, sizeof(t), t);	write_memory(handle, REQUEST_CPU_WRITE_6502, INDEX_IMPLIED, 0xa000, sizeof(t), t);}

int lem_interrupt(void){	uint16_t cycles = 0;	uint16_t b = read_register(REG_B);	switch (read_register(REG_A)) {	case 0:		if (b) {			if (connected == 0) {				clock_gettime(CLOCK_REALTIME, &tp_prev);				// TODO don't start up for ~1s			}			connected = 1;			vram = b;		} else {			connected = 0;		}		break;	case 1:		if (b) {			custom_font = 1;			font_ram = b;		} else {			custom_font = 1;		}		break;	case 2:		if (b) {			custom_pal = 1;			pal_ram = b;		} else {			custom_pal = 1;		}		break;	case 3:		border_col = b;		break;	case 4:		write_memory(b, FONT_LEN, font);		cycles = 256;		break;	case 5:		write_memory(b, PAL_LEN, pal);		cycles = 16;		break;	default:		break;	}	return cycles;}

static CORE_ADDRvax_push_dummy_call (struct gdbarch *gdbarch, struct value *function,		     struct regcache *regcache, CORE_ADDR bp_addr, int nargs,		     struct value **args, CORE_ADDR sp,		     function_call_return_method return_method,		     CORE_ADDR struct_addr){  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);  CORE_ADDR fp = sp;  gdb_byte buf[4];  /* Set up the function arguments.  */  sp = vax_store_arguments (regcache, nargs, args, sp);  /* Store return value address.  */  if (return_method == return_method_struct)    regcache_cooked_write_unsigned (regcache, VAX_R1_REGNUM, struct_addr);  /* Store return address in the PC slot.  */  sp -= 4;  store_unsigned_integer (buf, 4, byte_order, bp_addr);  write_memory (sp, buf, 4);  /* Store the (fake) frame pointer in the FP slot.  */  sp -= 4;  store_unsigned_integer (buf, 4, byte_order, fp);  write_memory (sp, buf, 4);  /* Skip the AP slot.  */  sp -= 4;  /* Store register save mask and control bits.  */  sp -= 4;  store_unsigned_integer (buf, 4, byte_order, 0);  write_memory (sp, buf, 4);  /* Store condition handler.  */  sp -= 4;  store_unsigned_integer (buf, 4, byte_order, 0);  write_memory (sp, buf, 4);  /* Update the stack pointer and frame pointer.  */  store_unsigned_integer (buf, 4, byte_order, sp);  regcache->cooked_write (VAX_SP_REGNUM, buf);  regcache->cooked_write (VAX_FP_REGNUM, buf);  /* Return the saved (fake) frame pointer.  */  return fp;}

EXPORTint add_breakpoint(mach_port_t task, vm_address_t patch_addr, int cont, callback handler) {    kern_return_t kret;    char *tmp;    mach_vm_size_t len = 1;     // number of bytes to write    uint8_t opcode = 0xcc;      // the CC byte to write    interface *face;    face = find_interface(task);    if(face->registered_exception_handler == 0) {        DEBUG_PRINT("[+add_breakpoint] HERE IN ADD BREAK/n %d", 0);        register_(task);    }    kret = mach_vm_protect(task, patch_addr, len, FALSE, VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE);    RETURN_ON_MACH_ERROR("[-add_breakpoint] mach_vm_protect()", kret);    if (patch_addr <= MAX_BREAKS) {        DEBUG_PRINT("[-add_breakpoint] INVALID BREAKPOINT ADDRESS %lx/n", patch_addr);        return -1;    } else if(face->current_break >= MAX_BREAKS) {        DEBUG_PRINT("[-add_breakpoint] Max %d breaks reached!/n", MAX_BREAKS);        return -1;    }    DEBUG_PRINT("[+add_breakpoint] Breakpoint %u: %lx added/n", face->current_break, patch_addr);    tmp = (char*) read_memory(task, patch_addr, 1);    breakpoint_struct *new_break = safe_malloc(sizeof(breakpoint_struct));    new_break->address = patch_addr;    new_break->original = tmp[0] & 0xff;    new_break->handler = handler;    if(face->single_step) {        new_break->index = face->single_step_index;    }    else {        new_break->index = face->current_break == 0 ? 0 : face->breaks[face->current_break-1]->index + 1;    }    new_break->flags = cont;    if(face->max_break == 0) {        face->max_break = 1;    }    if(face->current_break >= (face->max_break - 1)) {        DEBUG_PRINT("[+add_breakpoint] ALLOCATING MORE BP! CURRENTLY: %d/n", face->current_break);        face->breaks = safe_realloc(face->breaks, sizeof(breakpoint_struct*)  *(face->max_break*2));        face->max_break *= 2;    }    // face->breaks = safe_realloc(face->breaks, sizeof(breakpoint_struct*)  *(face->current_break+1));    face->breaks[face->current_break++] = new_break;    write_memory(task, patch_addr, opcode, len); // write the byte    kret = mach_vm_protect(task, patch_addr, (mach_vm_size_t)1, FALSE, VM_PROT_READ | VM_PROT_EXECUTE);    RETURN_ON_MACH_ERROR("[-add_breakpoint] RESTORE mach_vm_protect()", kret);    return 1;}

static voidsparc64obsd_collect_uthread(const struct regcache *regcache,			    int regnum, CORE_ADDR addr){  CORE_ADDR sp;  gdb_byte buf[8];  gdb_assert (regnum >= -1);  if (regnum == SPARC_SP_REGNUM || regnum == -1)    {      CORE_ADDR fp_addr = addr + SPARC64OBSD_UTHREAD_FP_OFFSET;      regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf);      write_memory (fp_addr,buf, 8);    }  if (regnum == SPARC64_PC_REGNUM || regnum == -1)    {      CORE_ADDR i7, i7_addr = addr + SPARC64OBSD_UTHREAD_PC_OFFSET;      regcache_raw_collect (regcache, SPARC64_PC_REGNUM, buf);      i7 = extract_unsigned_integer (buf, 8) - 8;      write_memory_unsigned_integer (i7_addr, 8, i7);      if (regnum == SPARC64_PC_REGNUM)	return;    }  regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf);  sp = extract_unsigned_integer (buf, 8);  sparc_collect_rwindow (regcache, sp, regnum);}

static voidsparc_ravenscar_store_registers (struct regcache *regcache, int regnum){  struct gdbarch *gdbarch = get_regcache_arch (regcache);  int buf_size = register_size (gdbarch, regnum);  char buf [buf_size];  ULONGEST register_address;  if (register_in_thread_descriptor_p (regnum))    register_address =      ptid_get_tid (inferior_ptid) + sparc_register_offsets [regnum];  else if (register_on_stack_p (regnum))    {      regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM,                                     &register_address);      register_address += sparc_register_offsets [regnum];    }  else    return;  regcache_raw_collect (regcache, regnum, buf);  write_memory (register_address,                buf,                buf_size);}

static void firmware_update(usb_dev_handle *handle, const char *file){	uint8_t *firmware;	const int firmsize = 0x3800;	assert(firmsize <= 0x3800);	firmware = malloc(firmsize);	memset(firmware, 0xff, firmsize);	if(hex_load(file, firmsize, firmware) == false){		puts("image open error!");		goto end;	}	snrom_wram_open(handle);	int ppu, cpu = 0;	ppu = cartridge_ram_transform(handle, firmware, REQUEST_PPU_WRITE, REQUEST_PPU_READ, 0x0000, 0x2000, false);	if(firmsize >= 0x2000){		cpu = cartridge_ram_transform(handle, firmware + 0x2000, REQUEST_CPU_WRITE_6502, REQUEST_CPU_READ, 0x6000, firmsize - 0x2000, false);	}	if((ppu == 0) && (cpu == 0)){//		write_memory(handle, REQUEST_FIRMWARE_PROGRAM, firmsize, 0x2000, 0, firmware);		puts("USB connection will be disconnteced. This is normally.");		puts("Re-turn on kazzo's power.");		write_memory(handle, REQUEST_FIRMWARE_PROGRAM, firmsize, 0x0000, 0, firmware);	}else{		puts("firmware transform error!");		snrom_wram_close(handle);	}end:	free(firmware);}

/*! * @brief Restores the process state and detaches. * @param pid Process identifier to restore. * @param s Pointer to /c state with code and registers. * @param only_memory Idicates if restore only memory at EIP or also registers * @returns Indication of success or failure. * @retval 0 Indicates success. */LONGrestore_state(LONG pid, state *s, int only_memory) {	unsigned long *mem_ptr = NULL;	LONG i = 0;	LONG result = 0;	if (s == NULL)		return ERROR_INVALID_PARAMETER; 	mem_ptr = (unsigned long *)(s->memory);	if (mem_ptr == NULL)		return ERROR_INVALID_PARAMETER;	result = write_memory(pid, s->regs.eip, mem_ptr, MMAP_STUB_SIZE);	if (result != 0)		return result;	if (only_memory > 0)		return 0;	result = setregs(pid, &(s->regs));	if (result != 0)		return result;	result = detach(pid);	if (result != 0)		return result;	return 0;}

static CORE_ADDRamd64_windows_adjust_args_passed_by_pointer (struct value **args,					     int nargs, CORE_ADDR sp){  int i;  for (i = 0; i < nargs; i++)    if (amd64_windows_passed_by_pointer (value_type (args[i])))      {	struct type *type = value_type (args[i]);	const gdb_byte *valbuf = value_contents (args[i]);	const int len = TYPE_LENGTH (type);	/* Store a copy of that argument on the stack, aligned to	   a 16 bytes boundary, and then use the copy's address as	   the argument.  */	sp -= len;	sp &= ~0xf;	write_memory (sp, valbuf, len);	args[i]	  = value_addr (value_from_contents_and_address (type, valbuf, sp));      }  return sp;}

static inti386_darwin_sstep_at_sigreturn (x86_thread_state_t *regs){  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);  static const gdb_byte darwin_syscall[] = { 0xcd, 0x80 }; /* int 0x80 */  gdb_byte buf[sizeof (darwin_syscall)];  /* Check if PC is at a sigreturn system call.  */  if (target_read_memory (regs->uts.ts32.__eip, buf, sizeof (buf)) == 0      && memcmp (buf, darwin_syscall, sizeof (darwin_syscall)) == 0      && regs->uts.ts32.__eax == 0xb8 /* SYS_sigreturn */)    {      ULONGEST uctx_addr;      ULONGEST mctx_addr;      ULONGEST flags_addr;      unsigned int eflags;      uctx_addr = read_memory_unsigned_integer		    (regs->uts.ts32.__esp + 4, 4, byte_order);      mctx_addr = read_memory_unsigned_integer		    (uctx_addr + 28, 4, byte_order);      flags_addr = mctx_addr + 12 + 9 * 4;      read_memory (flags_addr, (gdb_byte *) &eflags, 4);      eflags |= X86_EFLAGS_T;      write_memory (flags_addr, (gdb_byte *) &eflags, 4);      return 1;    }  return 0;}

/* Attach to PID `pid', take a snapshot, modify its state to have it call * `dlopen()', restore the previously saved snapshot and detach. */static int inject(pid_t pid, char *filename, char all_thrs){    regs_t regs;    char buf[PAGE_SIZE];    ssize_t size;    int r = -1;    if(attach(pid, all_thrs) != 0)        goto ret;    if(read_registers(pid, &regs) != 0)        goto ret;    if((size = read_memory(pid, (void *)SP(regs), buf, sizeof(buf))) < 0)        goto ret;    r = 0;    if(force_dlopen(pid, filename) != 0)        r = -1;    if(write_memory(pid, (void *)SP(regs), buf, size) != size)        r = -1;    if(write_registers(pid, &regs) != 0)        r = -1;    if(detach(pid, all_thrs) != 0)        r = -1;ret:    return r;}

static void change_mem_val (pid_t pid, CfgEntry *cfg_en, T read_val, T value,			    value_t *buf, ptr_t mem_offs){	list<CheckEntry> *chk_lp = cfg_en->checks;	ptr_t mem_addr;	i32 ret;	if (cfg_en->dynval == DYN_VAL_WATCH)		goto out;	if (chk_lp) {		ret = process_checks(pid, cfg_en->dynmem, chk_lp, mem_offs);		if (ret)			goto out;	}	ret = check_mem_val(read_val, value, cfg_en->check);	if (ret)		goto out;	memcpy(buf, &value, sizeof(T));	mem_addr = mem_offs + cfg_en->addr;	ret = write_memory(pid, mem_addr, buf, "MEMORY");	if (ret)		goto out;out:	return;}

 remote_buffer(const void *data, int dataLen) : remote_buffer(dataLen) {     if (this->data != 0) {         // Return value ignored, this is a constructor, we don't         // have exceptions, and we already printed an error.         write_memory(this->data, data, dataLen);     } }

/*! * @brief Executes an stub of code on a debugged process. * @param pid Process identifier where to execute code. * @param addr Process addr to store the code. * @param stub Pointer to code stub to execute. * @param stub_size ptrace friendly length of the stub to execute. * @returns Indication of success or failure. * @retval 0 indicates success. */LONGexecute_stub(LONG pid, unsigned long addr, unsigned long *stub, ULONG stub_size) {	LONG i = 0;	LONG result = 0;	struct user_regs_struct stub_regs;	if (stub_size == 0 || stub == NULL)		return ERROR_INVALID_PARAMETER;	result = write_memory(pid, addr, stub, stub_size);	if (result != 0)		return result;	// Jump into the nops stub, makes code modification	// more reliable.	result = getregs(pid, &stub_regs);	if (result != 0)		return result;	dprintf("[EXECUTE_STUB] Original EIP 0x%x", stub_regs.eip);	stub_regs.eip = stub_regs.eip + 8;	result = setregs(pid, &stub_regs);	if (result != 0)		return result;	dprintf("[EXECUTE_STUB] Redirecting to 0x%x", stub_regs.eip);	result = cont(pid);	if (result != 0)		return result;	return 0;}

static intamd64_darwin_sstep_at_sigreturn (x86_thread_state_t *regs){  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);  static const gdb_byte darwin_syscall[] = { 0x0f, 0x05 }; /* syscall */  gdb_byte buf[sizeof (darwin_syscall)];  /* Check if PC is at a sigreturn system call.  */  if (target_read_memory (regs->uts.ts64.__rip, buf, sizeof (buf)) == 0      && memcmp (buf, darwin_syscall, sizeof (darwin_syscall)) == 0      && (regs->uts.ts64.__rax & 0xffffffff) == 0x20000b8 /* SYS_sigreturn */)    {      ULONGEST mctx_addr;      ULONGEST flags_addr;      unsigned int rflags;      mctx_addr = read_memory_unsigned_integer		    (regs->uts.ts64.__rdi + 48, 8, byte_order);      flags_addr = mctx_addr + 16 + 17 * 8;      /* AMD64 is little endian.  */      read_memory (flags_addr, (gdb_byte *) &rflags, 4);      rflags |= X86_EFLAGS_T;      write_memory (flags_addr, (gdb_byte *) &rflags, 4);      return 1;    }  return 0;}

EXPORTBOOL GetThreadSelectorEntry(HANDLE hThread, DWORD dwSelector, LPLDT_ENTRY lpSelectorEntry){	//fprintf(stderr, "GetThreadSelectorEntry %d %ld /n", hThread, dwSelector);/*** Note: technically, some functions are called with threadid's instead of pids**       which would break things except the pid is only really needed in those**       fuctions the first time one of them is called.  What a hack */	if(!allocated_fs_base){		char *fake_data = (char *) malloc(0x40);		// Allocate some memory to put our fake data structures				allocated_fs_base = (int) allocate(hThread, 0, 128);		if(!allocated_fs_base){			//printf("Couldn't allocate memory/n");			return 0;		}		virtual_protect(hThread, allocated_fs_base, 128, PAGE_READWRITE);		// Put some fake data to access		memset(fake_data, 0x0, 0x40);		memcpy(fake_data,	"/xff/xff/xff/xff" /*SEH*/ 							"/xff/xff/xff/xbf" /* stack top */ 							"/x00/x00/x00/xbf" /* stack bottom */											, 12);		int *p = (int *) (fake_data + 0x30); // SEH		*p = htonl(allocated_fs_base);		write_memory(hThread, allocated_fs_base, 0x40, fake_data);	}	lpSelectorEntry->BaseLow = allocated_fs_base & 0xffff;	lpSelectorEntry->HighWord.Bytes.BaseMid = (allocated_fs_base & 0xff0000) >> 16;	lpSelectorEntry->HighWord.Bytes.BaseHi = (allocated_fs_base & 0xff000000) >> 24;	return 1;}

static CORE_ADDRamd64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,		       struct regcache *regcache, CORE_ADDR bp_addr,		       int nargs, struct value **args,	CORE_ADDR sp,		       int struct_return, CORE_ADDR struct_addr){  gdb_byte buf[8];  /* Pass arguments.  */  sp = amd64_push_arguments (regcache, nargs, args, sp, struct_return);  /* Pass "hidden" argument".  */  if (struct_return)    {      store_unsigned_integer (buf, 8, struct_addr);      regcache_cooked_write (regcache, AMD64_RDI_REGNUM, buf);    }  /* Store return address.  */  sp -= 8;  store_unsigned_integer (buf, 8, bp_addr);  write_memory (sp, buf, 8);  /* Finally, update the stack pointer...  */  store_unsigned_integer (buf, 8, sp);  regcache_cooked_write (regcache, AMD64_RSP_REGNUM, buf);  /* ...and fake a frame pointer.  */  regcache_cooked_write (regcache, AMD64_RBP_REGNUM, buf);  return sp + 16;}

static int cartridge_ram_transform(usb_dev_handle *handle, const uint8_t *firmware, enum request w, enum request r, long address, long length, bool dump){	uint8_t *compare;	compare = malloc(length);	write_memory(handle, w, INDEX_IMPLIED, address, length, firmware);	read_memory(handle, r, INDEX_IMPLIED, address, length, compare);	int ret = memcmp(firmware, compare, length);	if(dump == true){		int i;		uint8_t *t = compare;		for(i = 0; i < length; i += 0x10){			int j;			printf("%06x:", i);			for(j = 0; j < 0x10; j++){				const char *safix;				switch(j){				case 7:					safix = "-";					break;				case 0x0f:					safix = "/n";					break;				default:					safix = " ";					break;				}				printf("%02x%s", *t, safix);				t++;			}		}	}	free(compare);	return ret;}

static voidsparc32obsd_collect_uthread(const struct regcache *regcache,			    int regnum, CORE_ADDR addr){  struct gdbarch *gdbarch = get_regcache_arch (regcache);  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);  CORE_ADDR sp;  gdb_byte buf[4];  gdb_assert (regnum >= -1);  if (regnum == SPARC_SP_REGNUM || regnum == -1)    {      CORE_ADDR fp_addr = addr + SPARC32OBSD_UTHREAD_FP_OFFSET;      regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf);      write_memory (fp_addr,buf, 4);    }  if (regnum == SPARC32_PC_REGNUM || regnum == -1)    {      CORE_ADDR i7, i7_addr = addr + SPARC32OBSD_UTHREAD_PC_OFFSET;      regcache_raw_collect (regcache, SPARC32_PC_REGNUM, buf);      i7 = extract_unsigned_integer (buf, 4, byte_order) - 8;      write_memory_unsigned_integer (i7_addr, 4, byte_order, i7);      if (regnum == SPARC32_PC_REGNUM)	return;    }  regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf);  sp = extract_unsigned_integer (buf, 4, byte_order);  sparc_collect_rwindow (regcache, sp, regnum);}

/* Store VALUE at ADDR in the inferior as a LEN-byte signed integer: */voidwrite_memory_signed_integer(CORE_ADDR addr, int len, LONGEST value){  char *buf = (char *)alloca(len);  store_signed_integer((gdb_byte *)buf, len, value);  write_memory(addr, (const bfd_byte *)buf, len);}

int main(int c, char **v){	usb_init();	usb_dev_handle *handle = device_open();		if(handle == NULL){		return 0;	}	switch(c){	case 1:		echo(handle);		printf("work time %3.1f second/n", ((double) clock() / (double) CLOCKS_PER_SEC));		fflush(stdout);		system("pause");		break;	case 2:		firmware_version(handle);		break;	case 3:		switch(v[1][0]){		case 'w':			firmware_update(handle, v[2]);			break;		case 'r':			firmware_download(handle, v[2]);			break;		case 'v':			firmware_verify(handle, v[2]);			break;		case 'p':{			if(DEBUG == 0){				break;			}			int i = 0x1000;			const char *ret = "test ok";			while(i != 0){				if(ppu_read(handle, i) == false){					ret = "test ng";					break;				}				if((i+1) % 100 == 0){					fprintf(stderr, "/r%05d", i+1);					fflush(stderr);				}				i--;			}			puts(ret);			}break;		case 'd':			if(DEBUG == 1){				write_memory(handle, REQUEST_FIRMWARE_PROGRAM, 0x200, 0x0000, 0, NULL);			}			break;		}		break;	}	usb_close(handle);	return 0;}

// WORKINGEXPORTBOOL WriteProcessMemory(HANDLE hProcess, LPVOID lpBaseAddress, LPCVOID lpBuffer, SIZE_T nSize, SIZE_T* lpNumberOfBytesWritten){    short sts = write_memory(hProcess, (mach_vm_address_t) lpBaseAddress, (mach_msg_type_number_t) nSize, (char *) lpBuffer);    *lpNumberOfBytesWritten = nSize;    return sts;}

static voidi386_linux_resume (ptid_t ptid, int step, enum target_signal signal){  int pid = PIDGET (ptid);  int request = PTRACE_CONT;  if (pid == -1)    /* Resume all threads.  */    /* I think this only gets used in the non-threaded case, where "resume       all threads" and "resume inferior_ptid" are the same.  */    pid = PIDGET (inferior_ptid);  if (step)    {      CORE_ADDR pc = read_pc_pid (pid_to_ptid (pid));      gdb_byte buf[LINUX_SYSCALL_LEN];      request = PTRACE_SINGLESTEP;      /* Returning from a signal trampoline is done by calling a         special system call (sigreturn or rt_sigreturn, see         i386-linux-tdep.c for more information).  This system call         restores the registers that were saved when the signal was         raised, including %eflags.  That means that single-stepping         won't work.  Instead, we'll have to modify the signal context         that's about to be restored, and set the trace flag there.  */      /* First check if PC is at a system call.  */      if (deprecated_read_memory_nobpt (pc, buf, LINUX_SYSCALL_LEN) == 0	  && memcmp (buf, linux_syscall, LINUX_SYSCALL_LEN) == 0)	{	  int syscall = read_register_pid (LINUX_SYSCALL_REGNUM,	                                   pid_to_ptid (pid));	  /* Then check the system call number.  */	  if (syscall == SYS_sigreturn || syscall == SYS_rt_sigreturn)	    {	      CORE_ADDR sp = read_register (I386_ESP_REGNUM);	      CORE_ADDR addr = sp;	      unsigned long int eflags;	      if (syscall == SYS_rt_sigreturn)		addr = read_memory_integer (sp + 8, 4) + 20;	      /* Set the trace flag in the context that's about to be                 restored.  */	      addr += LINUX_SIGCONTEXT_EFLAGS_OFFSET;	      read_memory (addr, (gdb_byte *) &eflags, 4);	      eflags |= 0x0100;	      write_memory (addr, (gdb_byte *) &eflags, 4);	    }	}    }  if (ptrace (request, pid, 0, target_signal_to_host (signal)) == -1)    perror_with_name (("ptrace"));}

static CORE_ADDRmn10300_push_return_address (CORE_ADDR pc, CORE_ADDR sp){  unsigned char buf[4];  store_unsigned_integer (buf, 4, CALL_DUMMY_ADDRESS ());  write_memory (sp - 4, buf, 4);  return sp - 4;}

	/* /brief	* enforce_exception_filter overrides runtime installed functions	*	* If do_enforce is "true", the function overwrites the beginning of	* SetUnhandledExceptionFilter function with a patch which rejects	* all subsequent attempts to register a filter.	* If do_enforce is "false", the original functionality of	* SetUnhandledExceptionFilter is restored.	*	* /author	* Radu Racariu <[email
C++ write_n函数代码示例
C++ write_loop函数代码示例