Merge branch 'master' of git://git.qemu.org/qemu into qom-cpu

Adapt header include paths.

Signed-off-by: Andreas Färber <afaerber@suse.de>

diff --cc MAINTAINERS
Simple merge

diff --cc hw/Makefile.objs
Simple merge

diff --cc hw/alpha_dp264.c
Simple merge

diff --cc hw/alpha_sys.h
Simple merge

diff --cc hw/alpha_typhoon.c
Simple merge

diff --cc hw/kvm/apic.c
Simple merge

diff --cc hw/kvm/clock.c
Simple merge

diff --cc hw/ppc.c
Simple merge

diff --cc hw/ppc.h
index ec33f9c,17005c7..e73ae83
--- 1/hw/ppc.h
--- 2/hw/ppc.h
+++ b/hw/ppc.h
@@@ -1,4 -1,7 +1,7 @@@
 -void ppc_set_irq (CPUPPCState *env, int n_IRQ, int level);
+ #ifndef HW_PPC_H
+ #define HW_PPC_H 1
+ 
 +void ppc_set_irq(PowerPCCPU *cpu, int n_IRQ, int level);
  
  /* PowerPC hardware exceptions management helpers */
  typedef void (*clk_setup_cb)(void *opaque, uint32_t freq);
@@@ -89,4 -92,6 +92,6 @@@ enum 
  #define PPC_SERIAL_MM_BAUDBASE 399193
  
  /* ppc_booke.c */
 -void ppc_booke_timers_init(CPUPPCState *env, uint32_t freq, uint32_t flags);
 +void ppc_booke_timers_init(PowerPCCPU *cpu, uint32_t freq, uint32_t flags);
+ 
+ #endif

diff --cc hw/ppc/e500.c
Simple merge

diff --cc hw/ppc405_uc.c
Simple merge

diff --cc hw/ppc440_bamboo.c
Simple merge

diff --cc hw/ppc4xx.h
index 5d891ae,2b96d47..59dba9e
--- 1/hw/ppc4xx.h
--- 2/hw/ppc4xx.h
+++ b/hw/ppc4xx.h
@@@ -25,12 -25,12 +25,12 @@@
  #if !defined(PPC_4XX_H)
  #define PPC_4XX_H
  
- #include "pci.h"
+ #include "pci/pci.h"
  
  /* PowerPC 4xx core initialization */
 -CPUPPCState *ppc4xx_init (const char *cpu_model,
 -                       clk_setup_t *cpu_clk, clk_setup_t *tb_clk,
 -                       uint32_t sysclk);
 +PowerPCCPU *ppc4xx_init(const char *cpu_model,
 +                        clk_setup_t *cpu_clk, clk_setup_t *tb_clk,
 +                        uint32_t sysclk);
  
  /* PowerPC 4xx universal interrupt controller */
  enum {

diff --cc hw/ppc4xx_devs.c
Simple merge

diff --cc hw/ppc_booke.c
Simple merge

diff --cc hw/qdev-properties-system.c
index 86b4cf6,0000000..c73c713
mode 100644,000000..100644
--- 1/hw/qdev-properties-system.c
--- /dev/null
+++ b/hw/qdev-properties-system.c
@@@ -1,357 -1,0 +1,358 @@@
- #include "net.h"
 +/*
 + * qdev property parsing and global properties
 + * (parts specific for qemu-system-*)
 + *
 + * This file is based on code from hw/qdev-properties.c from
 + * commit 074a86fccd185616469dfcdc0e157f438aebba18,
 + * Copyright (c) Gerd Hoffmann <kraxel@redhat.com> and other contributors.
 + *
 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
 + * See the COPYING file in the top-level directory.
 + */
 +
- #include "qerror.h"
- #include "blockdev.h"
++#include "net/net.h"
 +#include "qdev.h"
- #include "qapi/qapi-visit-core.h"
++#include "qapi/qmp/qerror.h"
++#include "sysemu/blockdev.h"
 +#include "hw/block-common.h"
 +#include "net/hub.h"
++#include "qapi/visitor.h"
++#include "char/char.h"
 +
 +static void get_pointer(Object *obj, Visitor *v, Property *prop,
 +                        const char *(*print)(void *ptr),
 +                        const char *name, Error **errp)
 +{
 +    DeviceState *dev = DEVICE(obj);
 +    void **ptr = qdev_get_prop_ptr(dev, prop);
 +    char *p;
 +
 +    p = (char *) (*ptr ? print(*ptr) : "");
 +    visit_type_str(v, &p, name, errp);
 +}
 +
 +static void set_pointer(Object *obj, Visitor *v, Property *prop,
 +                        int (*parse)(DeviceState *dev, const char *str,
 +                                     void **ptr),
 +                        const char *name, Error **errp)
 +{
 +    DeviceState *dev = DEVICE(obj);
 +    Error *local_err = NULL;
 +    void **ptr = qdev_get_prop_ptr(dev, prop);
 +    char *str;
 +    int ret;
 +
 +    if (dev->state != DEV_STATE_CREATED) {
 +        error_set(errp, QERR_PERMISSION_DENIED);
 +        return;
 +    }
 +
 +    visit_type_str(v, &str, name, &local_err);
 +    if (local_err) {
 +        error_propagate(errp, local_err);
 +        return;
 +    }
 +    if (!*str) {
 +        g_free(str);
 +        *ptr = NULL;
 +        return;
 +    }
 +    ret = parse(dev, str, ptr);
 +    error_set_from_qdev_prop_error(errp, ret, dev, prop, str);
 +    g_free(str);
 +}
 +
 +/* --- drive --- */
 +
 +static int parse_drive(DeviceState *dev, const char *str, void **ptr)
 +{
 +    BlockDriverState *bs;
 +
 +    bs = bdrv_find(str);
 +    if (bs == NULL) {
 +        return -ENOENT;
 +    }
 +    if (bdrv_attach_dev(bs, dev) < 0) {
 +        return -EEXIST;
 +    }
 +    *ptr = bs;
 +    return 0;
 +}
 +
 +static void release_drive(Object *obj, const char *name, void *opaque)
 +{
 +    DeviceState *dev = DEVICE(obj);
 +    Property *prop = opaque;
 +    BlockDriverState **ptr = qdev_get_prop_ptr(dev, prop);
 +
 +    if (*ptr) {
 +        bdrv_detach_dev(*ptr, dev);
 +        blockdev_auto_del(*ptr);
 +    }
 +}
 +
 +static const char *print_drive(void *ptr)
 +{
 +    return bdrv_get_device_name(ptr);
 +}
 +
 +static void get_drive(Object *obj, Visitor *v, void *opaque,
 +                      const char *name, Error **errp)
 +{
 +    get_pointer(obj, v, opaque, print_drive, name, errp);
 +}
 +
 +static void set_drive(Object *obj, Visitor *v, void *opaque,
 +                      const char *name, Error **errp)
 +{
 +    set_pointer(obj, v, opaque, parse_drive, name, errp);
 +}
 +
 +PropertyInfo qdev_prop_drive = {
 +    .name  = "drive",
 +    .get   = get_drive,
 +    .set   = set_drive,
 +    .release = release_drive,
 +};
 +
 +/* --- character device --- */
 +
 +static int parse_chr(DeviceState *dev, const char *str, void **ptr)
 +{
 +    CharDriverState *chr = qemu_chr_find(str);
 +    if (chr == NULL) {
 +        return -ENOENT;
 +    }
 +    if (chr->avail_connections < 1) {
 +        return -EEXIST;
 +    }
 +    *ptr = chr;
 +    --chr->avail_connections;
 +    return 0;
 +}
 +
 +static void release_chr(Object *obj, const char *name, void *opaque)
 +{
 +    DeviceState *dev = DEVICE(obj);
 +    Property *prop = opaque;
 +    CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);
 +
 +    if (*ptr) {
 +        qemu_chr_add_handlers(*ptr, NULL, NULL, NULL, NULL);
 +    }
 +}
 +
 +
 +static const char *print_chr(void *ptr)
 +{
 +    CharDriverState *chr = ptr;
 +
 +    return chr->label ? chr->label : "";
 +}
 +
 +static void get_chr(Object *obj, Visitor *v, void *opaque,
 +                    const char *name, Error **errp)
 +{
 +    get_pointer(obj, v, opaque, print_chr, name, errp);
 +}
 +
 +static void set_chr(Object *obj, Visitor *v, void *opaque,
 +                    const char *name, Error **errp)
 +{
 +    set_pointer(obj, v, opaque, parse_chr, name, errp);
 +}
 +
 +PropertyInfo qdev_prop_chr = {
 +    .name  = "chr",
 +    .get   = get_chr,
 +    .set   = set_chr,
 +    .release = release_chr,
 +};
 +
 +/* --- netdev device --- */
 +
 +static int parse_netdev(DeviceState *dev, const char *str, void **ptr)
 +{
 +    NetClientState *netdev = qemu_find_netdev(str);
 +
 +    if (netdev == NULL) {
 +        return -ENOENT;
 +    }
 +    if (netdev->peer) {
 +        return -EEXIST;
 +    }
 +    *ptr = netdev;
 +    return 0;
 +}
 +
 +static const char *print_netdev(void *ptr)
 +{
 +    NetClientState *netdev = ptr;
 +
 +    return netdev->name ? netdev->name : "";
 +}
 +
 +static void get_netdev(Object *obj, Visitor *v, void *opaque,
 +                       const char *name, Error **errp)
 +{
 +    get_pointer(obj, v, opaque, print_netdev, name, errp);
 +}
 +
 +static void set_netdev(Object *obj, Visitor *v, void *opaque,
 +                       const char *name, Error **errp)
 +{
 +    set_pointer(obj, v, opaque, parse_netdev, name, errp);
 +}
 +
 +PropertyInfo qdev_prop_netdev = {
 +    .name  = "netdev",
 +    .get   = get_netdev,
 +    .set   = set_netdev,
 +};
 +
 +/* --- vlan --- */
 +
 +static int print_vlan(DeviceState *dev, Property *prop, char *dest, size_t len)
 +{
 +    NetClientState **ptr = qdev_get_prop_ptr(dev, prop);
 +
 +    if (*ptr) {
 +        int id;
 +        if (!net_hub_id_for_client(*ptr, &id)) {
 +            return snprintf(dest, len, "%d", id);
 +        }
 +    }
 +
 +    return snprintf(dest, len, "<null>");
 +}
 +
 +static void get_vlan(Object *obj, Visitor *v, void *opaque,
 +                     const char *name, Error **errp)
 +{
 +    DeviceState *dev = DEVICE(obj);
 +    Property *prop = opaque;
 +    NetClientState **ptr = qdev_get_prop_ptr(dev, prop);
 +    int32_t id = -1;
 +
 +    if (*ptr) {
 +        int hub_id;
 +        if (!net_hub_id_for_client(*ptr, &hub_id)) {
 +            id = hub_id;
 +        }
 +    }
 +
 +    visit_type_int32(v, &id, name, errp);
 +}
 +
 +static void set_vlan(Object *obj, Visitor *v, void *opaque,
 +                     const char *name, Error **errp)
 +{
 +    DeviceState *dev = DEVICE(obj);
 +    Property *prop = opaque;
 +    NetClientState **ptr = qdev_get_prop_ptr(dev, prop);
 +    Error *local_err = NULL;
 +    int32_t id;
 +    NetClientState *hubport;
 +
 +    if (dev->state != DEV_STATE_CREATED) {
 +        error_set(errp, QERR_PERMISSION_DENIED);
 +        return;
 +    }
 +
 +    visit_type_int32(v, &id, name, &local_err);
 +    if (local_err) {
 +        error_propagate(errp, local_err);
 +        return;
 +    }
 +    if (id == -1) {
 +        *ptr = NULL;
 +        return;
 +    }
 +
 +    hubport = net_hub_port_find(id);
 +    if (!hubport) {
 +        error_set(errp, QERR_INVALID_PARAMETER_VALUE,
 +                  name, prop->info->name);
 +        return;
 +    }
 +    *ptr = hubport;
 +}
 +
 +PropertyInfo qdev_prop_vlan = {
 +    .name  = "vlan",
 +    .print = print_vlan,
 +    .get   = get_vlan,
 +    .set   = set_vlan,
 +};
 +
 +int qdev_prop_set_drive(DeviceState *dev, const char *name,
 +                        BlockDriverState *value)
 +{
 +    Error *errp = NULL;
 +    const char *bdrv_name = value ? bdrv_get_device_name(value) : "";
 +    object_property_set_str(OBJECT(dev), bdrv_name,
 +                            name, &errp);
 +    if (errp) {
 +        qerror_report_err(errp);
 +        error_free(errp);
 +        return -1;
 +    }
 +    return 0;
 +}
 +
 +void qdev_prop_set_drive_nofail(DeviceState *dev, const char *name,
 +                                BlockDriverState *value)
 +{
 +    if (qdev_prop_set_drive(dev, name, value) < 0) {
 +        exit(1);
 +    }
 +}
 +void qdev_prop_set_chr(DeviceState *dev, const char *name,
 +                       CharDriverState *value)
 +{
 +    Error *errp = NULL;
 +    assert(!value || value->label);
 +    object_property_set_str(OBJECT(dev),
 +                            value ? value->label : "", name, &errp);
 +    assert_no_error(errp);
 +}
 +
 +void qdev_prop_set_netdev(DeviceState *dev, const char *name,
 +                          NetClientState *value)
 +{
 +    Error *errp = NULL;
 +    assert(!value || value->name);
 +    object_property_set_str(OBJECT(dev),
 +                            value ? value->name : "", name, &errp);
 +    assert_no_error(errp);
 +}
 +
 +void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd)
 +{
 +    qdev_prop_set_macaddr(dev, "mac", nd->macaddr.a);
 +    if (nd->netdev) {
 +        qdev_prop_set_netdev(dev, "netdev", nd->netdev);
 +    }
 +    if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
 +        object_property_find(OBJECT(dev), "vectors", NULL)) {
 +        qdev_prop_set_uint32(dev, "vectors", nd->nvectors);
 +    }
 +    nd->instantiated = 1;
 +}
 +
 +static int qdev_add_one_global(QemuOpts *opts, void *opaque)
 +{
 +    GlobalProperty *g;
 +
 +    g = g_malloc0(sizeof(*g));
 +    g->driver   = qemu_opt_get(opts, "driver");
 +    g->property = qemu_opt_get(opts, "property");
 +    g->value    = qemu_opt_get(opts, "value");
 +    qdev_prop_register_global(g);
 +    return 0;
 +}
 +
 +void qemu_add_globals(void)
 +{
 +    qemu_opts_foreach(qemu_find_opts("global"), qdev_add_one_global, NULL, 0);
 +}

diff --cc hw/qdev-properties.c
Simple merge

diff --cc hw/qdev.c
index fa0af21,c4a9857..f2c2484
--- 1/hw/qdev.c
--- 2/hw/qdev.c
+++ b/hw/qdev.c
@@@ -25,10 -25,11 +25,10 @@@
     inherit from a particular bus (e.g. PCI or I2C) rather than
     this API directly.  */
  
 -#include "net/net.h"
  #include "qdev.h"
- #include "sysemu.h"
- #include "error.h"
- #include "qapi/qapi-visit-core.h"
+ #include "sysemu/sysemu.h"
+ #include "qapi/error.h"
+ #include "qapi/visitor.h"
  
  int qdev_hotplug = 0;
  static bool qdev_hot_added = false;

diff --cc hw/s390-virtio-bus.c
Simple merge

diff --cc hw/spapr.c
Simple merge

diff --cc hw/virtex_ml507.c
Simple merge

diff --cc include/exec/cpu-common.h
index a62b6ea,4d4f8d4..2e5f11f
--- 1/cpu-common.h
--- 2/include/exec/cpu-common.h
+++ b/include/exec/cpu-common.h
@@@ -3,27 -3,15 +3,27 @@@
  
  /* CPU interfaces that are target independent.  */
  
- #include "hwaddr.h"
+ #include "exec/hwaddr.h"
  
  #ifndef NEED_CPU_H
- #include "poison.h"
+ #include "exec/poison.h"
  #endif
  
- #include "bswap.h"
- #include "qemu-queue.h"
+ #include "qemu/bswap.h"
+ #include "qemu/queue.h"
  
 +/**
 + * CPUListState:
 + * @cpu_fprintf: Print function.
 + * @file: File to print to using @cpu_fprint.
 + *
 + * State commonly used for iterating over CPU models.
 + */
 +typedef struct CPUListState {
 +    fprintf_function cpu_fprintf;
 +    FILE *file;
 +} CPUListState;
 +
  #if !defined(CONFIG_USER_ONLY)
  
  enum device_endian {

diff --cc include/exec/cpu-defs.h
Simple merge

diff --cc include/qom/cpu.h
Simple merge

diff --cc include/sysemu/kvm.h
Simple merge

diff --cc kvm-all.c
Simple merge

diff --cc target-alpha/cpu-qom.h
Simple merge

diff --cc target-alpha/cpu.c
index 59d8669,11a19eb..212a625
--- 1/target-alpha/cpu.c
--- 2/target-alpha/cpu.c
+++ b/target-alpha/cpu.c
@@@ -21,211 -21,8 +21,211 @@@
  
  #include "cpu.h"
  #include "qemu-common.h"
- #include "error.h"
++#include "qapi/error.h"
  
  
 +static void alpha_cpu_realize(Object *obj, Error **errp)
 +{
 +#ifndef CONFIG_USER_ONLY
 +    AlphaCPU *cpu = ALPHA_CPU(obj);
 +
 +    qemu_init_vcpu(&cpu->env);
 +#endif
 +}
 +
 +/* Sort alphabetically by type name. */
 +static gint alpha_cpu_list_compare(gconstpointer a, gconstpointer b)
 +{
 +    ObjectClass *class_a = (ObjectClass *)a;
 +    ObjectClass *class_b = (ObjectClass *)b;
 +    const char *name_a, *name_b;
 +
 +    name_a = object_class_get_name(class_a);
 +    name_b = object_class_get_name(class_b);
 +    return strcmp(name_a, name_b);
 +}
 +
 +static void alpha_cpu_list_entry(gpointer data, gpointer user_data)
 +{
 +    ObjectClass *oc = data;
 +    CPUListState *s = user_data;
 +
 +    (*s->cpu_fprintf)(s->file, "  %s\n",
 +                      object_class_get_name(oc));
 +}
 +
 +void alpha_cpu_list(FILE *f, fprintf_function cpu_fprintf)
 +{
 +    CPUListState s = {
 +        .file = f,
 +        .cpu_fprintf = cpu_fprintf,
 +    };
 +    GSList *list;
 +
 +    list = object_class_get_list(TYPE_ALPHA_CPU, false);
 +    list = g_slist_sort(list, alpha_cpu_list_compare);
 +    (*cpu_fprintf)(f, "Available CPUs:\n");
 +    g_slist_foreach(list, alpha_cpu_list_entry, &s);
 +    g_slist_free(list);
 +}
 +
 +/* Models */
 +
 +#define TYPE(model) model "-" TYPE_ALPHA_CPU
 +
 +typedef struct AlphaCPUAlias {
 +    const char *alias;
 +    const char *typename;
 +} AlphaCPUAlias;
 +
 +static const AlphaCPUAlias alpha_cpu_aliases[] = {
 +    { "21064",   TYPE("ev4") },
 +    { "21164",   TYPE("ev5") },
 +    { "21164a",  TYPE("ev56") },
 +    { "21164pc", TYPE("pca56") },
 +    { "21264",   TYPE("ev6") },
 +    { "21264a",  TYPE("ev67") },
 +};
 +
 +static ObjectClass *alpha_cpu_class_by_name(const char *cpu_model)
 +{
 +    ObjectClass *oc = NULL;
 +    char *typename;
 +    int i;
 +
 +    if (cpu_model == NULL) {
 +        return NULL;
 +    }
 +
 +    oc = object_class_by_name(cpu_model);
 +    if (oc != NULL) {
 +        return oc;
 +    }
 +
 +    for (i = 0; i < ARRAY_SIZE(alpha_cpu_aliases); i++) {
 +        if (strcmp(cpu_model, alpha_cpu_aliases[i].alias) == 0) {
 +            oc = object_class_by_name(alpha_cpu_aliases[i].typename);
 +            assert(oc != NULL);
 +            return oc;
 +        }
 +    }
 +
 +    typename = g_strdup_printf("%s-" TYPE_ALPHA_CPU, cpu_model);
 +    oc = object_class_by_name(typename);
 +    g_free(typename);
 +    return oc;
 +}
 +
 +AlphaCPU *cpu_alpha_init(const char *cpu_model)
 +{
 +    AlphaCPU *cpu;
 +    CPUAlphaState *env;
 +    ObjectClass *cpu_class;
 +
 +    cpu_class = alpha_cpu_class_by_name(cpu_model);
 +    if (cpu_class == NULL) {
 +        /* Default to ev67; no reason not to emulate insns by default.  */
 +        cpu_class = object_class_by_name(TYPE("ev67"));
 +    }
 +    cpu = ALPHA_CPU(object_new(object_class_get_name(cpu_class)));
 +    env = &cpu->env;
 +
 +    env->cpu_model_str = cpu_model;
 +
 +    alpha_cpu_realize(OBJECT(cpu), NULL);
 +    return cpu;
 +}
 +
 +static void ev4_cpu_initfn(Object *obj)
 +{
 +    AlphaCPU *cpu = ALPHA_CPU(obj);
 +    CPUAlphaState *env = &cpu->env;
 +
 +    env->implver = IMPLVER_2106x;
 +}
 +
 +static const TypeInfo ev4_cpu_type_info = {
 +    .name = TYPE("ev4"),
 +    .parent = TYPE_ALPHA_CPU,
 +    .instance_init = ev4_cpu_initfn,
 +};
 +
 +static void ev5_cpu_initfn(Object *obj)
 +{
 +    AlphaCPU *cpu = ALPHA_CPU(obj);
 +    CPUAlphaState *env = &cpu->env;
 +
 +    env->implver = IMPLVER_21164;
 +}
 +
 +static const TypeInfo ev5_cpu_type_info = {
 +    .name = TYPE("ev5"),
 +    .parent = TYPE_ALPHA_CPU,
 +    .instance_init = ev5_cpu_initfn,
 +};
 +
 +static void ev56_cpu_initfn(Object *obj)
 +{
 +    AlphaCPU *cpu = ALPHA_CPU(obj);
 +    CPUAlphaState *env = &cpu->env;
 +
 +    env->amask |= AMASK_BWX;
 +}
 +
 +static const TypeInfo ev56_cpu_type_info = {
 +    .name = TYPE("ev56"),
 +    .parent = TYPE("ev5"),
 +    .instance_init = ev56_cpu_initfn,
 +};
 +
 +static void pca56_cpu_initfn(Object *obj)
 +{
 +    AlphaCPU *cpu = ALPHA_CPU(obj);
 +    CPUAlphaState *env = &cpu->env;
 +
 +    env->amask |= AMASK_MVI;
 +}
 +
 +static const TypeInfo pca56_cpu_type_info = {
 +    .name = TYPE("pca56"),
 +    .parent = TYPE("ev56"),
 +    .instance_init = pca56_cpu_initfn,
 +};
 +
 +static void ev6_cpu_initfn(Object *obj)
 +{
 +    AlphaCPU *cpu = ALPHA_CPU(obj);
 +    CPUAlphaState *env = &cpu->env;
 +
 +    env->implver = IMPLVER_21264;
 +    env->amask = AMASK_BWX | AMASK_FIX | AMASK_MVI | AMASK_TRAP;
 +}
 +
 +static const TypeInfo ev6_cpu_type_info = {
 +    .name = TYPE("ev6"),
 +    .parent = TYPE_ALPHA_CPU,
 +    .instance_init = ev6_cpu_initfn,
 +};
 +
 +static void ev67_cpu_initfn(Object *obj)
 +{
 +    AlphaCPU *cpu = ALPHA_CPU(obj);
 +    CPUAlphaState *env = &cpu->env;
 +
 +    env->amask |= AMASK_CIX | AMASK_PREFETCH;
 +}
 +
 +static const TypeInfo ev67_cpu_type_info = {
 +    .name = TYPE("ev67"),
 +    .parent = TYPE("ev6"),
 +    .instance_init = ev67_cpu_initfn,
 +};
 +
 +static const TypeInfo ev68_cpu_type_info = {
 +    .name = TYPE("ev68"),
 +    .parent = TYPE("ev67"),
 +};
 +
  static void alpha_cpu_initfn(Object *obj)
  {
      AlphaCPU *cpu = ALPHA_CPU(obj);

diff --cc target-alpha/cpu.h
Simple merge

diff --cc target-alpha/sys_helper.c
Simple merge

diff --cc target-alpha/translate.c
index dc0c97c,3afc3c6..5cb40b7
--- 1/target-alpha/translate.c
--- 2/target-alpha/translate.c
+++ b/target-alpha/translate.c
@@@ -88,9 -88,9 +88,9 @@@ static TCGv cpu_usp
  /* register names */
  static char cpu_reg_names[10*4+21*5 + 10*5+21*6];
  
- #include "gen-icount.h"
+ #include "exec/gen-icount.h"
  
 -static void alpha_translate_init(void)
 +void alpha_translate_init(void)
  {
      int i;
      char *p;

diff --cc target-arm/helper.c
Simple merge

diff --cc target-i386/cpu.c
Simple merge

diff --cc target-i386/kvm.c
Simple merge

diff --cc target-m68k/helper.c
Simple merge

diff --cc target-ppc/kvm.c
Simple merge

diff --cc target-ppc/kvm_ppc.h
Simple merge

diff --cc target-s390x/cpu.h
Simple merge

diff --cc target-s390x/interrupt.c
Simple merge

diff --cc target-s390x/kvm.c
Simple merge

diff --cc target-s390x/misc_helper.c
Simple merge