target-arm: Handle UNDEF cases for Neon invalid modified-immediates
[qemu.git] / qemu-common.h
blob82e27c18d315217dfeac3db25a3e13f49591839f
1 /* Common header file that is included by all of qemu. */
2 #ifndef QEMU_COMMON_H
3 #define QEMU_COMMON_H
5 #include "config-host.h"
7 #define QEMU_NORETURN __attribute__ ((__noreturn__))
8 #ifdef CONFIG_GCC_ATTRIBUTE_WARN_UNUSED_RESULT
9 #define QEMU_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
10 #else
11 #define QEMU_WARN_UNUSED_RESULT
12 #endif
14 #define QEMU_BUILD_BUG_ON(x) typedef char __build_bug_on__##__LINE__[(x)?-1:1];
16 typedef struct QEMUTimer QEMUTimer;
17 typedef struct QEMUFile QEMUFile;
18 typedef struct QEMUBH QEMUBH;
19 typedef struct DeviceState DeviceState;
21 struct Monitor;
22 typedef struct Monitor Monitor;
24 /* we put basic includes here to avoid repeating them in device drivers */
25 #include <stdlib.h>
26 #include <stdio.h>
27 #include <stdarg.h>
28 #include <stdbool.h>
29 #include <string.h>
30 #include <strings.h>
31 #include <inttypes.h>
32 #include <limits.h>
33 #include <time.h>
34 #include <ctype.h>
35 #include <errno.h>
36 #include <unistd.h>
37 #include <fcntl.h>
38 #include <sys/stat.h>
39 #include <sys/time.h>
40 #include <assert.h>
42 #ifndef O_LARGEFILE
43 #define O_LARGEFILE 0
44 #endif
45 #ifndef O_BINARY
46 #define O_BINARY 0
47 #endif
48 #ifndef MAP_ANONYMOUS
49 #define MAP_ANONYMOUS MAP_ANON
50 #endif
51 #ifndef ENOMEDIUM
52 #define ENOMEDIUM ENODEV
53 #endif
54 #if !defined(ENOTSUP)
55 #define ENOTSUP 4096
56 #endif
57 #ifndef TIME_MAX
58 #define TIME_MAX LONG_MAX
59 #endif
61 #ifndef CONFIG_IOVEC
62 #define CONFIG_IOVEC
63 struct iovec {
64 void *iov_base;
65 size_t iov_len;
68 * Use the same value as Linux for now.
70 #define IOV_MAX 1024
71 #else
72 #include <sys/uio.h>
73 #endif
75 #if defined __GNUC__
76 # if (__GNUC__ < 4) || \
77 defined(__GNUC_MINOR__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 4)
78 /* gcc versions before 4.4.x don't support gnu_printf, so use printf. */
79 # define GCC_ATTR __attribute__((__unused__, format(printf, 1, 2)))
80 # define GCC_FMT_ATTR(n, m) __attribute__((format(printf, n, m)))
81 # else
82 /* Use gnu_printf when supported (qemu uses standard format strings). */
83 # define GCC_ATTR __attribute__((__unused__, format(gnu_printf, 1, 2)))
84 # define GCC_FMT_ATTR(n, m) __attribute__((format(gnu_printf, n, m)))
85 # endif
86 #else
87 #define GCC_ATTR /**/
88 #define GCC_FMT_ATTR(n, m)
89 #endif
91 typedef int (*fprintf_function)(FILE *f, const char *fmt, ...)
92 GCC_FMT_ATTR(2, 3);
94 #ifdef _WIN32
95 #define fsync _commit
96 #define lseek _lseeki64
97 int qemu_ftruncate64(int, int64_t);
98 #define ftruncate qemu_ftruncate64
100 static inline char *realpath(const char *path, char *resolved_path)
102 _fullpath(resolved_path, path, _MAX_PATH);
103 return resolved_path;
106 #define PRId64 "I64d"
107 #define PRIx64 "I64x"
108 #define PRIu64 "I64u"
109 #define PRIo64 "I64o"
110 #endif
112 /* FIXME: Remove NEED_CPU_H. */
113 #ifndef NEED_CPU_H
115 #include <setjmp.h>
116 #include "osdep.h"
117 #include "bswap.h"
119 #else
121 #include "cpu.h"
123 #endif /* !defined(NEED_CPU_H) */
125 /* bottom halves */
126 typedef void QEMUBHFunc(void *opaque);
128 void async_context_push(void);
129 void async_context_pop(void);
130 int get_async_context_id(void);
132 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque);
133 void qemu_bh_schedule(QEMUBH *bh);
134 /* Bottom halfs that are scheduled from a bottom half handler are instantly
135 * invoked. This can create an infinite loop if a bottom half handler
136 * schedules itself. qemu_bh_schedule_idle() avoids this infinite loop by
137 * ensuring that the bottom half isn't executed until the next main loop
138 * iteration.
140 void qemu_bh_schedule_idle(QEMUBH *bh);
141 void qemu_bh_cancel(QEMUBH *bh);
142 void qemu_bh_delete(QEMUBH *bh);
143 int qemu_bh_poll(void);
144 void qemu_bh_update_timeout(int *timeout);
146 void qemu_get_timedate(struct tm *tm, int offset);
147 int qemu_timedate_diff(struct tm *tm);
149 /* cutils.c */
150 void pstrcpy(char *buf, int buf_size, const char *str);
151 char *pstrcat(char *buf, int buf_size, const char *s);
152 int strstart(const char *str, const char *val, const char **ptr);
153 int stristart(const char *str, const char *val, const char **ptr);
154 int qemu_strnlen(const char *s, int max_len);
155 time_t mktimegm(struct tm *tm);
156 int qemu_fls(int i);
157 int qemu_fdatasync(int fd);
158 int fcntl_setfl(int fd, int flag);
161 * strtosz() suffixes used to specify the default treatment of an
162 * argument passed to strtosz() without an explicit suffix.
163 * These should be defined using upper case characters in the range
164 * A-Z, as strtosz() will use qemu_toupper() on the given argument
165 * prior to comparison.
167 #define STRTOSZ_DEFSUFFIX_TB 'T'
168 #define STRTOSZ_DEFSUFFIX_GB 'G'
169 #define STRTOSZ_DEFSUFFIX_MB 'M'
170 #define STRTOSZ_DEFSUFFIX_KB 'K'
171 #define STRTOSZ_DEFSUFFIX_B 'B'
172 int64_t strtosz(const char *nptr, char **end);
173 int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix);
175 /* path.c */
176 void init_paths(const char *prefix);
177 const char *path(const char *pathname);
179 #define qemu_isalnum(c) isalnum((unsigned char)(c))
180 #define qemu_isalpha(c) isalpha((unsigned char)(c))
181 #define qemu_iscntrl(c) iscntrl((unsigned char)(c))
182 #define qemu_isdigit(c) isdigit((unsigned char)(c))
183 #define qemu_isgraph(c) isgraph((unsigned char)(c))
184 #define qemu_islower(c) islower((unsigned char)(c))
185 #define qemu_isprint(c) isprint((unsigned char)(c))
186 #define qemu_ispunct(c) ispunct((unsigned char)(c))
187 #define qemu_isspace(c) isspace((unsigned char)(c))
188 #define qemu_isupper(c) isupper((unsigned char)(c))
189 #define qemu_isxdigit(c) isxdigit((unsigned char)(c))
190 #define qemu_tolower(c) tolower((unsigned char)(c))
191 #define qemu_toupper(c) toupper((unsigned char)(c))
192 #define qemu_isascii(c) isascii((unsigned char)(c))
193 #define qemu_toascii(c) toascii((unsigned char)(c))
195 #ifdef _WIN32
196 /* ffs() in oslib-win32.c for WIN32, strings.h for the rest of the world */
197 int ffs(int i);
198 #endif
200 void *qemu_oom_check(void *ptr);
201 void *qemu_malloc(size_t size);
202 void *qemu_realloc(void *ptr, size_t size);
203 void *qemu_mallocz(size_t size);
204 void qemu_free(void *ptr);
205 char *qemu_strdup(const char *str);
206 char *qemu_strndup(const char *str, size_t size);
208 void qemu_mutex_lock_iothread(void);
209 void qemu_mutex_unlock_iothread(void);
211 int qemu_open(const char *name, int flags, ...);
212 ssize_t qemu_write_full(int fd, const void *buf, size_t count)
213 QEMU_WARN_UNUSED_RESULT;
214 void qemu_set_cloexec(int fd);
216 #ifndef _WIN32
217 int qemu_add_child_watch(pid_t pid);
218 int qemu_eventfd(int pipefd[2]);
219 int qemu_pipe(int pipefd[2]);
220 #endif
222 /* Error handling. */
224 void QEMU_NORETURN hw_error(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
226 /* IO callbacks. */
227 typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size);
228 typedef int IOCanReadHandler(void *opaque);
229 typedef void IOHandler(void *opaque);
231 void qemu_iohandler_fill(int *pnfds, fd_set *readfds, fd_set *writefds, fd_set *xfds);
232 void qemu_iohandler_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds, int rc);
234 struct ParallelIOArg {
235 void *buffer;
236 int count;
239 typedef int (*DMA_transfer_handler) (void *opaque, int nchan, int pos, int size);
241 /* A load of opaque types so that device init declarations don't have to
242 pull in all the real definitions. */
243 typedef struct NICInfo NICInfo;
244 typedef struct HCIInfo HCIInfo;
245 typedef struct AudioState AudioState;
246 typedef struct BlockDriverState BlockDriverState;
247 typedef struct DriveInfo DriveInfo;
248 typedef struct DisplayState DisplayState;
249 typedef struct DisplayChangeListener DisplayChangeListener;
250 typedef struct DisplaySurface DisplaySurface;
251 typedef struct DisplayAllocator DisplayAllocator;
252 typedef struct PixelFormat PixelFormat;
253 typedef struct TextConsole TextConsole;
254 typedef TextConsole QEMUConsole;
255 typedef struct CharDriverState CharDriverState;
256 typedef struct MACAddr MACAddr;
257 typedef struct VLANState VLANState;
258 typedef struct VLANClientState VLANClientState;
259 typedef struct i2c_bus i2c_bus;
260 typedef struct i2c_slave i2c_slave;
261 typedef struct SMBusDevice SMBusDevice;
262 typedef struct PCIHostState PCIHostState;
263 typedef struct PCIExpressHost PCIExpressHost;
264 typedef struct PCIBus PCIBus;
265 typedef struct PCIDevice PCIDevice;
266 typedef struct PCIExpressDevice PCIExpressDevice;
267 typedef struct PCIBridge PCIBridge;
268 typedef struct PCIEAERMsg PCIEAERMsg;
269 typedef struct PCIEAERLog PCIEAERLog;
270 typedef struct PCIEAERErr PCIEAERErr;
271 typedef struct PCIEPort PCIEPort;
272 typedef struct PCIESlot PCIESlot;
273 typedef struct SerialState SerialState;
274 typedef struct IRQState *qemu_irq;
275 typedef struct PCMCIACardState PCMCIACardState;
276 typedef struct MouseTransformInfo MouseTransformInfo;
277 typedef struct uWireSlave uWireSlave;
278 typedef struct I2SCodec I2SCodec;
279 typedef struct SSIBus SSIBus;
280 typedef struct EventNotifier EventNotifier;
281 typedef struct VirtIODevice VirtIODevice;
283 typedef uint64_t pcibus_t;
285 void cpu_exec_init_all(unsigned long tb_size);
287 /* CPU save/load. */
288 void cpu_save(QEMUFile *f, void *opaque);
289 int cpu_load(QEMUFile *f, void *opaque, int version_id);
291 /* Force QEMU to stop what it's doing and service IO */
292 void qemu_service_io(void);
294 /* Force QEMU to process pending events */
295 void qemu_notify_event(void);
297 /* Unblock cpu */
298 void qemu_cpu_kick(void *env);
299 void qemu_cpu_kick_self(void);
300 int qemu_cpu_is_self(void *env);
302 /* work queue */
303 struct qemu_work_item {
304 struct qemu_work_item *next;
305 void (*func)(void *data);
306 void *data;
307 int done;
310 #ifdef CONFIG_USER_ONLY
311 #define qemu_init_vcpu(env) do { } while (0)
312 #else
313 void qemu_init_vcpu(void *env);
314 #endif
316 typedef struct QEMUIOVector {
317 struct iovec *iov;
318 int niov;
319 int nalloc;
320 size_t size;
321 } QEMUIOVector;
323 void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint);
324 void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov);
325 void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len);
326 void qemu_iovec_copy(QEMUIOVector *dst, QEMUIOVector *src, uint64_t skip,
327 size_t size);
328 void qemu_iovec_concat(QEMUIOVector *dst, QEMUIOVector *src, size_t size);
329 void qemu_iovec_destroy(QEMUIOVector *qiov);
330 void qemu_iovec_reset(QEMUIOVector *qiov);
331 void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf);
332 void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count);
333 void qemu_iovec_memset(QEMUIOVector *qiov, int c, size_t count);
334 void qemu_iovec_memset_skip(QEMUIOVector *qiov, int c, size_t count,
335 size_t skip);
337 void qemu_progress_init(int enabled, float min_skip);
338 void qemu_progress_end(void);
339 void qemu_progress_print(float percent, int max);
341 /* Convert a byte between binary and BCD. */
342 static inline uint8_t to_bcd(uint8_t val)
344 return ((val / 10) << 4) | (val % 10);
347 static inline uint8_t from_bcd(uint8_t val)
349 return ((val >> 4) * 10) + (val & 0x0f);
352 /* compute with 96 bit intermediate result: (a*b)/c */
353 static inline uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
355 union {
356 uint64_t ll;
357 struct {
358 #ifdef HOST_WORDS_BIGENDIAN
359 uint32_t high, low;
360 #else
361 uint32_t low, high;
362 #endif
363 } l;
364 } u, res;
365 uint64_t rl, rh;
367 u.ll = a;
368 rl = (uint64_t)u.l.low * (uint64_t)b;
369 rh = (uint64_t)u.l.high * (uint64_t)b;
370 rh += (rl >> 32);
371 res.l.high = rh / c;
372 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
373 return res.ll;
376 #include "module.h"
378 #endif