X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fhelper%2Ftypes.h;h=50f5fe2d4c1dc6d3e2418e482137e41e5d87dac8;hb=46d9ba4c8b675deb96ac533885500eb62b6c9909;hp=6e6d59e45281c6e75a68ab2d2f5a0c97ea8629ba;hpb=68c598e88d5e09728ea845a81ab279c615bbaf0f;p=openocd.git diff --git a/src/helper/types.h b/src/helper/types.h index 6e6d59e452..50f5fe2d4c 100644 --- a/src/helper/types.h +++ b/src/helper/types.h @@ -2,7 +2,7 @@ * Copyright (C) 2004, 2005 by Dominic Rath * * Dominic.Rath@gmx.de * * * - * Copyright (C) 2007,2008 Øyvind Harboe * + * Copyright (C) 2007,2008 Øyvind Harboe * * oyvind.harboe@zylin.com * * * * This program is free software; you can redistribute it and/or modify * @@ -23,60 +23,154 @@ #ifndef TYPES_H #define TYPES_H -#ifdef HAVE_CONFIG_H -#include "config.h" +#ifdef HAVE_SYS_TYPES_H +#include #endif - -#ifndef u8 -typedef unsigned char u8; +#ifdef HAVE_STDINT_H +#include #endif - -#ifndef u16 -typedef unsigned short u16; +#ifdef HAVE_INTTYPES_H +#include #endif -#ifndef u32 -typedef unsigned int u32; -#endif +typedef struct jtag_tap_s jtag_tap_t; -#ifndef u64 -typedef unsigned long long u64; -#endif +#ifdef HAVE_STDBOOL_H +#include +#else /* HAVE_STDBOOL_H */ +#define __bool_true_false_are_defined 1 + +#ifndef HAVE__BOOL +#ifndef __cplusplus + +#define false 0 +#define true 1 + +typedef int _Bool; +#else +typedef bool _Bool; +#endif /* __cplusplus */ +#endif /* HAVE__BOOL */ + +#define bool _Bool +#endif /* HAVE_STDBOOL_H */ +/// turns a macro argument into a string constant +#define stringify(s) __stringify(s) +#define __stringify(s) #s -/* DANGER!!!! here be dragons! Note that the pointer in - * memory might be unaligned. On some CPU's, i.e. ARM7, - * the 2 lsb are ignored for 32 bit access, on others - * it will cause an exception and on e.g. x86, it works - * the same as if aligned. +/* DANGER!!!! here be dragons! + * + * Leave these fn's as byte accesses because it is safe + * across architectures. Clever usage of 32 bit access + * will create problems on some hosts. + * + * Note that the "buf" pointer in memory is probably unaligned. + * + * Were these functions to be re-written to take a 32 bit wide or 16 bit wide + * memory access shortcut, then on some CPU's, i.e. ARM7, the 2 lsbytes of the address are + * ignored for 32 bit access, whereas on other CPU's a 32 bit wide unaligned memory access + * will cause an exception, and lastly on x86, an unaligned "greater than bytewide" + * memory access works as if aligned. So what follows below will work for all + * platforms and gives the compiler leeway to do its own platform specific optimizations. + * + * Again, note that the "buf" pointer in memory is probably unaligned. */ -#define le_to_h_u32(x) ((u32)((x)[0] | (x)[1] << 8 | (x)[2] << 16 | (x)[3] << 24)) -#define le_to_h_u16(x) ((u16)((x)[0] | (x)[1] << 8)) -#define be_to_h_u32(x) ((u32)((x)[3] | (x)[2] << 8 | (x)[1] << 16 | (x)[0] << 24)) -#define be_to_h_u16(x) ((u16)((x)[1] | (x)[0] << 8)) - -#define h_u32_to_le(buf, val) do {\ -(buf)[3] = ((val) & 0xff000000) >> 24;\ -(buf)[2] = ((val) & 0x00ff0000) >> 16;\ -(buf)[1] = ((val) & 0x0000ff00) >> 8;\ -(buf)[0] = ((val) & 0x000000ff);\ -} while (0) -#define h_u32_to_be(buf, val) do {\ -(buf)[0] = ((val) & 0xff000000) >> 24;\ -(buf)[1] = ((val) & 0x00ff0000) >> 16;\ -(buf)[2] = ((val) & 0x0000ff00) >> 8;\ -(buf)[3] = ((val) & 0x000000ff);\ -} while (0) - -#define h_u16_to_le(buf, val) do {\ -(buf)[1] = ((val) & 0xff00) >> 8;\ -(buf)[0] = ((val) & 0x00ff) >> 0;\ -} while (0) -#define h_u16_to_be(buf, val) do {\ -(buf)[0] = ((val) & 0xff00) >> 8;\ -(buf)[1] = ((val) & 0x00ff) >> 0;\ -} while (0) +static inline uint32_t le_to_h_u32(const uint8_t* buf) +{ + return (uint32_t)(buf[0] | buf[1] << 8 | buf[2] << 16 | buf[3] << 24); +} + +static inline uint16_t le_to_h_u16(const uint8_t* buf) +{ + return (uint16_t)(buf[0] | buf[1] << 8); +} + +static inline uint32_t be_to_h_u32(const uint8_t* buf) +{ + return (uint32_t)(buf[3] | buf[2] << 8 | buf[1] << 16 | buf[0] << 24); +} + +static inline uint16_t be_to_h_u16(const uint8_t* buf) +{ + return (uint16_t)(buf[1] | buf[0] << 8); +} + +static inline void h_u32_to_le(uint8_t* buf, int val) +{ + buf[3] = (uint8_t) (val >> 24); + buf[2] = (uint8_t) (val >> 16); + buf[1] = (uint8_t) (val >> 8); + buf[0] = (uint8_t) (val >> 0); +} + +static inline void h_u32_to_be(uint8_t* buf, int val) +{ + buf[0] = (uint8_t) (val >> 24); + buf[1] = (uint8_t) (val >> 16); + buf[2] = (uint8_t) (val >> 8); + buf[3] = (uint8_t) (val >> 0); +} + +static inline void h_u16_to_le(uint8_t* buf, int val) +{ + buf[1] = (uint8_t) (val >> 8); + buf[0] = (uint8_t) (val >> 0); +} + +static inline void h_u16_to_be(uint8_t* buf, int val) +{ + buf[0] = (uint8_t) (val >> 8); + buf[1] = (uint8_t) (val >> 0); +} + +#if defined(__ECOS) + +/* eCos plain lacks these definition... A series of upstream patches + * could probably repair it, but it seems like too much work to be + * worth it. + */ + +#if !defined(_STDINT_H) +#define PRIx32 "x" +#define PRId32 "d" +#define SCNx32 "x" +#define PRIi32 "i" +#define PRIu32 "u" + +typedef CYG_ADDRWORD intptr_t; +typedef int64_t intmax_t; +typedef uint64_t uintmax_t; +#define INT8_MAX 0x7f +#define INT8_MIN (-INT8_MAX - 1) +# define UINT8_MAX (255) +#define INT16_MAX 0x7fff +#define INT16_MIN (-INT16_MAX - 1) +# define UINT16_MAX (65535) +#define INT32_MAX 0x7fffffffL +#define INT32_MIN (-INT32_MAX - 1L) +# define UINT32_MAX (4294967295U) +#define INT64_MAX 0x7fffffffffffffffLL +#define INT64_MIN (-INT64_MAX - 1LL) +#define UINT64_MAX (__CONCAT(INT64_MAX, U) * 2ULL + 1ULL) +#endif + + #ifndef LLONG_MAX + #define ULLONG_MAX UINT64_C(0xFFFFFFFFFFFFFFFF) + #define LLONG_MAX INT64_C(0x7FFFFFFFFFFFFFFF) + #define LLONG_MIN ULLONG_MAX + #endif + + +#define ULLONG_MAX 18446744073709551615 + +/* C99, eCos is C90 compliant (with bits of C99) */ +#define isblank(c) ((c) == ' ' || (c) == '\t') + + +#endif + #endif /* TYPES_H */