Index: aes.c =================================================================== RCS file: /sources/qemu/qemu/aes.c,v retrieving revision 1.4 diff -u -p -r1.4 aes.c --- aes.c 11 Nov 2007 02:51:15 -0000 1.4 +++ aes.c 29 Nov 2007 23:50:00 -0000 @@ -30,7 +30,10 @@ #include "qemu-common.h" #include "aes.h" +#ifndef NDEBUG #define NDEBUG +#endif + #include typedef uint32_t u32; Index: block-vpc.c =================================================================== RCS file: /sources/qemu/qemu/block-vpc.c,v retrieving revision 1.7 diff -u -p -r1.7 block-vpc.c --- block-vpc.c 11 Nov 2007 02:51:16 -0000 1.7 +++ block-vpc.c 29 Nov 2007 23:50:00 -0000 @@ -81,7 +81,7 @@ typedef struct BDRVVPCState { static int vpc_probe(const uint8_t *buf, int buf_size, const char *filename) { - if (buf_size >= 8 && !strncmp(buf, "conectix", 8)) + if (buf_size >= 8 && !strncmp((const char *)buf, "conectix", 8)) return 100; return 0; } Index: block-vvfat.c =================================================================== RCS file: /sources/qemu/qemu/block-vvfat.c,v retrieving revision 1.13 diff -u -p -r1.13 block-vvfat.c --- block-vvfat.c 18 Nov 2007 01:44:35 -0000 1.13 +++ block-vvfat.c 29 Nov 2007 23:50:00 -0000 @@ -412,7 +412,7 @@ static void init_mbr(BDRVVVFATState* s) /* direntry functions */ /* dest is assumed to hold 258 bytes, and pads with 0xffff up to next multiple of 26 */ -static inline int short2long_name(unsigned char* dest,const char* src) +static inline int short2long_name(char* dest,const char* src) { int i; for(i=0;i<129 && src[i];i++) { @@ -565,7 +565,7 @@ static inline uint32_t fat_get(BDRVVVFAT uint16_t* entry=array_get(&(s->fat),cluster); return le16_to_cpu(*entry); } else { - const uint8_t* x=s->fat.pointer+cluster*3/2; + const uint8_t* x=(const uint8_t*)(s->fat.pointer)+cluster*3/2; return ((x[0]|(x[1]<<8))>>(cluster&1?4:0))&0x0fff; } } @@ -626,7 +626,7 @@ static inline direntry_t* create_short_a entry=array_get_next(&(s->directory)); memset(entry->name,0x20,11); - strncpy(entry->name,filename,i); + strncpy((char*)entry->name,filename,i); if(j > 0) for (i = 0; i < 3 && filename[j+1+i]; i++) @@ -868,7 +868,7 @@ static int init_directories(BDRVVVFATSta { direntry_t* entry=array_get_next(&(s->directory)); entry->attributes=0x28; /* archive | volume label */ - snprintf(entry->name,11,"QEMU VVFAT"); + snprintf((char*)entry->name,11,"QEMU VVFAT"); } /* Now build FAT, and write back information into directory */ @@ -1187,7 +1187,7 @@ static inline int read_cluster(BDRVVVFAT s->current_mapping = mapping; read_cluster_directory: offset = s->cluster_size*(cluster_num-s->current_mapping->begin); - s->cluster = s->directory.pointer+offset + s->cluster = (unsigned char*)s->directory.pointer+offset + 0x20*s->current_mapping->info.dir.first_dir_index; assert(((s->cluster-(unsigned char*)s->directory.pointer)%s->cluster_size)==0); assert((char*)s->cluster+s->cluster_size <= s->directory.pointer+s->directory.next*s->directory.item_size); @@ -1457,7 +1457,7 @@ static int parse_long_name(long_file_nam } if (pointer[0] & 0x40) - lfn->len = offset + strlen(lfn->name + offset); + lfn->len = offset + strlen((char*)lfn->name + offset); return 0; } @@ -1496,7 +1496,7 @@ static int parse_short_name(BDRVVVFATSta } else lfn->name[i + j + 1] = '\0'; - lfn->len = strlen(lfn->name); + lfn->len = strlen((char*)lfn->name); return 0; } @@ -1792,8 +1792,8 @@ DLOG(fprintf(stderr, "check direntry %d: fprintf(stderr, "Error in short name (%d)\n", subret); goto fail; } - if (subret > 0 || !strcmp(lfn.name, ".") - || !strcmp(lfn.name, "..")) + if (subret > 0 || !strcmp((char*)lfn.name, ".") + || !strcmp((char*)lfn.name, "..")) continue; } lfn.checksum = 0x100; /* cannot use long name twice */ @@ -1802,7 +1802,7 @@ DLOG(fprintf(stderr, "check direntry %d: fprintf(stderr, "Name too long: %s/%s\n", path, lfn.name); goto fail; } - strcpy(path2 + path_len + 1, lfn.name); + strcpy(path2 + path_len + 1, (char*)lfn.name); if (is_directory(direntries + i)) { if (begin_of_direntry(direntries + i) == 0) { @@ -2234,7 +2234,7 @@ static int commit_one_file(BDRVVVFATStat assert(size >= 0); ret = vvfat_read(s->bs, cluster2sector(s, c), - cluster, (rest_size + 0x1ff) / 0x200); + (uint8_t*)cluster, (rest_size + 0x1ff) / 0x200); if (ret < 0) return ret; Index: gdbstub.c =================================================================== RCS file: /sources/qemu/qemu/gdbstub.c,v retrieving revision 1.71 diff -u -p -r1.71 gdbstub.c --- gdbstub.c 17 Nov 2007 17:14:37 -0000 1.71 +++ gdbstub.c 29 Nov 2007 23:50:00 -0000 @@ -209,7 +209,7 @@ static int put_packet(GDBState *s, char *(p++) = tohex((csum) & 0xf); s->last_packet_len = p - s->last_packet; - put_buffer(s, s->last_packet, s->last_packet_len); + put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len); #ifdef CONFIG_USER_ONLY i = get_char(s); @@ -1189,7 +1189,7 @@ static void gdb_read_byte(GDBState *s, i #ifdef DEBUG_GDB printf("Got NACK, retransmitting\n"); #endif - put_buffer(s, s->last_packet, s->last_packet_len); + put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len); } #ifdef DEBUG_GDB else if (ch == '+') @@ -1238,11 +1238,11 @@ static void gdb_read_byte(GDBState *s, i } if (s->line_csum != (csum & 0xff)) { reply[0] = '-'; - put_buffer(s, reply, 1); + put_buffer(s, (uint8_t *)reply, 1); s->state = RS_IDLE; } else { reply[0] = '+'; - put_buffer(s, reply, 1); + put_buffer(s, (uint8_t *)reply, 1); s->state = gdb_handle_packet(s, env, s->line_buf); } break; Index: monitor.c =================================================================== RCS file: /sources/qemu/qemu/monitor.c,v retrieving revision 1.87 diff -u -p -r1.87 monitor.c --- monitor.c 18 Nov 2007 01:44:35 -0000 1.87 +++ monitor.c 29 Nov 2007 23:50:00 -0000 @@ -85,7 +85,7 @@ void term_flush(void) if (term_outbuf_index > 0) { for (i = 0; i < MAX_MON; i++) if (monitor_hd[i] && monitor_hd[i]->focus == 0) - qemu_chr_write(monitor_hd[i], term_outbuf, term_outbuf_index); + qemu_chr_write(monitor_hd[i], (uint8_t*)term_outbuf, term_outbuf_index); term_outbuf_index = 0; } } @@ -1818,7 +1818,7 @@ static int64_t expr_unary(void) case '$': { char buf[128], *q; - target_long reg; + target_long reg=0; pch++; q = buf; @@ -2035,7 +2035,7 @@ static void monitor_handle_command(const char cmdname[256]; char buf[1024]; void *str_allocated[MAX_ARGS]; - void *args[MAX_ARGS]; + intptr_t args[MAX_ARGS]; #ifdef DEBUG term_printf("command='%s'\n", cmdline); @@ -2119,7 +2119,7 @@ static void monitor_handle_command(const term_printf("%s: too many arguments\n", cmdname); goto fail; } - args[nb_args++] = str; + args[nb_args++] = (intptr_t)str; } break; case '/': @@ -2197,9 +2197,9 @@ static void monitor_handle_command(const } if (nb_args + 3 > MAX_ARGS) goto error_args; - args[nb_args++] = (void*)(long)count; - args[nb_args++] = (void*)(long)format; - args[nb_args++] = (void*)(long)size; + args[nb_args++] = count; + args[nb_args++] = format; + args[nb_args++] = size; } break; case 'i': @@ -2228,7 +2228,7 @@ static void monitor_handle_command(const typestr++; if (nb_args >= MAX_ARGS) goto error_args; - args[nb_args++] = (void *)(long)has_arg; + args[nb_args++] = has_arg; if (!has_arg) { if (nb_args >= MAX_ARGS) goto error_args; @@ -2242,16 +2242,16 @@ static void monitor_handle_command(const if (c == 'i') { if (nb_args >= MAX_ARGS) goto error_args; - args[nb_args++] = (void *)(long)val; + args[nb_args++] = val; } else { if ((nb_args + 1) >= MAX_ARGS) goto error_args; #if TARGET_PHYS_ADDR_BITS > 32 - args[nb_args++] = (void *)(long)((val >> 32) & 0xffffffff); + args[nb_args++] = ((val >> 32) & 0xffffffff); #else - args[nb_args++] = (void *)0; + args[nb_args++] = 0; #endif - args[nb_args++] = (void *)(long)(val & 0xffffffff); + args[nb_args++] = (val & 0xffffffff); } } break; @@ -2278,7 +2278,7 @@ static void monitor_handle_command(const } if (nb_args >= MAX_ARGS) goto error_args; - args[nb_args++] = (void *)(long)has_option; + args[nb_args++] = has_option; } break; default: Index: vl.c =================================================================== RCS file: /sources/qemu/qemu/vl.c,v retrieving revision 1.373 diff -u -p -r1.373 vl.c --- vl.c 25 Nov 2007 01:57:38 -0000 1.373 +++ vl.c 29 Nov 2007 23:50:01 -0000 @@ -1115,9 +1115,9 @@ static void timer_save(QEMUFile *f, void if (cpu_ticks_enabled) { hw_error("cannot save state if virtual timers are running"); } - qemu_put_be64s(f, &cpu_ticks_offset); - qemu_put_be64s(f, &ticks_per_sec); - qemu_put_be64s(f, &cpu_clock_offset); + qemu_put_be64s(f, (uint64_t *)&cpu_ticks_offset); + qemu_put_be64s(f, (uint64_t *)&ticks_per_sec); + qemu_put_be64s(f, (uint64_t *)&cpu_clock_offset); } static int timer_load(QEMUFile *f, void *opaque, int version_id) @@ -1127,10 +1127,10 @@ static int timer_load(QEMUFile *f, void if (cpu_ticks_enabled) { return -EINVAL; } - qemu_get_be64s(f, &cpu_ticks_offset); - qemu_get_be64s(f, &ticks_per_sec); + qemu_get_be64s(f, (uint64_t *)&cpu_ticks_offset); + qemu_get_be64s(f, (uint64_t *)&ticks_per_sec); if (version_id == 2) { - qemu_get_be64s(f, &cpu_clock_offset); + qemu_get_be64s(f, (uint64_t *)&cpu_clock_offset); } return 0; } @@ -1606,7 +1606,7 @@ void qemu_chr_printf(CharDriverState *s, va_list ap; va_start(ap, fmt); vsnprintf(buf, sizeof(buf), fmt, ap); - qemu_chr_write(s, buf, strlen(buf)); + qemu_chr_write(s, (uint8_t *)buf, strlen(buf)); va_end(ap); } @@ -1695,7 +1695,7 @@ static int mux_chr_write(CharDriverState (secs / 60) % 60, secs % 60, (int)((ti / 1000000) % 1000)); - d->drv->chr_write(d->drv, buf1, strlen(buf1)); + d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1)); } } } @@ -1726,13 +1726,13 @@ static void mux_print_help(CharDriverSta } else { sprintf(cbuf,"\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r", term_escape_char); } - chr->chr_write(chr, cbuf, strlen(cbuf)); + chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf)); for (i = 0; mux_help[i] != NULL; i++) { for (j=0; mux_help[i][j] != '\0'; j++) { if (mux_help[i][j] == '%') - chr->chr_write(chr, ebuf, strlen(ebuf)); + chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf)); else - chr->chr_write(chr, &mux_help[i][j], 1); + chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1); } } } @@ -1751,7 +1751,7 @@ static int mux_proc_byte(CharDriverState case 'x': { char *term = "QEMU: Terminated\n\r"; - chr->chr_write(chr,term,strlen(term)); + chr->chr_write(chr,(uint8_t *)term,strlen(term)); exit(0); break; } @@ -2900,7 +2900,7 @@ static int udp_chr_read_poll(void *opaqu * first */ while (s->max_size > 0 && s->bufptr < s->bufcnt) { - qemu_chr_read(chr, &s->buf[s->bufptr], 1); + qemu_chr_read(chr, (uint8_t *)&s->buf[s->bufptr], 1); s->bufptr++; s->max_size = qemu_chr_can_read(chr); } @@ -2921,7 +2921,7 @@ static void udp_chr_read(void *opaque) s->bufptr = 0; while (s->max_size > 0 && s->bufptr < s->bufcnt) { - qemu_chr_read(chr, &s->buf[s->bufptr], 1); + qemu_chr_read(chr, (uint8_t *)&s->buf[s->bufptr], 1); s->bufptr++; s->max_size = qemu_chr_can_read(chr); } @@ -3033,7 +3033,7 @@ static int tcp_chr_read_poll(void *opaqu #define IAC_BREAK 243 static void tcp_chr_process_IAC_bytes(CharDriverState *chr, TCPCharDriver *s, - char *buf, int *size) + uint8_t *buf, int *size) { /* Handle any telnet client's basic IAC options to satisfy char by * char mode with no echo. All IAC options will be removed from @@ -4396,7 +4396,8 @@ static NetSocketState *net_socket_fd_ini { int so_type=-1, optlen=sizeof(so_type); - if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type, &optlen)< 0) { + if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type, + (socklen_t *)&optlen)< 0) { fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd); return NULL; } @@ -5413,7 +5414,7 @@ static int qemu_savevm_state(QEMUFile *f /* ID string */ len = strlen(se->idstr); qemu_put_byte(f, len); - qemu_put_buffer(f, se->idstr, len); + qemu_put_buffer(f, (uint8_t *)se->idstr, len); qemu_put_be32(f, se->instance_id); qemu_put_be32(f, se->version_id); @@ -5474,7 +5475,7 @@ static int qemu_loadvm_state(QEMUFile *f if (qemu_ftell(f) >= end_pos) break; len = qemu_get_byte(f); - qemu_get_buffer(f, idstr, len); + qemu_get_buffer(f, (uint8_t *)idstr, len); idstr[len] = '\0'; instance_id = qemu_get_be32(f); version_id = qemu_get_be32(f); @@ -7901,7 +7902,7 @@ int main(int argc, char **argv) /* We just do some generic consistency checks */ { /* Could easily be extended to 64 devices if needed */ - const unsigned char *p; + const char *p; boot_devices_bitmap = 0; for (p = boot_devices; *p != '\0'; p++) { Index: vnc.c =================================================================== RCS file: /sources/qemu/qemu/vnc.c,v retrieving revision 1.29 diff -u -p -r1.29 vnc.c --- vnc.c 18 Nov 2007 01:44:36 -0000 1.29 +++ vnc.c 29 Nov 2007 23:50:01 -0000 @@ -369,7 +369,7 @@ static void vnc_write_pixels_generic(Vnc static void send_framebuffer_update_raw(VncState *vs, int x, int y, int w, int h) { int i; - char *row; + uint8_t *row; vnc_framebuffer_update(vs, x, y, w, h, 0); @@ -433,8 +433,8 @@ static void send_framebuffer_update(VncS static void vnc_copy(DisplayState *ds, int src_x, int src_y, int dst_x, int dst_y, int w, int h) { int src, dst; - char *src_row; - char *dst_row; + uint8_t *src_row; + uint8_t *dst_row; char *old_row; int y = 0; int pitch = ds->linesize; @@ -492,7 +492,7 @@ static void vnc_update_client(void *opaq if (vs->need_update && vs->csock != -1) { int y; - char *row; + uint8_t *row; char *old_row; uint32_t width_mask[VNC_DIRTY_WORDS]; int n_rectangles; @@ -509,10 +509,11 @@ static void vnc_update_client(void *opaq for (y = 0; y < vs->height; y++) { if (vnc_and_bits(vs->dirty_row[y], width_mask, VNC_DIRTY_WORDS)) { int x; - char *ptr, *old_ptr; + uint8_t *ptr; + char *old_ptr; ptr = row; - old_ptr = old_row; + old_ptr = (char*)old_row; for (x = 0; x < vs->ds->width; x += 16) { if (memcmp(old_ptr, ptr, 16 * vs->depth) == 0) { @@ -1184,22 +1185,23 @@ static int protocol_client_msg(VncState if (len == 1) return 20; - set_pixel_format(vs, read_u8(data, 4), read_u8(data, 5), - read_u8(data, 6), read_u8(data, 7), - read_u16(data, 8), read_u16(data, 10), - read_u16(data, 12), read_u8(data, 14), - read_u8(data, 15), read_u8(data, 16)); + set_pixel_format(vs, read_u8((uint8_t *)data, 4), + read_u8((uint8_t *)data, 5), read_u8((uint8_t *)data, 6), + read_u8((uint8_t *)data, 7), read_u16((uint8_t *)data, 8), + read_u16((uint8_t *)data, 10), read_u16((uint8_t *)data, 12), + read_u8((uint8_t *)data, 14), read_u8((uint8_t *)data, 15), + read_u8((uint8_t *)data, 16)); break; case 2: if (len == 1) return 4; if (len == 4) - return 4 + (read_u16(data, 2) * 4); + return 4 + (read_u16((uint8_t *)data, 2) * 4); - limit = read_u16(data, 2); + limit = read_u16((uint8_t *)data, 2); for (i = 0; i < limit; i++) { - int32_t val = read_s32(data, 4 + (i * 4)); + int32_t val = read_s32((uint8_t *)data, 4 + (i * 4)); memcpy(data + 4 + (i * 4), &val, sizeof(val)); } @@ -1210,32 +1212,34 @@ static int protocol_client_msg(VncState return 10; framebuffer_update_request(vs, - read_u8(data, 1), read_u16(data, 2), read_u16(data, 4), - read_u16(data, 6), read_u16(data, 8)); + read_u8((uint8_t *)data, 1), read_u16((uint8_t *)data, 2), + read_u16((uint8_t *)data, 4), read_u16((uint8_t *)data, 6), + read_u16((uint8_t *)data, 8)); break; case 4: if (len == 1) return 8; - key_event(vs, read_u8(data, 1), read_u32(data, 4)); + key_event(vs, read_u8((uint8_t *)data, 1), read_u32((uint8_t *)data, 4)); break; case 5: if (len == 1) return 6; - pointer_event(vs, read_u8(data, 1), read_u16(data, 2), read_u16(data, 4)); + pointer_event(vs, read_u8((uint8_t *)data, 1), read_u16((uint8_t *)data, 2), + read_u16((uint8_t *)data, 4)); break; case 6: if (len == 1) return 8; if (len == 8) { - uint32_t dlen = read_u32(data, 4); + uint32_t dlen = read_u32((uint8_t *)data, 4); if (dlen > 0) return 8 + dlen; } - client_cut_text(vs, read_u32(data, 4), data + 8); + client_cut_text(vs, read_u32((uint8_t *)data, 4), data + 8); break; default: printf("Msg: %d\n", data[0]); @@ -1322,9 +1326,9 @@ static void make_challenge(VncState *vs) static int protocol_client_auth_vnc(VncState *vs, char *data, size_t len) { - char response[VNC_AUTH_CHALLENGE_SIZE]; + unsigned char response[VNC_AUTH_CHALLENGE_SIZE]; int i, j, pwlen; - char key[8]; + unsigned char key[8]; if (!vs->password || !vs->password[0]) { VNC_DEBUG("No password configured on server"); @@ -1733,7 +1737,7 @@ static int vnc_start_tls(struct VncState static int protocol_client_vencrypt_auth(VncState *vs, char *data, size_t len) { - int auth = read_u32(data, 0); + int auth = read_u32((uint8_t *)data, 0); if (auth != vs->subauth) { VNC_DEBUG("Rejecting auth %d\n", auth); Index: vnchextile.h =================================================================== RCS file: /sources/qemu/qemu/vnchextile.h,v retrieving revision 1.4 diff -u -p -r1.4 vnchextile.h --- vnchextile.h 16 Sep 2007 21:07:51 -0000 1.4 +++ vnchextile.h 29 Nov 2007 23:50:01 -0000 @@ -13,7 +13,7 @@ static void CONCAT(send_hextile_tile_, N uint32_t *last_fg32, int *has_bg, int *has_fg) { - char *row = (vs->ds->data + y * vs->ds->linesize + x * vs->depth); + uint8_t *row = (vs->ds->data + y * vs->ds->linesize + x * vs->depth); pixel_t *irow = (pixel_t *)row; int j, i; pixel_t *last_bg = (pixel_t *)last_bg32; Index: audio/alsaaudio.c =================================================================== RCS file: /sources/qemu/qemu/audio/alsaaudio.c,v retrieving revision 1.11 diff -u -p -r1.11 alsaaudio.c --- audio/alsaaudio.c 17 Nov 2007 17:35:54 -0000 1.11 +++ audio/alsaaudio.c 29 Nov 2007 23:50:01 -0000 @@ -331,7 +331,8 @@ static int alsa_open (int in, struct als goto err; } - err = snd_pcm_hw_params_set_rate_near (handle, hw_params, &freq, 0); + err = snd_pcm_hw_params_set_rate_near (handle, hw_params, + (unsigned int *)&freq, 0); if (err < 0) { alsa_logerr2 (err, typ, "Failed to set frequency %d\n", req->freq); goto err; @@ -340,7 +341,7 @@ static int alsa_open (int in, struct als err = snd_pcm_hw_params_set_channels_near ( handle, hw_params, - &nchannels + (unsigned int *)&nchannels ); if (err < 0) { alsa_logerr2 (err, typ, "Failed to set number of channels %d\n", Index: hw/acpi.c =================================================================== RCS file: /sources/qemu/qemu/hw/acpi.c,v retrieving revision 1.17 diff -u -p -r1.17 acpi.c --- hw/acpi.c 17 Nov 2007 17:14:39 -0000 1.17 +++ hw/acpi.c 29 Nov 2007 23:50:01 -0000 @@ -439,7 +439,7 @@ static void pm_save(QEMUFile* f,void *op qemu_put_8s(f, &s->apmc); qemu_put_8s(f, &s->apms); qemu_put_timer(f, s->tmr_timer); - qemu_put_be64s(f, &s->tmr_overflow_time); + qemu_put_be64s(f, (uint64_t *)&s->tmr_overflow_time); } static int pm_load(QEMUFile* f,void* opaque,int version_id) @@ -460,7 +460,7 @@ static int pm_load(QEMUFile* f,void* opa qemu_get_8s(f, &s->apmc); qemu_get_8s(f, &s->apms); qemu_get_timer(f, s->tmr_timer); - qemu_get_be64s(f, &s->tmr_overflow_time); + qemu_get_be64s(f, (uint64_t *)&s->tmr_overflow_time); pm_io_space_update(s); Index: hw/apic.c =================================================================== RCS file: /sources/qemu/qemu/hw/apic.c,v retrieving revision 1.18 diff -u -p -r1.18 apic.c --- hw/apic.c 17 Nov 2007 17:14:40 -0000 1.18 +++ hw/apic.c 29 Nov 2007 23:50:01 -0000 @@ -761,10 +761,10 @@ static void apic_save(QEMUFile *f, void qemu_put_be32s(f, &s->icr[0]); qemu_put_be32s(f, &s->icr[1]); qemu_put_be32s(f, &s->divide_conf); - qemu_put_be32s(f, &s->count_shift); + qemu_put_be32s(f, (uint32_t *)&s->count_shift); qemu_put_be32s(f, &s->initial_count); - qemu_put_be64s(f, &s->initial_count_load_time); - qemu_put_be64s(f, &s->next_time); + qemu_put_be64s(f, (uint64_t *)&s->initial_count_load_time); + qemu_put_be64s(f, (uint64_t *)&s->next_time); qemu_put_timer(f, s->timer); } @@ -797,10 +797,10 @@ static int apic_load(QEMUFile *f, void * qemu_get_be32s(f, &s->icr[0]); qemu_get_be32s(f, &s->icr[1]); qemu_get_be32s(f, &s->divide_conf); - qemu_get_be32s(f, &s->count_shift); + qemu_get_be32s(f, (uint32_t *)&s->count_shift); qemu_get_be32s(f, &s->initial_count); - qemu_get_be64s(f, &s->initial_count_load_time); - qemu_get_be64s(f, &s->next_time); + qemu_get_be64s(f, (uint64_t *)&s->initial_count_load_time); + qemu_get_be64s(f, (uint64_t *)&s->next_time); if (version_id >= 2) qemu_get_timer(f, s->timer); Index: hw/cirrus_vga.c =================================================================== RCS file: /sources/qemu/qemu/hw/cirrus_vga.c,v retrieving revision 1.29 diff -u -p -r1.29 cirrus_vga.c --- hw/cirrus_vga.c 17 Nov 2007 17:14:40 -0000 1.29 +++ hw/cirrus_vga.c 29 Nov 2007 23:50:01 -0000 @@ -2985,7 +2985,7 @@ static void cirrus_vga_save(QEMUFile *f, qemu_put_buffer(f, s->gr + 2, 254); qemu_put_8s(f, &s->ar_index); qemu_put_buffer(f, s->ar, 21); - qemu_put_be32s(f, &s->ar_flip_flop); + qemu_put_be32s(f, (uint32_t *)&s->ar_flip_flop); qemu_put_8s(f, &s->cr_index); qemu_put_buffer(f, s->cr, 256); qemu_put_8s(f, &s->msr); @@ -3000,7 +3000,7 @@ static void cirrus_vga_save(QEMUFile *f, qemu_put_buffer(f, s->dac_cache, 3); qemu_put_buffer(f, s->palette, 768); - qemu_put_be32s(f, &s->bank_offset); + qemu_put_be32s(f, (uint32_t *)&s->bank_offset); qemu_put_8s(f, &s->cirrus_hidden_dac_lockindex); qemu_put_8s(f, &s->cirrus_hidden_dac_data); @@ -3036,7 +3036,7 @@ static int cirrus_vga_load(QEMUFile *f, qemu_get_buffer(f, s->gr + 2, 254); qemu_get_8s(f, &s->ar_index); qemu_get_buffer(f, s->ar, 21); - qemu_get_be32s(f, &s->ar_flip_flop); + qemu_get_be32s(f, (uint32_t *)&s->ar_flip_flop); qemu_get_8s(f, &s->cr_index); qemu_get_buffer(f, s->cr, 256); qemu_get_8s(f, &s->msr); @@ -3051,7 +3051,7 @@ static int cirrus_vga_load(QEMUFile *f, qemu_get_buffer(f, s->dac_cache, 3); qemu_get_buffer(f, s->palette, 768); - qemu_get_be32s(f, &s->bank_offset); + qemu_get_be32s(f, (uint32_t *)&s->bank_offset); qemu_get_8s(f, &s->cirrus_hidden_dac_lockindex); qemu_get_8s(f, &s->cirrus_hidden_dac_data); Index: hw/dma.c =================================================================== RCS file: /sources/qemu/qemu/hw/dma.c,v retrieving revision 1.16 diff -u -p -r1.16 dma.c --- hw/dma.c 17 Nov 2007 17:14:41 -0000 1.16 +++ hw/dma.c 29 Nov 2007 23:50:01 -0000 @@ -482,12 +482,12 @@ static void dma_save (QEMUFile *f, void qemu_put_8s (f, &d->command); qemu_put_8s (f, &d->mask); qemu_put_8s (f, &d->flip_flop); - qemu_put_be32s (f, &d->dshift); + qemu_put_be32s (f, (uint32_t *)&d->dshift); for (i = 0; i < 4; ++i) { struct dma_regs *r = &d->regs[i]; - qemu_put_be32s (f, &r->now[0]); - qemu_put_be32s (f, &r->now[1]); + qemu_put_be32s (f, (uint32_t *)&r->now[0]); + qemu_put_be32s (f, (uint32_t *)&r->now[1]); qemu_put_be16s (f, &r->base[0]); qemu_put_be16s (f, &r->base[1]); qemu_put_8s (f, &r->mode); @@ -510,12 +510,12 @@ static int dma_load (QEMUFile *f, void * qemu_get_8s (f, &d->command); qemu_get_8s (f, &d->mask); qemu_get_8s (f, &d->flip_flop); - qemu_get_be32s (f, &d->dshift); + qemu_get_be32s (f, (uint32_t *)&d->dshift); for (i = 0; i < 4; ++i) { struct dma_regs *r = &d->regs[i]; - qemu_get_be32s (f, &r->now[0]); - qemu_get_be32s (f, &r->now[1]); + qemu_get_be32s (f, (uint32_t *)&r->now[0]); + qemu_get_be32s (f, (uint32_t *)&r->now[1]); qemu_get_be16s (f, &r->base[0]); qemu_get_be16s (f, &r->base[1]); qemu_get_8s (f, &r->mode); Index: hw/fdc.c =================================================================== RCS file: /sources/qemu/qemu/hw/fdc.c,v retrieving revision 1.33 diff -u -p -r1.33 fdc.c --- hw/fdc.c 17 Nov 2007 17:14:41 -0000 1.33 +++ hw/fdc.c 29 Nov 2007 23:50:01 -0000 @@ -180,7 +180,7 @@ typedef struct fd_format_t { uint8_t last_sect; uint8_t max_track; uint8_t max_head; - const unsigned char *str; + const char *str; } fd_format_t; static const fd_format_t fd_formats[] = { Index: hw/i8254.c =================================================================== RCS file: /sources/qemu/qemu/hw/i8254.c,v retrieving revision 1.12 diff -u -p -r1.12 i8254.c --- hw/i8254.c 17 Nov 2007 17:14:42 -0000 1.12 +++ hw/i8254.c 29 Nov 2007 23:50:01 -0000 @@ -397,7 +397,7 @@ static void pit_save(QEMUFile *f, void * for(i = 0; i < 3; i++) { s = &pit->channels[i]; - qemu_put_be32s(f, &s->count); + qemu_put_be32s(f, (uint32_t *)&s->count); qemu_put_be16s(f, &s->latched_count); qemu_put_8s(f, &s->count_latched); qemu_put_8s(f, &s->status_latched); @@ -409,9 +409,9 @@ static void pit_save(QEMUFile *f, void * qemu_put_8s(f, &s->mode); qemu_put_8s(f, &s->bcd); qemu_put_8s(f, &s->gate); - qemu_put_be64s(f, &s->count_load_time); + qemu_put_be64s(f, (uint64_t *)&s->count_load_time); if (s->irq_timer) { - qemu_put_be64s(f, &s->next_transition_time); + qemu_put_be64s(f, (uint64_t *)&s->next_transition_time); qemu_put_timer(f, s->irq_timer); } } @@ -428,7 +428,7 @@ static int pit_load(QEMUFile *f, void *o for(i = 0; i < 3; i++) { s = &pit->channels[i]; - qemu_get_be32s(f, &s->count); + qemu_get_be32s(f, (uint32_t *)&s->count); qemu_get_be16s(f, &s->latched_count); qemu_get_8s(f, &s->count_latched); qemu_get_8s(f, &s->status_latched); @@ -440,9 +440,9 @@ static int pit_load(QEMUFile *f, void *o qemu_get_8s(f, &s->mode); qemu_get_8s(f, &s->bcd); qemu_get_8s(f, &s->gate); - qemu_get_be64s(f, &s->count_load_time); + qemu_get_be64s(f, (uint64_t *)&s->count_load_time); if (s->irq_timer) { - qemu_get_be64s(f, &s->next_transition_time); + qemu_get_be64s(f, (uint64_t *)&s->next_transition_time); qemu_get_timer(f, s->irq_timer); } } Index: hw/ide.c =================================================================== RCS file: /sources/qemu/qemu/hw/ide.c,v retrieving revision 1.72 diff -u -p -r1.72 ide.c --- hw/ide.c 18 Nov 2007 01:44:37 -0000 1.72 +++ hw/ide.c 29 Nov 2007 23:50:01 -0000 @@ -471,12 +471,12 @@ static void ide_identify(IDEState *s) put_le16(p + 5, 512); /* XXX: retired, remove ? */ put_le16(p + 6, s->sectors); snprintf(buf, sizeof(buf), "QM%05d", s->drive_serial); - padstr((uint8_t *)(p + 10), buf, 20); /* serial number */ + padstr((char *)(p + 10), buf, 20); /* serial number */ put_le16(p + 20, 3); /* XXX: retired, remove ? */ put_le16(p + 21, 512); /* cache size in sectors */ put_le16(p + 22, 4); /* ecc bytes */ - padstr((uint8_t *)(p + 23), QEMU_VERSION, 8); /* firmware version */ - padstr((uint8_t *)(p + 27), "QEMU HARDDISK", 40); /* model */ + padstr((char *)(p + 23), QEMU_VERSION, 8); /* firmware version */ + padstr((char *)(p + 27), "QEMU HARDDISK", 40); /* model */ #if MAX_MULT_SECTORS > 1 put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS); #endif @@ -536,12 +536,12 @@ static void ide_atapi_identify(IDEState /* Removable CDROM, 50us response, 12 byte packets */ put_le16(p + 0, (2 << 14) | (5 << 8) | (1 << 7) | (2 << 5) | (0 << 0)); snprintf(buf, sizeof(buf), "QM%05d", s->drive_serial); - padstr((uint8_t *)(p + 10), buf, 20); /* serial number */ + padstr((char *)(p + 10), buf, 20); /* serial number */ put_le16(p + 20, 3); /* buffer type */ put_le16(p + 21, 512); /* cache size in sectors */ put_le16(p + 22, 4); /* ecc bytes */ - padstr((uint8_t *)(p + 23), QEMU_VERSION, 8); /* firmware version */ - padstr((uint8_t *)(p + 27), "QEMU CD-ROM", 40); /* model */ + padstr((char *)(p + 23), QEMU_VERSION, 8); /* firmware version */ + padstr((char *)(p + 27), "QEMU CD-ROM", 40); /* model */ put_le16(p + 48, 1); /* dword I/O (XXX: should not be set on CDROM) */ #ifdef USE_DMA_CDROM put_le16(p + 49, 1 << 9 | 1 << 8); /* DMA and LBA supported */ @@ -591,10 +591,10 @@ static void ide_cfata_identify(IDEState put_le16(p + 7, s->nb_sectors >> 16); /* Sectors per card */ put_le16(p + 8, s->nb_sectors); /* Sectors per card */ snprintf(buf, sizeof(buf), "QM%05d", s->drive_serial); - padstr((uint8_t *)(p + 10), buf, 20); /* Serial number in ASCII */ + padstr((char *)(p + 10), buf, 20); /* Serial number in ASCII */ put_le16(p + 22, 0x0004); /* ECC bytes */ - padstr((uint8_t *) (p + 23), QEMU_VERSION, 8); /* Firmware Revision */ - padstr((uint8_t *) (p + 27), "QEMU MICRODRIVE", 40);/* Model number */ + padstr((char *) (p + 23), QEMU_VERSION, 8); /* Firmware Revision */ + padstr((char *) (p + 27), "QEMU MICRODRIVE", 40);/* Model number */ #if MAX_MULT_SECTORS > 1 put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS); #else @@ -2508,8 +2508,8 @@ static void ide_init_ioport(IDEState *id /* save per IDE drive data */ static void ide_save(QEMUFile* f, IDEState *s) { - qemu_put_be32s(f, &s->mult_sectors); - qemu_put_be32s(f, &s->identify_set); + qemu_put_be32s(f, (uint32_t *)&s->mult_sectors); + qemu_put_be32s(f, (uint32_t *)&s->identify_set); if (s->identify_set) { qemu_put_buffer(f, (const uint8_t *)s->identify_data, 512); } @@ -2536,8 +2536,8 @@ static void ide_save(QEMUFile* f, IDESta /* load per IDE drive data */ static void ide_load(QEMUFile* f, IDEState *s) { - qemu_get_be32s(f, &s->mult_sectors); - qemu_get_be32s(f, &s->identify_set); + qemu_get_be32s(f, (uint32_t *)&s->mult_sectors); + qemu_get_be32s(f, (uint32_t *)&s->identify_set); if (s->identify_set) { qemu_get_buffer(f, (uint8_t *)s->identify_data, 512); } Index: hw/mc146818rtc.c =================================================================== RCS file: /sources/qemu/qemu/hw/mc146818rtc.c,v retrieving revision 1.15 diff -u -p -r1.15 mc146818rtc.c --- hw/mc146818rtc.c 18 Nov 2007 01:44:37 -0000 1.15 +++ hw/mc146818rtc.c 29 Nov 2007 23:50:01 -0000 @@ -421,18 +421,18 @@ static void rtc_save(QEMUFile *f, void * qemu_put_buffer(f, s->cmos_data, 128); qemu_put_8s(f, &s->cmos_index); - qemu_put_be32s(f, &s->current_tm.tm_sec); - qemu_put_be32s(f, &s->current_tm.tm_min); - qemu_put_be32s(f, &s->current_tm.tm_hour); - qemu_put_be32s(f, &s->current_tm.tm_wday); - qemu_put_be32s(f, &s->current_tm.tm_mday); - qemu_put_be32s(f, &s->current_tm.tm_mon); - qemu_put_be32s(f, &s->current_tm.tm_year); + qemu_put_be32s(f, (uint32_t *)&s->current_tm.tm_sec); + qemu_put_be32s(f, (uint32_t *)&s->current_tm.tm_min); + qemu_put_be32s(f, (uint32_t *)&s->current_tm.tm_hour); + qemu_put_be32s(f, (uint32_t *)&s->current_tm.tm_wday); + qemu_put_be32s(f, (uint32_t *)&s->current_tm.tm_mday); + qemu_put_be32s(f, (uint32_t *)&s->current_tm.tm_mon); + qemu_put_be32s(f, (uint32_t *)&s->current_tm.tm_year); qemu_put_timer(f, s->periodic_timer); - qemu_put_be64s(f, &s->next_periodic_time); + qemu_put_be64s(f, (uint64_t *)&s->next_periodic_time); - qemu_put_be64s(f, &s->next_second_time); + qemu_put_be64s(f, (uint64_t *)&s->next_second_time); qemu_put_timer(f, s->second_timer); qemu_put_timer(f, s->second_timer2); } @@ -447,18 +447,18 @@ static int rtc_load(QEMUFile *f, void *o qemu_get_buffer(f, s->cmos_data, 128); qemu_get_8s(f, &s->cmos_index); - qemu_get_be32s(f, &s->current_tm.tm_sec); - qemu_get_be32s(f, &s->current_tm.tm_min); - qemu_get_be32s(f, &s->current_tm.tm_hour); - qemu_get_be32s(f, &s->current_tm.tm_wday); - qemu_get_be32s(f, &s->current_tm.tm_mday); - qemu_get_be32s(f, &s->current_tm.tm_mon); - qemu_get_be32s(f, &s->current_tm.tm_year); + qemu_get_be32s(f, (uint32_t *)&s->current_tm.tm_sec); + qemu_get_be32s(f, (uint32_t *)&s->current_tm.tm_min); + qemu_get_be32s(f, (uint32_t *)&s->current_tm.tm_hour); + qemu_get_be32s(f, (uint32_t *)&s->current_tm.tm_wday); + qemu_get_be32s(f, (uint32_t *)&s->current_tm.tm_mday); + qemu_get_be32s(f, (uint32_t *)&s->current_tm.tm_mon); + qemu_get_be32s(f, (uint32_t *)&s->current_tm.tm_year); qemu_get_timer(f, s->periodic_timer); - qemu_get_be64s(f, &s->next_periodic_time); + qemu_get_be64s(f, (uint64_t *)&s->next_periodic_time); - qemu_get_be64s(f, &s->next_second_time); + qemu_get_be64s(f, (uint64_t *)&s->next_second_time); qemu_get_timer(f, s->second_timer); qemu_get_timer(f, s->second_timer2); return 0; Index: hw/ne2000.c =================================================================== RCS file: /sources/qemu/qemu/hw/ne2000.c,v retrieving revision 1.31 diff -u -p -r1.31 ne2000.c --- hw/ne2000.c 18 Nov 2007 01:44:37 -0000 1.31 +++ hw/ne2000.c 29 Nov 2007 23:50:01 -0000 @@ -647,12 +647,12 @@ static uint32_t ne2000_reset_ioport_read static void ne2000_save(QEMUFile* f,void* opaque) { NE2000State* s=(NE2000State*)opaque; - int tmp; + unsigned int tmp=0; - if (s->pci_dev) - pci_device_save(s->pci_dev, f); + if (s->pci_dev) + pci_device_save(s->pci_dev, f); - qemu_put_8s(f, &s->rxcr); + qemu_put_8s(f, &s->rxcr); qemu_put_8s(f, &s->cmd); qemu_put_be32s(f, &s->start); @@ -670,31 +670,30 @@ static void ne2000_save(QEMUFile* f,void qemu_put_buffer(f, s->phys, 6); qemu_put_8s(f, &s->curpag); qemu_put_buffer(f, s->mult, 8); - tmp = 0; qemu_put_be32s(f, &tmp); /* ignored, was irq */ - qemu_put_buffer(f, s->mem, NE2000_MEM_SIZE); + qemu_put_buffer(f, (uint8_t *)s->mem, NE2000_MEM_SIZE); } static int ne2000_load(QEMUFile* f,void* opaque,int version_id) { NE2000State* s=(NE2000State*)opaque; - int ret; - int tmp; + int ret; + unsigned int tmp; - if (version_id > 3) - return -EINVAL; + if (version_id > 3) + return -EINVAL; - if (s->pci_dev && version_id >= 3) { - ret = pci_device_load(s->pci_dev, f); - if (ret < 0) - return ret; - } - - if (version_id >= 2) { - qemu_get_8s(f, &s->rxcr); - } else { - s->rxcr = 0x0c; - } + if (s->pci_dev && version_id >= 3) { + ret = pci_device_load(s->pci_dev, f); + if (ret < 0) + return ret; + } + + if (version_id >= 2) { + qemu_get_8s(f, &s->rxcr); + } else { + s->rxcr = 0x0c; + } qemu_get_8s(f, &s->cmd); qemu_get_be32s(f, &s->start); @@ -713,7 +712,7 @@ static int ne2000_load(QEMUFile* f,void* qemu_get_8s(f, &s->curpag); qemu_get_buffer(f, s->mult, 8); qemu_get_be32s(f, &tmp); /* ignored */ - qemu_get_buffer(f, s->mem, NE2000_MEM_SIZE); + qemu_get_buffer(f, (uint8_t *)s->mem, NE2000_MEM_SIZE); return 0; } Index: hw/pc.c =================================================================== RCS file: /sources/qemu/qemu/hw/pc.c,v retrieving revision 1.95 diff -u -p -r1.95 pc.c --- hw/pc.c 18 Nov 2007 08:46:58 -0000 1.95 +++ hw/pc.c 29 Nov 2007 23:50:01 -0000 @@ -548,7 +548,7 @@ static void load_linux(const char *kerne initrd_max = ram_size-ACPI_DATA_SIZE-1; /* kernel command line */ - pstrcpy(cmdline_addr, 4096, kernel_cmdline); + pstrcpy((char *)cmdline_addr, 4096, kernel_cmdline); if (protocol >= 0x202) { stl_p(header+0x228, cmdline_addr-phys_ram_base); Index: hw/pcnet.c =================================================================== RCS file: /sources/qemu/qemu/hw/pcnet.c,v retrieving revision 1.20 diff -u -p -r1.20 pcnet.c --- hw/pcnet.c 17 Nov 2007 17:14:45 -0000 1.20 +++ hw/pcnet.c 29 Nov 2007 23:50:01 -0000 @@ -350,8 +350,8 @@ static inline void pcnet_tmd_load(PCNetS } else { s->phys_mem_read(s->dma_opaque, addr, (void *)tmd, sizeof(*tmd), 0); le32_to_cpus(&tmd->tbadr); - le16_to_cpus(&tmd->length); - le16_to_cpus(&tmd->status); + le16_to_cpus((uint16_t *)&tmd->length); + le16_to_cpus((uint16_t *)&tmd->status); le32_to_cpus(&tmd->misc); le32_to_cpus(&tmd->res); if (BCR_SWSTYLE(s) == 3) { @@ -416,8 +416,8 @@ static inline void pcnet_rmd_load(PCNetS } else { s->phys_mem_read(s->dma_opaque, addr, (void *)rmd, sizeof(*rmd), 0); le32_to_cpus(&rmd->rbadr); - le16_to_cpus(&rmd->buf_length); - le16_to_cpus(&rmd->status); + le16_to_cpus((uint16_t *)&rmd->buf_length); + le16_to_cpus((uint16_t *)&rmd->status); le32_to_cpus(&rmd->msg_length); le32_to_cpus(&rmd->res); if (BCR_SWSTYLE(s) == 3) { @@ -1843,9 +1843,9 @@ static void pcnet_save(QEMUFile *f, void if (s->pci_dev) pci_device_save(s->pci_dev, f); - qemu_put_be32s(f, &s->rap); - qemu_put_be32s(f, &s->isr); - qemu_put_be32s(f, &s->lnkst); + qemu_put_be32s(f, (uint32_t*)&s->rap); + qemu_put_be32s(f, (uint32_t*)&s->isr); + qemu_put_be32s(f, (uint32_t*)&s->lnkst); qemu_put_be32s(f, &s->rdra); qemu_put_be32s(f, &s->tdra); qemu_put_buffer(f, s->prom, 16); @@ -1854,10 +1854,10 @@ static void pcnet_save(QEMUFile *f, void for (i = 0; i < 32; i++) qemu_put_be16s(f, &s->bcr[i]); qemu_put_be64s(f, &s->timer); - qemu_put_be32s(f, &s->xmit_pos); - qemu_put_be32s(f, &s->recv_pos); + qemu_put_be32s(f, (uint32_t*)&s->xmit_pos); + qemu_put_be32s(f, (uint32_t*)&s->recv_pos); qemu_put_buffer(f, s->buffer, 4096); - qemu_put_be32s(f, &s->tx_busy); + qemu_put_be32s(f, (uint32_t*)&s->tx_busy); qemu_put_timer(f, s->poll_timer); } @@ -1875,9 +1875,9 @@ static int pcnet_load(QEMUFile *f, void return ret; } - qemu_get_be32s(f, &s->rap); - qemu_get_be32s(f, &s->isr); - qemu_get_be32s(f, &s->lnkst); + qemu_get_be32s(f, (uint32_t*)&s->rap); + qemu_get_be32s(f, (uint32_t*)&s->isr); + qemu_get_be32s(f, (uint32_t*)&s->lnkst); qemu_get_be32s(f, &s->rdra); qemu_get_be32s(f, &s->tdra); qemu_get_buffer(f, s->prom, 16); @@ -1886,10 +1886,10 @@ static int pcnet_load(QEMUFile *f, void for (i = 0; i < 32; i++) qemu_get_be16s(f, &s->bcr[i]); qemu_get_be64s(f, &s->timer); - qemu_get_be32s(f, &s->xmit_pos); - qemu_get_be32s(f, &s->recv_pos); + qemu_get_be32s(f, (uint32_t*)&s->xmit_pos); + qemu_get_be32s(f, (uint32_t*)&s->recv_pos); qemu_get_buffer(f, s->buffer, 4096); - qemu_get_be32s(f, &s->tx_busy); + qemu_get_be32s(f, (uint32_t*)&s->tx_busy); qemu_get_timer(f, s->poll_timer); return 0; Index: hw/ps2.c =================================================================== RCS file: /sources/qemu/qemu/hw/ps2.c,v retrieving revision 1.9 diff -u -p -r1.9 ps2.c --- hw/ps2.c 17 Nov 2007 17:14:46 -0000 1.9 +++ hw/ps2.c 29 Nov 2007 23:50:01 -0000 @@ -470,19 +470,19 @@ static void ps2_reset(void *opaque) static void ps2_common_save (QEMUFile *f, PS2State *s) { - qemu_put_be32s (f, &s->write_cmd); - qemu_put_be32s (f, &s->queue.rptr); - qemu_put_be32s (f, &s->queue.wptr); - qemu_put_be32s (f, &s->queue.count); + qemu_put_be32s (f, (uint32_t *)&s->write_cmd); + qemu_put_be32s (f, (uint32_t *)&s->queue.rptr); + qemu_put_be32s (f, (uint32_t *)&s->queue.wptr); + qemu_put_be32s (f, (uint32_t *)&s->queue.count); qemu_put_buffer (f, s->queue.data, sizeof (s->queue.data)); } static void ps2_common_load (QEMUFile *f, PS2State *s) { - qemu_get_be32s (f, &s->write_cmd); - qemu_get_be32s (f, &s->queue.rptr); - qemu_get_be32s (f, &s->queue.wptr); - qemu_get_be32s (f, &s->queue.count); + qemu_get_be32s (f, (uint32_t *)&s->write_cmd); + qemu_get_be32s (f, (uint32_t *)&s->queue.rptr); + qemu_get_be32s (f, (uint32_t *)&s->queue.wptr); + qemu_get_be32s (f, (uint32_t *)&s->queue.count); qemu_get_buffer (f, s->queue.data, sizeof (s->queue.data)); } @@ -491,8 +491,8 @@ static void ps2_kbd_save(QEMUFile* f, vo PS2KbdState *s = (PS2KbdState*)opaque; ps2_common_save (f, &s->common); - qemu_put_be32s(f, &s->scan_enabled); - qemu_put_be32s(f, &s->translate); + qemu_put_be32s(f, (uint32_t *)&s->scan_enabled); + qemu_put_be32s(f, (uint32_t *)&s->translate); } static void ps2_mouse_save(QEMUFile* f, void* opaque) @@ -506,9 +506,9 @@ static void ps2_mouse_save(QEMUFile* f, qemu_put_8s(f, &s->mouse_wrap); qemu_put_8s(f, &s->mouse_type); qemu_put_8s(f, &s->mouse_detect_state); - qemu_put_be32s(f, &s->mouse_dx); - qemu_put_be32s(f, &s->mouse_dy); - qemu_put_be32s(f, &s->mouse_dz); + qemu_put_be32s(f, (uint32_t *)&s->mouse_dx); + qemu_put_be32s(f, (uint32_t *)&s->mouse_dy); + qemu_put_be32s(f, (uint32_t *)&s->mouse_dz); qemu_put_8s(f, &s->mouse_buttons); } @@ -520,8 +520,8 @@ static int ps2_kbd_load(QEMUFile* f, voi return -EINVAL; ps2_common_load (f, &s->common); - qemu_get_be32s(f, &s->scan_enabled); - qemu_get_be32s(f, &s->translate); + qemu_get_be32s(f, (uint32_t *)&s->scan_enabled); + qemu_get_be32s(f, (uint32_t *)&s->translate); return 0; } @@ -539,9 +539,9 @@ static int ps2_mouse_load(QEMUFile* f, v qemu_get_8s(f, &s->mouse_wrap); qemu_get_8s(f, &s->mouse_type); qemu_get_8s(f, &s->mouse_detect_state); - qemu_get_be32s(f, &s->mouse_dx); - qemu_get_be32s(f, &s->mouse_dy); - qemu_get_be32s(f, &s->mouse_dz); + qemu_get_be32s(f, (uint32_t *)&s->mouse_dx); + qemu_get_be32s(f, (uint32_t *)&s->mouse_dy); + qemu_get_be32s(f, (uint32_t *)&s->mouse_dz); qemu_get_8s(f, &s->mouse_buttons); return 0; } Index: hw/rtl8139.c =================================================================== RCS file: /sources/qemu/qemu/hw/rtl8139.c,v retrieving revision 1.16 diff -u -p -r1.16 rtl8139.c --- hw/rtl8139.c 18 Nov 2007 01:44:38 -0000 1.16 +++ hw/rtl8139.c 29 Nov 2007 23:50:01 -0000 @@ -3119,7 +3119,7 @@ static uint32_t rtl8139_mmio_readl(void static void rtl8139_save(QEMUFile* f,void* opaque) { RTL8139State* s=(RTL8139State*)opaque; - int i; + unsigned int i; pci_device_save(s->pci_dev, f); @@ -3172,7 +3172,7 @@ static void rtl8139_save(QEMUFile* f,voi i = 0; qemu_put_be32s(f, &i); /* unused. */ qemu_put_buffer(f, s->macaddr, 6); - qemu_put_be32s(f, &s->rtl8139_mmio_io_addr); + qemu_put_be32s(f, (uint32_t *)&s->rtl8139_mmio_io_addr); qemu_put_be32s(f, &s->currTxDesc); qemu_put_be32s(f, &s->currCPlusRxDesc); @@ -3184,7 +3184,7 @@ static void rtl8139_save(QEMUFile* f,voi { qemu_put_be16s(f, &s->eeprom.contents[i]); } - qemu_put_be32s(f, &s->eeprom.mode); + qemu_put_be32s(f, (uint32_t *)&s->eeprom.mode); qemu_put_be32s(f, &s->eeprom.tick); qemu_put_8s(f, &s->eeprom.address); qemu_put_be16s(f, &s->eeprom.input); @@ -3197,7 +3197,7 @@ static void rtl8139_save(QEMUFile* f,voi qemu_put_be32s(f, &s->TCTR); qemu_put_be32s(f, &s->TimerInt); - qemu_put_be64s(f, &s->TCTR_base); + qemu_put_be64s(f, (uint64_t*)&s->TCTR_base); RTL8139TallyCounters_save(f, &s->tally_counters); } @@ -3205,7 +3205,8 @@ static void rtl8139_save(QEMUFile* f,voi static int rtl8139_load(QEMUFile* f,void* opaque,int version_id) { RTL8139State* s=(RTL8139State*)opaque; - int i, ret; + unsigned int i; + int ret; /* just 2 versions for now */ if (version_id > 3) @@ -3266,7 +3267,7 @@ static int rtl8139_load(QEMUFile* f,void qemu_get_be32s(f, &i); /* unused. */ qemu_get_buffer(f, s->macaddr, 6); - qemu_get_be32s(f, &s->rtl8139_mmio_io_addr); + qemu_get_be32s(f, (uint32_t *)&s->rtl8139_mmio_io_addr); qemu_get_be32s(f, &s->currTxDesc); qemu_get_be32s(f, &s->currCPlusRxDesc); @@ -3278,7 +3279,7 @@ static int rtl8139_load(QEMUFile* f,void { qemu_get_be16s(f, &s->eeprom.contents[i]); } - qemu_get_be32s(f, &s->eeprom.mode); + qemu_get_be32s(f, (uint32_t *)&s->eeprom.mode); qemu_get_be32s(f, &s->eeprom.tick); qemu_get_8s(f, &s->eeprom.address); qemu_get_be16s(f, &s->eeprom.input); @@ -3294,7 +3295,7 @@ static int rtl8139_load(QEMUFile* f,void { qemu_get_be32s(f, &s->TCTR); qemu_get_be32s(f, &s->TimerInt); - qemu_get_be64s(f, &s->TCTR_base); + qemu_get_be64s(f, (uint64_t*)&s->TCTR_base); RTL8139TallyCounters_load(f, &s->tally_counters); } Index: hw/sb16.c =================================================================== RCS file: /sources/qemu/qemu/hw/sb16.c,v retrieving revision 1.24 diff -u -p -r1.24 sb16.c --- hw/sb16.c 17 Nov 2007 17:14:47 -0000 1.24 +++ hw/sb16.c 29 Nov 2007 23:50:01 -0000 @@ -1257,29 +1257,29 @@ static void SB_save (QEMUFile *f, void * { SB16State *s = opaque; - qemu_put_be32s (f, &s->irq); - qemu_put_be32s (f, &s->dma); - qemu_put_be32s (f, &s->hdma); - qemu_put_be32s (f, &s->port); - qemu_put_be32s (f, &s->ver); - qemu_put_be32s (f, &s->in_index); - qemu_put_be32s (f, &s->out_data_len); - qemu_put_be32s (f, &s->fmt_stereo); - qemu_put_be32s (f, &s->fmt_signed); - qemu_put_be32s (f, &s->fmt_bits); + qemu_put_be32s (f, (uint32_t *)&s->irq); + qemu_put_be32s (f, (uint32_t *)&s->dma); + qemu_put_be32s (f, (uint32_t *)&s->hdma); + qemu_put_be32s (f, (uint32_t *)&s->port); + qemu_put_be32s (f, (uint32_t *)&s->ver); + qemu_put_be32s (f, (uint32_t *)&s->in_index); + qemu_put_be32s (f, (uint32_t *)&s->out_data_len); + qemu_put_be32s (f, (uint32_t *)&s->fmt_stereo); + qemu_put_be32s (f, (uint32_t *)&s->fmt_signed); + qemu_put_be32s (f, (uint32_t *)&s->fmt_bits); qemu_put_be32s (f, &s->fmt); - qemu_put_be32s (f, &s->dma_auto); - qemu_put_be32s (f, &s->block_size); - qemu_put_be32s (f, &s->fifo); - qemu_put_be32s (f, &s->freq); - qemu_put_be32s (f, &s->time_const); - qemu_put_be32s (f, &s->speaker); - qemu_put_be32s (f, &s->needed_bytes); - qemu_put_be32s (f, &s->cmd); - qemu_put_be32s (f, &s->use_hdma); - qemu_put_be32s (f, &s->highspeed); - qemu_put_be32s (f, &s->can_write); - qemu_put_be32s (f, &s->v2x6); + qemu_put_be32s (f, (uint32_t *)&s->dma_auto); + qemu_put_be32s (f, (uint32_t *)&s->block_size); + qemu_put_be32s (f, (uint32_t *)&s->fifo); + qemu_put_be32s (f, (uint32_t *)&s->freq); + qemu_put_be32s (f, (uint32_t *)&s->time_const); + qemu_put_be32s (f, (uint32_t *)&s->speaker); + qemu_put_be32s (f, (uint32_t *)&s->needed_bytes); + qemu_put_be32s (f, (uint32_t *)&s->cmd); + qemu_put_be32s (f, (uint32_t *)&s->use_hdma); + qemu_put_be32s (f, (uint32_t *)&s->highspeed); + qemu_put_be32s (f, (uint32_t *)&s->can_write); + qemu_put_be32s (f, (uint32_t *)&s->v2x6); qemu_put_8s (f, &s->csp_param); qemu_put_8s (f, &s->csp_value); @@ -1288,21 +1288,21 @@ static void SB_save (QEMUFile *f, void * qemu_put_buffer (f, s->csp_regs, 256); qemu_put_8s (f, &s->csp_index); qemu_put_buffer (f, s->csp_reg83, 4); - qemu_put_be32s (f, &s->csp_reg83r); - qemu_put_be32s (f, &s->csp_reg83w); + qemu_put_be32s (f, (uint32_t *)&s->csp_reg83r); + qemu_put_be32s (f, (uint32_t *)&s->csp_reg83w); qemu_put_buffer (f, s->in2_data, sizeof (s->in2_data)); qemu_put_buffer (f, s->out_data, sizeof (s->out_data)); qemu_put_8s (f, &s->test_reg); qemu_put_8s (f, &s->last_read_byte); - qemu_put_be32s (f, &s->nzero); - qemu_put_be32s (f, &s->left_till_irq); - qemu_put_be32s (f, &s->dma_running); - qemu_put_be32s (f, &s->bytes_per_second); - qemu_put_be32s (f, &s->align); + qemu_put_be32s (f, (uint32_t *)&s->nzero); + qemu_put_be32s (f, (uint32_t *)&s->left_till_irq); + qemu_put_be32s (f, (uint32_t *)&s->dma_running); + qemu_put_be32s (f, (uint32_t *)&s->bytes_per_second); + qemu_put_be32s (f, (uint32_t *)&s->align); - qemu_put_be32s (f, &s->mixer_nreg); + qemu_put_be32s (f, (uint32_t *)&s->mixer_nreg); qemu_put_buffer (f, s->mixer_regs, 256); } @@ -1314,29 +1314,29 @@ static int SB_load (QEMUFile *f, void *o return -EINVAL; } - qemu_get_be32s (f, &s->irq); - qemu_get_be32s (f, &s->dma); - qemu_get_be32s (f, &s->hdma); - qemu_get_be32s (f, &s->port); - qemu_get_be32s (f, &s->ver); - qemu_get_be32s (f, &s->in_index); - qemu_get_be32s (f, &s->out_data_len); - qemu_get_be32s (f, &s->fmt_stereo); - qemu_get_be32s (f, &s->fmt_signed); - qemu_get_be32s (f, &s->fmt_bits); + qemu_get_be32s (f, (uint32_t *)&s->irq); + qemu_get_be32s (f, (uint32_t *)&s->dma); + qemu_get_be32s (f, (uint32_t *)&s->hdma); + qemu_get_be32s (f, (uint32_t *)&s->port); + qemu_get_be32s (f, (uint32_t *)&s->ver); + qemu_get_be32s (f, (uint32_t *)&s->in_index); + qemu_get_be32s (f, (uint32_t *)&s->out_data_len); + qemu_get_be32s (f, (uint32_t *)&s->fmt_stereo); + qemu_get_be32s (f, (uint32_t *)&s->fmt_signed); + qemu_get_be32s (f, (uint32_t *)&s->fmt_bits); qemu_get_be32s (f, &s->fmt); - qemu_get_be32s (f, &s->dma_auto); - qemu_get_be32s (f, &s->block_size); - qemu_get_be32s (f, &s->fifo); - qemu_get_be32s (f, &s->freq); - qemu_get_be32s (f, &s->time_const); - qemu_get_be32s (f, &s->speaker); - qemu_get_be32s (f, &s->needed_bytes); - qemu_get_be32s (f, &s->cmd); - qemu_get_be32s (f, &s->use_hdma); - qemu_get_be32s (f, &s->highspeed); - qemu_get_be32s (f, &s->can_write); - qemu_get_be32s (f, &s->v2x6); + qemu_get_be32s (f, (uint32_t *)&s->dma_auto); + qemu_get_be32s (f, (uint32_t *)&s->block_size); + qemu_get_be32s (f, (uint32_t *)&s->fifo); + qemu_get_be32s (f, (uint32_t *)&s->freq); + qemu_get_be32s (f, (uint32_t *)&s->time_const); + qemu_get_be32s (f, (uint32_t *)&s->speaker); + qemu_get_be32s (f, (uint32_t *)&s->needed_bytes); + qemu_get_be32s (f, (uint32_t *)&s->cmd); + qemu_get_be32s (f, (uint32_t *)&s->use_hdma); + qemu_get_be32s (f, (uint32_t *)&s->highspeed); + qemu_get_be32s (f, (uint32_t *)&s->can_write); + qemu_get_be32s (f, (uint32_t *)&s->v2x6); qemu_get_8s (f, &s->csp_param); qemu_get_8s (f, &s->csp_value); @@ -1345,21 +1345,21 @@ static int SB_load (QEMUFile *f, void *o qemu_get_buffer (f, s->csp_regs, 256); qemu_get_8s (f, &s->csp_index); qemu_get_buffer (f, s->csp_reg83, 4); - qemu_get_be32s (f, &s->csp_reg83r); - qemu_get_be32s (f, &s->csp_reg83w); + qemu_get_be32s (f, (uint32_t *)&s->csp_reg83r); + qemu_get_be32s (f, (uint32_t *)&s->csp_reg83w); qemu_get_buffer (f, s->in2_data, sizeof (s->in2_data)); qemu_get_buffer (f, s->out_data, sizeof (s->out_data)); qemu_get_8s (f, &s->test_reg); qemu_get_8s (f, &s->last_read_byte); - qemu_get_be32s (f, &s->nzero); - qemu_get_be32s (f, &s->left_till_irq); - qemu_get_be32s (f, &s->dma_running); - qemu_get_be32s (f, &s->bytes_per_second); - qemu_get_be32s (f, &s->align); + qemu_get_be32s (f, (uint32_t *)&s->nzero); + qemu_get_be32s (f, (uint32_t *)&s->left_till_irq); + qemu_get_be32s (f, (uint32_t *)&s->dma_running); + qemu_get_be32s (f, (uint32_t *)&s->bytes_per_second); + qemu_get_be32s (f, (uint32_t *)&s->align); - qemu_get_be32s (f, &s->mixer_nreg); + qemu_get_be32s (f, (uint32_t *)&s->mixer_nreg); qemu_get_buffer (f, s->mixer_regs, 256); if (s->voice) { Index: hw/sd.c =================================================================== RCS file: /sources/qemu/qemu/hw/sd.c,v retrieving revision 1.10 diff -u -p -r1.10 sd.c --- hw/sd.c 25 Nov 2007 18:46:17 -0000 1.10 +++ hw/sd.c 29 Nov 2007 23:50:01 -0000 @@ -353,7 +353,7 @@ static void sd_reset(SDState *sd, BlockD uint32_t size; uint64_t sect; - bdrv_get_geometry(bdrv, §); + bdrv_get_geometry(bdrv, (int64_t *)§); sect <<= 9; if (sect > 0x40000000) Index: hw/usb-uhci.c =================================================================== RCS file: /sources/qemu/qemu/hw/usb-uhci.c,v retrieving revision 1.22 diff -u -p -r1.22 usb-uhci.c --- hw/usb-uhci.c 17 Nov 2007 17:14:50 -0000 1.22 +++ hw/usb-uhci.c 29 Nov 2007 23:50:01 -0000 @@ -508,7 +508,7 @@ static void uhci_async_complete_packet(U 0 if TD successful 1 if TD unsuccessful or inactive */ -static int uhci_handle_td(UHCIState *s, UHCI_TD *td, int *int_mask, +static int uhci_handle_td(UHCIState *s, UHCI_TD *td, uint32_t *int_mask, int completion) { uint8_t pid; @@ -733,8 +733,8 @@ static void uhci_frame_timer(void *opaqu { UHCIState *s = opaque; int64_t expire_time; - uint32_t frame_addr, link, old_td_ctrl, val; - int int_mask, cnt, ret; + uint32_t frame_addr, link, old_td_ctrl, val, int_mask; + int cnt, ret; UHCI_TD td; UHCI_QH qh; uint32_t old_async_qh; Index: hw/vga.c =================================================================== RCS file: /sources/qemu/qemu/hw/vga.c,v retrieving revision 1.58 diff -u -p -r1.58 vga.c --- hw/vga.c 17 Nov 2007 17:14:50 -0000 1.58 +++ hw/vga.c 29 Nov 2007 23:50:01 -0000 @@ -1687,12 +1687,12 @@ static void vga_save(QEMUFile *f, void * qemu_put_buffer(f, s->gr, 16); qemu_put_8s(f, &s->ar_index); qemu_put_buffer(f, s->ar, 21); - qemu_put_be32s(f, &s->ar_flip_flop); + qemu_put_be32s(f, (uint32_t*)&s->ar_flip_flop); qemu_put_8s(f, &s->cr_index); qemu_put_buffer(f, s->cr, 256); qemu_put_8s(f, &s->msr); qemu_put_8s(f, &s->fcr); - qemu_put_8s(f, &s->st00); + qemu_put_8s(f, (uint8_t *)&s->st00); qemu_put_8s(f, &s->st01); qemu_put_8s(f, &s->dac_state); @@ -1702,7 +1702,7 @@ static void vga_save(QEMUFile *f, void * qemu_put_buffer(f, s->dac_cache, 3); qemu_put_buffer(f, s->palette, 768); - qemu_put_be32s(f, &s->bank_offset); + qemu_put_be32s(f, (uint32_t *)&s->bank_offset); #ifdef CONFIG_BOCHS_VBE qemu_put_byte(f, 1); qemu_put_be16s(f, &s->vbe_index); @@ -1737,7 +1737,7 @@ static int vga_load(QEMUFile *f, void *o qemu_get_buffer(f, s->gr, 16); qemu_get_8s(f, &s->ar_index); qemu_get_buffer(f, s->ar, 21); - qemu_get_be32s(f, &s->ar_flip_flop); + qemu_get_be32s(f, (uint32_t*)&s->ar_flip_flop); qemu_get_8s(f, &s->cr_index); qemu_get_buffer(f, s->cr, 256); qemu_get_8s(f, &s->msr); @@ -1752,7 +1752,7 @@ static int vga_load(QEMUFile *f, void *o qemu_get_buffer(f, s->dac_cache, 3); qemu_get_buffer(f, s->palette, 768); - qemu_get_be32s(f, &s->bank_offset); + qemu_get_be32s(f, (uint32_t *)&s->bank_offset); is_vbe = qemu_get_byte(f); #ifdef CONFIG_BOCHS_VBE if (!is_vbe) Index: hw/vmware_vga.c =================================================================== RCS file: /sources/qemu/qemu/hw/vmware_vga.c,v retrieving revision 1.4 diff -u -p -r1.4 vmware_vga.c --- hw/vmware_vga.c 17 Nov 2007 17:14:50 -0000 1.4 +++ hw/vmware_vga.c 29 Nov 2007 23:50:01 -0000 @@ -1028,41 +1028,41 @@ static CPUWriteMemoryFunc *vmsvga_vram_w static void vmsvga_save(struct vmsvga_state_s *s, QEMUFile *f) { - qemu_put_be32s(f, &s->depth); - qemu_put_be32s(f, &s->enable); - qemu_put_be32s(f, &s->config); - qemu_put_be32s(f, &s->cursor.id); - qemu_put_be32s(f, &s->cursor.x); - qemu_put_be32s(f, &s->cursor.y); - qemu_put_be32s(f, &s->cursor.on); - qemu_put_be32s(f, &s->index); + qemu_put_be32s(f, (uint32_t *)&s->depth); + qemu_put_be32s(f, (uint32_t *)&s->enable); + qemu_put_be32s(f, (uint32_t *)&s->config); + qemu_put_be32s(f, (uint32_t *)&s->cursor.id); + qemu_put_be32s(f, (uint32_t *)&s->cursor.x); + qemu_put_be32s(f, (uint32_t *)&s->cursor.y); + qemu_put_be32s(f, (uint32_t *)&s->cursor.on); + qemu_put_be32s(f, (uint32_t *)&s->index); qemu_put_buffer(f, (uint8_t *) s->scratch, s->scratch_size * 4); - qemu_put_be32s(f, &s->new_width); - qemu_put_be32s(f, &s->new_height); + qemu_put_be32s(f, (uint32_t *)&s->new_width); + qemu_put_be32s(f, (uint32_t *)&s->new_height); qemu_put_be32s(f, &s->guest); qemu_put_be32s(f, &s->svgaid); - qemu_put_be32s(f, &s->syncing); - qemu_put_be32s(f, &s->fb_size); + qemu_put_be32s(f, (uint32_t *)&s->syncing); + qemu_put_be32s(f, (uint32_t *)&s->fb_size); } static int vmsvga_load(struct vmsvga_state_s *s, QEMUFile *f) { int depth; - qemu_get_be32s(f, &depth); - qemu_get_be32s(f, &s->enable); - qemu_get_be32s(f, &s->config); - qemu_get_be32s(f, &s->cursor.id); - qemu_get_be32s(f, &s->cursor.x); - qemu_get_be32s(f, &s->cursor.y); - qemu_get_be32s(f, &s->cursor.on); - qemu_get_be32s(f, &s->index); + qemu_get_be32s(f, (uint32_t *)&depth); + qemu_get_be32s(f, (uint32_t *)&s->enable); + qemu_get_be32s(f, (uint32_t *)&s->config); + qemu_get_be32s(f, (uint32_t *)&s->cursor.id); + qemu_get_be32s(f, (uint32_t *)&s->cursor.x); + qemu_get_be32s(f, (uint32_t *)&s->cursor.y); + qemu_get_be32s(f, (uint32_t *)&s->cursor.on); + qemu_get_be32s(f, (uint32_t *)&s->index); qemu_get_buffer(f, (uint8_t *) s->scratch, s->scratch_size * 4); - qemu_get_be32s(f, &s->new_width); - qemu_get_be32s(f, &s->new_height); + qemu_get_be32s(f, (uint32_t *)&s->new_width); + qemu_get_be32s(f, (uint32_t *)&s->new_height); qemu_get_be32s(f, &s->guest); qemu_get_be32s(f, &s->svgaid); - qemu_get_be32s(f, &s->syncing); - qemu_get_be32s(f, &s->fb_size); + qemu_get_be32s(f, (uint32_t *)&s->syncing); + qemu_get_be32s(f, (uint32_t *)&s->fb_size); if (s->enable && depth != s->depth) { printf("%s: need colour depth of %i bits to resume operation.\n",