1 /* 2 * Constants for memory operations 3 * 4 * Authors: 5 * Richard Henderson <rth@twiddle.net> 6 * 7 * This work is licensed under the terms of the GNU GPL, version 2 or later. 8 * See the COPYING file in the top-level directory. 9 * 10 */ 11 12 #ifndef MEMOP_H 13 #define MEMOP_H 14 15 #include "qemu/host-utils.h" 16 17 typedef enum MemOp { 18 MO_8 = 0, 19 MO_16 = 1, 20 MO_32 = 2, 21 MO_64 = 3, 22 MO_128 = 4, 23 MO_256 = 5, 24 MO_512 = 6, 25 MO_1024 = 7, 26 MO_SIZE = 0x07, /* Mask for the above. */ 27 28 MO_SIGN = 0x08, /* Sign-extended, otherwise zero-extended. */ 29 30 MO_BSWAP = 0x10, /* Host reverse endian. */ 31 #ifdef HOST_WORDS_BIGENDIAN 32 MO_LE = MO_BSWAP, 33 MO_BE = 0, 34 #else 35 MO_LE = 0, 36 MO_BE = MO_BSWAP, 37 #endif 38 #ifdef NEED_CPU_H 39 #ifdef TARGET_WORDS_BIGENDIAN 40 MO_TE = MO_BE, 41 #else 42 MO_TE = MO_LE, 43 #endif 44 #endif 45 46 /* 47 * MO_UNALN accesses are never checked for alignment. 48 * MO_ALIGN accesses will result in a call to the CPU's 49 * do_unaligned_access hook if the guest address is not aligned. 50 * The default depends on whether the target CPU defines 51 * TARGET_ALIGNED_ONLY. 52 * 53 * Some architectures (e.g. ARMv8) need the address which is aligned 54 * to a size more than the size of the memory access. 55 * Some architectures (e.g. SPARCv9) need an address which is aligned, 56 * but less strictly than the natural alignment. 57 * 58 * MO_ALIGN supposes the alignment size is the size of a memory access. 59 * 60 * There are three options: 61 * - unaligned access permitted (MO_UNALN). 62 * - an alignment to the size of an access (MO_ALIGN); 63 * - an alignment to a specified size, which may be more or less than 64 * the access size (MO_ALIGN_x where 'x' is a size in bytes); 65 */ 66 MO_ASHIFT = 5, 67 MO_AMASK = 0x7 << MO_ASHIFT, 68 #ifdef NEED_CPU_H 69 #ifdef TARGET_ALIGNED_ONLY 70 MO_ALIGN = 0, 71 MO_UNALN = MO_AMASK, 72 #else 73 MO_ALIGN = MO_AMASK, 74 MO_UNALN = 0, 75 #endif 76 #endif 77 MO_ALIGN_2 = 1 << MO_ASHIFT, 78 MO_ALIGN_4 = 2 << MO_ASHIFT, 79 MO_ALIGN_8 = 3 << MO_ASHIFT, 80 MO_ALIGN_16 = 4 << MO_ASHIFT, 81 MO_ALIGN_32 = 5 << MO_ASHIFT, 82 MO_ALIGN_64 = 6 << MO_ASHIFT, 83 84 /* Combinations of the above, for ease of use. */ 85 MO_UB = MO_8, 86 MO_UW = MO_16, 87 MO_UL = MO_32, 88 MO_SB = MO_SIGN | MO_8, 89 MO_SW = MO_SIGN | MO_16, 90 MO_SL = MO_SIGN | MO_32, 91 MO_Q = MO_64, 92 93 MO_LEUW = MO_LE | MO_UW, 94 MO_LEUL = MO_LE | MO_UL, 95 MO_LESW = MO_LE | MO_SW, 96 MO_LESL = MO_LE | MO_SL, 97 MO_LEQ = MO_LE | MO_Q, 98 99 MO_BEUW = MO_BE | MO_UW, 100 MO_BEUL = MO_BE | MO_UL, 101 MO_BESW = MO_BE | MO_SW, 102 MO_BESL = MO_BE | MO_SL, 103 MO_BEQ = MO_BE | MO_Q, 104 105 #ifdef NEED_CPU_H 106 MO_TEUW = MO_TE | MO_UW, 107 MO_TEUL = MO_TE | MO_UL, 108 MO_TESW = MO_TE | MO_SW, 109 MO_TESL = MO_TE | MO_SL, 110 MO_TEQ = MO_TE | MO_Q, 111 #endif 112 113 MO_SSIZE = MO_SIZE | MO_SIGN, 114 } MemOp; 115 116 /* MemOp to size in bytes. */ 117 static inline unsigned memop_size(MemOp op) 118 { 119 return 1 << (op & MO_SIZE); 120 } 121 122 /* Size in bytes to MemOp. */ 123 static inline MemOp size_memop(unsigned size) 124 { 125 #ifdef CONFIG_DEBUG_TCG 126 /* Power of 2 up to 8. */ 127 assert((size & (size - 1)) == 0 && size >= 1 && size <= 8); 128 #endif 129 return ctz32(size); 130 } 131 132 /* Big endianness from MemOp. */ 133 static inline bool memop_big_endian(MemOp op) 134 { 135 return (op & MO_BSWAP) == MO_BE; 136 } 137 138 #endif 139