Merge branch 'ps/reftable-portability' into jch

gitster · gitster · commit e5f544319257 · 2026-04-01T10:28:48.000-07:00
Update reftable library part with what is used in libgit2 to improve
portability to different target codebases and platforms.

* ps/reftable-portability:
  reftable: introduce "reftable-system.h" header
  reftable/system: add abstraction to mmap files
  reftable/system: add abstraction to retrieve time in milliseconds
  reftable/fsck: use REFTABLE_UNUSED instead of UNUSED
  reftable/stack: don't call fsync(3p) unless provided
  reftable/system: provide `REFTABLE_INLINE()` macro
diff --git a/reftable/basics.h b/reftable/basics.h
@@ -75,22 +75,22 @@ char *reftable_buf_detach(struct reftable_buf *buf);
 
 /* Bigendian en/decoding of integers */
 
-static inline void reftable_put_be16(void *out, uint16_t i)
+REFTABLE_INLINE(void) reftable_put_be16(void *out, uint16_t i)
 {
 	unsigned char *p = out;
 	p[0] = (uint8_t)((i >> 8) & 0xff);
 	p[1] = (uint8_t)((i >> 0) & 0xff);
 }
 
-static inline void reftable_put_be24(void *out, uint32_t i)
+REFTABLE_INLINE(void) reftable_put_be24(void *out, uint32_t i)
 {
 	unsigned char *p = out;
 	p[0] = (uint8_t)((i >> 16) & 0xff);
 	p[1] = (uint8_t)((i >>  8) & 0xff);
 	p[2] = (uint8_t)((i >>  0) & 0xff);
 }
 
-static inline void reftable_put_be32(void *out, uint32_t i)
+REFTABLE_INLINE(void) reftable_put_be32(void *out, uint32_t i)
 {
 	unsigned char *p = out;
 	p[0] = (uint8_t)((i >> 24) & 0xff);
@@ -99,7 +99,7 @@ static inline void reftable_put_be32(void *out, uint32_t i)
 	p[3] = (uint8_t)((i >>  0) & 0xff);
 }
 
-static inline void reftable_put_be64(void *out, uint64_t i)
+REFTABLE_INLINE(void) reftable_put_be64(void *out, uint64_t i)
 {
 	unsigned char *p = out;
 	p[0] = (uint8_t)((i >> 56) & 0xff);
@@ -112,22 +112,22 @@ static inline void reftable_put_be64(void *out, uint64_t i)
 	p[7] = (uint8_t)((i >>  0) & 0xff);
 }
 
-static inline uint16_t reftable_get_be16(const void *in)
+REFTABLE_INLINE(uint16_t) reftable_get_be16(const void *in)
 {
 	const unsigned char *p = in;
 	return (uint16_t)(p[0]) << 8 |
 	       (uint16_t)(p[1]) << 0;
 }
 
-static inline uint32_t reftable_get_be24(const void *in)
+REFTABLE_INLINE(uint32_t) reftable_get_be24(const void *in)
 {
 	const unsigned char *p = in;
 	return (uint32_t)(p[0]) << 16 |
 	       (uint32_t)(p[1]) << 8 |
 	       (uint32_t)(p[2]) << 0;
 }
 
-static inline uint32_t reftable_get_be32(const void *in)
+REFTABLE_INLINE(uint32_t) reftable_get_be32(const void *in)
 {
 	const unsigned char *p = in;
 	return (uint32_t)(p[0]) << 24 |
@@ -136,7 +136,7 @@ static inline uint32_t reftable_get_be32(const void *in)
 	       (uint32_t)(p[3]) <<  0;
 }
 
-static inline uint64_t reftable_get_be64(const void *in)
+REFTABLE_INLINE(uint64_t) reftable_get_be64(const void *in)
 {
 	const unsigned char *p = in;
 	return (uint64_t)(p[0]) << 56 |
@@ -187,7 +187,7 @@ void reftable_free(void *p);
 void *reftable_calloc(size_t nelem, size_t elsize);
 char *reftable_strdup(const char *str);
 
-static inline int reftable_alloc_size(size_t nelem, size_t elsize, size_t *out)
+REFTABLE_INLINE(int) reftable_alloc_size(size_t nelem, size_t elsize, size_t *out)
 {
 	if (nelem && elsize > SIZE_MAX / nelem)
 		return -1;
@@ -215,7 +215,7 @@ static inline int reftable_alloc_size(size_t nelem, size_t elsize, size_t *out)
 		} \
 	} while (0)
 
-static inline void *reftable_alloc_grow(void *p, size_t nelem, size_t elsize,
+REFTABLE_INLINE(void) *reftable_alloc_grow(void *p, size_t nelem, size_t elsize,
 					size_t *allocp)
 {
 	void *new_p;
diff --git a/reftable/blocksource.c b/reftable/blocksource.c
@@ -93,13 +93,12 @@ void block_source_from_buf(struct reftable_block_source *bs,
 }
 
 struct file_block_source {
-	uint64_t size;
-	unsigned char *data;
+	struct reftable_mmap mmap;
 };
 
 static uint64_t file_size(void *b)
 {
-	return ((struct file_block_source *)b)->size;
+	return ((struct file_block_source *)b)->mmap.size;
 }
 
 static void file_release_data(void *b REFTABLE_UNUSED, struct reftable_block_data *dest REFTABLE_UNUSED)
@@ -109,16 +108,16 @@ static void file_release_data(void *b REFTABLE_UNUSED, struct reftable_block_dat
 static void file_close(void *v)
 {
 	struct file_block_source *b = v;
-	munmap(b->data, b->size);
+	reftable_munmap(&b->mmap);
 	reftable_free(b);
 }
 
 static ssize_t file_read_data(void *v, struct reftable_block_data *dest, uint64_t off,
 			      uint32_t size)
 {
 	struct file_block_source *b = v;
-	assert(off + size <= b->size);
-	dest->data = b->data + off;
+	assert(off + size <= b->mmap.size);
+	dest->data = (unsigned char *) b->mmap.data + off;
 	dest->len = size;
 	return size;
 }
@@ -156,13 +155,9 @@ int reftable_block_source_from_file(struct reftable_block_source *bs,
 		goto out;
 	}
 
-	p->size = st.st_size;
-	p->data = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
-	if (p->data == MAP_FAILED) {
-		err = REFTABLE_IO_ERROR;
-		p->data = NULL;
+	err = reftable_mmap(&p->mmap, fd, st.st_size);
+	if (err < 0)
 		goto out;
-	}
 
 	assert(!bs->ops);
 	bs->ops = &file_vtable;
diff --git a/reftable/fsck.c b/reftable/fsck.c
@@ -63,7 +63,7 @@ static int table_check_name(struct reftable_table *table,
 
 static int table_checks(struct reftable_table *table,
 			reftable_fsck_report_fn report_fn,
-			reftable_fsck_verbose_fn verbose_fn UNUSED,
+			reftable_fsck_verbose_fn verbose_fn REFTABLE_UNUSED,
 			void *cb_data)
 {
 	table_check_fn table_check_fns[] = {
diff --git a/reftable/pq.h b/reftable/pq.h
@@ -27,12 +27,12 @@ int merged_iter_pqueue_add(struct merged_iter_pqueue *pq, const struct pq_entry
 void merged_iter_pqueue_release(struct merged_iter_pqueue *pq);
 int pq_less(struct pq_entry *a, struct pq_entry *b);
 
-static inline struct pq_entry merged_iter_pqueue_top(struct merged_iter_pqueue pq)
+REFTABLE_INLINE(struct) pq_entry merged_iter_pqueue_top(struct merged_iter_pqueue pq)
 {
 	return pq.heap[0];
 }
 
-static inline int merged_iter_pqueue_is_empty(struct merged_iter_pqueue pq)
+REFTABLE_INLINE(int) merged_iter_pqueue_is_empty(struct merged_iter_pqueue pq)
 {
 	return pq.len == 0;
 }
diff --git a/reftable/record.h b/reftable/record.h
@@ -26,7 +26,7 @@ struct string_view {
 };
 
 /* Advance `s.buf` by `n`, and decrease length. */
-static inline void string_view_consume(struct string_view *s, int n)
+REFTABLE_INLINE(void) string_view_consume(struct string_view *s, int n)
 {
 	s->buf += n;
 	s->len -= n;
@@ -147,7 +147,7 @@ int reftable_record_decode(struct reftable_record *rec, struct reftable_buf key,
 			   uint32_t hash_size, struct reftable_buf *scratch);
 int reftable_record_is_deletion(struct reftable_record *rec);
 
-static inline uint8_t reftable_record_type(struct reftable_record *rec)
+REFTABLE_INLINE(uint8_t) reftable_record_type(struct reftable_record *rec)
 {
 	return rec->type;
 }
diff --git a/reftable/reftable-basics.h b/reftable/reftable-basics.h
@@ -9,7 +9,7 @@
 #ifndef REFTABLE_BASICS_H
 #define REFTABLE_BASICS_H
 
-#include <stddef.h>
+#include "reftable-system.h"
 
 /* A buffer that contains arbitrary byte slices. */
 struct reftable_buf {
diff --git a/reftable/reftable-block.h b/reftable/reftable-block.h
@@ -9,8 +9,7 @@
 #ifndef REFTABLE_BLOCK_H
 #define REFTABLE_BLOCK_H
 
-#include <stdint.h>
-
+#include "reftable-system.h"
 #include "reftable-basics.h"
 #include "reftable-blocksource.h"
 #include "reftable-iterator.h"
diff --git a/reftable/reftable-blocksource.h b/reftable/reftable-blocksource.h
@@ -9,7 +9,7 @@
 #ifndef REFTABLE_BLOCKSOURCE_H
 #define REFTABLE_BLOCKSOURCE_H
 
-#include <stdint.h>
+#include "reftable-system.h"
 
 /*
  * Generic wrapper for a seekable readable file.
diff --git a/reftable/reftable-error.h b/reftable/reftable-error.h
@@ -9,6 +9,8 @@
 #ifndef REFTABLE_ERROR_H
 #define REFTABLE_ERROR_H
 
+#include "reftable-system.h"
+
 /*
  * Errors in reftable calls are signaled with negative integer return values. 0
  * means success.
diff --git a/reftable/reftable-fsck.h b/reftable/reftable-fsck.h
@@ -1,6 +1,7 @@
 #ifndef REFTABLE_FSCK_H
 #define REFTABLE_FSCK_H
 
+#include "reftable-system.h"
 #include "reftable-stack.h"
 
 enum reftable_fsck_error {
diff --git a/reftable/reftable-iterator.h b/reftable/reftable-iterator.h
@@ -9,6 +9,7 @@
 #ifndef REFTABLE_ITERATOR_H
 #define REFTABLE_ITERATOR_H
 
+#include "reftable-system.h"
 #include "reftable-record.h"
 
 struct reftable_iterator_vtable;
diff --git a/reftable/reftable-merged.h b/reftable/reftable-merged.h
@@ -9,6 +9,7 @@
 #ifndef REFTABLE_MERGED_H
 #define REFTABLE_MERGED_H
 
+#include "reftable-system.h"
 #include "reftable-iterator.h"
 
 /*
diff --git a/reftable/reftable-record.h b/reftable/reftable-record.h
@@ -9,8 +9,8 @@
 #ifndef REFTABLE_RECORD_H
 #define REFTABLE_RECORD_H
 
+#include "reftable-system.h"
 #include "reftable-basics.h"
-#include <stdint.h>
 
 /*
  * Basic data types
diff --git a/reftable/reftable-stack.h b/reftable/reftable-stack.h
@@ -9,6 +9,7 @@
 #ifndef REFTABLE_STACK_H
 #define REFTABLE_STACK_H
 
+#include "reftable-system.h"
 #include "reftable-writer.h"
 
 /*
diff --git a/reftable/reftable-system.h b/reftable/reftable-system.h
@@ -0,0 +1,7 @@
+#ifndef REFTABLE_SYSTEM_H
+#define REFTABLE_SYSTEM_H
+
+#define MINGW_DONT_HANDLE_IN_USE_ERROR
+#include "compat/posix.h"
+
+#endif
diff --git a/reftable/reftable-table.h b/reftable/reftable-table.h
@@ -9,6 +9,7 @@
 #ifndef REFTABLE_TABLE_H
 #define REFTABLE_TABLE_H
 
+#include "reftable-system.h"
 #include "reftable-iterator.h"
 #include "reftable-block.h"
 #include "reftable-blocksource.h"
diff --git a/reftable/reftable-writer.h b/reftable/reftable-writer.h
@@ -9,11 +9,9 @@
 #ifndef REFTABLE_WRITER_H
 #define REFTABLE_WRITER_H
 
+#include "reftable-system.h"
 #include "reftable-record.h"
 
-#include <stdint.h>
-#include <unistd.h> /* ssize_t */
-
 /* Writing single reftables */
 
 /* reftable_write_options sets options for writing a single reftable. */
diff --git a/reftable/stack.c b/reftable/stack.c
@@ -33,7 +33,7 @@ static int stack_fsync(const struct reftable_write_options *opts, int fd)
 {
 	if (opts->fsync)
 		return opts->fsync(fd);
-	return fsync(fd);
+	return 0;
 }
 
 static ssize_t reftable_write_data(int fd, const void *data, size_t size)
@@ -372,45 +372,26 @@ static int reftable_stack_reload_once(struct reftable_stack *st,
 	return err;
 }
 
-/* return negative if a before b. */
-static int tv_cmp(struct timeval *a, struct timeval *b)
-{
-	time_t diff = a->tv_sec - b->tv_sec;
-	int udiff = a->tv_usec - b->tv_usec;
-
-	if (diff != 0)
-		return diff;
-
-	return udiff;
-}
-
 static int reftable_stack_reload_maybe_reuse(struct reftable_stack *st,
 					     int reuse_open)
 {
 	char **names = NULL, **names_after = NULL;
-	struct timeval deadline;
+	uint64_t deadline;
 	int64_t delay = 0;
 	int tries = 0, err;
 	int fd = -1;
 
-	err = gettimeofday(&deadline, NULL);
-	if (err < 0)
-		goto out;
-	deadline.tv_sec += 3;
+	deadline = reftable_time_ms() + 3000;
 
 	while (1) {
-		struct timeval now;
-
-		err = gettimeofday(&now, NULL);
-		if (err < 0)
-			goto out;
+		uint64_t now = reftable_time_ms();
 
 		/*
 		 * Only look at deadlines after the first few times. This
 		 * simplifies debugging in GDB.
 		 */
 		tries++;
-		if (tries > 3 && tv_cmp(&now, &deadline) >= 0)
+		if (tries > 3 && now >= deadline)
 			goto out;
 
 		fd = open(st->list_file, O_RDONLY);
diff --git a/reftable/system.c b/reftable/system.c
@@ -4,6 +4,7 @@
 #include "basics.h"
 #include "reftable-error.h"
 #include "../lockfile.h"
+#include "../trace.h"
 #include "../tempfile.h"
 
 uint32_t reftable_rand(void)
@@ -131,3 +132,28 @@ int flock_commit(struct reftable_flock *l)
 
 	return 0;
 }
+
+uint64_t reftable_time_ms(void)
+{
+	return getnanotime() / 1000000;
+}
+
+int reftable_mmap(struct reftable_mmap *out, int fd, size_t len)
+{
+	void *data = xmmap_gently(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
+	if (data == MAP_FAILED)
+		return REFTABLE_IO_ERROR;
+
+	out->data = data;
+	out->size = len;
+
+	return 0;
+}
+
+int reftable_munmap(struct reftable_mmap *mmap)
+{
+	if (munmap(mmap->data, mmap->size) < 0)
+		return REFTABLE_IO_ERROR;
+	memset(mmap, 0, sizeof(*mmap));
+	return 0;
+}
diff --git a/reftable/system.h b/reftable/system.h

Original file line number	Diff line number	Diff line change
`@@ -75,22 +75,22 @@ char reftable_buf_detach(struct reftable_buf buf);`
`75`	`75`
`76`	`76`	`/* Bigendian en/decoding of integers */`
`77`	`77`
`78`		`-static inline void reftable_put_be16(void *out, uint16_t i)`
	`78`	`+REFTABLE_INLINE(void) reftable_put_be16(void *out, uint16_t i)`
`79`	`79`	`{`
`80`	`80`	`unsigned char *p = out;`
`81`	`81`	`p[0] = (uint8_t)((i >> 8) & 0xff);`
`82`	`82`	`p[1] = (uint8_t)((i >> 0) & 0xff);`
`83`	`83`	`}`
`84`	`84`
`85`		`-static inline void reftable_put_be24(void *out, uint32_t i)`
	`85`	`+REFTABLE_INLINE(void) reftable_put_be24(void *out, uint32_t i)`
`86`	`86`	`{`
`87`	`87`	`unsigned char *p = out;`
`88`	`88`	`p[0] = (uint8_t)((i >> 16) & 0xff);`
`89`	`89`	`p[1] = (uint8_t)((i >> 8) & 0xff);`
`90`	`90`	`p[2] = (uint8_t)((i >> 0) & 0xff);`
`91`	`91`	`}`
`92`	`92`
`93`		`-static inline void reftable_put_be32(void *out, uint32_t i)`
	`93`	`+REFTABLE_INLINE(void) reftable_put_be32(void *out, uint32_t i)`
`94`	`94`	`{`
`95`	`95`	`unsigned char *p = out;`
`96`	`96`	`p[0] = (uint8_t)((i >> 24) & 0xff);`
`@@ -99,7 +99,7 @@ static inline void reftable_put_be32(void *out, uint32_t i)`
`99`	`99`	`p[3] = (uint8_t)((i >> 0) & 0xff);`
`100`	`100`	`}`
`101`	`101`
`102`		`-static inline void reftable_put_be64(void *out, uint64_t i)`
	`102`	`+REFTABLE_INLINE(void) reftable_put_be64(void *out, uint64_t i)`
`103`	`103`	`{`
`104`	`104`	`unsigned char *p = out;`
`105`	`105`	`p[0] = (uint8_t)((i >> 56) & 0xff);`
`@@ -112,22 +112,22 @@ static inline void reftable_put_be64(void *out, uint64_t i)`
`112`	`112`	`p[7] = (uint8_t)((i >> 0) & 0xff);`
`113`	`113`	`}`
`114`	`114`
`115`		`-static inline uint16_t reftable_get_be16(const void *in)`
	`115`	`+REFTABLE_INLINE(uint16_t) reftable_get_be16(const void *in)`
`116`	`116`	`{`
`117`	`117`	`const unsigned char *p = in;`
`118`	`118`	`return (uint16_t)(p[0]) << 8 \|`
`119`	`119`	`(uint16_t)(p[1]) << 0;`
`120`	`120`	`}`
`121`	`121`
`122`		`-static inline uint32_t reftable_get_be24(const void *in)`
	`122`	`+REFTABLE_INLINE(uint32_t) reftable_get_be24(const void *in)`
`123`	`123`	`{`
`124`	`124`	`const unsigned char *p = in;`
`125`	`125`	`return (uint32_t)(p[0]) << 16 \|`
`126`	`126`	`(uint32_t)(p[1]) << 8 \|`
`127`	`127`	`(uint32_t)(p[2]) << 0;`
`128`	`128`	`}`
`129`	`129`
`130`		`-static inline uint32_t reftable_get_be32(const void *in)`
	`130`	`+REFTABLE_INLINE(uint32_t) reftable_get_be32(const void *in)`
`131`	`131`	`{`
`132`	`132`	`const unsigned char *p = in;`
`133`	`133`	`return (uint32_t)(p[0]) << 24 \|`
`@@ -136,7 +136,7 @@ static inline uint32_t reftable_get_be32(const void *in)`
`136`	`136`	`(uint32_t)(p[3]) << 0;`
`137`	`137`	`}`
`138`	`138`
`139`		`-static inline uint64_t reftable_get_be64(const void *in)`
	`139`	`+REFTABLE_INLINE(uint64_t) reftable_get_be64(const void *in)`
`140`	`140`	`{`
`141`	`141`	`const unsigned char *p = in;`
`142`	`142`	`return (uint64_t)(p[0]) << 56 \|`
`@@ -187,7 +187,7 @@ void reftable_free(void *p);`
`187`	`187`	`void *reftable_calloc(size_t nelem, size_t elsize);`
`188`	`188`	`char reftable_strdup(const char str);`
`189`	`189`
`190`		`-static inline int reftable_alloc_size(size_t nelem, size_t elsize, size_t *out)`
	`190`	`+REFTABLE_INLINE(int) reftable_alloc_size(size_t nelem, size_t elsize, size_t *out)`
`191`	`191`	`{`
`192`	`192`	`if (nelem && elsize > SIZE_MAX / nelem)`
`193`	`193`	`return -1;`
`@@ -215,7 +215,7 @@ static inline int reftable_alloc_size(size_t nelem, size_t elsize, size_t *out)`
`215`	`215`	`} \`
`216`	`216`	`} while (0)`
`217`	`217`
`218`		`-static inline void reftable_alloc_grow(void p, size_t nelem, size_t elsize,`
	`218`	`+REFTABLE_INLINE(void) reftable_alloc_grow(void p, size_t nelem, size_t elsize,`
`219`	`219`	`size_t *allocp)`
`220`	`220`	`{`
`221`	`221`	`void *new_p;`
Original file line number	Diff line number	Diff line change
`@@ -93,13 +93,12 @@ void block_source_from_buf(struct reftable_block_source *bs,`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`struct file_block_source {`
`96`		`- uint64_t size;`
`97`		`- unsigned char *data;`
	`96`	`+ struct reftable_mmap mmap;`
`98`	`97`	`};`
`99`	`98`
`100`	`99`	`static uint64_t file_size(void *b)`
`101`	`100`	`{`
`102`		`- return ((struct file_block_source *)b)->size;`
	`101`	`+ return ((struct file_block_source *)b)->mmap.size;`
`103`	`102`	`}`
`104`	`103`
`105`	`104`	`static void file_release_data(void b REFTABLE_UNUSED, struct reftable_block_data dest REFTABLE_UNUSED)`
`@@ -109,16 +108,16 @@ static void file_release_data(void *b REFTABLE_UNUSED, struct reftable_block_dat`
`109`	`108`	`static void file_close(void *v)`
`110`	`109`	`{`
`111`	`110`	`struct file_block_source *b = v;`
`112`		`- munmap(b->data, b->size);`
	`111`	`+ reftable_munmap(&b->mmap);`
`113`	`112`	`reftable_free(b);`
`114`	`113`	`}`
`115`	`114`
`116`	`115`	`static ssize_t file_read_data(void v, struct reftable_block_data dest, uint64_t off,`
`117`	`116`	`uint32_t size)`
`118`	`117`	`{`
`119`	`118`	`struct file_block_source *b = v;`
`120`		`- assert(off + size <= b->size);`
`121`		`- dest->data = b->data + off;`
	`119`	`+ assert(off + size <= b->mmap.size);`
	`120`	`+ dest->data = (unsigned char *) b->mmap.data + off;`
`122`	`121`	`dest->len = size;`
`123`	`122`	`return size;`
`124`	`123`	`}`
`@@ -156,13 +155,9 @@ int reftable_block_source_from_file(struct reftable_block_source *bs,`
`156`	`155`	`goto out;`
`157`	`156`	`}`
`158`	`157`
`159`		`- p->size = st.st_size;`
`160`		`- p->data = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);`
`161`		`- if (p->data == MAP_FAILED) {`
`162`		`- err = REFTABLE_IO_ERROR;`
`163`		`- p->data = NULL;`
	`158`	`+ err = reftable_mmap(&p->mmap, fd, st.st_size);`
	`159`	`+ if (err < 0)`
`164`	`160`	`goto out;`
`165`		`- }`
`166`	`161`
`167`	`162`	`assert(!bs->ops);`
`168`	`163`	`bs->ops = &file_vtable;`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ static int table_check_name(struct reftable_table *table,`
`63`	`63`
`64`	`64`	`static int table_checks(struct reftable_table *table,`
`65`	`65`	`reftable_fsck_report_fn report_fn,`
`66`		`- reftable_fsck_verbose_fn verbose_fn UNUSED,`
	`66`	`+ reftable_fsck_verbose_fn verbose_fn REFTABLE_UNUSED,`
`67`	`67`	`void *cb_data)`
`68`	`68`	`{`
`69`	`69`	`table_check_fn table_check_fns[] = {`
Original file line number	Diff line number	Diff line change
`@@ -27,12 +27,12 @@ int merged_iter_pqueue_add(struct merged_iter_pqueue *pq, const struct pq_entry`
`27`	`27`	`void merged_iter_pqueue_release(struct merged_iter_pqueue *pq);`
`28`	`28`	`int pq_less(struct pq_entry a, struct pq_entry b);`
`29`	`29`
`30`		`-static inline struct pq_entry merged_iter_pqueue_top(struct merged_iter_pqueue pq)`
	`30`	`+REFTABLE_INLINE(struct) pq_entry merged_iter_pqueue_top(struct merged_iter_pqueue pq)`
`31`	`31`	`{`
`32`	`32`	`return pq.heap[0];`
`33`	`33`	`}`
`34`	`34`
`35`		`-static inline int merged_iter_pqueue_is_empty(struct merged_iter_pqueue pq)`
	`35`	`+REFTABLE_INLINE(int) merged_iter_pqueue_is_empty(struct merged_iter_pqueue pq)`
`36`	`36`	`{`
`37`	`37`	`return pq.len == 0;`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ struct string_view {`
`26`	`26`	`};`
`27`	`27`
`28`	`28`	/* Advance `s.buf` by `n`, and decrease length. */
`29`		`-static inline void string_view_consume(struct string_view *s, int n)`
	`29`	`+REFTABLE_INLINE(void) string_view_consume(struct string_view *s, int n)`
`30`	`30`	`{`
`31`	`31`	`s->buf += n;`
`32`	`32`	`s->len -= n;`
`@@ -147,7 +147,7 @@ int reftable_record_decode(struct reftable_record *rec, struct reftable_buf key,`
`147`	`147`	`uint32_t hash_size, struct reftable_buf *scratch);`
`148`	`148`	`int reftable_record_is_deletion(struct reftable_record *rec);`
`149`	`149`
`150`		`-static inline uint8_t reftable_record_type(struct reftable_record *rec)`
	`150`	`+REFTABLE_INLINE(uint8_t) reftable_record_type(struct reftable_record *rec)`
`151`	`151`	`{`
`152`	`152`	`return rec->type;`
`153`	`153`	`}`