src/helper/replacements.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2
   3 /***************************************************************************
   4  *   Copyright (C) 2006 by Dominic Rath                                    *
   5  *   Dominic.Rath@gmx.de                                                   *
   6  *                                                                         *
   7  *   Copyright (C) 2007,2008 Øyvind Harboe                                 *
   8  *   oyvind.harboe@zylin.com                                               *
   9  *                                                                         *
  10  *   Copyright (C) 2008 by Spencer Oliver                                  *
  11  *   spen@spen-soft.co.uk                                                  *
  12  ***************************************************************************/
  13
  14 #ifndef OPENOCD_HELPER_REPLACEMENTS_H
  15 #define OPENOCD_HELPER_REPLACEMENTS_H
  16
  17 #include <stdint.h>
  18 #include <helper/system.h>
  19
  20 /* MIN,MAX macros */
  21 #ifndef MIN
  22 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
  23 #endif
  24 #ifndef MAX
  25 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
  26 #endif
  27
  28 /* for systems that do not support ENOTSUP
  29  * win32 being one of them */
  30 #ifndef ENOTSUP
  31 #define ENOTSUP 134             /* Not supported */
  32 #endif
  33
  34 /* for systems that do not support O_BINARY
  35  * linux being one of them */
  36 #ifndef O_BINARY
  37 #define O_BINARY 0
  38 #endif
  39
  40 #ifndef HAVE_SYS_TIME_H
  41
  42 #ifndef _TIMEVAL_DEFINED
  43 #define _TIMEVAL_DEFINED
  44
  45 struct timeval {
  46         long tv_sec;
  47         long tv_usec;
  48 };
  49
  50 #endif  /* _TIMEVAL_DEFINED */
  51
  52 #endif
  53
  54 /* gettimeofday() */
  55 #ifndef HAVE_GETTIMEOFDAY
  56
  57 #ifdef _WIN32
  58 struct timezone {
  59         int tz_minuteswest;
  60         int tz_dsttime;
  61 };
  62 #endif
  63 struct timezone;
  64
  65 int gettimeofday(struct timeval *tv, struct timezone *tz);
  66
  67 #endif
  68
  69 #ifndef IN_REPLACEMENTS_C
  70 /**** clear_malloc & fill_malloc ****/
  71 void *clear_malloc(size_t size);
  72 void *fill_malloc(size_t size);
  73 #endif
  74
  75 /*
  76  * Now you have 3 ways for the malloc function:
  77  *
  78  * 1. Do not change anything, use the original malloc
  79  *
  80  * 2. Use the clear_malloc function instead of the original malloc.
  81  *    In this case you must use the following define:
  82  *    #define malloc((_a)) clear_malloc((_a))
  83  *
  84  * 3. Use the fill_malloc function instead of the original malloc.
  85  *    In this case you must use the following define:
  86  *    #define malloc((_a)) fill_malloc((_a))
  87  *
  88  * We have figured out that there could exist some malloc problems
  89  * where variables are using without to be initialise. To find this
  90  * places, use the fill_malloc function. With this function we want
  91  * to initialize memory to some known bad state. This is quite easily
  92  * spotted in the debugger and will trap to an invalid address.
  93  *
  94  * clear_malloc can be used if you want to set not initialise
  95  * variable to 0.
  96  *
  97  * If you do not want to change the malloc function, to not use one of
  98  * the following macros. Which is the default way.
  99  */
 100
 101 /* #define malloc(_a) clear_malloc(_a)
 102  * #define malloc(_a) fill_malloc(_a) */
 103
 104 /* GNU extensions to the C library that may be missing on some systems */
 105 #ifndef HAVE_STRNDUP
 106 char *strndup(const char *s, size_t n);
 107 #endif  /* HAVE_STRNDUP */
 108
 109 #ifndef HAVE_STRNLEN
 110 size_t strnlen(const char *s, size_t maxlen);
 111 #endif  /* HAVE_STRNLEN */
 112
 113 #ifndef HAVE_USLEEP
 114 #ifdef _WIN32
 115 static inline unsigned usleep(unsigned int usecs)
 116 {
 117         Sleep((usecs/1000));
 118         return 0;
 119 }
 120 #else
 121 #error no usleep defined for your platform
 122 #endif
 123 #endif  /* HAVE_USLEEP */
 124
 125 /* Windows specific */
 126 #ifdef _WIN32
 127
 128 #include <windows.h>
 129 #include <time.h>
 130
 131 /* Windows does not declare sockaddr_un */
 132 #define UNIX_PATH_LEN 108
 133 struct sockaddr_un {
 134         uint16_t sun_family;
 135         char sun_path[UNIX_PATH_LEN];
 136 };
 137
 138 /* win32 systems do not support ETIMEDOUT */
 139
 140 #ifndef ETIMEDOUT
 141 #define ETIMEDOUT WSAETIMEDOUT
 142 #endif
 143
 144 #if IS_MINGW == 1
 145 static inline unsigned char inb(unsigned short int port)
 146 {
 147         unsigned char _v;
 148         __asm__ __volatile__ ("inb %w1,%0" : "=a" (_v) : "Nd" (port));
 149         return _v;
 150 }
 151
 152 static inline void outb(unsigned char value, unsigned short int port)
 153 {
 154         __asm__ __volatile__ ("outb %b0,%w1" : : "a" (value), "Nd" (port));
 155 }
 156
 157 /* mingw does not have ffs, so use gcc builtin types */
 158 #define ffs __builtin_ffs
 159
 160 #endif  /* IS_MINGW */
 161
 162 int win_select(int max_fd, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *tv);
 163
 164 #endif  /* _WIN32 */
 165
 166 /* generic socket functions for Windows and Posix */
 167 static inline int write_socket(int handle, const void *buffer, unsigned int count)
 168 {
 169 #ifdef _WIN32
 170         return send(handle, buffer, count, 0);
 171 #else
 172         return write(handle, buffer, count);
 173 #endif
 174 }
 175
 176 static inline int read_socket(int handle, void *buffer, unsigned int count)
 177 {
 178 #ifdef _WIN32
 179         return recv(handle, buffer, count, 0);
 180 #else
 181         return read(handle, buffer, count);
 182 #endif
 183 }
 184
 185 static inline int close_socket(int sock)
 186 {
 187 #ifdef _WIN32
 188         return closesocket(sock);
 189 #else
 190         return close(sock);
 191 #endif
 192 }
 193
 194 static inline void socket_block(int fd)
 195 {
 196 #ifdef _WIN32
 197         unsigned long nonblock = 0;
 198         ioctlsocket(fd, FIONBIO, &nonblock);
 199 #else
 200         int oldopts = fcntl(fd, F_GETFL, 0);
 201         fcntl(fd, F_SETFL, oldopts & ~O_NONBLOCK);
 202 #endif
 203 }
 204
 205 static inline void socket_nonblock(int fd)
 206 {
 207 #ifdef _WIN32
 208         unsigned long nonblock = 1;
 209         ioctlsocket(fd, FIONBIO, &nonblock);
 210 #else
 211         int oldopts = fcntl(fd, F_GETFL, 0);
 212         fcntl(fd, F_SETFL, oldopts | O_NONBLOCK);
 213 #endif
 214 }
 215
 216 static inline int socket_select(int max_fd,
 217         fd_set *rfds,
 218         fd_set *wfds,
 219         fd_set *efds,
 220         struct timeval *tv)
 221 {
 222 #ifdef _WIN32
 223         return win_select(max_fd, rfds, wfds, efds, tv);
 224 #else
 225         return select(max_fd, rfds, wfds, efds, tv);
 226 #endif
 227 }
 228
 229 #ifndef HAVE_ELF_H
 230
 231 typedef uint32_t Elf32_Addr;
 232 typedef uint16_t Elf32_Half;
 233 typedef uint32_t Elf32_Off;
 234 typedef uint32_t Elf32_Word;
 235 typedef uint32_t Elf32_Size;
 236
 237 #define EI_NIDENT   16
 238
 239 typedef struct {
 240         unsigned char e_ident[EI_NIDENT];       /* Magic number and other info */
 241         Elf32_Half e_type;                      /* Object file type */
 242         Elf32_Half e_machine;                   /* Architecture */
 243         Elf32_Word e_version;                   /* Object file version */
 244         Elf32_Addr e_entry;                     /* Entry point virtual address */
 245         Elf32_Off e_phoff;                      /* Program header table file offset */
 246         Elf32_Off e_shoff;                      /* Section header table file offset */
 247         Elf32_Word e_flags;                     /* Processor-specific flags */
 248         Elf32_Half e_ehsize;                    /* ELF header size in bytes */
 249         Elf32_Half e_phentsize;         /* Program header table entry size */
 250         Elf32_Half e_phnum;                     /* Program header table entry count */
 251         Elf32_Half e_shentsize;         /* Section header table entry size */
 252         Elf32_Half e_shnum;                     /* Section header table entry count */
 253         Elf32_Half e_shstrndx;                  /* Section header string table index */
 254 } Elf32_Ehdr;
 255
 256 #define ELFMAG                  "\177ELF"
 257 #define SELFMAG                 4
 258
 259 #define EI_CLASS                4               /* File class byte index */
 260 #define ELFCLASS32              1               /* 32-bit objects */
 261 #define ELFCLASS64              2               /* 64-bit objects */
 262
 263 #define EI_DATA                 5               /* Data encoding byte index */
 264 #define ELFDATA2LSB             1               /* 2's complement, little endian */
 265 #define ELFDATA2MSB             2               /* 2's complement, big endian */
 266
 267 typedef struct {
 268         Elf32_Word p_type;              /* Segment type */
 269         Elf32_Off p_offset;             /* Segment file offset */
 270         Elf32_Addr p_vaddr;             /* Segment virtual address */
 271         Elf32_Addr p_paddr;             /* Segment physical address */
 272         Elf32_Size p_filesz;    /* Segment size in file */
 273         Elf32_Size p_memsz;             /* Segment size in memory */
 274         Elf32_Word p_flags;             /* Segment flags */
 275         Elf32_Size p_align;             /* Segment alignment */
 276 } Elf32_Phdr;
 277
 278 #define PT_LOAD                 1               /* Loadable program segment */
 279
 280 #endif  /* HAVE_ELF_H */
 281
 282 #ifndef HAVE_ELF64
 283
 284 typedef uint64_t Elf64_Addr;
 285 typedef uint16_t Elf64_Half;
 286 typedef uint64_t Elf64_Off;
 287 typedef uint32_t Elf64_Word;
 288 typedef uint64_t Elf64_Xword;
 289
 290 typedef struct {
 291         unsigned char e_ident[EI_NIDENT];       /* Magic number and other info */
 292         Elf64_Half e_type;                      /* Object file type */
 293         Elf64_Half e_machine;           /* Architecture */
 294         Elf64_Word e_version;           /* Object file version */
 295         Elf64_Addr e_entry;                     /* Entry point virtual address */
 296         Elf64_Off e_phoff;                      /* Program header table file offset */
 297         Elf64_Off e_shoff;                      /* Section header table file offset */
 298         Elf64_Word e_flags;                     /* Processor-specific flags */
 299         Elf64_Half e_ehsize;            /* ELF header size in bytes */
 300         Elf64_Half e_phentsize;         /* Program header table entry size */
 301         Elf64_Half e_phnum;                     /* Program header table entry count */
 302         Elf64_Half e_shentsize;         /* Section header table entry size */
 303         Elf64_Half e_shnum;                     /* Section header table entry count */
 304         Elf64_Half e_shstrndx;          /* Section header string table index */
 305 } Elf64_Ehdr;
 306
 307 typedef struct {
 308         Elf64_Word p_type;              /* Segment type */
 309         Elf64_Word p_flags;             /* Segment flags */
 310         Elf64_Off p_offset;             /* Segment file offset */
 311         Elf64_Addr p_vaddr;             /* Segment virtual address */
 312         Elf64_Addr p_paddr;             /* Segment physical address */
 313         Elf64_Xword p_filesz;   /* Segment size in file */
 314         Elf64_Xword p_memsz;    /* Segment size in memory */
 315         Elf64_Xword p_align;    /* Segment alignment */
 316 } Elf64_Phdr;
 317
 318 #endif /* HAVE_ELF64 */
 319
 320 #endif /* OPENOCD_HELPER_REPLACEMENTS_H */