forked from google/honggfuzz
-
Notifications
You must be signed in to change notification settings - Fork 25
/
util.h
125 lines (92 loc) · 4 KB
/
util.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
/*
*
* honggfuzz - utilities
* -----------------------------------------
*
* Author: Robert Swiecki <[email protected]>
*
* Copyright 2010-2015 by Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License. You may obtain
* a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
* implied. See the License for the specific language governing
* permissions and limitations under the License.
*
*/
#ifndef _HF_UTIL_H_
#define _HF_UTIL_H_
#include <stdarg.h>
#ifdef __clang__
#include <stdatomic.h>
#endif
#include <stdint.h>
#define MX_LOCK(m) util_mutexLock(m, __func__, __LINE__)
#define MX_UNLOCK(m) util_mutexUnlock(m, __func__, __LINE__)
#define MX_SCOPED_LOCK(m) MX_LOCK(m); defer { MX_UNLOCK(m); }
/* Atomics */
#define ATOMIC_GET(x) __atomic_load_n(&(x), __ATOMIC_SEQ_CST)
#define ATOMIC_SET(x, y) __atomic_store_n(&(x), y, __ATOMIC_SEQ_CST)
#define ATOMIC_CLEAR(x) __atomic_store_n(&(x), 0, __ATOMIC_SEQ_CST)
#define ATOMIC_XCHG(x, y) __atomic_exchange_n(&(x), y, __ATOMIC_SEQ_CST)
#define ATOMIC_PRE_INC(x) __atomic_add_fetch(&(x), 1, __ATOMIC_SEQ_CST)
#define ATOMIC_POST_INC(x) __atomic_fetch_add(&(x), 1, __ATOMIC_SEQ_CST)
#define ATOMIC_PRE_DEC(x) __atomic_sub_fetch(&(x), 1, __ATOMIC_SEQ_CST)
#define ATOMIC_POST_DEC(x) __atomic_fetch_sub(&(x), 1, __ATOMIC_SEQ_CST)
#define ATOMIC_PRE_ADD(x, y) __atomic_add_fetch(&(x), y, __ATOMIC_SEQ_CST)
#define ATOMIC_POST_ADD(x, y) __atomic_fetch_add(&(x), y, __ATOMIC_SEQ_CST)
#define ATOMIC_PRE_SUB(x, y) __atomic_sub_fetch(&(x), y, __ATOMIC_SEQ_CST)
#define ATOMIC_POST_SUB(x, y) __atomic_fetch_sub(&(x), y, __ATOMIC_SEQ_CST)
#define ATOMIC_PRE_AND(x, y) __atomic_and_fetch(&(x), y, __ATOMIC_SEQ_CST)
#define ATOMIC_POST_AND(x, y) __atomic_fetch_and(&(x), y, __ATOMIC_SEQ_CST)
#define ATOMIC_PRE_OR(x, y) __atomic_or_fetch(&(x), y, __ATOMIC_SEQ_CST)
#define ATOMIC_POST_OR(x, y) __atomic_fetch_or(&(x), y, __ATOMIC_SEQ_CST)
#define ATOMIC_PRE_INC_RELAXED(x) __atomic_add_fetch(&(x), 1, __ATOMIC_RELAXED)
#define ATOMIC_POST_OR_RELAXED(x, y) __atomic_fetch_or(&(x), y, __ATOMIC_RELAXED)
__attribute__ ((always_inline))
static inline uint8_t ATOMIC_BTS(uint8_t * addr, size_t offset)
{
uint8_t oldbit;
addr += (offset / 8);
#if defined(__x86_64__)
/* *INDENT-OFF* */
__asm__("lock btsq %2, %1\n"
"sbb %0, %0\n"
:"=r"(oldbit), "+m"(*addr)
:"Ir"(offset % 8)
);
/* *INDENT-ON* */
#else
oldbit = ATOMIC_POST_OR(*addr, ((uint8_t) 1U << (offset % 8)));
#endif
return oldbit;
}
extern void *util_Malloc(size_t sz);
extern void *util_Calloc(size_t sz);
extern void *util_MMap(size_t sz);
extern void *util_Realloc(void *ptr, size_t sz);
extern char *util_StrDup(const char *s);
extern uint64_t util_rndGet(uint64_t min, uint64_t max);
extern void util_rndBuf(uint8_t * buf, size_t sz);
extern uint64_t util_rnd64(void);
extern int util_ssnprintf(char *str, size_t size, const char *format, ...);
extern int util_vssnprintf(char *str, size_t size, const char *format, va_list ap);
extern void util_getLocalTime(const char *fmt, char *buf, size_t len, time_t tm);
extern void util_nullifyStdio(void);
extern bool util_redirectStdin(const char *inputFile);
extern uint64_t util_hash(const char *buf, size_t len);
extern int64_t util_timeNowMillis(void);
extern uint64_t util_getUINT32(const uint8_t * buf);
extern uint64_t util_getUINT64(const uint8_t * buf);
extern void util_mutexLock(pthread_mutex_t * mutex, const char *func, int line);
extern void util_mutexUnlock(pthread_mutex_t * mutex, const char *func, int line);
extern int64_t fastArray64Search(uint64_t * array, size_t arraySz, uint64_t key);
extern bool util_isANumber(const char *s);
extern size_t util_decodeCString(char *s);
#endif