From fdeac5678805a587d27597b8f48e113ab8175b86 Mon Sep 17 00:00:00 2001
From: Magnus Edenhill <magnus@edenhill.se>
Date: Mon, 11 Apr 2016 11:59:07 +0200
Subject: [PATCH] Fix __inline vs inline (issue #253)

---
 src/queue.h                |  4 ++--
 src/rd.h                   | 28 +++++++++++------------
 src/rdaddr.h               |  4 ++--
 src/rdatomic.h             | 16 ++++++-------
 src/rdcrc32.h              |  8 +++----
 src/rdinterval.h           | 16 ++++++-------
 src/rdkafka.c              |  2 +-
 src/rdkafka.h              |  4 +++-
 src/rdkafka_broker.h       |  2 +-
 src/rdkafka_buf.h          | 46 +++++++++++++++++++-------------------
 src/rdkafka_feature.c      |  2 +-
 src/rdkafka_int.h          |  2 +-
 src/rdkafka_msg.h          | 18 +++++++--------
 src/rdkafka_offset.h       |  2 +-
 src/rdkafka_partition.c    |  6 ++---
 src/rdkafka_partition.h    |  6 ++---
 src/rdkafka_proto.h        | 18 +++++++--------
 src/rdkafka_queue.c        |  2 +-
 src/rdkafka_queue.h        | 22 +++++++++---------
 src/rdkafka_subscription.c |  2 +-
 src/rdkafka_timer.c        |  8 +++----
 src/rdkafka_transport.c    |  2 +-
 src/rdlist.c               |  2 +-
 src/rdlist.h               |  2 +-
 src/rdposix.h              |  3 ++-
 src/rdrand.h               |  4 ++--
 src/rdtime.h               | 14 ++++++------
 src/rdwin32.h              |  7 +++---
 src/snappy.c               |  7 +++---
 tests/test.c               |  4 ++--
 tests/test.h               | 10 ++++-----
 31 files changed, 138 insertions(+), 135 deletions(-)

diff --git a/src/queue.h b/src/queue.h
index fd36a9fb44..2c7b9873a1 100644
--- a/src/queue.h
+++ b/src/queue.h
@@ -681,8 +681,8 @@ struct {								\
 #ifdef _MSC_VER
 #define __launder_type(x)  ((const void *)(x))
 #else
-static __inline const void * __launder_type(const void *);
-static __inline const void *
+static RD_INLINE const void * __launder_type(const void *);
+static RD_INLINE const void *
 __launder_type(const void *__x)
 {
 	__asm __volatile("" : "+r" (__x));
diff --git a/src/rd.h b/src/rd.h
index fa77c3e7e7..d29096dd41 100644
--- a/src/rd.h
+++ b/src/rd.h
@@ -77,29 +77,29 @@
 * allocation fails all hope is lost and the application
 * will fail anyway, so no need to handle it handsomely.
 */
-static __inline RD_UNUSED void *rd_calloc(size_t num, size_t sz) {
+static RD_INLINE RD_UNUSED void *rd_calloc(size_t num, size_t sz) {
 	void *p = calloc(num, sz);
 	assert(p);
 	return p;
 }
 
-static __inline RD_UNUSED void *rd_malloc(size_t sz) {
+static RD_INLINE RD_UNUSED void *rd_malloc(size_t sz) {
 	void *p = malloc(sz);
 	assert(p);
 	return p;
 }
 
-static __inline RD_UNUSED void *rd_realloc(void *ptr, size_t sz) {
+static RD_INLINE RD_UNUSED void *rd_realloc(void *ptr, size_t sz) {
 	void *p = realloc(ptr, sz);
 	assert(p);
 	return p;
 }
 
-static __inline RD_UNUSED void rd_free(void *ptr) {
+static RD_INLINE RD_UNUSED void rd_free(void *ptr) {
 	free(ptr);
 }
 
-static __inline RD_UNUSED char *rd_strdup(const char *s) {
+static RD_INLINE RD_UNUSED char *rd_strdup(const char *s) {
 #ifndef _MSC_VER
 	char *n = strdup(s);
 #else
@@ -109,7 +109,7 @@ static __inline RD_UNUSED char *rd_strdup(const char *s) {
 	return n;
 }
 
-static __inline RD_UNUSED char *rd_strndup(const char *s, size_t len) {
+static RD_INLINE RD_UNUSED char *rd_strndup(const char *s, size_t len) {
 #if HAVE_STRNDUP
 	char *n = strndup(s, len);
 	assert(n);
@@ -190,7 +190,7 @@ static __inline RD_UNUSED char *rd_strndup(const char *s, size_t len) {
  *
  * Use rd_free() to free the returned pointer.
 */
-static __inline RD_UNUSED void *rd_memdup (const void *src, size_t size) {
+static RD_INLINE RD_UNUSED void *rd_memdup (const void *src, size_t size) {
 	void *dst = rd_malloc(size);
 	memcpy(dst, src, size);
 	return dst;
@@ -212,7 +212,7 @@ typedef rd_atomic32_t rd_refcnt_t;
 #endif
 
 #ifdef RD_REFCNT_USE_LOCKS
-static __inline RD_UNUSED int rd_refcnt_init (rd_refcnt_t *R, int v) {
+static RD_INLINE RD_UNUSED int rd_refcnt_init (rd_refcnt_t *R, int v) {
         int r;
         mtx_init(&R->lock, mtx_plain);
         mtx_lock(&R->lock);
@@ -225,7 +225,7 @@ static __inline RD_UNUSED int rd_refcnt_init (rd_refcnt_t *R, int v) {
 #endif
 
 #ifdef RD_REFCNT_USE_LOCKS
-static __inline RD_UNUSED void rd_refcnt_destroy (rd_refcnt_t *R) {
+static RD_INLINE RD_UNUSED void rd_refcnt_destroy (rd_refcnt_t *R) {
         mtx_lock(&R->lock);
         assert(R->v == 0);
         mtx_unlock(&R->lock);
@@ -238,7 +238,7 @@ static __inline RD_UNUSED void rd_refcnt_destroy (rd_refcnt_t *R) {
 
 
 #ifdef RD_REFCNT_USE_LOCKS
-static __inline RD_UNUSED int rd_refcnt_set (rd_refcnt_t *R, int v) {
+static RD_INLINE RD_UNUSED int rd_refcnt_set (rd_refcnt_t *R, int v) {
         int r;
         mtx_lock(&R->lock);
         r = R->v = v;
@@ -251,7 +251,7 @@ static __inline RD_UNUSED int rd_refcnt_set (rd_refcnt_t *R, int v) {
 
 
 #ifdef RD_REFCNT_USE_LOCKS
-static __inline RD_UNUSED int rd_refcnt_add0 (rd_refcnt_t *R) {
+static RD_INLINE RD_UNUSED int rd_refcnt_add0 (rd_refcnt_t *R) {
         int r;
         mtx_lock(&R->lock);
         r = ++(R->v);
@@ -262,7 +262,7 @@ static __inline RD_UNUSED int rd_refcnt_add0 (rd_refcnt_t *R) {
 #define rd_refcnt_add0(R)  rd_atomic32_add(R, 1)
 #endif
 
-static __inline RD_UNUSED int rd_refcnt_sub0 (rd_refcnt_t *R) {
+static RD_INLINE RD_UNUSED int rd_refcnt_sub0 (rd_refcnt_t *R) {
         int r;
 #ifdef RD_REFCNT_USE_LOCKS
         mtx_lock(&R->lock);
@@ -277,7 +277,7 @@ static __inline RD_UNUSED int rd_refcnt_sub0 (rd_refcnt_t *R) {
 }
 
 #ifdef RD_REFCNT_USE_LOCKS
-static __inline RD_UNUSED int rd_refcnt_get (rd_refcnt_t *R) {
+static RD_INLINE RD_UNUSED int rd_refcnt_get (rd_refcnt_t *R) {
         int r;
         mtx_lock(&R->lock);
         r = R->v;
@@ -377,7 +377,7 @@ LIST_HEAD(rd_shptr0_head, rd_shptr0_s);
 extern struct rd_shptr0_head rd_shared_ptr_debug_list;
 extern mtx_t rd_shared_ptr_debug_mtx;
 
-static __inline RD_UNUSED RD_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
+static RD_INLINE RD_UNUSED RD_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
 rd_shptr0_t *rd_shared_ptr_get0 (const char *func, int line,
                                  const char *typename,
                                  rd_refcnt_t *ref, void *obj) {
diff --git a/src/rdaddr.h b/src/rdaddr.h
index 950baab050..dd1c419ed7 100644
--- a/src/rdaddr.h
+++ b/src/rdaddr.h
@@ -123,9 +123,9 @@ typedef struct rd_sockaddr_list_s {
  * 
  */
  
-static __inline rd_sockaddr_inx_t *
+static RD_INLINE rd_sockaddr_inx_t *
 rd_sockaddr_list_next (rd_sockaddr_list_t *rsal) RD_UNUSED;
-static __inline rd_sockaddr_inx_t *
+static RD_INLINE rd_sockaddr_inx_t *
 rd_sockaddr_list_next (rd_sockaddr_list_t *rsal) {
 	rsal->rsal_curr = (rsal->rsal_curr + 1) % rsal->rsal_cnt;
 	return &rsal->rsal_addr[rsal->rsal_curr];
diff --git a/src/rdatomic.h b/src/rdatomic.h
index 96dc24c06f..907a715440 100644
--- a/src/rdatomic.h
+++ b/src/rdatomic.h
@@ -9,7 +9,7 @@ typedef struct {
 	int64_t val;
 } rd_atomic64_t;
 
-static __inline int32_t RD_UNUSED rd_atomic32_add (rd_atomic32_t *ra, int32_t v) {
+static RD_INLINE int32_t RD_UNUSED rd_atomic32_add (rd_atomic32_t *ra, int32_t v) {
 #ifndef _MSC_VER
 	return ATOMIC_OP(add, fetch, &ra->val, v);
 #else
@@ -17,7 +17,7 @@ static __inline int32_t RD_UNUSED rd_atomic32_add (rd_atomic32_t *ra, int32_t v)
 #endif
 }
 
-static __inline int32_t RD_UNUSED rd_atomic32_sub(rd_atomic32_t *ra, int32_t v) {
+static RD_INLINE int32_t RD_UNUSED rd_atomic32_sub(rd_atomic32_t *ra, int32_t v) {
 #ifndef _MSC_VER
 	return ATOMIC_OP(sub, fetch, &ra->val, v);
 #else
@@ -25,7 +25,7 @@ static __inline int32_t RD_UNUSED rd_atomic32_sub(rd_atomic32_t *ra, int32_t v)
 #endif
 }
 
-static __inline int32_t RD_UNUSED rd_atomic32_get(rd_atomic32_t *ra) {
+static RD_INLINE int32_t RD_UNUSED rd_atomic32_get(rd_atomic32_t *ra) {
 #ifndef _MSC_VER
 	return ATOMIC_OP(fetch, add, &ra->val, 0);
 #else
@@ -33,7 +33,7 @@ static __inline int32_t RD_UNUSED rd_atomic32_get(rd_atomic32_t *ra) {
 #endif
 }
 
-static __inline int32_t RD_UNUSED rd_atomic32_set(rd_atomic32_t *ra, int32_t v) {
+static RD_INLINE int32_t RD_UNUSED rd_atomic32_set(rd_atomic32_t *ra, int32_t v) {
 #ifndef _MSC_VER
 	return ra->val = v; // FIXME
 #else
@@ -42,7 +42,7 @@ static __inline int32_t RD_UNUSED rd_atomic32_set(rd_atomic32_t *ra, int32_t v)
 }
 
 
-static __inline int64_t RD_UNUSED rd_atomic64_add (rd_atomic64_t *ra, int64_t v) {
+static RD_INLINE int64_t RD_UNUSED rd_atomic64_add (rd_atomic64_t *ra, int64_t v) {
 #ifndef _MSC_VER
 	return ATOMIC_OP(add, fetch, &ra->val, v);
 #else
@@ -50,7 +50,7 @@ static __inline int64_t RD_UNUSED rd_atomic64_add (rd_atomic64_t *ra, int64_t v)
 #endif
 }
 
-static __inline int64_t RD_UNUSED rd_atomic64_sub(rd_atomic64_t *ra, int64_t v) {
+static RD_INLINE int64_t RD_UNUSED rd_atomic64_sub(rd_atomic64_t *ra, int64_t v) {
 #ifndef _MSC_VER
 	return ATOMIC_OP(sub, fetch, &ra->val, v);
 #else
@@ -58,7 +58,7 @@ static __inline int64_t RD_UNUSED rd_atomic64_sub(rd_atomic64_t *ra, int64_t v)
 #endif
 }
 
-static __inline int64_t RD_UNUSED rd_atomic64_get(rd_atomic64_t *ra) {
+static RD_INLINE int64_t RD_UNUSED rd_atomic64_get(rd_atomic64_t *ra) {
 #ifndef _MSC_VER
 	return ATOMIC_OP(fetch, add, &ra->val, 0);
 #else
@@ -67,7 +67,7 @@ static __inline int64_t RD_UNUSED rd_atomic64_get(rd_atomic64_t *ra) {
 }
 
 
-static __inline int64_t RD_UNUSED rd_atomic64_set(rd_atomic64_t *ra, int64_t v) {
+static RD_INLINE int64_t RD_UNUSED rd_atomic64_set(rd_atomic64_t *ra, int64_t v) {
 #ifndef _MSC_VER
 	return ra->val = v; // FIXME
 #else
diff --git a/src/rdcrc32.h b/src/rdcrc32.h
index 02b99c3f9b..1024194c43 100644
--- a/src/rdcrc32.h
+++ b/src/rdcrc32.h
@@ -68,7 +68,7 @@ rd_crc32_t rd_crc32_reflect(rd_crc32_t data, size_t data_len);
  *
  * \return     The initial crc value.
  *****************************************************************************/
-static __inline rd_crc32_t rd_crc32_init(void)
+static RD_INLINE rd_crc32_t rd_crc32_init(void)
 {
 #if WITH_ZLIB
         return crc32(0, NULL, 0);
@@ -94,7 +94,7 @@ static __inline rd_crc32_t rd_crc32_init(void)
  * \param data_len Number of bytes in the \a data buffer.
  * \return         The updated crc value.
  *****************************************************************************/
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 rd_crc32_t rd_crc32_update(rd_crc32_t crc, const unsigned char *data, size_t data_len)
 {
 #if WITH_ZLIB
@@ -120,7 +120,7 @@ rd_crc32_t rd_crc32_update(rd_crc32_t crc, const unsigned char *data, size_t dat
  * \param crc  The current crc value.
  * \return     The final crc value.
  *****************************************************************************/
-static __inline rd_crc32_t rd_crc32_finalize(rd_crc32_t crc)
+static RD_INLINE rd_crc32_t rd_crc32_finalize(rd_crc32_t crc)
 {
 #if WITH_ZLIB
         return crc;
@@ -133,7 +133,7 @@ static __inline rd_crc32_t rd_crc32_finalize(rd_crc32_t crc)
 /**
  * Wrapper for performing CRC32 on the provided buffer.
  */
-static __inline rd_crc32_t rd_crc32 (const char *data, size_t data_len) {
+static RD_INLINE rd_crc32_t rd_crc32 (const char *data, size_t data_len) {
 	return rd_crc32_finalize(rd_crc32_update(rd_crc32_init(),
 						 (const unsigned char *)data,
 						 data_len));
diff --git a/src/rdinterval.h b/src/rdinterval.h
index 83f8e51167..e965d57af4 100644
--- a/src/rdinterval.h
+++ b/src/rdinterval.h
@@ -11,7 +11,7 @@ typedef struct rd_interval_s {
 } rd_interval_t;
 
 
-static __inline RD_UNUSED void rd_interval_init (rd_interval_t *ri) {
+static RD_INLINE RD_UNUSED void rd_interval_init (rd_interval_t *ri) {
         memset(ri, 0, sizeof(*ri));
 }
 
@@ -28,7 +28,7 @@ static __inline RD_UNUSED void rd_interval_init (rd_interval_t *ri) {
  * If 'interval_us' is set to 0 the fixed interval will be used, see
  * 'rd_interval_fixed()'.
  */
-static __inline RD_UNUSED rd_ts_t rd_interval (rd_interval_t *ri,
+static RD_INLINE RD_UNUSED rd_ts_t rd_interval (rd_interval_t *ri,
                                                rd_ts_t interval_us,
                                                rd_ts_t now) {
         rd_ts_t diff;
@@ -52,7 +52,7 @@ static __inline RD_UNUSED rd_ts_t rd_interval (rd_interval_t *ri,
  * Reset the interval to zero, i.e., the next call to rd_interval()
  * will be immediate.
  */
-static __inline RD_UNUSED void rd_interval_reset (rd_interval_t *ri) {
+static RD_INLINE RD_UNUSED void rd_interval_reset (rd_interval_t *ri) {
         ri->ri_ts_last = 0;
         ri->ri_backoff = 0;
 }
@@ -60,7 +60,7 @@ static __inline RD_UNUSED void rd_interval_reset (rd_interval_t *ri) {
 /**
  * Back off the next interval by `backoff_us` microseconds.
  */
-static __inline RD_UNUSED void rd_interval_backoff (rd_interval_t *ri,
+static RD_INLINE RD_UNUSED void rd_interval_backoff (rd_interval_t *ri,
                                                     int backoff_us) {
         ri->ri_backoff = backoff_us;
 }
@@ -70,7 +70,7 @@ static __inline RD_UNUSED void rd_interval_backoff (rd_interval_t *ri,
  * If `expedite_us` is 0 the interval will be set to trigger
  * immedately on the next rd_interval() call.
  */
-static __inline RD_UNUSED void rd_interval_expedite (rd_interval_t *ri,
+static RD_INLINE RD_UNUSED void rd_interval_expedite (rd_interval_t *ri,
 						     int expedite_us) {
 	if (!expedite_us)
 		ri->ri_ts_last = 0;
@@ -82,7 +82,7 @@ static __inline RD_UNUSED void rd_interval_expedite (rd_interval_t *ri,
  * Specifies a fixed interval to use if rd_interval() is called with
  * `interval_us` set to 0.
  */
-static __inline RD_UNUSED void rd_interval_fixed (rd_interval_t *ri,
+static RD_INLINE RD_UNUSED void rd_interval_fixed (rd_interval_t *ri,
                                                   rd_ts_t fixed_us) {
         ri->ri_fixed = fixed_us;
 }
@@ -92,7 +92,7 @@ static __inline RD_UNUSED void rd_interval_fixed (rd_interval_t *ri,
  * A disabled interval will never return a positive value from
  * rd_interval().
  */
-static __inline RD_UNUSED void rd_interval_disable (rd_interval_t *ri) {
+static RD_INLINE RD_UNUSED void rd_interval_disable (rd_interval_t *ri) {
         /* Set last beat to a large value a long time in the future. */
         ri->ri_ts_last = 6000000000000000000LL; /* in about 190000 years */
 }
@@ -100,6 +100,6 @@ static __inline RD_UNUSED void rd_interval_disable (rd_interval_t *ri) {
 /**
  * Returns true if the interval is disabled.
  */
-static __inline RD_UNUSED int rd_interval_disabled (const rd_interval_t *ri) {
+static RD_INLINE RD_UNUSED int rd_interval_disabled (const rd_interval_t *ri) {
         return ri->ri_ts_last == 6000000000000000000LL;
 }
diff --git a/src/rdkafka.c b/src/rdkafka.c
index 582e6b011e..f51bd04360 100644
--- a/src/rdkafka.c
+++ b/src/rdkafka.c
@@ -610,7 +610,7 @@ static void rd_kafka_destroy_internal (rd_kafka_t *rk) {
 /**
  * Emit stats for toppar
  */
-static __inline void rd_kafka_stats_emit_toppar (char **bufp, size_t *sizep,
+static RD_INLINE void rd_kafka_stats_emit_toppar (char **bufp, size_t *sizep,
 					       size_t *ofp,
 					       rd_kafka_toppar_t *rktp,
 					       int first) {
diff --git a/src/rdkafka.h b/src/rdkafka.h
index 96dde09023..bf2d4971e4 100644
--- a/src/rdkafka.h
+++ b/src/rdkafka.h
@@ -58,6 +58,7 @@ extern "C" {
 #include <basetsd.h>
 typedef SSIZE_T ssize_t;
 #define RD_UNUSED
+#define RD_INLINE __inline
 #define RD_DEPRECATED
 #undef RD_EXPORT
 #ifdef LIBRDKAFKA_EXPORTS
@@ -68,6 +69,7 @@ typedef SSIZE_T ssize_t;
 
 #else
 #define RD_UNUSED __attribute__((unused))
+#define RD_INLINE inline
 #define RD_EXPORT
 #define RD_DEPRECATED __attribute__((deprecated))
 #endif
@@ -688,7 +690,7 @@ void rd_kafka_message_destroy(rd_kafka_message_t *rkmessage);
  * @brief Returns the error string for an errored rd_kafka_message_t or NULL if
  *        there was no error.
  */
-static __inline const char *
+static RD_INLINE const char *
 RD_UNUSED 
 rd_kafka_message_errstr(const rd_kafka_message_t *rkmessage) {
 	if (!rkmessage->err)
diff --git a/src/rdkafka_broker.h b/src/rdkafka_broker.h
index 0917cff71f..62ca3ce060 100644
--- a/src/rdkafka_broker.h
+++ b/src/rdkafka_broker.h
@@ -186,7 +186,7 @@ rd_kafka_broker_t *rd_kafka_broker_find_by_nodeid0 (rd_kafka_t *rk,
 /**
  * Filter out brokers that are currently in a blocking request.
  */
-static __inline RD_UNUSED int
+static RD_INLINE RD_UNUSED int
 rd_kafka_broker_filter_non_blocking (rd_kafka_broker_t *rkb, void *opaque) {
         return rd_atomic32_get(&rkb->rkb_blocking_request_cnt) > 0;
 }
diff --git a/src/rdkafka_buf.h b/src/rdkafka_buf.h
index 3167e4c00c..89b62d3a05 100644
--- a/src/rdkafka_buf.h
+++ b/src/rdkafka_buf.h
@@ -335,7 +335,7 @@ void rd_kafka_buf_callback (rd_kafka_t *rk,
 /**
  * Set request API type version
  */
-static __inline void rd_kafka_buf_version_set (rd_kafka_buf_t *rkbuf,
+static RD_INLINE void rd_kafka_buf_version_set (rd_kafka_buf_t *rkbuf,
                                                int16_t version) {
         rkbuf->rkbuf_reqhdr.ApiVersion = version;
 }
@@ -346,7 +346,7 @@ void rd_kafka_buf_grow (rd_kafka_buf_t *rkbuf, size_t needed_len);
 /**
  * Set buffer write position.
  */
-static __inline RD_UNUSED void rd_kafka_buf_write_seek (rd_kafka_buf_t *rkbuf,
+static RD_INLINE RD_UNUSED void rd_kafka_buf_write_seek (rd_kafka_buf_t *rkbuf,
 							int of) {
 	rd_kafka_assert(NULL, of >= 0 && of < (int)rkbuf->rkbuf_size);
 	rkbuf->rkbuf_wof = of;
@@ -357,7 +357,7 @@ static __inline RD_UNUSED void rd_kafka_buf_write_seek (rd_kafka_buf_t *rkbuf,
  * There must be enough space allocated in the rkbuf.
  * Returns offset to written destination buffer.
  */
-static __inline size_t rd_kafka_buf_write (rd_kafka_buf_t *rkbuf,
+static RD_INLINE size_t rd_kafka_buf_write (rd_kafka_buf_t *rkbuf,
                                         const void *data, size_t len) {
         ssize_t remain = rkbuf->rkbuf_size - (rkbuf->rkbuf_wof + len);
 
@@ -379,7 +379,7 @@ static __inline size_t rd_kafka_buf_write (rd_kafka_buf_t *rkbuf,
  * Returns pointer to buffer at 'offset' and makes sure at least 'len'
  * following bytes are available, else returns NULL.
  */
-static __inline RD_UNUSED void *rd_kafka_buf_at (rd_kafka_buf_t *rkbuf,
+static RD_INLINE RD_UNUSED void *rd_kafka_buf_at (rd_kafka_buf_t *rkbuf,
 						 int of, int len) {
 	ssize_t remain = rkbuf->rkbuf_size - (of + len);
 
@@ -398,7 +398,7 @@ static __inline RD_UNUSED void *rd_kafka_buf_at (rd_kafka_buf_t *rkbuf,
  * NOTE: rd_kafka_buf_update() MUST NOT be called when a CRC calculation
  *       is in progress (between rd_kafka_buf_crc_init() & .._crc_finalize())
  */
-static __inline void rd_kafka_buf_update (rd_kafka_buf_t *rkbuf, size_t of,
+static RD_INLINE void rd_kafka_buf_update (rd_kafka_buf_t *rkbuf, size_t of,
                                           const void *data, size_t len) {
         ssize_t remain = rkbuf->rkbuf_size - (of + len);
         rd_kafka_assert(NULL, remain >= 0);
@@ -411,7 +411,7 @@ static __inline void rd_kafka_buf_update (rd_kafka_buf_t *rkbuf, size_t of,
 /**
  * Write int8_t to buffer.
  */
-static __inline size_t rd_kafka_buf_write_i8 (rd_kafka_buf_t *rkbuf,
+static RD_INLINE size_t rd_kafka_buf_write_i8 (rd_kafka_buf_t *rkbuf,
 					      int8_t v) {
         return rd_kafka_buf_write(rkbuf, &v, sizeof(v));
 }
@@ -420,7 +420,7 @@ static __inline size_t rd_kafka_buf_write_i8 (rd_kafka_buf_t *rkbuf,
  * Update int8_t in buffer at offset 'of'.
  * 'of' should have been previously returned by `.._buf_write_i8()`.
  */
-static __inline void rd_kafka_buf_update_i8 (rd_kafka_buf_t *rkbuf,
+static RD_INLINE void rd_kafka_buf_update_i8 (rd_kafka_buf_t *rkbuf,
 					     size_t of, int8_t v) {
         rd_kafka_buf_update(rkbuf, of, &v, sizeof(v));
 }
@@ -429,7 +429,7 @@ static __inline void rd_kafka_buf_update_i8 (rd_kafka_buf_t *rkbuf,
  * Write int16_t to buffer.
  * The value will be endian-swapped before write.
  */
-static __inline size_t rd_kafka_buf_write_i16 (rd_kafka_buf_t *rkbuf,
+static RD_INLINE size_t rd_kafka_buf_write_i16 (rd_kafka_buf_t *rkbuf,
 					       int16_t v) {
         v = htobe16(v);
         return rd_kafka_buf_write(rkbuf, &v, sizeof(v));
@@ -439,7 +439,7 @@ static __inline size_t rd_kafka_buf_write_i16 (rd_kafka_buf_t *rkbuf,
  * Update int16_t in buffer at offset 'of'.
  * 'of' should have been previously returned by `.._buf_write_i16()`.
  */
-static __inline void rd_kafka_buf_update_i16 (rd_kafka_buf_t *rkbuf,
+static RD_INLINE void rd_kafka_buf_update_i16 (rd_kafka_buf_t *rkbuf,
                                               size_t of, int16_t v) {
         v = htobe16(v);
         rd_kafka_buf_update(rkbuf, of, &v, sizeof(v));
@@ -449,7 +449,7 @@ static __inline void rd_kafka_buf_update_i16 (rd_kafka_buf_t *rkbuf,
  * Write int32_t to buffer.
  * The value will be endian-swapped before write.
  */
-static __inline size_t rd_kafka_buf_write_i32 (rd_kafka_buf_t *rkbuf,
+static RD_INLINE size_t rd_kafka_buf_write_i32 (rd_kafka_buf_t *rkbuf,
                                                int32_t v) {
         v = htobe32(v);
         return rd_kafka_buf_write(rkbuf, &v, sizeof(v));
@@ -459,7 +459,7 @@ static __inline size_t rd_kafka_buf_write_i32 (rd_kafka_buf_t *rkbuf,
  * Update int32_t in buffer at offset 'of'.
  * 'of' should have been previously returned by `.._buf_write_i32()`.
  */
-static __inline void rd_kafka_buf_update_i32 (rd_kafka_buf_t *rkbuf,
+static RD_INLINE void rd_kafka_buf_update_i32 (rd_kafka_buf_t *rkbuf,
                                               size_t of, int32_t v) {
         v = htobe32(v);
         rd_kafka_buf_update(rkbuf, of, &v, sizeof(v));
@@ -469,7 +469,7 @@ static __inline void rd_kafka_buf_update_i32 (rd_kafka_buf_t *rkbuf,
  * Update int32_t in buffer at offset 'of'.
  * 'of' should have been previously returned by `.._buf_write_i32()`.
  */
-static __inline void rd_kafka_buf_update_u32 (rd_kafka_buf_t *rkbuf,
+static RD_INLINE void rd_kafka_buf_update_u32 (rd_kafka_buf_t *rkbuf,
                                               size_t of, uint32_t v) {
         v = htobe32(v);
         rd_kafka_buf_update(rkbuf, of, &v, sizeof(v));
@@ -480,7 +480,7 @@ static __inline void rd_kafka_buf_update_u32 (rd_kafka_buf_t *rkbuf,
  * Write int64_t to buffer.
  * The value will be endian-swapped before write.
  */
-static __inline size_t rd_kafka_buf_write_i64 (rd_kafka_buf_t *rkbuf, int64_t v) {
+static RD_INLINE size_t rd_kafka_buf_write_i64 (rd_kafka_buf_t *rkbuf, int64_t v) {
         v = htobe64(v);
         return rd_kafka_buf_write(rkbuf, &v, sizeof(v));
 }
@@ -489,7 +489,7 @@ static __inline size_t rd_kafka_buf_write_i64 (rd_kafka_buf_t *rkbuf, int64_t v)
  * Update int64_t in buffer at address 'ptr'.
  * 'of' should have been previously returned by `.._buf_write_i64()`.
  */
-static __inline void rd_kafka_buf_update_i64 (rd_kafka_buf_t *rkbuf,
+static RD_INLINE void rd_kafka_buf_update_i64 (rd_kafka_buf_t *rkbuf,
                                               size_t of, int64_t v) {
         v = htobe64(v);
         rd_kafka_buf_update(rkbuf, of, &v, sizeof(v));
@@ -499,7 +499,7 @@ static __inline void rd_kafka_buf_update_i64 (rd_kafka_buf_t *rkbuf,
 /**
  * Write (copy) Kafka string to buffer.
  */
-static __inline size_t rd_kafka_buf_write_kstr (rd_kafka_buf_t *rkbuf,
+static RD_INLINE size_t rd_kafka_buf_write_kstr (rd_kafka_buf_t *rkbuf,
                                                 const rd_kafkap_str_t *kstr) {
         return rd_kafka_buf_write(rkbuf, RD_KAFKAP_STR_SER(kstr),
 				  RD_KAFKAP_STR_SIZE(kstr));
@@ -508,7 +508,7 @@ static __inline size_t rd_kafka_buf_write_kstr (rd_kafka_buf_t *rkbuf,
 /**
  * Write (copy) char * string to buffer.
  */
-static __inline size_t rd_kafka_buf_write_str (rd_kafka_buf_t *rkbuf,
+static RD_INLINE size_t rd_kafka_buf_write_str (rd_kafka_buf_t *rkbuf,
                                                const char *str, size_t len) {
         size_t r;
         if (!str)
@@ -525,7 +525,7 @@ static __inline size_t rd_kafka_buf_write_str (rd_kafka_buf_t *rkbuf,
 /**
  * Push (i.e., no copy) Kafka string to buffer iovec
  */
-static __inline void rd_kafka_buf_push_kstr (rd_kafka_buf_t *rkbuf,
+static RD_INLINE void rd_kafka_buf_push_kstr (rd_kafka_buf_t *rkbuf,
                                              const rd_kafkap_str_t *kstr) {
 	rd_kafka_buf_push(rkbuf, RD_KAFKAP_STR_SER(kstr),
 			  RD_KAFKAP_STR_SIZE(kstr));
@@ -536,7 +536,7 @@ static __inline void rd_kafka_buf_push_kstr (rd_kafka_buf_t *rkbuf,
 /**
  * Write (copy) Kafka bytes to buffer.
  */
-static __inline size_t rd_kafka_buf_write_kbytes (rd_kafka_buf_t *rkbuf,
+static RD_INLINE size_t rd_kafka_buf_write_kbytes (rd_kafka_buf_t *rkbuf,
 					          const rd_kafkap_bytes_t *kbytes){
         return rd_kafka_buf_write(rkbuf, RD_KAFKAP_BYTES_SER(kbytes),
                                   RD_KAFKAP_BYTES_SIZE(kbytes));
@@ -545,7 +545,7 @@ static __inline size_t rd_kafka_buf_write_kbytes (rd_kafka_buf_t *rkbuf,
 /**
  * Push (i.e., no copy) Kafka bytes to buffer iovec
  */
-static __inline void rd_kafka_buf_push_kbytes (rd_kafka_buf_t *rkbuf,
+static RD_INLINE void rd_kafka_buf_push_kbytes (rd_kafka_buf_t *rkbuf,
 					       const rd_kafkap_bytes_t *kbytes){
 	rd_kafka_buf_push(rkbuf, RD_KAFKAP_BYTES_SER(kbytes),
 			  RD_KAFKAP_BYTES_SIZE(kbytes));
@@ -554,7 +554,7 @@ static __inline void rd_kafka_buf_push_kbytes (rd_kafka_buf_t *rkbuf,
 /**
  * Write (copy) binary bytes to buffer as Kafka bytes encapsulate data.
  */
-static __inline size_t rd_kafka_buf_write_bytes (rd_kafka_buf_t *rkbuf,
+static RD_INLINE size_t rd_kafka_buf_write_bytes (rd_kafka_buf_t *rkbuf,
                                                  const void *payload, size_t size) {
         size_t r;
         if (!payload)
@@ -584,7 +584,7 @@ size_t rd_kafka_buf_write_Message (rd_kafka_buf_t *rkbuf,
 /**
  * Start calculating CRC from now and track it in '*crcp'.
  */
-static __inline RD_UNUSED void rd_kafka_buf_crc_init (rd_kafka_buf_t *rkbuf) {
+static RD_INLINE RD_UNUSED void rd_kafka_buf_crc_init (rd_kafka_buf_t *rkbuf) {
 	rd_kafka_assert(NULL, !(rkbuf->rkbuf_flags & RD_KAFKA_OP_F_CRC));
 	rkbuf->rkbuf_flags |= RD_KAFKA_OP_F_CRC;
 	rkbuf->rkbuf_crc = rd_crc32_init();
@@ -593,7 +593,7 @@ static __inline RD_UNUSED void rd_kafka_buf_crc_init (rd_kafka_buf_t *rkbuf) {
 /**
  * Finalizes CRC calculation and returns the calculated checksum.
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 rd_crc32_t rd_kafka_buf_crc_finalize (rd_kafka_buf_t *rkbuf) {
 	rkbuf->rkbuf_flags &= ~RD_KAFKA_OP_F_CRC;
 	return rd_crc32_finalize(rkbuf->rkbuf_crc);
@@ -603,7 +603,7 @@ rd_crc32_t rd_kafka_buf_crc_finalize (rd_kafka_buf_t *rkbuf) {
 /**
  * Returns the number of remaining unused iovecs in buffer.
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 int rd_kafka_buf_iov_remain (const rd_kafka_buf_t *rkbuf) {
 	return rkbuf->rkbuf_iovcnt - rkbuf->rkbuf_msg.msg_iovlen;
 }
diff --git a/src/rdkafka_feature.c b/src/rdkafka_feature.c
index 05b7ba1485..8cb161bb3e 100644
--- a/src/rdkafka_feature.c
+++ b/src/rdkafka_feature.c
@@ -217,7 +217,7 @@ int rd_kafka_get_legacy_ApiVersions (const char *broker_version,
  * @returns 1 if true, else 0.
  * @remark \p apis must be sorted using rd_kafka_ApiVersion_key_cmp()
  */
-static __inline int
+static RD_INLINE int
 rd_kafka_ApiVersion_check (const struct rd_kafka_ApiVersion *apis, size_t api_cnt,
 			   const struct rd_kafka_ApiVersion *match) {
 	const struct rd_kafka_ApiVersion *api;
diff --git a/src/rdkafka_int.h b/src/rdkafka_int.h
index 65ed7098b2..bfe6816d43 100644
--- a/src/rdkafka_int.h
+++ b/src/rdkafka_int.h
@@ -266,7 +266,7 @@ void rd_kafka_log0(const rd_kafka_t *rk, const char *extra, int level,
 
 extern rd_kafka_resp_err_t RD_TLS rd_kafka_last_error_code;
 
-static RD_UNUSED __inline
+static RD_UNUSED RD_INLINE
 rd_kafka_resp_err_t rd_kafka_set_last_error (rd_kafka_resp_err_t err,
 					     int errnox) {
 	if (errnox)
diff --git a/src/rdkafka_msg.h b/src/rdkafka_msg.h
index 63b75664e9..1027b7c073 100644
--- a/src/rdkafka_msg.h
+++ b/src/rdkafka_msg.h
@@ -78,7 +78,7 @@ typedef struct rd_kafka_msgq_s {
 /**
  * Returns the number of messages in the specified queue.
  */
-static __inline RD_UNUSED int rd_kafka_msgq_len (rd_kafka_msgq_t *rkmq) {
+static RD_INLINE RD_UNUSED int rd_kafka_msgq_len (rd_kafka_msgq_t *rkmq) {
 	return (int)rd_atomic32_get(&rkmq->rkmq_msg_cnt);
 }
 
@@ -92,7 +92,7 @@ int rd_kafka_msg_new (rd_kafka_itopic_t *rkt, int32_t force_partition,
 		      void *msg_opaque);
 
 
-static __inline RD_UNUSED void rd_kafka_msgq_init (rd_kafka_msgq_t *rkmq) {
+static RD_INLINE RD_UNUSED void rd_kafka_msgq_init (rd_kafka_msgq_t *rkmq) {
 	TAILQ_INIT(&rkmq->rkmq_msgs);
 	rd_atomic32_set(&rkmq->rkmq_msg_cnt, 0);
 	rd_atomic64_set(&rkmq->rkmq_msg_bytes, 0);
@@ -103,7 +103,7 @@ static __inline RD_UNUSED void rd_kafka_msgq_init (rd_kafka_msgq_t *rkmq) {
  * 'src' will be cleared.
  * Proper locks for 'src' and 'dst' must be held.
  */
-static __inline RD_UNUSED void rd_kafka_msgq_concat (rd_kafka_msgq_t *dst,
+static RD_INLINE RD_UNUSED void rd_kafka_msgq_concat (rd_kafka_msgq_t *dst,
 						   rd_kafka_msgq_t *src) {
 	TAILQ_CONCAT(&dst->rkmq_msgs, &src->rkmq_msgs, rkm_link);
 	(void)rd_atomic32_add(&dst->rkmq_msg_cnt, rd_atomic32_get(&src->rkmq_msg_cnt));
@@ -115,7 +115,7 @@ static __inline RD_UNUSED void rd_kafka_msgq_concat (rd_kafka_msgq_t *dst,
  * Move queue 'src' to 'dst' (overwrites dst)
  * Source will be cleared.
  */
-static __inline RD_UNUSED void rd_kafka_msgq_move (rd_kafka_msgq_t *dst,
+static RD_INLINE RD_UNUSED void rd_kafka_msgq_move (rd_kafka_msgq_t *dst,
 						 rd_kafka_msgq_t *src) {
 	TAILQ_MOVE(&dst->rkmq_msgs, &src->rkmq_msgs, rkm_link);
 	rd_atomic32_set(&dst->rkmq_msg_cnt, rd_atomic32_get(&src->rkmq_msg_cnt));
@@ -127,7 +127,7 @@ static __inline RD_UNUSED void rd_kafka_msgq_move (rd_kafka_msgq_t *dst,
 /**
  * rd_free all msgs in msgq and reinitialize the msgq.
  */
-static __inline RD_UNUSED void rd_kafka_msgq_purge (rd_kafka_t *rk,
+static RD_INLINE RD_UNUSED void rd_kafka_msgq_purge (rd_kafka_t *rk,
                                                     rd_kafka_msgq_t *rkmq) {
 	rd_kafka_msg_t *rkm, *next;
 
@@ -146,7 +146,7 @@ static __inline RD_UNUSED void rd_kafka_msgq_purge (rd_kafka_t *rk,
 /**
  * Remove message from message queue
  */
-static __inline RD_UNUSED 
+static RD_INLINE RD_UNUSED 
 rd_kafka_msg_t *rd_kafka_msgq_deq (rd_kafka_msgq_t *rkmq,
 				   rd_kafka_msg_t *rkm,
 				   int do_count) {
@@ -162,7 +162,7 @@ rd_kafka_msg_t *rd_kafka_msgq_deq (rd_kafka_msgq_t *rkmq,
 	return rkm;
 }
 
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 rd_kafka_msg_t *rd_kafka_msgq_pop (rd_kafka_msgq_t *rkmq) {
 	rd_kafka_msg_t *rkm;
 
@@ -175,7 +175,7 @@ rd_kafka_msg_t *rd_kafka_msgq_pop (rd_kafka_msgq_t *rkmq) {
 /**
  * Insert message at head of message queue.
  */
-static __inline RD_UNUSED void rd_kafka_msgq_insert (rd_kafka_msgq_t *rkmq,
+static RD_INLINE RD_UNUSED void rd_kafka_msgq_insert (rd_kafka_msgq_t *rkmq,
 						   rd_kafka_msg_t *rkm) {
 	TAILQ_INSERT_HEAD(&rkmq->rkmq_msgs, rkm, rkm_link);
 	(void)rd_atomic32_add(&rkmq->rkmq_msg_cnt, 1);
@@ -185,7 +185,7 @@ static __inline RD_UNUSED void rd_kafka_msgq_insert (rd_kafka_msgq_t *rkmq,
 /**
  * Append message to tail of message queue.
  */
-static __inline RD_UNUSED void rd_kafka_msgq_enq (rd_kafka_msgq_t *rkmq,
+static RD_INLINE RD_UNUSED void rd_kafka_msgq_enq (rd_kafka_msgq_t *rkmq,
 						rd_kafka_msg_t *rkm) {
 	TAILQ_INSERT_TAIL(&rkmq->rkmq_msgs, rkm, rkm_link);
 	(void)rd_atomic32_add(&rkmq->rkmq_msg_cnt, 1);
diff --git a/src/rdkafka_offset.h b/src/rdkafka_offset.h
index bf3a42576f..3c3b4bdb2b 100644
--- a/src/rdkafka_offset.h
+++ b/src/rdkafka_offset.h
@@ -41,7 +41,7 @@ const char *rd_kafka_offset2str (int64_t offset);
  *
  * See head of rdkafka_offset.c for more information.
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 void rd_kafka_offset_store0 (rd_kafka_toppar_t *rktp, int64_t offset,
 			     int lock) {
 	if (lock)
diff --git a/src/rdkafka_partition.c b/src/rdkafka_partition.c
index b4700d5a8c..3affde7f90 100644
--- a/src/rdkafka_partition.c
+++ b/src/rdkafka_partition.c
@@ -48,7 +48,7 @@ const char *rd_kafka_fetch_states[] = {
 };
 
 
-static __inline void rd_kafka_broker_fetch_toppar_del (rd_kafka_broker_t *rkb,
+static RD_INLINE void rd_kafka_broker_fetch_toppar_del (rd_kafka_broker_t *rkb,
                                                        rd_kafka_toppar_t *rktp);
 
 
@@ -1320,7 +1320,7 @@ void rd_kafka_toppar_seek (rd_kafka_toppar_t *rktp,
  * Locality: broker thread
  * Locks: none
  */
-static __inline void rd_kafka_broker_fetch_toppar_add (rd_kafka_broker_t *rkb,
+static RD_INLINE void rd_kafka_broker_fetch_toppar_add (rd_kafka_broker_t *rkb,
                                                        rd_kafka_toppar_t *rktp){
         if (rktp->rktp_fetch)
                 return; /* Already added */
@@ -1346,7 +1346,7 @@ static __inline void rd_kafka_broker_fetch_toppar_add (rd_kafka_broker_t *rkb,
  * Locality: broker thread
  * Locks: none
  */
-static __inline void rd_kafka_broker_fetch_toppar_del (rd_kafka_broker_t *rkb,
+static RD_INLINE void rd_kafka_broker_fetch_toppar_del (rd_kafka_broker_t *rkb,
                                                        rd_kafka_toppar_t *rktp){
         if (!rktp->rktp_fetch)
                 return; /* Not added */
diff --git a/src/rdkafka_partition.h b/src/rdkafka_partition.h
index 0e12dec18b..cd5e0c71fe 100644
--- a/src/rdkafka_partition.h
+++ b/src/rdkafka_partition.h
@@ -320,7 +320,7 @@ void rd_kafka_toppar_fetch_stopped (rd_kafka_toppar_t *rktp,
 /**
  * Updates the current toppar fetch round-robin next pointer.
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 void rd_kafka_broker_fetch_toppar_next (rd_kafka_broker_t *rkb,
                                         rd_kafka_toppar_t *sugg_next) {
         if (CIRCLEQ_EMPTY(&rkb->rkb_fetch_toppars) ||
@@ -411,7 +411,7 @@ struct rd_kafka_toppar_ver {
 /**
  * @brief Toppar + Op version comparator.
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 int rd_kafka_toppar_ver_cmp (const void *_a, const void *_b) {
 	const struct rd_kafka_toppar_ver *a = _a, *b = _b;
 	const rd_kafka_toppar_t *rktp_a = rd_kafka_toppar_s2i(a->s_rktp);
@@ -429,7 +429,7 @@ int rd_kafka_toppar_ver_cmp (const void *_a, const void *_b) {
 /**
  * @brief Frees up resources for \p tver but not the \p tver itself.
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 void rd_kafka_toppar_ver_destroy (struct rd_kafka_toppar_ver *tver) {
 	rd_kafka_toppar_destroy(tver->s_rktp);
 }
diff --git a/src/rdkafka_proto.h b/src/rdkafka_proto.h
index db3b73e3f0..79b762a24a 100644
--- a/src/rdkafka_proto.h
+++ b/src/rdkafka_proto.h
@@ -201,7 +201,7 @@ static RD_UNUSED void rd_kafkap_str_destroy (rd_kafkap_str_t *kstr) {
  * Nul-terminates the string, but the trailing \0 is not part of
  * the serialized string.
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 rd_kafkap_str_t *rd_kafkap_str_new (const char *str, int len) {
 	rd_kafkap_str_t *kstr;
 	int16_t klen;
@@ -236,12 +236,12 @@ rd_kafkap_str_t *rd_kafkap_str_new (const char *str, int len) {
  * Makes a copy of `src`. The copy will be fully allocated and should
  * be freed with rd_kafka_pstr_destroy()
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 rd_kafkap_str_t *rd_kafkap_str_copy (const rd_kafkap_str_t *src) {
         return rd_kafkap_str_new(src->str, src->len);
 }
 
-static __inline RD_UNUSED int rd_kafkap_str_cmp (const rd_kafkap_str_t *a,
+static RD_INLINE RD_UNUSED int rd_kafkap_str_cmp (const rd_kafkap_str_t *a,
 						 const rd_kafkap_str_t *b) {
 	int minlen = RD_MIN(a->len, b->len);
 	int r = memcmp(a->str, b->str, minlen);
@@ -251,7 +251,7 @@ static __inline RD_UNUSED int rd_kafkap_str_cmp (const rd_kafkap_str_t *a,
 		return a->len - b->len;
 }
 
-static __inline RD_UNUSED int rd_kafkap_str_cmp_str (const rd_kafkap_str_t *a,
+static RD_INLINE RD_UNUSED int rd_kafkap_str_cmp_str (const rd_kafkap_str_t *a,
 						     const char *str) {
 	int len = (int)strlen(str);
 	int minlen = RD_MIN(a->len, len);
@@ -262,7 +262,7 @@ static __inline RD_UNUSED int rd_kafkap_str_cmp_str (const rd_kafkap_str_t *a,
 		return a->len - len;
 }
 
-static __inline RD_UNUSED int rd_kafkap_str_cmp_str2 (const char *str,
+static RD_INLINE RD_UNUSED int rd_kafkap_str_cmp_str2 (const char *str,
 						      const rd_kafkap_str_t *b){
 	int len = (int)strlen(str);
 	int minlen = RD_MIN(b->len, len);
@@ -321,7 +321,7 @@ static RD_UNUSED void rd_kafkap_bytes_destroy (rd_kafkap_bytes_t *kbytes) {
  * Allocate a new Kafka bytes and make a copy of 'bytes'.
  * Supports Kafka NULL bytes.
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 rd_kafkap_bytes_t *rd_kafkap_bytes_new (const char *bytes, int32_t len) {
 	rd_kafkap_bytes_t *kbytes;
 	int32_t klen;
@@ -351,13 +351,13 @@ rd_kafkap_bytes_t *rd_kafkap_bytes_new (const char *bytes, int32_t len) {
  * Makes a copy of `src`. The copy will be fully allocated and should
  * be freed with rd_kafkap_bytes_destroy()
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 rd_kafkap_bytes_t *rd_kafkap_bytes_copy (const rd_kafkap_bytes_t *src) {
         return rd_kafkap_bytes_new(src->data, src->len);
 }
 
 
-static __inline RD_UNUSED int rd_kafkap_bytes_cmp (const rd_kafkap_bytes_t *a,
+static RD_INLINE RD_UNUSED int rd_kafkap_bytes_cmp (const rd_kafkap_bytes_t *a,
 						   const rd_kafkap_bytes_t *b) {
 	int minlen = RD_MIN(a->len, b->len);
 	int r = memcmp(a->data, b->data, minlen);
@@ -367,7 +367,7 @@ static __inline RD_UNUSED int rd_kafkap_bytes_cmp (const rd_kafkap_bytes_t *a,
 		return a->len - b->len;
 }
 
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 int rd_kafkap_bytes_cmp_data (const rd_kafkap_bytes_t *a,
 			      const char *data, int len) {
 	int minlen = RD_MIN(a->len, len);
diff --git a/src/rdkafka_queue.c b/src/rdkafka_queue.c
index 43637514b3..edaa3a291b 100644
--- a/src/rdkafka_queue.c
+++ b/src/rdkafka_queue.c
@@ -223,7 +223,7 @@ int rd_kafka_q_move_cnt (rd_kafka_q_t *dstq, rd_kafka_q_t *srcq,
 /**
  * Filters out outdated ops.
  */
-static __inline rd_kafka_op_t *rd_kafka_op_filter (rd_kafka_q_t *rkq,
+static RD_INLINE rd_kafka_op_t *rd_kafka_op_filter (rd_kafka_q_t *rkq,
                                                    rd_kafka_op_t *rko) {
         if (unlikely(!rko))
                 return NULL;
diff --git a/src/rdkafka_queue.h b/src/rdkafka_queue.h
index 8f10f21129..71ca18b733 100644
--- a/src/rdkafka_queue.h
+++ b/src/rdkafka_queue.h
@@ -38,14 +38,14 @@ rd_kafka_q_t *rd_kafka_q_new (rd_kafka_t *rk);
 void rd_kafka_q_destroy_final (rd_kafka_q_t *rkq);
 
 
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 void rd_kafka_q_keep (rd_kafka_q_t *rkq) {
         mtx_lock(&rkq->rkq_lock);
         rkq->rkq_refcnt++;
         mtx_unlock(&rkq->rkq_lock);
 }
 
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 void rd_kafka_q_destroy (rd_kafka_q_t *rkq) {
         int do_delete = 0;
 
@@ -64,7 +64,7 @@ void rd_kafka_q_destroy (rd_kafka_q_t *rkq) {
  * WARNING: All messages will be lost and leaked.
  * NOTE: No locking is performed.
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 void rd_kafka_q_reset (rd_kafka_q_t *rkq) {
 	TAILQ_INIT(&rkq->rkq_q);
         rd_dassert(TAILQ_EMPTY(&rkq->rkq_q));
@@ -77,7 +77,7 @@ void rd_kafka_q_reset (rd_kafka_q_t *rkq) {
  * Disable a queue.
  * Attempting to enqueue messages to the queue will cause an assert.
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 void rd_kafka_q_disable0 (rd_kafka_q_t *rkq, int do_lock) {
         if (do_lock)
                 mtx_lock(&rkq->rkq_lock);
@@ -103,7 +103,7 @@ void rd_kafka_q_fwd_set0 (rd_kafka_q_t *srcq, rd_kafka_q_t *destq, int do_lock);
  *
  * Locality: any thread.
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 int rd_kafka_q_enq (rd_kafka_q_t *rkq, rd_kafka_op_t *rko) {
 	rd_kafka_q_t *fwdq;
 
@@ -149,7 +149,7 @@ int rd_kafka_q_enq (rd_kafka_q_t *rkq, rd_kafka_op_t *rko) {
  * NOTE: rkq_lock MUST be held
  * Locality: any thread
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 void rd_kafka_q_deq0 (rd_kafka_q_t *rkq, rd_kafka_op_t *rko) {
         rd_dassert(rkq->rkq_flags & RD_KAFKA_Q_F_READY);
 	rd_dassert(rkq->rkq_qlen > 0 &&
@@ -167,7 +167,7 @@ void rd_kafka_q_deq0 (rd_kafka_q_t *rkq, rd_kafka_op_t *rko) {
  *
  * Locality: any thread.
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 void rd_kafka_q_concat0 (rd_kafka_q_t *rkq, rd_kafka_q_t *srcq,
 			 int do_lock) {
 	if (do_lock)
@@ -200,7 +200,7 @@ void rd_kafka_q_concat0 (rd_kafka_q_t *rkq, rd_kafka_q_t *srcq,
  *
  * Locality: any thread.
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 void rd_kafka_q_prepend0 (rd_kafka_q_t *rkq, rd_kafka_q_t *srcq,
                           int do_lock) {
 	if (do_lock)
@@ -226,7 +226,7 @@ void rd_kafka_q_prepend0 (rd_kafka_q_t *rkq, rd_kafka_q_t *srcq,
 
 
 /* Returns the number of elements in the queue */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 int rd_kafka_q_len (rd_kafka_q_t *rkq) {
 	int qlen;
 	mtx_lock(&rkq->rkq_lock);
@@ -239,7 +239,7 @@ int rd_kafka_q_len (rd_kafka_q_t *rkq) {
 }
 
 /* Returns the total size of elements in the queue */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 uint64_t rd_kafka_q_size (rd_kafka_q_t *rkq) {
 	uint64_t sz;
 	mtx_lock(&rkq->rkq_lock);
@@ -286,7 +286,7 @@ void rd_kafka_q_fix_offsets (rd_kafka_q_t *rkq, int64_t min_offset,
  *         is not removed from the queue and may thus not be held for longer
  *         than the lock is held.
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 rd_kafka_op_t *rd_kafka_q_last (rd_kafka_q_t *rkq, rd_kafka_op_type_t op_type,
 				int allow_err) {
 	rd_kafka_op_t *rko;
diff --git a/src/rdkafka_subscription.c b/src/rdkafka_subscription.c
index 37e7b892a5..7884624f9b 100644
--- a/src/rdkafka_subscription.c
+++ b/src/rdkafka_subscription.c
@@ -44,7 +44,7 @@
  * A rd_kafka_t handle can never migrate from simple to high-level, or
  * vice versa, so we dont need a ..consumer_del().
  */
-static __inline int rd_kafka_high_level_consumer_add (rd_kafka_t *rk) {
+static RD_INLINE int rd_kafka_high_level_consumer_add (rd_kafka_t *rk) {
         if (rd_atomic32_get(&rk->rk_simple_cnt) > 0)
                 return 0;
 
diff --git a/src/rdkafka_timer.c b/src/rdkafka_timer.c
index 720bce1728..ba24e422e9 100644
--- a/src/rdkafka_timer.c
+++ b/src/rdkafka_timer.c
@@ -32,21 +32,21 @@
 #include "rdsysqueue.h"
 
 
-static __inline void rd_kafka_timers_lock (rd_kafka_timers_t *rkts) {
+static RD_INLINE void rd_kafka_timers_lock (rd_kafka_timers_t *rkts) {
         mtx_lock(&rkts->rkts_lock);
 }
 
-static __inline void rd_kafka_timers_unlock (rd_kafka_timers_t *rkts) {
+static RD_INLINE void rd_kafka_timers_unlock (rd_kafka_timers_t *rkts) {
         mtx_unlock(&rkts->rkts_lock);
 }
 
 
-static __inline int rd_kafka_timer_started (const rd_kafka_timer_t *rtmr) {
+static RD_INLINE int rd_kafka_timer_started (const rd_kafka_timer_t *rtmr) {
 	return rtmr->rtmr_interval ? 1 : 0;
 }
 
 
-static __inline int rd_kafka_timer_scheduled (const rd_kafka_timer_t *rtmr) {
+static RD_INLINE int rd_kafka_timer_scheduled (const rd_kafka_timer_t *rtmr) {
 	return rtmr->rtmr_next ? 1 : 0;
 }
 
diff --git a/src/rdkafka_transport.c b/src/rdkafka_transport.c
index 724ada8e0f..471302eaf9 100644
--- a/src/rdkafka_transport.c
+++ b/src/rdkafka_transport.c
@@ -358,7 +358,7 @@ static void rd_kafka_transport_ssl_init (void) {
  *
  * Locality: broker thread
  */
-static __inline int
+static RD_INLINE int
 rd_kafka_transport_ssl_io_update (rd_kafka_transport_t *rktrans, int ret,
 				  char *errstr, size_t errstr_size) {
 	int serr = SSL_get_error(rktrans->rktrans_ssl, ret);
diff --git a/src/rdlist.c b/src/rdlist.c
index 64d944cd5e..f2fdaa84be 100644
--- a/src/rdlist.c
+++ b/src/rdlist.c
@@ -156,7 +156,7 @@ void *rd_list_remove_cmp (rd_list_t *rl, void *match_elem,
  */
 static RD_TLS int (*rd_list_cmp_curr) (const void *, const void *);
 
-static __inline
+static RD_INLINE
 int rd_list_cmp_trampoline (const void *_a, const void *_b) {
 	const void *a = *(const void **)_a, *b = *(const void **)_b;
 
diff --git a/src/rdlist.h b/src/rdlist.h
index 8d2a1dc50a..89c01eb6c4 100644
--- a/src/rdlist.h
+++ b/src/rdlist.h
@@ -147,7 +147,7 @@ void *rd_list_elem (const rd_list_t *rl, int idx);
 /**
  * Returns the number of elements in list.
  */
-static __inline RD_UNUSED int rd_list_cnt (const rd_list_t *rl) {
+static RD_INLINE RD_UNUSED int rd_list_cnt (const rd_list_t *rl) {
         return rl->rl_cnt;
 }
 
diff --git a/src/rdposix.h b/src/rdposix.h
index c4266ef900..3ea0a5c428 100644
--- a/src/rdposix.h
+++ b/src/rdposix.h
@@ -52,6 +52,7 @@
 #endif
 
 #define RD_UNUSED   __attribute__((unused))
+#define RD_INLINE   inline
 #define RD_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
 #define RD_NORETURN __attribute__((noreturn))
 #define RD_IS_CONSTANT(p)  __builtin_constant_p((p))
@@ -102,7 +103,7 @@
  * Microsecond sleep.
  * Will retry on signal interrupt unless *terminate is true.
  */
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 void rd_usleep (int usec, rd_atomic32_t *terminate) {
         struct timespec req = {usec / 1000000, (long)(usec % 1000000) * 1000};
 
diff --git a/src/rdrand.h b/src/rdrand.h
index 4a12c8983b..6a11c8ccf6 100644
--- a/src/rdrand.h
+++ b/src/rdrand.h
@@ -32,8 +32,8 @@
 /**
  * Returns a random (using rand(3)) number between 'low'..'high' (inclusive).
  */
-static __inline int rd_jitter (int low, int high) RD_UNUSED;
-static __inline int rd_jitter (int low, int high) {
+static RD_INLINE int rd_jitter (int low, int high) RD_UNUSED;
+static RD_INLINE int rd_jitter (int low, int high) {
 	return (low + (rand() % (high+1)));
 	
 }
diff --git a/src/rdtime.h b/src/rdtime.h
index 9159041c55..6ff57acca0 100644
--- a/src/rdtime.h
+++ b/src/rdtime.h
@@ -65,8 +65,8 @@
  * @remark There is no monotonic clock on OSX, the system time
  *         is returned instead.
  */
-static __inline rd_ts_t rd_clock (void) RD_UNUSED;
-static __inline rd_ts_t rd_clock (void) {
+static RD_INLINE rd_ts_t rd_clock (void) RD_UNUSED;
+static RD_INLINE rd_ts_t rd_clock (void) {
 #ifdef __APPLE__
 	/* No monotonic clock on Darwin */
 	struct timeval tv;
@@ -87,7 +87,7 @@ static __inline rd_ts_t rd_clock (void) {
  * @returns UTC wallclock time as number of microseconds since
  *          beginning of the epoch.
  */
-static __inline RD_UNUSED rd_ts_t rd_uclock (void) {
+static RD_INLINE RD_UNUSED rd_ts_t rd_uclock (void) {
 	struct timeval tv;
 	rd_gettimeofday(&tv, NULL);
 	return ((rd_ts_t)tv.tv_sec * 1000000LLU) + (rd_ts_t)tv.tv_usec;
@@ -98,8 +98,8 @@ static __inline RD_UNUSED rd_ts_t rd_uclock (void) {
 /**
  * Thread-safe version of ctime() that strips the trailing newline.
  */
-static __inline const char *rd_ctime (const time_t *t) RD_UNUSED;
-static __inline const char *rd_ctime (const time_t *t) {
+static RD_INLINE const char *rd_ctime (const time_t *t) RD_UNUSED;
+static RD_INLINE const char *rd_ctime (const time_t *t) {
 	static RD_TLS char ret[27];
 
 #ifndef _MSC_VER
@@ -123,7 +123,7 @@ static __inline const char *rd_ctime (const time_t *t) {
  * @returns the absolute timeout which should later be passed
  *          to rd_timeout_adjust().
  */
-static __inline rd_ts_t rd_timeout_init (int timeout_ms) {
+static RD_INLINE rd_ts_t rd_timeout_init (int timeout_ms) {
 	if (timeout_ms == RD_POLL_INFINITE ||
 	    timeout_ms == RD_POLL_NOWAIT)
 		return 0;
@@ -138,7 +138,7 @@ static __inline rd_ts_t rd_timeout_init (int timeout_ms) {
  *
  * Honours RD_POLL_INFINITE, RD_POLL_NOWAIT.
  */
-static __inline void rd_timeout_adjust (rd_ts_t abs_timeout,
+static RD_INLINE void rd_timeout_adjust (rd_ts_t abs_timeout,
 					int *timeout_msp) {
 	if (*timeout_msp == RD_POLL_INFINITE ||
 	    *timeout_msp == RD_POLL_NOWAIT)
diff --git a/src/rdwin32.h b/src/rdwin32.h
index 8184a47b91..b8a24407b0 100644
--- a/src/rdwin32.h
+++ b/src/rdwin32.h
@@ -79,6 +79,7 @@ struct msghdr {
 #endif
 
 #define RD_UNUSED
+#define RD_INLINE  __inline
 #define RD_WARN_UNUSED_RESULT
 #define RD_NORETURN __declspec(noreturn)
 #define RD_IS_CONSTANT(p)  (0)
@@ -101,7 +102,7 @@ struct msghdr {
 
 #define RD_FORMAT(...)
 
-static RD_UNUSED __inline
+static RD_UNUSED RD_INLINE
 int rd_vsnprintf (char *str, size_t size, const char *format, va_list ap) {
         int cnt = -1;
 
@@ -113,7 +114,7 @@ int rd_vsnprintf (char *str, size_t size, const char *format, va_list ap) {
         return cnt;
 }
 
-static RD_UNUSED __inline
+static RD_UNUSED RD_INLINE
 int rd_snprintf (char *str, size_t size, const char *format, ...) {
         int cnt;
         va_list ap;
@@ -133,7 +134,7 @@ int rd_snprintf (char *str, size_t size, const char *format, ...) {
 /**
  * Errors
  */
-static __inline RD_UNUSED const char *rd_strerror(int err) {
+static RD_INLINE RD_UNUSED const char *rd_strerror(int err) {
 	static RD_TLS char ret[128];
 
 	strerror_s(ret, sizeof(ret) - 1, err);
diff --git a/src/snappy.c b/src/snappy.c
index df9f414ce5..eddf7855bd 100644
--- a/src/snappy.c
+++ b/src/snappy.c
@@ -57,7 +57,6 @@
 #endif
 
 #include "rd.h"
-#define inline __inline
 
 #define CRASH_UNLESS(x) BUG_ON(!(x))
 #define CHECK(cond) CRASH_UNLESS(cond)
@@ -129,7 +128,7 @@ static inline bool is_little_endian(void)
 #define rd_ctz64(n) __builtin_ctzll(n)
 #else
 #include <intrin.h>
-static int __inline rd_clz(u32 x) {
+static int RD_INLINE rd_clz(u32 x) {
 	int r = 0;
 	if (_BitScanForward(&r, x))
 		return 31 - r;
@@ -137,7 +136,7 @@ static int __inline rd_clz(u32 x) {
 		return 32;
 }
 
-static int __inline rd_ctz(u32 x) {
+static int RD_INLINE rd_ctz(u32 x) {
 	int r = 0;
 	if (_BitScanForward(&r, x))
 		return r;
@@ -145,7 +144,7 @@ static int __inline rd_ctz(u32 x) {
 		return 32;
 }
 
-static int __inline rd_ctz64(u64 x) {
+static int RD_INLINE rd_ctz64(u64 x) {
 #ifdef _M_X64
 	int r = 0;
 	if (_BitScanReverse64(&r, x))
diff --git a/tests/test.c b/tests/test.c
index cc6645494f..4ce60afe5a 100644
--- a/tests/test.c
+++ b/tests/test.c
@@ -420,7 +420,7 @@ void test_wait_exit (int timeout) {
 }
 
 
-static __inline unsigned int test_rand(void) {
+static RD_INLINE unsigned int test_rand(void) {
 	unsigned int r;
 #if _MSC_VER
 	rand_s(&r);
@@ -1607,7 +1607,7 @@ static struct test_mv_m *test_mv_mvec_add (struct test_mv_mvec *mvec) {
 /**
  * Returns message at index \p mi
  */
-static __inline struct test_mv_m *test_mv_mvec_get (struct test_mv_mvec *mvec,
+static RD_INLINE struct test_mv_m *test_mv_mvec_get (struct test_mv_mvec *mvec,
 						    int mi) {
 	return &mvec->m[mi];
 }
diff --git a/tests/test.h b/tests/test.h
index 568c7c9e91..42543206cb 100644
--- a/tests/test.h
+++ b/tests/test.h
@@ -40,7 +40,7 @@ extern mtx_t test_mtx;
 #define TEST_UNLOCK() mtx_unlock(&test_mtx)
 
 
-static __inline RD_UNUSED
+static RD_INLINE RD_UNUSED
 int tmout_multip (int msecs) {
         int r;
         TEST_LOCK();
@@ -182,12 +182,12 @@ char *test_str_id_generate (char *dest, size_t dest_size);
 /**
  * A microsecond monotonic clock
  */
-static __inline int64_t test_clock (void)
+static RD_INLINE int64_t test_clock (void)
 #ifndef _MSC_VER
 __attribute__((unused))
 #endif
 ;
-static __inline int64_t test_clock (void) {
+static RD_INLINE int64_t test_clock (void) {
 #ifdef __APPLE__
 	/* No monotonic clock on Darwin */
 	struct timeval tv;
@@ -242,8 +242,8 @@ void test_msg_parse0 (const char *func, int line,
 			testid,ptr,size,exp_partition,msgidp)
 
 
-static __inline int jitter (int low, int high) RD_UNUSED;
-static __inline int jitter (int low, int high) {
+static RD_INLINE int jitter (int low, int high) RD_UNUSED;
+static RD_INLINE int jitter (int low, int high) {
 	return (low + (rand() % (high+1)));
 }