Commit 4269c82b authored by Paolo Bonzini's avatar Paolo Bonzini
Browse files

exec: move memory access declarations to a common header, inline *_phys functions 



For now, this reduces the text size very slightly due to the newly-added
inlining:

   text size before: 9301965
   text size after: 9300645

Later, however, the declarations in include/exec/memory_ldst.inc.h will be
reused for the MemoryRegionCache slow path functions.

Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent 29de4ec1

include/exec/cpu-all.h

+30 −45
Original line number Diff line number Diff line
@@ -168,51 +168,36 @@ extern unsigned long reserved_va; 
#else



#include "exec/hwaddr.h"

uint32_t lduw_phys(AddressSpace *as, hwaddr addr);

uint32_t ldl_phys(AddressSpace *as, hwaddr addr);

uint64_t ldq_phys(AddressSpace *as, hwaddr addr);

void stl_phys_notdirty(AddressSpace *as, hwaddr addr, uint32_t val);

void stw_phys(AddressSpace *as, hwaddr addr, uint32_t val);

void stl_phys(AddressSpace *as, hwaddr addr, uint32_t val);

void stq_phys(AddressSpace *as, hwaddr addr, uint64_t val);



uint32_t address_space_lduw(AddressSpace *as, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

uint32_t address_space_ldl(AddressSpace *as, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

uint64_t address_space_ldq(AddressSpace *as, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stl_notdirty(AddressSpace *as, hwaddr addr, uint32_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stw(AddressSpace *as, hwaddr addr, uint32_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stl(AddressSpace *as, hwaddr addr, uint32_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stq(AddressSpace *as, hwaddr addr, uint64_t val,

                            MemTxAttrs attrs, MemTxResult *result);



uint32_t lduw_phys_cached(MemoryRegionCache *cache, hwaddr addr);

uint32_t ldl_phys_cached(MemoryRegionCache *cache, hwaddr addr);

uint64_t ldq_phys_cached(MemoryRegionCache *cache, hwaddr addr);

void stl_phys_notdirty_cached(MemoryRegionCache *cache, hwaddr addr, uint32_t val);

void stw_phys_cached(MemoryRegionCache *cache, hwaddr addr, uint32_t val);

void stl_phys_cached(MemoryRegionCache *cache, hwaddr addr, uint32_t val);

void stq_phys_cached(MemoryRegionCache *cache, hwaddr addr, uint64_t val);



uint32_t address_space_lduw_cached(MemoryRegionCache *cache, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

uint32_t address_space_ldl_cached(MemoryRegionCache *cache, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

uint64_t address_space_ldq_cached(MemoryRegionCache *cache, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stl_notdirty_cached(MemoryRegionCache *cache, hwaddr addr,

                            uint32_t val, MemTxAttrs attrs, MemTxResult *result);

void address_space_stw_cached(MemoryRegionCache *cache, hwaddr addr, uint32_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stl_cached(MemoryRegionCache *cache, hwaddr addr, uint32_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stq_cached(MemoryRegionCache *cache, hwaddr addr, uint64_t val,

                            MemTxAttrs attrs, MemTxResult *result);



#define SUFFIX

#define ARG1         as

#define ARG1_DECL    AddressSpace *as

#define TARGET_ENDIANNESS

#include "exec/memory_ldst.inc.h"



#define SUFFIX       _cached

#define ARG1         cache

#define ARG1_DECL    MemoryRegionCache *cache

#define TARGET_ENDIANNESS

#include "exec/memory_ldst.inc.h"



static inline void stl_phys_notdirty(AddressSpace *as, hwaddr addr, uint32_t val)

{

    address_space_stl_notdirty(as, addr, val,

                               MEMTXATTRS_UNSPECIFIED, NULL);

}



#define SUFFIX

#define ARG1         as

#define ARG1_DECL    AddressSpace *as

#define TARGET_ENDIANNESS

#include "exec/memory_ldst_phys.inc.h"



#define SUFFIX       _cached

#define ARG1         cache

#define ARG1_DECL    MemoryRegionCache *cache

#define TARGET_ENDIANNESS

#include "exec/memory_ldst_phys.inc.h"

#endif



/* page related stuff */

include/exec/memory.h

+44 −109
Original line number Diff line number Diff line
@@ -1676,49 +1676,16 @@ MemTxResult address_space_write(AddressSpace *as, hwaddr addr, 
 * @result: location to write the success/failure of the transaction;

 *   if NULL, this information is discarded

 */

uint32_t address_space_ldub(AddressSpace *as, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

uint32_t address_space_lduw_le(AddressSpace *as, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

uint32_t address_space_lduw_be(AddressSpace *as, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

uint32_t address_space_ldl_le(AddressSpace *as, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

uint32_t address_space_ldl_be(AddressSpace *as, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

uint64_t address_space_ldq_le(AddressSpace *as, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

uint64_t address_space_ldq_be(AddressSpace *as, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stb(AddressSpace *as, hwaddr addr, uint32_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stw_le(AddressSpace *as, hwaddr addr, uint32_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stw_be(AddressSpace *as, hwaddr addr, uint32_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stl_le(AddressSpace *as, hwaddr addr, uint32_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stl_be(AddressSpace *as, hwaddr addr, uint32_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stq_le(AddressSpace *as, hwaddr addr, uint64_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stq_be(AddressSpace *as, hwaddr addr, uint64_t val,

                            MemTxAttrs attrs, MemTxResult *result);



uint32_t ldub_phys(AddressSpace *as, hwaddr addr);

uint32_t lduw_le_phys(AddressSpace *as, hwaddr addr);

uint32_t lduw_be_phys(AddressSpace *as, hwaddr addr);

uint32_t ldl_le_phys(AddressSpace *as, hwaddr addr);

uint32_t ldl_be_phys(AddressSpace *as, hwaddr addr);

uint64_t ldq_le_phys(AddressSpace *as, hwaddr addr);

uint64_t ldq_be_phys(AddressSpace *as, hwaddr addr);

void stb_phys(AddressSpace *as, hwaddr addr, uint32_t val);

void stw_le_phys(AddressSpace *as, hwaddr addr, uint32_t val);

void stw_be_phys(AddressSpace *as, hwaddr addr, uint32_t val);

void stl_le_phys(AddressSpace *as, hwaddr addr, uint32_t val);

void stl_be_phys(AddressSpace *as, hwaddr addr, uint32_t val);

void stq_le_phys(AddressSpace *as, hwaddr addr, uint64_t val);

void stq_be_phys(AddressSpace *as, hwaddr addr, uint64_t val);



#define SUFFIX

#define ARG1         as

#define ARG1_DECL    AddressSpace *as

#include "exec/memory_ldst.inc.h"



#define SUFFIX

#define ARG1         as

#define ARG1_DECL    AddressSpace *as

#include "exec/memory_ldst_phys.inc.h"



struct MemoryRegionCache {

    hwaddr xlat;
@@ -1728,6 +1695,40 @@ struct MemoryRegionCache { 


#define MEMORY_REGION_CACHE_INVALID ((MemoryRegionCache) { .as = NULL })



/* address_space_ld*_cached: load from a cached #MemoryRegion

 * address_space_st*_cached: store into a cached #MemoryRegion

 *

 * These functions perform a load or store of the byte, word,

 * longword or quad to the specified address.  The address is

 * a physical address in the AddressSpace, but it must lie within

 * a #MemoryRegion that was mapped with address_space_cache_init.

 *

 * The _le suffixed functions treat the data as little endian;

 * _be indicates big endian; no suffix indicates "same endianness

 * as guest CPU".

 *

 * The "guest CPU endianness" accessors are deprecated for use outside

 * target-* code; devices should be CPU-agnostic and use either the LE

 * or the BE accessors.

 *

 * @cache: previously initialized #MemoryRegionCache to be accessed

 * @addr: address within the address space

 * @val: data value, for stores

 * @attrs: memory transaction attributes

 * @result: location to write the success/failure of the transaction;

 *   if NULL, this information is discarded

 */



#define SUFFIX       _cached

#define ARG1         cache

#define ARG1_DECL    MemoryRegionCache *cache

#include "exec/memory_ldst.inc.h"



#define SUFFIX       _cached

#define ARG1         cache

#define ARG1_DECL    MemoryRegionCache *cache

#include "exec/memory_ldst_phys.inc.h"



/* address_space_cache_init: prepare for repeated access to a physical

 * memory region

 *
@@ -1772,72 +1773,6 @@ void address_space_cache_invalidate(MemoryRegionCache *cache, 
 */

void address_space_cache_destroy(MemoryRegionCache *cache);



/* address_space_ld*_cached: load from a cached #MemoryRegion

 * address_space_st*_cached: store into a cached #MemoryRegion

 *

 * These functions perform a load or store of the byte, word,

 * longword or quad to the specified address.  The address is

 * a physical address in the AddressSpace, but it must lie within

 * a #MemoryRegion that was mapped with address_space_cache_init.

 *

 * The _le suffixed functions treat the data as little endian;

 * _be indicates big endian; no suffix indicates "same endianness

 * as guest CPU".

 *

 * The "guest CPU endianness" accessors are deprecated for use outside

 * target-* code; devices should be CPU-agnostic and use either the LE

 * or the BE accessors.

 *

 * @cache: previously initialized #MemoryRegionCache to be accessed

 * @addr: address within the address space

 * @val: data value, for stores

 * @attrs: memory transaction attributes

 * @result: location to write the success/failure of the transaction;

 *   if NULL, this information is discarded

 */

uint32_t address_space_ldub_cached(MemoryRegionCache *cache, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

uint32_t address_space_lduw_le_cached(MemoryRegionCache *cache, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

uint32_t address_space_lduw_be_cached(MemoryRegionCache *cache, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

uint32_t address_space_ldl_le_cached(MemoryRegionCache *cache, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

uint32_t address_space_ldl_be_cached(MemoryRegionCache *cache, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

uint64_t address_space_ldq_le_cached(MemoryRegionCache *cache, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

uint64_t address_space_ldq_be_cached(MemoryRegionCache *cache, hwaddr addr,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stb_cached(MemoryRegionCache *cache, hwaddr addr, uint32_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stw_le_cached(MemoryRegionCache *cache, hwaddr addr, uint32_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stw_be_cached(MemoryRegionCache *cache, hwaddr addr, uint32_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stl_le_cached(MemoryRegionCache *cache, hwaddr addr, uint32_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stl_be_cached(MemoryRegionCache *cache, hwaddr addr, uint32_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stq_le_cached(MemoryRegionCache *cache, hwaddr addr, uint64_t val,

                            MemTxAttrs attrs, MemTxResult *result);

void address_space_stq_be_cached(MemoryRegionCache *cache, hwaddr addr, uint64_t val,

                            MemTxAttrs attrs, MemTxResult *result);



uint32_t ldub_phys_cached(MemoryRegionCache *cache, hwaddr addr);

uint32_t lduw_le_phys_cached(MemoryRegionCache *cache, hwaddr addr);

uint32_t lduw_be_phys_cached(MemoryRegionCache *cache, hwaddr addr);

uint32_t ldl_le_phys_cached(MemoryRegionCache *cache, hwaddr addr);

uint32_t ldl_be_phys_cached(MemoryRegionCache *cache, hwaddr addr);

uint64_t ldq_le_phys_cached(MemoryRegionCache *cache, hwaddr addr);

uint64_t ldq_be_phys_cached(MemoryRegionCache *cache, hwaddr addr);

void stb_phys_cached(MemoryRegionCache *cache, hwaddr addr, uint32_t val);

void stw_le_phys_cached(MemoryRegionCache *cache, hwaddr addr, uint32_t val);

void stw_be_phys_cached(MemoryRegionCache *cache, hwaddr addr, uint32_t val);

void stl_le_phys_cached(MemoryRegionCache *cache, hwaddr addr, uint32_t val);

void stl_be_phys_cached(MemoryRegionCache *cache, hwaddr addr, uint32_t val);

void stq_le_phys_cached(MemoryRegionCache *cache, hwaddr addr, uint64_t val);

void stq_be_phys_cached(MemoryRegionCache *cache, hwaddr addr, uint64_t val);

/* address_space_get_iotlb_entry: translate an address into an IOTLB

 * entry. Should be called from an RCU critical section.

 */

include/exec/memory_ldst.inc.h

0 → 100644
+71 −0
Original line number Diff line number Diff line 
/*

 *  Physical memory access templates

 *

 *  Copyright (c) 2003 Fabrice Bellard

 *  Copyright (c) 2015 Linaro, Inc.

 *  Copyright (c) 2016 Red Hat, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, see <http://www.gnu.org/licenses/>.

 */



#ifdef TARGET_ENDIANNESS

extern uint32_t glue(address_space_lduw, SUFFIX)(ARG1_DECL,

    hwaddr addr, MemTxAttrs attrs, MemTxResult *result);

extern uint32_t glue(address_space_ldl, SUFFIX)(ARG1_DECL,

    hwaddr addr, MemTxAttrs attrs, MemTxResult *result);

extern uint64_t glue(address_space_ldq, SUFFIX)(ARG1_DECL,

    hwaddr addr, MemTxAttrs attrs, MemTxResult *result);

extern void glue(address_space_stl_notdirty, SUFFIX)(ARG1_DECL,

    hwaddr addr, uint32_t val, MemTxAttrs attrs, MemTxResult *result);

extern void glue(address_space_stw, SUFFIX)(ARG1_DECL,

    hwaddr addr, uint32_t val, MemTxAttrs attrs, MemTxResult *result);

extern void glue(address_space_stl, SUFFIX)(ARG1_DECL,

    hwaddr addr, uint32_t val, MemTxAttrs attrs, MemTxResult *result);

extern void glue(address_space_stq, SUFFIX)(ARG1_DECL,

    hwaddr addr, uint64_t val, MemTxAttrs attrs, MemTxResult *result);

#else

extern uint32_t glue(address_space_ldub, SUFFIX)(ARG1_DECL,

    hwaddr addr, MemTxAttrs attrs, MemTxResult *result);

extern uint32_t glue(address_space_lduw_le, SUFFIX)(ARG1_DECL,

    hwaddr addr, MemTxAttrs attrs, MemTxResult *result);

extern uint32_t glue(address_space_lduw_be, SUFFIX)(ARG1_DECL,

    hwaddr addr, MemTxAttrs attrs, MemTxResult *result);

extern uint32_t glue(address_space_ldl_le, SUFFIX)(ARG1_DECL,

    hwaddr addr, MemTxAttrs attrs, MemTxResult *result);

extern uint32_t glue(address_space_ldl_be, SUFFIX)(ARG1_DECL,

    hwaddr addr, MemTxAttrs attrs, MemTxResult *result);

extern uint64_t glue(address_space_ldq_le, SUFFIX)(ARG1_DECL,

    hwaddr addr, MemTxAttrs attrs, MemTxResult *result);

extern uint64_t glue(address_space_ldq_be, SUFFIX)(ARG1_DECL,

    hwaddr addr, MemTxAttrs attrs, MemTxResult *result);

extern void glue(address_space_stb, SUFFIX)(ARG1_DECL,

    hwaddr addr, uint32_t val, MemTxAttrs attrs, MemTxResult *result);

extern void glue(address_space_stw_le, SUFFIX)(ARG1_DECL,

    hwaddr addr, uint32_t val, MemTxAttrs attrs, MemTxResult *result);

extern void glue(address_space_stw_be, SUFFIX)(ARG1_DECL,

    hwaddr addr, uint32_t val, MemTxAttrs attrs, MemTxResult *result);

extern void glue(address_space_stl_le, SUFFIX)(ARG1_DECL,

    hwaddr addr, uint32_t val, MemTxAttrs attrs, MemTxResult *result);

extern void glue(address_space_stl_be, SUFFIX)(ARG1_DECL,

    hwaddr addr, uint32_t val, MemTxAttrs attrs, MemTxResult *result);

extern void glue(address_space_stq_le, SUFFIX)(ARG1_DECL,

    hwaddr addr, uint64_t val, MemTxAttrs attrs, MemTxResult *result);

extern void glue(address_space_stq_be, SUFFIX)(ARG1_DECL,

    hwaddr addr, uint64_t val, MemTxAttrs attrs, MemTxResult *result);

#endif



#undef ARG1_DECL

#undef ARG1

#undef SUFFIX

#undef TARGET_ENDIANNESS

include/exec/memory_ldst_phys.inc.h

0 → 100644
+147 −0
Original line number Diff line number Diff line 
/*

 *  Physical memory access templates

 *

 *  Copyright (c) 2003 Fabrice Bellard

 *  Copyright (c) 2015 Linaro, Inc.

 *  Copyright (c) 2016 Red Hat, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, see <http://www.gnu.org/licenses/>.

 */



#ifdef TARGET_ENDIANNESS

static inline uint32_t glue(ldl_phys, SUFFIX)(ARG1_DECL, hwaddr addr)

{

    return glue(address_space_ldl, SUFFIX)(ARG1, addr,

                                           MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline uint64_t glue(ldq_phys, SUFFIX)(ARG1_DECL, hwaddr addr)

{

    return glue(address_space_ldq, SUFFIX)(ARG1, addr,

                                           MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline uint32_t glue(lduw_phys, SUFFIX)(ARG1_DECL, hwaddr addr)

{

    return glue(address_space_lduw, SUFFIX)(ARG1, addr,

                                            MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline void glue(stl_phys, SUFFIX)(ARG1_DECL, hwaddr addr, uint32_t val)

{

    glue(address_space_stl, SUFFIX)(ARG1, addr, val,

                                    MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline void glue(stw_phys, SUFFIX)(ARG1_DECL, hwaddr addr, uint32_t val)

{

    glue(address_space_stw, SUFFIX)(ARG1, addr, val,

                                    MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline void glue(stq_phys, SUFFIX)(ARG1_DECL, hwaddr addr, uint64_t val)

{

    glue(address_space_stq, SUFFIX)(ARG1, addr, val,

                                    MEMTXATTRS_UNSPECIFIED, NULL);

}

#else

static inline uint32_t glue(ldl_le_phys, SUFFIX)(ARG1_DECL, hwaddr addr)

{

    return glue(address_space_ldl_le, SUFFIX)(ARG1, addr,

                                              MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline uint32_t glue(ldl_be_phys, SUFFIX)(ARG1_DECL, hwaddr addr)

{

    return glue(address_space_ldl_be, SUFFIX)(ARG1, addr,

                                              MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline uint64_t glue(ldq_le_phys, SUFFIX)(ARG1_DECL, hwaddr addr)

{

    return glue(address_space_ldq_le, SUFFIX)(ARG1, addr,

                                              MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline uint64_t glue(ldq_be_phys, SUFFIX)(ARG1_DECL, hwaddr addr)

{

    return glue(address_space_ldq_be, SUFFIX)(ARG1, addr,

                                              MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline uint32_t glue(ldub_phys, SUFFIX)(ARG1_DECL, hwaddr addr)

{

    return glue(address_space_ldub, SUFFIX)(ARG1, addr,

                                            MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline uint32_t glue(lduw_le_phys, SUFFIX)(ARG1_DECL, hwaddr addr)

{

    return glue(address_space_lduw_le, SUFFIX)(ARG1, addr,

                                               MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline uint32_t glue(lduw_be_phys, SUFFIX)(ARG1_DECL, hwaddr addr)

{

    return glue(address_space_lduw_be, SUFFIX)(ARG1, addr,

                                               MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline void glue(stl_le_phys, SUFFIX)(ARG1_DECL, hwaddr addr, uint32_t val)

{

    glue(address_space_stl_le, SUFFIX)(ARG1, addr, val,

                                       MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline void glue(stl_be_phys, SUFFIX)(ARG1_DECL, hwaddr addr, uint32_t val)

{

    glue(address_space_stl_be, SUFFIX)(ARG1, addr, val,

                                       MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline void glue(stb_phys, SUFFIX)(ARG1_DECL, hwaddr addr, uint32_t val)

{

    glue(address_space_stb, SUFFIX)(ARG1, addr, val,

                                    MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline void glue(stw_le_phys, SUFFIX)(ARG1_DECL, hwaddr addr, uint32_t val)

{

    glue(address_space_stw_le, SUFFIX)(ARG1, addr, val,

                                       MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline void glue(stw_be_phys, SUFFIX)(ARG1_DECL, hwaddr addr, uint32_t val)

{

    glue(address_space_stw_be, SUFFIX)(ARG1, addr, val,

                                       MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline void glue(stq_le_phys, SUFFIX)(ARG1_DECL, hwaddr addr, uint64_t val)

{

    glue(address_space_stq_le, SUFFIX)(ARG1, addr, val,

                                       MEMTXATTRS_UNSPECIFIED, NULL);

}



static inline void glue(stq_be_phys, SUFFIX)(ARG1_DECL, hwaddr addr, uint64_t val)

{

    glue(address_space_stq_be, SUFFIX)(ARG1, addr, val,

                                       MEMTXATTRS_UNSPECIFIED, NULL);

}

#endif



#undef ARG1_DECL

#undef ARG1

#undef SUFFIX

#undef TARGET_ENDIANNESS

memory_ldst.inc.c

+0 −126

File changed.

Preview size limit exceeded, changes collapsed.