qemu学习（二）————qemu中对处理器大小端的设置

最新推荐文章于 2024-07-26 17:29:41 发布
最新推荐文章于 2024-07-26 17:29:41 发布
阅读量8.6k 收藏 7
点赞数 1
分类专栏： 开源项目学习 QEMU
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/robinblog/article/details/8878767
版权

《一日二十四挨踢www.1024it.net》站文章在未特殊说明下默认为原创性文章。

在未有正式书面授权情况下，请勿转载。谢谢配合

 

 

 

 

 

 

/******************************************************************************
 * Copyright (c) 2011 IBM Corporation
 * All rights reserved.
 * This program and the accompanying materials
 * are made available under the terms of the BSD License
 * which accompanies this distribution, and is available at
 * http://www.opensource.org/licenses/bsd-license.php
 *
 * Contributors:
 *     IBM Corporation - initial implementation
 *****************************************************************************/

/*
 * Common byteorder (endianess) macros
 */

#ifndef BYTEORDER_H
#define BYTEORDER_H

static inline uint16_t
bswap_16 (uint16_t x)
{
    return ((x&0xff00) >> 8) | ((x&0xff) << 8);
}

static inline uint32_t
bswap_32 (uint32_t x)
{
    return bswap_16(x >> 16) | (bswap_16(x) << 16);
}

static inline uint64_t
bswap_64 (uint64_t x)
{
    return (uint64_t) bswap_32(x >> 32) | (uint64_t) bswap_32(x) << 32;
}


/* gcc defines __BIG_ENDIAN__ on big endian targets */
#ifdef __BIG_ENDIAN__

#define cpu_to_be16(x) (x)
#define cpu_to_be32(x) (x)
#define cpu_to_be64(x) (x)

#define be16_to_cpu(x) (x)
#define be32_to_cpu(x) (x)
#define be64_to_cpu(x) (x)

#define le16_to_cpu(x) bswap_16(x)
#define le32_to_cpu(x) bswap_32(x)
#define le64_to_cpu(x) bswap_64(x)

#define cpu_to_le16(x) bswap_16(x)
#define cpu_to_le32(x) bswap_32(x)
#define cpu_to_le64(x) bswap_64(x)

#else

#define cpu_to_be16(x) bswap_16(x)
#define cpu_to_be32(x) bswap_32(x)
#define cpu_to_be64(x) bswap_64(x)

#define be16_to_cpu(x) bswap_16(x)
#define be32_to_cpu(x) bswap_32(x)
#define be64_to_cpu(x) bswap_64(x)

#define le16_to_cpu(x) (x)
#define le32_to_cpu(x) (x)
#define le64_to_cpu(x) (x)

#define cpu_to_le16(x) (x)
#define cpu_to_le32(x) (x)
#define cpu_to_le64(x) (x)

#endif  /* __BIG_ENDIAN__ */

#endif  /* BYTEORDER_H */



上面的code存在于./roms/SLOF/include/byteorder.h中，用来控制字节顺序。


下面的三个函数，通过移位用算实现了16、32、64位整数的高低两部分的转换。（这里有个疑问，大小端是按照字节来布局的，还是按照整型数位数的一半？？？？）


static inline uint16_t
bswap_16 (uint16_t x)
{
    return ((x&0xff00) >> 8) | ((x&0xff) << 8);
}

static inline uint32_t
bswap_32 (uint32_t x)
{
    return bswap_16(x >> 16) | (bswap_16(x) << 16);
}

static inline uint64_t
bswap_64 (uint64_t x)
{
    return (uint64_t) bswap_32(x >> 32) | (uint64_t) bswap_32(x) << 32;
}



通过宏#ifdef __BIG_ENDIAN__来选择大端和小端。


********************************************************************************************************************************************************************

********************************************************************************************************************************************************************

前面提到了./roms/SLOF/include/byteorder.h里的字节序列，也提出了疑问。下面加入./include/qemu/bswap.h处关于大小端的定义（注意宏定义的if 和 else）： 


#ifndef BSWAP_H
#define BSWAP_H

#include "config-host.h"
#include <inttypes.h>
#include <limits.h>
#include "fpu/softfloat.h"

#ifdef CONFIG_MACHINE_BSWAP_H
# include <sys/endian.h>
# include <sys/types.h>
# include <machine/bswap.h>
#elif defined(CONFIG_BYTESWAP_H)
# include <byteswap.h>

static inline uint16_t bswap16(uint16_t x)
{
    return bswap_16(x);
}

static inline uint32_t bswap32(uint32_t x)
{
    return bswap_32(x);
}

static inline uint64_t bswap64(uint64_t x)
{
    return bswap_64(x);
}
# else
static inline uint16_t bswap16(uint16_t x)
{
    return (((x & 0x00ff) << 8) |
            ((x & 0xff00) >> 8));
}

static inline uint32_t bswap32(uint32_t x)
{
    return (((x & 0x000000ffU) << 24) |
            ((x & 0x0000ff00U) <<  8) |
            ((x & 0x00ff0000U) >>  8) |
            ((x & 0xff000000U) >> 24));
}

static inline uint64_t bswap64(uint64_t x)
{
    return (((x & 0x00000000000000ffULL) << 56) |
            ((x & 0x000000000000ff00ULL) << 40) |
            ((x & 0x0000000000ff0000ULL) << 24) |
            ((x & 0x00000000ff000000ULL) <<  8) |
            ((x & 0x000000ff00000000ULL) >>  8) |
            ((x & 0x0000ff0000000000ULL) >> 24) |
            ((x & 0x00ff000000000000ULL) >> 40) |
            ((x & 0xff00000000000000ULL) >> 56));
}
#endif /* ! CONFIG_MACHINE_BSWAP_H */

static inline void bswap16s(uint16_t *s)
{
    *s = bswap16(*s);
}

static inline void bswap32s(uint32_t *s)
{
    *s = bswap32(*s);
}

static inline void bswap64s(uint64_t *s)
{
    *s = bswap64(*s);
}

#if defined(HOST_WORDS_BIGENDIAN)
#define be_bswap(v, size) (v)
#define le_bswap(v, size) glue(bswap, size)(v)
#define be_bswaps(v, size)
#define le_bswaps(p, size) do { *p = glue(bswap, size)(*p); } while(0)
#else
#define le_bswap(v, size) (v)
#define be_bswap(v, size) glue(bswap, size)(v)
#define le_bswaps(v, size)
#define be_bswaps(p, size) do { *p = glue(bswap, size)(*p); } while(0)
#endif

#define CPU_CONVERT(endian, size, type)\
static inline type endian ## size ## _to_cpu(type v)\
{\
    return glue(endian, _bswap)(v, size);\
}\
\
static inline type cpu_to_ ## endian ## size(type v)\
{\
    return glue(endian, _bswap)(v, size);\
}\
\
static inline void endian ## size ## _to_cpus(type *p)\
{\
    glue(endian, _bswaps)(p, size);\
}\
\
static inline void cpu_to_ ## endian ## size ## s(type *p)\
{\
    glue(endian, _bswaps)(p, size);\
}\
\
static inline type endian ## size ## _to_cpup(const type *p)\
{\
    return glue(glue(endian, size), _to_cpu)(*p);\
}\
\
static inline void cpu_to_ ## endian ## size ## w(type *p, type v)\
{\
    *p = glue(glue(cpu_to_, endian), size)(v);\
}

CPU_CONVERT(be, 16, uint16_t)
CPU_CONVERT(be, 32, uint32_t)
CPU_CONVERT(be, 64, uint64_t)

CPU_CONVERT(le, 16, uint16_t)
CPU_CONVERT(le, 32, uint32_t)
CPU_CONVERT(le, 64, uint64_t)

/* len must be one of 1, 2, 4 */
static inline uint32_t qemu_bswap_len(uint32_t value, int len)
{
    return bswap32(value) >> (32 - 8 * len);
}

/* Unions for reinterpreting between floats and integers.  */

typedef union {
    float32 f;
    uint32_t l;
} CPU_FloatU;

typedef union {
    float64 d;
#if defined(HOST_WORDS_BIGENDIAN)
    struct {
        uint32_t upper;
        uint32_t lower;
    } l;
#else
    struct {
        uint32_t lower;
        uint32_t upper;
    } l;
#endif
    uint64_t ll;
} CPU_DoubleU;

typedef union {
     floatx80 d;
     struct {
         uint64_t lower;
         uint16_t upper;
     } l;
} CPU_LDoubleU;

typedef union {
    float128 q;
#if defined(HOST_WORDS_BIGENDIAN)
    struct {
        uint32_t upmost;
        uint32_t upper;
        uint32_t lower;
        uint32_t lowest;
    } l;
    struct {
        uint64_t upper;
        uint64_t lower;
    } ll;
#else
    struct {
        uint32_t lowest;
        uint32_t lower;
        uint32_t upper;
        uint32_t upmost;
    } l;
    struct {
        uint64_t lower;
        uint64_t upper;
    } ll;
#endif
} CPU_QuadU;

/* unaligned/endian-independent pointer access */

/*
 * the generic syntax is:
 *
 * load: ld{type}{sign}{size}{endian}_p(ptr)
 *
 * store: st{type}{size}{endian}_p(ptr, val)
 *
 * Note there are small differences with the softmmu access API!
 *
 * type is:
 * (empty): integer access
 *   f    : float access
 *
 * sign is:
 * (empty): for floats or 32 bit size
 *   u    : unsigned
 *   s    : signed
 *
 * size is:
 *   b: 8 bits
 *   w: 16 bits
 *   l: 32 bits
 *   q: 64 bits
 *
 * endian is:
 * (empty): host endian
 *   be   : big endian
 *   le   : little endian
 */

static inline int ldub_p(const void *ptr)
{
    return *(uint8_t *)ptr;
}

static inline int ldsb_p(const void *ptr)
{
    return *(int8_t *)ptr;
}

static inline void stb_p(void *ptr, int v)
{
    *(uint8_t *)ptr = v;
}

/* Any compiler worth its salt will turn these memcpy into native unaligned
   operations.  Thus we don't need to play games with packed attributes, or
   inline byte-by-byte stores.  */

static inline int lduw_p(const void *ptr)
{
    uint16_t r;
    memcpy(&r, ptr, sizeof(r));
    return r;
}

static inline int ldsw_p(const void *ptr)
{
    int16_t r;
    memcpy(&r, ptr, sizeof(r));
    return r;
}

static inline void stw_p(void *ptr, uint16_t v)
{
    memcpy(ptr, &v, sizeof(v));
}

static inline int ldl_p(const void *ptr)
{
    int32_t r;
    memcpy(&r, ptr, sizeof(r));
    return r;
}

static inline void stl_p(void *ptr, uint32_t v)
{
    memcpy(ptr, &v, sizeof(v));
}

static inline uint64_t ldq_p(const void *ptr)
{
    uint64_t r;
    memcpy(&r, ptr, sizeof(r));
    return r;
}

static inline void stq_p(void *ptr, uint64_t v)
{
    memcpy(ptr, &v, sizeof(v));
}

static inline int lduw_le_p(const void *ptr)
{
    return (uint16_t)le_bswap(lduw_p(ptr), 16);
}

static inline int ldsw_le_p(const void *ptr)
{
    return (int16_t)le_bswap(lduw_p(ptr), 16);
}

static inline int ldl_le_p(const void *ptr)
{
    return le_bswap(ldl_p(ptr), 32);
}

static inline uint64_t ldq_le_p(const void *ptr)
{
    return le_bswap(ldq_p(ptr), 64);
}

static inline void stw_le_p(void *ptr, int v)
{
    stw_p(ptr, le_bswap(v, 16));
}

static inline void stl_le_p(void *ptr, int v)
{
    stl_p(ptr, le_bswap(v, 32));
}

static inline void stq_le_p(void *ptr, uint64_t v)
{
    stq_p(ptr, le_bswap(v, 64));
}

/* float access */

static inline float32 ldfl_le_p(const void *ptr)
{
    CPU_FloatU u;
    u.l = ldl_le_p(ptr);
    return u.f;
}

static inline void stfl_le_p(void *ptr, float32 v)
{
    CPU_FloatU u;
    u.f = v;
    stl_le_p(ptr, u.l);
}

static inline float64 ldfq_le_p(const void *ptr)
{
    CPU_DoubleU u;
    u.ll = ldq_le_p(ptr);
    return u.d;
}

static inline void stfq_le_p(void *ptr, float64 v)
{
    CPU_DoubleU u;
    u.d = v;
    stq_le_p(ptr, u.ll);
}

static inline int lduw_be_p(const void *ptr)
{
    return (uint16_t)be_bswap(lduw_p(ptr), 16);
}

static inline int ldsw_be_p(const void *ptr)
{
    return (int16_t)be_bswap(lduw_p(ptr), 16);
}

static inline int ldl_be_p(const void *ptr)
{
    return be_bswap(ldl_p(ptr), 32);
}

static inline uint64_t ldq_be_p(const void *ptr)
{
    return be_bswap(ldq_p(ptr), 64);
}

static inline void stw_be_p(void *ptr, int v)
{
    stw_p(ptr, be_bswap(v, 16));
}

static inline void stl_be_p(void *ptr, int v)
{
    stl_p(ptr, be_bswap(v, 32));
}

static inline void stq_be_p(void *ptr, uint64_t v)
{
    stq_p(ptr, be_bswap(v, 64));
}

/* float access */

static inline float32 ldfl_be_p(const void *ptr)
{
    CPU_FloatU u;
    u.l = ldl_be_p(ptr);
    return u.f;
}

static inline void stfl_be_p(void *ptr, float32 v)
{
    CPU_FloatU u;
    u.f = v;
    stl_be_p(ptr, u.l);
}

static inline float64 ldfq_be_p(const void *ptr)
{
    CPU_DoubleU u;
    u.ll = ldq_be_p(ptr);
    return u.d;
}

static inline void stfq_be_p(void *ptr, float64 v)
{
    CPU_DoubleU u;
    u.d = v;
    stq_be_p(ptr, u.ll);
}

/* Legacy unaligned versions.  Note that we never had a complete set.  */

static inline void cpu_to_le16wu(uint16_t *p, uint16_t v)
{
    stw_le_p(p, v);
}

static inline void cpu_to_le32wu(uint32_t *p, uint32_t v)
{
    stl_le_p(p, v);
}

static inline uint16_t le16_to_cpupu(const uint16_t *p)
{
    return lduw_le_p(p);
}

static inline uint32_t le32_to_cpupu(const uint32_t *p)
{
    return ldl_le_p(p);
}

static inline uint32_t be32_to_cpupu(const uint32_t *p)
{
    return ldl_be_p(p);
}

static inline void cpu_to_be16wu(uint16_t *p, uint16_t v)
{
    stw_be_p(p, v);
}

static inline void cpu_to_be32wu(uint32_t *p, uint32_t v)
{
    stl_be_p(p, v);
}

static inline void cpu_to_be64wu(uint64_t *p, uint64_t v)
{
    stq_be_p(p, v);
}

static inline void cpu_to_32wu(uint32_t *p, uint32_t v)
{
    stl_p(p, v);
}

static inline unsigned long leul_to_cpu(unsigned long v)
{
    /* In order to break an include loop between here and
       qemu-common.h, don't rely on HOST_LONG_BITS.  */
#if ULONG_MAX == UINT32_MAX
    return le_bswap(v, 32);
#elif ULONG_MAX == UINT64_MAX
    return le_bswap(v, 64);
#else
# error Unknown sizeof long
#endif
}

#undef le_bswap
#undef be_bswap
#undef le_bswaps
#undef be_bswaps

#endif /* BSWAP_H */






IT山IT水
关注
专栏目录
QEMU源码全解析1 —— QEMU参数解析（1）
phmatthaus的专栏
07-02 1258
QEMU源码全解析1 —— QEMU参数解析（1）
QEMU源码全解析 —— PCI设备模拟（1）
phmatthaus的专栏
01-10 2002
QEMU源码全解析 —— PCI设备模拟（1）
qemu-system-aarch64 调试大端内核，开启RT_FULL，启动失败问题
于宸
08-26 2799
qemu-system-aarch64 来调试大端内核时，遇到以下几个问题，记录以下：   1、使用linux-4.9.84、linux-4.4.97内核 2、打入rt补丁。 3、配置CONFIG_BIG_ENDIAN，大端内核。 4、选择PREEMPT_LL时qemu可以启动。 5、选择PREEMPT_RT_FULL时，不能启动。 6、发现选择PREEMPT_RT_FULL时，伙伴...
关于驱动程序的可移植性
process的专栏
12-15 1629
差不多所有的linux内核设备驱动都可以运行在不止一种处理器上。这仅仅因为设备驱动作者遵循一些重要规则。这些规则包括使用合适的变量类型，而不是依赖于特定内存页大小，提防外部数据的大小端模式，设立合适的数据对齐并通过合适接口访问设备内存位置。本文解释了这些规则，展示了依据这些的重要性并给出了使用的例子。 内核内部数据类型 要牢记的其中一个重要的基本规则就是在写可移植代码时要注意你的变量有多大
Linux内核开发常用函数及其头文件
kanguolaikanguolaik的专栏
01-31 5997
一、protocol //protocol //-----include/linux/in.h IPPROTO_UDP INADDR_ANY struct sockaddr_in //-----include/linux/ip.h struct iphdr ip_hdr() //-----include/linux/udp.h struct udphdr ud
常见内核函数
weixin_48006170的博客
01-20 2885
container of 函数简介 linux内核中likely与unlikely likely和unlikely 参考/include/linux/compiler.h */ # define likely(x) __builtin_expect(!!(x), 1) # define unlikely(x) __builtin_expect(!!(x), 0) 两次 !! 翻转非逻辑值（比如1、2、3等数值，或某个指针等等）转化位逻辑值0或1，方便比较。 if分支跳转语句会降低cpu效率，lik
第二坑
coder
08-31 522
紧接下来，就是字符串转换，我觉得这个倒算个工具函数 void string2wstring( std::wstring & dest, const std::string &src ) {  dest.resize( src.size() );  for( std::string::size_type i = 0; i   dest[i]      = static_cast
QEMU源码全解析 —— CPU虚拟化（4）
phmatthaus的专栏
07-19 379
QEMU源码全解析 —— CPU虚拟化（4）
QEMU源码全解析 —— CPU虚拟化（3）
phmatthaus的专栏
07-18 439
QEMU源码全解析 —— CPU虚拟化（3）
QEMU源码全解析 —— CPU虚拟化（11）
最新发布
phmatthaus的专栏
07-26 452
QEMU源码全解析 —— CPU虚拟化（11）
设备驱动的兼容性，例如cpu_to_le16函数
热门推荐
bingqingsuimeng的专栏
08-27 1万+
中断管理 　　在2.1的开发中，有些Linux内部被修改了。新核心提供了对内部锁的很好的管理；通过使用几个细粒度的锁，而不是全局的锁，竞争条件被避免了，这样也获得了更好的性能----特别是SMP配置下。更细的锁机制的一个结果是intr_count不再存在了。2.1.34抛弃了这个全局变量，而布尔函数in_interrupt可以取而代之（这个函数从2.1.30开始存在）。目前，in_inter
cpu_to_le32()
Decisiveness的专栏
12-21 4204
http://www.csse.uwa.edu.au/~chris/uwasp/endian.html NAME Functions to manipulate the byte-ordering (the endianness) of captured data SYNOPSIS #include  uint16_t le16_to_cpu( uint16_t value );
Makefile:14: config-host.mak: No such file or directory
Think++
03-31 5939
Makefile:14: config-host.mak: No such file or directory Running configure for you... make: execvp: ./configure: Permission denied make: *** [config-host.mak] Error 127
configure配置安装详解【转】
Uaena的博客
08-02 4476
（转自：https://blog.csdn.net/u010977122/article/details/52959098） 由于最近项目需要在HMI层生成二维码，所以去网上找了第三方开源库。可是下载下来里面都是源码，没有动态库或者静态库，所以就需要自己去编译生成。源码库中只有一个configure的可运行得配置脚本，之前用过，没有详细了解，今天去网上查阅资料，以下是整理的一些心得笔记。 ...
C/C++中的大端和小端模式的说明、检测、转换与设置
John_Tito的博客
04-05 5964
C/C++中的大端和小端模式的说明、检测、转换与设置
htonl、ntohl、htons、ntohs函数实现
modi000的博客
03-12 850
转载：https://blog.csdn.net/lizhi200404520/article/details/7290193 typedef unsigned short int uint16; typedef unsigned long int uint32; // 短整型大小端互换 #define BigLittleSwap16(A) ((((uint16)(A) & 0xff00) >> 8) | \ .
le16_to_cpu()函数使用
kipdoudou的专栏
04-15 3316
因为之前需要处理一个__le16的数据，不知道怎么输出出来，才发现需要使用： u16 sc = le16_to_cpu(hdr->seq_ctrl); 来获取，之后使用%lu即可输出了，下边是网上搜来的比较官方的参考：有时间再看一下 http://www.csse.uwa.edu.au/~chris/uwasp/endian.html NAME Functions to manipul
imx6dl系统每次启动MAC地址都不一样
WXXGoodJob的博客
09-27 3108
  启动imx6dl，发现每次启动之后eth0 的mach地址都都是自动获取，导致每次启动都不一样，这个对于IP型（路由器，ip型影音设备，网络打印机，传真机等）设备来说，这是个致命的BUG，打印信息如下。 CAN device driver interface 2188000.ethernet supply phy not found, using dummy regulator pps ...
QEMU中自修改代码对效率的影响深度量化研究
QEMU，一个广泛使用的二进制翻译系统，由法国开发者开发，支持多种处理器架构间的模拟，如PPC、ARM、X86、MIPS、SPARC和X86_64。 研究中，作者选择QEMU作为实验平台，对比自修改代码与非自修改代码的执行情况。自...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值