Add missing function specifiers to match their declaration (#143)

pps83 · web-flow · commit a7b5cde289f7 · 2025-04-04T10:54:32.000+02:00
All these function are declared with `static LIBDIVIDE_INLINE`, but do not have them at definition
diff --git a/libdivide.h b/libdivide.h
@@ -821,11 +821,11 @@ static LIBDIVIDE_INLINE struct libdivide_u16_t libdivide_internal_u16_gen(
     return result;
 }
 
-struct libdivide_u16_t libdivide_u16_gen(uint16_t d) {
+static LIBDIVIDE_INLINE struct libdivide_u16_t libdivide_u16_gen(uint16_t d) {
     return libdivide_internal_u16_gen(d, 0);
 }
 
-struct libdivide_u16_branchfree_t libdivide_u16_branchfree_gen(uint16_t d) {
+static LIBDIVIDE_INLINE struct libdivide_u16_branchfree_t libdivide_u16_branchfree_gen(uint16_t d) {
     if (d == 1) {
         LIBDIVIDE_ERROR("branchfree divider must be != 1");
     }
@@ -838,7 +838,7 @@ struct libdivide_u16_branchfree_t libdivide_u16_branchfree_gen(uint16_t d) {
 // The original libdivide_u16_do takes a const pointer. However, this cannot be used
 // with a compile time constant libdivide_u16_t: it will generate a warning about
 // taking the address of a temporary. Hence this overload.
-uint16_t libdivide_u16_do_raw(uint16_t numer, uint16_t magic, uint8_t more) {
+static LIBDIVIDE_INLINE uint16_t libdivide_u16_do_raw(uint16_t numer, uint16_t magic, uint8_t more) {
     if (!magic) {
         return numer >> more;
     } else {
@@ -854,18 +854,18 @@ uint16_t libdivide_u16_do_raw(uint16_t numer, uint16_t magic, uint8_t more) {
     }
 }
 
-uint16_t libdivide_u16_do(uint16_t numer, const struct libdivide_u16_t *denom) {
+static LIBDIVIDE_INLINE uint16_t libdivide_u16_do(uint16_t numer, const struct libdivide_u16_t *denom) {
     return libdivide_u16_do_raw(numer, denom->magic, denom->more);
 }
 
-uint16_t libdivide_u16_branchfree_do(
+static LIBDIVIDE_INLINE uint16_t libdivide_u16_branchfree_do(
     uint16_t numer, const struct libdivide_u16_branchfree_t *denom) {
     uint16_t q = libdivide_mullhi_u16(numer, denom->magic);
     uint16_t t = ((numer - q) >> 1) + q;
     return t >> denom->more;
 }
 
-uint16_t libdivide_u16_recover(const struct libdivide_u16_t *denom) {
+static LIBDIVIDE_INLINE uint16_t libdivide_u16_recover(const struct libdivide_u16_t *denom) {
     uint8_t more = denom->more;
     uint8_t shift = more & LIBDIVIDE_16_SHIFT_MASK;
 
@@ -903,7 +903,7 @@ uint16_t libdivide_u16_recover(const struct libdivide_u16_t *denom) {
     }
 }
 
-uint16_t libdivide_u16_branchfree_recover(const struct libdivide_u16_branchfree_t *denom) {
+static LIBDIVIDE_INLINE uint16_t libdivide_u16_branchfree_recover(const struct libdivide_u16_branchfree_t *denom) {
     uint8_t more = denom->more;
     uint8_t shift = more & LIBDIVIDE_16_SHIFT_MASK;
 
@@ -985,11 +985,11 @@ static LIBDIVIDE_INLINE struct libdivide_u32_t libdivide_internal_u32_gen(
     return result;
 }
 
-struct libdivide_u32_t libdivide_u32_gen(uint32_t d) {
+static LIBDIVIDE_INLINE struct libdivide_u32_t libdivide_u32_gen(uint32_t d) {
     return libdivide_internal_u32_gen(d, 0);
 }
 
-struct libdivide_u32_branchfree_t libdivide_u32_branchfree_gen(uint32_t d) {
+static LIBDIVIDE_INLINE struct libdivide_u32_branchfree_t libdivide_u32_branchfree_gen(uint32_t d) {
     if (d == 1) {
         LIBDIVIDE_ERROR("branchfree divider must be != 1");
     }
@@ -999,7 +999,7 @@ struct libdivide_u32_branchfree_t libdivide_u32_branchfree_gen(uint32_t d) {
     return ret;
 }
 
-uint32_t libdivide_u32_do_raw(uint32_t numer, uint32_t magic, uint8_t more) {
+static LIBDIVIDE_INLINE uint32_t libdivide_u32_do_raw(uint32_t numer, uint32_t magic, uint8_t more) {
     if (!magic) {
         return numer >> more;
     } else {
@@ -1015,18 +1015,18 @@ uint32_t libdivide_u32_do_raw(uint32_t numer, uint32_t magic, uint8_t more) {
     }
 }
 
-uint32_t libdivide_u32_do(uint32_t numer, const struct libdivide_u32_t *denom) {
+static LIBDIVIDE_INLINE uint32_t libdivide_u32_do(uint32_t numer, const struct libdivide_u32_t *denom) {
     return libdivide_u32_do_raw(numer, denom->magic, denom->more);
 }
 
-uint32_t libdivide_u32_branchfree_do(
+static LIBDIVIDE_INLINE uint32_t libdivide_u32_branchfree_do(
     uint32_t numer, const struct libdivide_u32_branchfree_t *denom) {
     uint32_t q = libdivide_mullhi_u32(numer, denom->magic);
     uint32_t t = ((numer - q) >> 1) + q;
     return t >> denom->more;
 }
 
-uint32_t libdivide_u32_recover(const struct libdivide_u32_t *denom) {
+static LIBDIVIDE_INLINE uint32_t libdivide_u32_recover(const struct libdivide_u32_t *denom) {
     uint8_t more = denom->more;
     uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
 
@@ -1064,7 +1064,7 @@ uint32_t libdivide_u32_recover(const struct libdivide_u32_t *denom) {
     }
 }
 
-uint32_t libdivide_u32_branchfree_recover(const struct libdivide_u32_branchfree_t *denom) {
+static LIBDIVIDE_INLINE uint32_t libdivide_u32_branchfree_recover(const struct libdivide_u32_branchfree_t *denom) {
     uint8_t more = denom->more;
     uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
 
@@ -1148,11 +1148,11 @@ static LIBDIVIDE_INLINE struct libdivide_u64_t libdivide_internal_u64_gen(
     return result;
 }
 
-struct libdivide_u64_t libdivide_u64_gen(uint64_t d) {
+static LIBDIVIDE_INLINE struct libdivide_u64_t libdivide_u64_gen(uint64_t d) {
     return libdivide_internal_u64_gen(d, 0);
 }
 
-struct libdivide_u64_branchfree_t libdivide_u64_branchfree_gen(uint64_t d) {
+static LIBDIVIDE_INLINE struct libdivide_u64_branchfree_t libdivide_u64_branchfree_gen(uint64_t d) {
     if (d == 1) {
         LIBDIVIDE_ERROR("branchfree divider must be != 1");
     }
@@ -1162,7 +1162,7 @@ struct libdivide_u64_branchfree_t libdivide_u64_branchfree_gen(uint64_t d) {
     return ret;
 }
 
-uint64_t libdivide_u64_do_raw(uint64_t numer, uint64_t magic, uint8_t more) {
+static LIBDIVIDE_INLINE uint64_t libdivide_u64_do_raw(uint64_t numer, uint64_t magic, uint8_t more) {
    if (!magic) {
         return numer >> more;
     } else {
@@ -1178,18 +1178,18 @@ uint64_t libdivide_u64_do_raw(uint64_t numer, uint64_t magic, uint8_t more) {
     }
 }
 
-uint64_t libdivide_u64_do(uint64_t numer, const struct libdivide_u64_t *denom) {
+static LIBDIVIDE_INLINE uint64_t libdivide_u64_do(uint64_t numer, const struct libdivide_u64_t *denom) {
     return libdivide_u64_do_raw(numer, denom->magic, denom->more);
 }
 
-uint64_t libdivide_u64_branchfree_do(
+static LIBDIVIDE_INLINE uint64_t libdivide_u64_branchfree_do(
     uint64_t numer, const struct libdivide_u64_branchfree_t *denom) {
     uint64_t q = libdivide_mullhi_u64(numer, denom->magic);
     uint64_t t = ((numer - q) >> 1) + q;
     return t >> denom->more;
 }
 
-uint64_t libdivide_u64_recover(const struct libdivide_u64_t *denom) {
+static LIBDIVIDE_INLINE uint64_t libdivide_u64_recover(const struct libdivide_u64_t *denom) {
     uint8_t more = denom->more;
     uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
 
@@ -1233,7 +1233,7 @@ uint64_t libdivide_u64_recover(const struct libdivide_u64_t *denom) {
     }
 }
 
-uint64_t libdivide_u64_branchfree_recover(const struct libdivide_u64_branchfree_t *denom) {
+static LIBDIVIDE_INLINE uint64_t libdivide_u64_branchfree_recover(const struct libdivide_u64_branchfree_t *denom) {
     uint8_t more = denom->more;
     uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
 
@@ -1336,11 +1336,11 @@ static LIBDIVIDE_INLINE struct libdivide_s16_t libdivide_internal_s16_gen(
     return result;
 }
 
-struct libdivide_s16_t libdivide_s16_gen(int16_t d) {
+static LIBDIVIDE_INLINE struct libdivide_s16_t libdivide_s16_gen(int16_t d) {
     return libdivide_internal_s16_gen(d, 0);
 }
 
-struct libdivide_s16_branchfree_t libdivide_s16_branchfree_gen(int16_t d) {
+static LIBDIVIDE_INLINE struct libdivide_s16_branchfree_t libdivide_s16_branchfree_gen(int16_t d) {
     struct libdivide_s16_t tmp = libdivide_internal_s16_gen(d, 1);
     struct libdivide_s16_branchfree_t result = {tmp.magic, tmp.more};
     return result;
@@ -1349,7 +1349,7 @@ struct libdivide_s16_branchfree_t libdivide_s16_branchfree_gen(int16_t d) {
 // The original libdivide_s16_do takes a const pointer. However, this cannot be used
 // with a compile time constant libdivide_s16_t: it will generate a warning about
 // taking the address of a temporary. Hence this overload.
-int16_t libdivide_s16_do_raw(int16_t numer, int16_t magic, uint8_t more) {
+static LIBDIVIDE_INLINE int16_t libdivide_s16_do_raw(int16_t numer, int16_t magic, uint8_t more) {
     uint8_t shift = more & LIBDIVIDE_16_SHIFT_MASK;
 
     if (!magic) {
@@ -1376,11 +1376,11 @@ int16_t libdivide_s16_do_raw(int16_t numer, int16_t magic, uint8_t more) {
     }
 }
 
-int16_t libdivide_s16_do(int16_t numer, const struct libdivide_s16_t *denom) {
+static LIBDIVIDE_INLINE int16_t libdivide_s16_do(int16_t numer, const struct libdivide_s16_t *denom) {
     return libdivide_s16_do_raw(numer, denom->magic, denom->more);
 }
 
-int16_t libdivide_s16_branchfree_do(int16_t numer, const struct libdivide_s16_branchfree_t *denom) {
+static LIBDIVIDE_INLINE int16_t libdivide_s16_branchfree_do(int16_t numer, const struct libdivide_s16_branchfree_t *denom) {
     uint8_t more = denom->more;
     uint8_t shift = more & LIBDIVIDE_16_SHIFT_MASK;
     // must be arithmetic shift and then sign extend
@@ -1404,7 +1404,7 @@ int16_t libdivide_s16_branchfree_do(int16_t numer, const struct libdivide_s16_br
     return q;
 }
 
-int16_t libdivide_s16_recover(const struct libdivide_s16_t *denom) {
+static LIBDIVIDE_INLINE int16_t libdivide_s16_recover(const struct libdivide_s16_t *denom) {
     uint8_t more = denom->more;
     uint8_t shift = more & LIBDIVIDE_16_SHIFT_MASK;
     if (!denom->magic) {
@@ -1439,7 +1439,7 @@ int16_t libdivide_s16_recover(const struct libdivide_s16_t *denom) {
     }
 }
 
-int16_t libdivide_s16_branchfree_recover(const struct libdivide_s16_branchfree_t *denom) {
+static LIBDIVIDE_INLINE int16_t libdivide_s16_branchfree_recover(const struct libdivide_s16_branchfree_t *denom) {
     const struct libdivide_s16_t den = {denom->magic, denom->more};
     return libdivide_s16_recover(&den);
 }
@@ -1512,17 +1512,17 @@ static LIBDIVIDE_INLINE struct libdivide_s32_t libdivide_internal_s32_gen(
     return result;
 }
 
-struct libdivide_s32_t libdivide_s32_gen(int32_t d) {
+static LIBDIVIDE_INLINE struct libdivide_s32_t libdivide_s32_gen(int32_t d) {
     return libdivide_internal_s32_gen(d, 0);
 }
 
-struct libdivide_s32_branchfree_t libdivide_s32_branchfree_gen(int32_t d) {
+static LIBDIVIDE_INLINE struct libdivide_s32_branchfree_t libdivide_s32_branchfree_gen(int32_t d) {
     struct libdivide_s32_t tmp = libdivide_internal_s32_gen(d, 1);
     struct libdivide_s32_branchfree_t result = {tmp.magic, tmp.more};
     return result;
 }
 
-int32_t libdivide_s32_do_raw(int32_t numer, int32_t magic, uint8_t more) {
+static LIBDIVIDE_INLINE int32_t libdivide_s32_do_raw(int32_t numer, int32_t magic, uint8_t more) {
     uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
 
     if (!magic) {
@@ -1549,11 +1549,11 @@ int32_t libdivide_s32_do_raw(int32_t numer, int32_t magic, uint8_t more) {
     }
 }
 
-int32_t libdivide_s32_do(int32_t numer, const struct libdivide_s32_t *denom) {
+static LIBDIVIDE_INLINE int32_t libdivide_s32_do(int32_t numer, const struct libdivide_s32_t *denom) {
     return libdivide_s32_do_raw(numer, denom->magic, denom->more);
 }
 
-int32_t libdivide_s32_branchfree_do(int32_t numer, const struct libdivide_s32_branchfree_t *denom) {
+static LIBDIVIDE_INLINE int32_t libdivide_s32_branchfree_do(int32_t numer, const struct libdivide_s32_branchfree_t *denom) {
     uint8_t more = denom->more;
     uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
     // must be arithmetic shift and then sign extend
@@ -1577,7 +1577,7 @@ int32_t libdivide_s32_branchfree_do(int32_t numer, const struct libdivide_s32_br
     return q;
 }
 
-int32_t libdivide_s32_recover(const struct libdivide_s32_t *denom) {
+static LIBDIVIDE_INLINE int32_t libdivide_s32_recover(const struct libdivide_s32_t *denom) {
     uint8_t more = denom->more;
     uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
     if (!denom->magic) {
@@ -1612,7 +1612,7 @@ int32_t libdivide_s32_recover(const struct libdivide_s32_t *denom) {
     }
 }
 
-int32_t libdivide_s32_branchfree_recover(const struct libdivide_s32_branchfree_t *denom) {
+static LIBDIVIDE_INLINE int32_t libdivide_s32_branchfree_recover(const struct libdivide_s32_branchfree_t *denom) {
     const struct libdivide_s32_t den = {denom->magic, denom->more};
     return libdivide_s32_recover(&den);
 }
@@ -1685,17 +1685,17 @@ static LIBDIVIDE_INLINE struct libdivide_s64_t libdivide_internal_s64_gen(
     return result;
 }
 
-struct libdivide_s64_t libdivide_s64_gen(int64_t d) {
+static LIBDIVIDE_INLINE struct libdivide_s64_t libdivide_s64_gen(int64_t d) {
     return libdivide_internal_s64_gen(d, 0);
 }
 
-struct libdivide_s64_branchfree_t libdivide_s64_branchfree_gen(int64_t d) {
+static LIBDIVIDE_INLINE struct libdivide_s64_branchfree_t libdivide_s64_branchfree_gen(int64_t d) {
     struct libdivide_s64_t tmp = libdivide_internal_s64_gen(d, 1);
     struct libdivide_s64_branchfree_t ret = {tmp.magic, tmp.more};
     return ret;
 }
 
-int64_t libdivide_s64_do_raw(int64_t numer, int64_t magic, uint8_t more) {
+static LIBDIVIDE_INLINE int64_t libdivide_s64_do_raw(int64_t numer, int64_t magic, uint8_t more) {
     uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
 
     if (!magic) {  // shift path
@@ -1723,11 +1723,11 @@ int64_t libdivide_s64_do_raw(int64_t numer, int64_t magic, uint8_t more) {
     }
 }
 
-int64_t libdivide_s64_do(int64_t numer, const struct libdivide_s64_t *denom) {
+static LIBDIVIDE_INLINE int64_t libdivide_s64_do(int64_t numer, const struct libdivide_s64_t *denom) {
     return libdivide_s64_do_raw(numer, denom->magic, denom->more);
 }
 
-int64_t libdivide_s64_branchfree_do(int64_t numer, const struct libdivide_s64_branchfree_t *denom) {
+static LIBDIVIDE_INLINE int64_t libdivide_s64_branchfree_do(int64_t numer, const struct libdivide_s64_branchfree_t *denom) {
     uint8_t more = denom->more;
     uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
     // must be arithmetic shift and then sign extend
@@ -1751,7 +1751,7 @@ int64_t libdivide_s64_branchfree_do(int64_t numer, const struct libdivide_s64_br
     return q;
 }
 
-int64_t libdivide_s64_recover(const struct libdivide_s64_t *denom) {
+static LIBDIVIDE_INLINE int64_t libdivide_s64_recover(const struct libdivide_s64_t *denom) {
     uint8_t more = denom->more;
     uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
     if (denom->magic == 0) {  // shift path
@@ -1777,7 +1777,7 @@ int64_t libdivide_s64_recover(const struct libdivide_s64_t *denom) {
     }
 }
 
-int64_t libdivide_s64_branchfree_recover(const struct libdivide_s64_branchfree_t *denom) {
+static LIBDIVIDE_INLINE int64_t libdivide_s64_branchfree_recover(const struct libdivide_s64_branchfree_t *denom) {
     const struct libdivide_s64_t den = {denom->magic, denom->more};
     return libdivide_s64_recover(&den);
 }

Original file line number	Diff line number	Diff line change
`@@ -821,11 +821,11 @@ static LIBDIVIDE_INLINE struct libdivide_u16_t libdivide_internal_u16_gen(`
`821`	`821`	`return result;`
`822`	`822`	`}`
`823`	`823`
`824`		`-struct libdivide_u16_t libdivide_u16_gen(uint16_t d) {`
	`824`	`+static LIBDIVIDE_INLINE struct libdivide_u16_t libdivide_u16_gen(uint16_t d) {`
`825`	`825`	`return libdivide_internal_u16_gen(d, 0);`
`826`	`826`	`}`
`827`	`827`
`828`		`-struct libdivide_u16_branchfree_t libdivide_u16_branchfree_gen(uint16_t d) {`
	`828`	`+static LIBDIVIDE_INLINE struct libdivide_u16_branchfree_t libdivide_u16_branchfree_gen(uint16_t d) {`
`829`	`829`	`if (d == 1) {`
`830`	`830`	`LIBDIVIDE_ERROR("branchfree divider must be != 1");`
`831`	`831`	`}`
`@@ -838,7 +838,7 @@ struct libdivide_u16_branchfree_t libdivide_u16_branchfree_gen(uint16_t d) {`
`838`	`838`	`// The original libdivide_u16_do takes a const pointer. However, this cannot be used`
`839`	`839`	`// with a compile time constant libdivide_u16_t: it will generate a warning about`
`840`	`840`	`// taking the address of a temporary. Hence this overload.`
`841`		`-uint16_t libdivide_u16_do_raw(uint16_t numer, uint16_t magic, uint8_t more) {`
	`841`	`+static LIBDIVIDE_INLINE uint16_t libdivide_u16_do_raw(uint16_t numer, uint16_t magic, uint8_t more) {`
`842`	`842`	`if (!magic) {`
`843`	`843`	`return numer >> more;`
`844`	`844`	`} else {`
`@@ -854,18 +854,18 @@ uint16_t libdivide_u16_do_raw(uint16_t numer, uint16_t magic, uint8_t more) {`
`854`	`854`	`}`
`855`	`855`	`}`
`856`	`856`
`857`		`-uint16_t libdivide_u16_do(uint16_t numer, const struct libdivide_u16_t *denom) {`
	`857`	`+static LIBDIVIDE_INLINE uint16_t libdivide_u16_do(uint16_t numer, const struct libdivide_u16_t *denom) {`
`858`	`858`	`return libdivide_u16_do_raw(numer, denom->magic, denom->more);`
`859`	`859`	`}`
`860`	`860`
`861`		`-uint16_t libdivide_u16_branchfree_do(`
	`861`	`+static LIBDIVIDE_INLINE uint16_t libdivide_u16_branchfree_do(`
`862`	`862`	`uint16_t numer, const struct libdivide_u16_branchfree_t *denom) {`
`863`	`863`	`uint16_t q = libdivide_mullhi_u16(numer, denom->magic);`
`864`	`864`	`uint16_t t = ((numer - q) >> 1) + q;`
`865`	`865`	`return t >> denom->more;`
`866`	`866`	`}`
`867`	`867`
`868`		`-uint16_t libdivide_u16_recover(const struct libdivide_u16_t *denom) {`
	`868`	`+static LIBDIVIDE_INLINE uint16_t libdivide_u16_recover(const struct libdivide_u16_t *denom) {`
`869`	`869`	`uint8_t more = denom->more;`
`870`	`870`	`uint8_t shift = more & LIBDIVIDE_16_SHIFT_MASK;`
`871`	`871`
`@@ -903,7 +903,7 @@ uint16_t libdivide_u16_recover(const struct libdivide_u16_t *denom) {`
`903`	`903`	`}`
`904`	`904`	`}`
`905`	`905`
`906`		`-uint16_t libdivide_u16_branchfree_recover(const struct libdivide_u16_branchfree_t *denom) {`
	`906`	`+static LIBDIVIDE_INLINE uint16_t libdivide_u16_branchfree_recover(const struct libdivide_u16_branchfree_t *denom) {`
`907`	`907`	`uint8_t more = denom->more;`
`908`	`908`	`uint8_t shift = more & LIBDIVIDE_16_SHIFT_MASK;`
`909`	`909`
`@@ -985,11 +985,11 @@ static LIBDIVIDE_INLINE struct libdivide_u32_t libdivide_internal_u32_gen(`
`985`	`985`	`return result;`
`986`	`986`	`}`
`987`	`987`
`988`		`-struct libdivide_u32_t libdivide_u32_gen(uint32_t d) {`
	`988`	`+static LIBDIVIDE_INLINE struct libdivide_u32_t libdivide_u32_gen(uint32_t d) {`
`989`	`989`	`return libdivide_internal_u32_gen(d, 0);`
`990`	`990`	`}`
`991`	`991`
`992`		`-struct libdivide_u32_branchfree_t libdivide_u32_branchfree_gen(uint32_t d) {`
	`992`	`+static LIBDIVIDE_INLINE struct libdivide_u32_branchfree_t libdivide_u32_branchfree_gen(uint32_t d) {`
`993`	`993`	`if (d == 1) {`
`994`	`994`	`LIBDIVIDE_ERROR("branchfree divider must be != 1");`
`995`	`995`	`}`
`@@ -999,7 +999,7 @@ struct libdivide_u32_branchfree_t libdivide_u32_branchfree_gen(uint32_t d) {`
`999`	`999`	`return ret;`
`1000`	`1000`	`}`
`1001`	`1001`
`1002`		`-uint32_t libdivide_u32_do_raw(uint32_t numer, uint32_t magic, uint8_t more) {`
	`1002`	`+static LIBDIVIDE_INLINE uint32_t libdivide_u32_do_raw(uint32_t numer, uint32_t magic, uint8_t more) {`
`1003`	`1003`	`if (!magic) {`
`1004`	`1004`	`return numer >> more;`
`1005`	`1005`	`} else {`
`@@ -1015,18 +1015,18 @@ uint32_t libdivide_u32_do_raw(uint32_t numer, uint32_t magic, uint8_t more) {`
`1015`	`1015`	`}`
`1016`	`1016`	`}`
`1017`	`1017`
`1018`		`-uint32_t libdivide_u32_do(uint32_t numer, const struct libdivide_u32_t *denom) {`
	`1018`	`+static LIBDIVIDE_INLINE uint32_t libdivide_u32_do(uint32_t numer, const struct libdivide_u32_t *denom) {`
`1019`	`1019`	`return libdivide_u32_do_raw(numer, denom->magic, denom->more);`
`1020`	`1020`	`}`
`1021`	`1021`
`1022`		`-uint32_t libdivide_u32_branchfree_do(`
	`1022`	`+static LIBDIVIDE_INLINE uint32_t libdivide_u32_branchfree_do(`
`1023`	`1023`	`uint32_t numer, const struct libdivide_u32_branchfree_t *denom) {`
`1024`	`1024`	`uint32_t q = libdivide_mullhi_u32(numer, denom->magic);`
`1025`	`1025`	`uint32_t t = ((numer - q) >> 1) + q;`
`1026`	`1026`	`return t >> denom->more;`
`1027`	`1027`	`}`
`1028`	`1028`
`1029`		`-uint32_t libdivide_u32_recover(const struct libdivide_u32_t *denom) {`
	`1029`	`+static LIBDIVIDE_INLINE uint32_t libdivide_u32_recover(const struct libdivide_u32_t *denom) {`
`1030`	`1030`	`uint8_t more = denom->more;`
`1031`	`1031`	`uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;`
`1032`	`1032`
`@@ -1064,7 +1064,7 @@ uint32_t libdivide_u32_recover(const struct libdivide_u32_t *denom) {`
`1064`	`1064`	`}`
`1065`	`1065`	`}`
`1066`	`1066`
`1067`		`-uint32_t libdivide_u32_branchfree_recover(const struct libdivide_u32_branchfree_t *denom) {`
	`1067`	`+static LIBDIVIDE_INLINE uint32_t libdivide_u32_branchfree_recover(const struct libdivide_u32_branchfree_t *denom) {`
`1068`	`1068`	`uint8_t more = denom->more;`
`1069`	`1069`	`uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;`
`1070`	`1070`
`@@ -1148,11 +1148,11 @@ static LIBDIVIDE_INLINE struct libdivide_u64_t libdivide_internal_u64_gen(`
`1148`	`1148`	`return result;`
`1149`	`1149`	`}`
`1150`	`1150`
`1151`		`-struct libdivide_u64_t libdivide_u64_gen(uint64_t d) {`
	`1151`	`+static LIBDIVIDE_INLINE struct libdivide_u64_t libdivide_u64_gen(uint64_t d) {`
`1152`	`1152`	`return libdivide_internal_u64_gen(d, 0);`
`1153`	`1153`	`}`
`1154`	`1154`
`1155`		`-struct libdivide_u64_branchfree_t libdivide_u64_branchfree_gen(uint64_t d) {`
	`1155`	`+static LIBDIVIDE_INLINE struct libdivide_u64_branchfree_t libdivide_u64_branchfree_gen(uint64_t d) {`
`1156`	`1156`	`if (d == 1) {`
`1157`	`1157`	`LIBDIVIDE_ERROR("branchfree divider must be != 1");`
`1158`	`1158`	`}`
`@@ -1162,7 +1162,7 @@ struct libdivide_u64_branchfree_t libdivide_u64_branchfree_gen(uint64_t d) {`
`1162`	`1162`	`return ret;`
`1163`	`1163`	`}`
`1164`	`1164`
`1165`		`-uint64_t libdivide_u64_do_raw(uint64_t numer, uint64_t magic, uint8_t more) {`
	`1165`	`+static LIBDIVIDE_INLINE uint64_t libdivide_u64_do_raw(uint64_t numer, uint64_t magic, uint8_t more) {`
`1166`	`1166`	`if (!magic) {`
`1167`	`1167`	`return numer >> more;`
`1168`	`1168`	`} else {`
`@@ -1178,18 +1178,18 @@ uint64_t libdivide_u64_do_raw(uint64_t numer, uint64_t magic, uint8_t more) {`
`1178`	`1178`	`}`
`1179`	`1179`	`}`
`1180`	`1180`
`1181`		`-uint64_t libdivide_u64_do(uint64_t numer, const struct libdivide_u64_t *denom) {`
	`1181`	`+static LIBDIVIDE_INLINE uint64_t libdivide_u64_do(uint64_t numer, const struct libdivide_u64_t *denom) {`
`1182`	`1182`	`return libdivide_u64_do_raw(numer, denom->magic, denom->more);`
`1183`	`1183`	`}`
`1184`	`1184`
`1185`		`-uint64_t libdivide_u64_branchfree_do(`
	`1185`	`+static LIBDIVIDE_INLINE uint64_t libdivide_u64_branchfree_do(`
`1186`	`1186`	`uint64_t numer, const struct libdivide_u64_branchfree_t *denom) {`
`1187`	`1187`	`uint64_t q = libdivide_mullhi_u64(numer, denom->magic);`
`1188`	`1188`	`uint64_t t = ((numer - q) >> 1) + q;`
`1189`	`1189`	`return t >> denom->more;`
`1190`	`1190`	`}`
`1191`	`1191`
`1192`		`-uint64_t libdivide_u64_recover(const struct libdivide_u64_t *denom) {`
	`1192`	`+static LIBDIVIDE_INLINE uint64_t libdivide_u64_recover(const struct libdivide_u64_t *denom) {`
`1193`	`1193`	`uint8_t more = denom->more;`
`1194`	`1194`	`uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;`
`1195`	`1195`
`@@ -1233,7 +1233,7 @@ uint64_t libdivide_u64_recover(const struct libdivide_u64_t *denom) {`
`1233`	`1233`	`}`
`1234`	`1234`	`}`
`1235`	`1235`
`1236`		`-uint64_t libdivide_u64_branchfree_recover(const struct libdivide_u64_branchfree_t *denom) {`
	`1236`	`+static LIBDIVIDE_INLINE uint64_t libdivide_u64_branchfree_recover(const struct libdivide_u64_branchfree_t *denom) {`
`1237`	`1237`	`uint8_t more = denom->more;`
`1238`	`1238`	`uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;`
`1239`	`1239`
`@@ -1336,11 +1336,11 @@ static LIBDIVIDE_INLINE struct libdivide_s16_t libdivide_internal_s16_gen(`
`1336`	`1336`	`return result;`
`1337`	`1337`	`}`
`1338`	`1338`
`1339`		`-struct libdivide_s16_t libdivide_s16_gen(int16_t d) {`
	`1339`	`+static LIBDIVIDE_INLINE struct libdivide_s16_t libdivide_s16_gen(int16_t d) {`
`1340`	`1340`	`return libdivide_internal_s16_gen(d, 0);`
`1341`	`1341`	`}`
`1342`	`1342`
`1343`		`-struct libdivide_s16_branchfree_t libdivide_s16_branchfree_gen(int16_t d) {`
	`1343`	`+static LIBDIVIDE_INLINE struct libdivide_s16_branchfree_t libdivide_s16_branchfree_gen(int16_t d) {`
`1344`	`1344`	`struct libdivide_s16_t tmp = libdivide_internal_s16_gen(d, 1);`
`1345`	`1345`	`struct libdivide_s16_branchfree_t result = {tmp.magic, tmp.more};`
`1346`	`1346`	`return result;`
`@@ -1349,7 +1349,7 @@ struct libdivide_s16_branchfree_t libdivide_s16_branchfree_gen(int16_t d) {`
`1349`	`1349`	`// The original libdivide_s16_do takes a const pointer. However, this cannot be used`
`1350`	`1350`	`// with a compile time constant libdivide_s16_t: it will generate a warning about`
`1351`	`1351`	`// taking the address of a temporary. Hence this overload.`
`1352`		`-int16_t libdivide_s16_do_raw(int16_t numer, int16_t magic, uint8_t more) {`
	`1352`	`+static LIBDIVIDE_INLINE int16_t libdivide_s16_do_raw(int16_t numer, int16_t magic, uint8_t more) {`
`1353`	`1353`	`uint8_t shift = more & LIBDIVIDE_16_SHIFT_MASK;`
`1354`	`1354`
`1355`	`1355`	`if (!magic) {`
`@@ -1376,11 +1376,11 @@ int16_t libdivide_s16_do_raw(int16_t numer, int16_t magic, uint8_t more) {`
`1376`	`1376`	`}`
`1377`	`1377`	`}`
`1378`	`1378`
`1379`		`-int16_t libdivide_s16_do(int16_t numer, const struct libdivide_s16_t *denom) {`
	`1379`	`+static LIBDIVIDE_INLINE int16_t libdivide_s16_do(int16_t numer, const struct libdivide_s16_t *denom) {`
`1380`	`1380`	`return libdivide_s16_do_raw(numer, denom->magic, denom->more);`
`1381`	`1381`	`}`
`1382`	`1382`
`1383`		`-int16_t libdivide_s16_branchfree_do(int16_t numer, const struct libdivide_s16_branchfree_t *denom) {`
	`1383`	`+static LIBDIVIDE_INLINE int16_t libdivide_s16_branchfree_do(int16_t numer, const struct libdivide_s16_branchfree_t *denom) {`
`1384`	`1384`	`uint8_t more = denom->more;`
`1385`	`1385`	`uint8_t shift = more & LIBDIVIDE_16_SHIFT_MASK;`
`1386`	`1386`	`// must be arithmetic shift and then sign extend`
`@@ -1404,7 +1404,7 @@ int16_t libdivide_s16_branchfree_do(int16_t numer, const struct libdivide_s16_br`
`1404`	`1404`	`return q;`
`1405`	`1405`	`}`
`1406`	`1406`
`1407`		`-int16_t libdivide_s16_recover(const struct libdivide_s16_t *denom) {`
	`1407`	`+static LIBDIVIDE_INLINE int16_t libdivide_s16_recover(const struct libdivide_s16_t *denom) {`
`1408`	`1408`	`uint8_t more = denom->more;`
`1409`	`1409`	`uint8_t shift = more & LIBDIVIDE_16_SHIFT_MASK;`
`1410`	`1410`	`if (!denom->magic) {`
`@@ -1439,7 +1439,7 @@ int16_t libdivide_s16_recover(const struct libdivide_s16_t *denom) {`
`1439`	`1439`	`}`
`1440`	`1440`	`}`
`1441`	`1441`
`1442`		`-int16_t libdivide_s16_branchfree_recover(const struct libdivide_s16_branchfree_t *denom) {`
	`1442`	`+static LIBDIVIDE_INLINE int16_t libdivide_s16_branchfree_recover(const struct libdivide_s16_branchfree_t *denom) {`
`1443`	`1443`	`const struct libdivide_s16_t den = {denom->magic, denom->more};`
`1444`	`1444`	`return libdivide_s16_recover(&den);`
`1445`	`1445`	`}`
`@@ -1512,17 +1512,17 @@ static LIBDIVIDE_INLINE struct libdivide_s32_t libdivide_internal_s32_gen(`
`1512`	`1512`	`return result;`
`1513`	`1513`	`}`
`1514`	`1514`
`1515`		`-struct libdivide_s32_t libdivide_s32_gen(int32_t d) {`
	`1515`	`+static LIBDIVIDE_INLINE struct libdivide_s32_t libdivide_s32_gen(int32_t d) {`
`1516`	`1516`	`return libdivide_internal_s32_gen(d, 0);`
`1517`	`1517`	`}`
`1518`	`1518`
`1519`		`-struct libdivide_s32_branchfree_t libdivide_s32_branchfree_gen(int32_t d) {`
	`1519`	`+static LIBDIVIDE_INLINE struct libdivide_s32_branchfree_t libdivide_s32_branchfree_gen(int32_t d) {`
`1520`	`1520`	`struct libdivide_s32_t tmp = libdivide_internal_s32_gen(d, 1);`
`1521`	`1521`	`struct libdivide_s32_branchfree_t result = {tmp.magic, tmp.more};`
`1522`	`1522`	`return result;`
`1523`	`1523`	`}`
`1524`	`1524`
`1525`		`-int32_t libdivide_s32_do_raw(int32_t numer, int32_t magic, uint8_t more) {`
	`1525`	`+static LIBDIVIDE_INLINE int32_t libdivide_s32_do_raw(int32_t numer, int32_t magic, uint8_t more) {`
`1526`	`1526`	`uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;`
`1527`	`1527`
`1528`	`1528`	`if (!magic) {`
`@@ -1549,11 +1549,11 @@ int32_t libdivide_s32_do_raw(int32_t numer, int32_t magic, uint8_t more) {`
`1549`	`1549`	`}`
`1550`	`1550`	`}`
`1551`	`1551`
`1552`		`-int32_t libdivide_s32_do(int32_t numer, const struct libdivide_s32_t *denom) {`
	`1552`	`+static LIBDIVIDE_INLINE int32_t libdivide_s32_do(int32_t numer, const struct libdivide_s32_t *denom) {`
`1553`	`1553`	`return libdivide_s32_do_raw(numer, denom->magic, denom->more);`
`1554`	`1554`	`}`
`1555`	`1555`
`1556`		`-int32_t libdivide_s32_branchfree_do(int32_t numer, const struct libdivide_s32_branchfree_t *denom) {`
	`1556`	`+static LIBDIVIDE_INLINE int32_t libdivide_s32_branchfree_do(int32_t numer, const struct libdivide_s32_branchfree_t *denom) {`
`1557`	`1557`	`uint8_t more = denom->more;`
`1558`	`1558`	`uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;`
`1559`	`1559`	`// must be arithmetic shift and then sign extend`
`@@ -1577,7 +1577,7 @@ int32_t libdivide_s32_branchfree_do(int32_t numer, const struct libdivide_s32_br`
`1577`	`1577`	`return q;`
`1578`	`1578`	`}`
`1579`	`1579`
`1580`		`-int32_t libdivide_s32_recover(const struct libdivide_s32_t *denom) {`
	`1580`	`+static LIBDIVIDE_INLINE int32_t libdivide_s32_recover(const struct libdivide_s32_t *denom) {`
`1581`	`1581`	`uint8_t more = denom->more;`
`1582`	`1582`	`uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;`
`1583`	`1583`	`if (!denom->magic) {`
`@@ -1612,7 +1612,7 @@ int32_t libdivide_s32_recover(const struct libdivide_s32_t *denom) {`
`1612`	`1612`	`}`
`1613`	`1613`	`}`
`1614`	`1614`
`1615`		`-int32_t libdivide_s32_branchfree_recover(const struct libdivide_s32_branchfree_t *denom) {`
	`1615`	`+static LIBDIVIDE_INLINE int32_t libdivide_s32_branchfree_recover(const struct libdivide_s32_branchfree_t *denom) {`
`1616`	`1616`	`const struct libdivide_s32_t den = {denom->magic, denom->more};`
`1617`	`1617`	`return libdivide_s32_recover(&den);`
`1618`	`1618`	`}`
`@@ -1685,17 +1685,17 @@ static LIBDIVIDE_INLINE struct libdivide_s64_t libdivide_internal_s64_gen(`
`1685`	`1685`	`return result;`
`1686`	`1686`	`}`
`1687`	`1687`
`1688`		`-struct libdivide_s64_t libdivide_s64_gen(int64_t d) {`
	`1688`	`+static LIBDIVIDE_INLINE struct libdivide_s64_t libdivide_s64_gen(int64_t d) {`
`1689`	`1689`	`return libdivide_internal_s64_gen(d, 0);`
`1690`	`1690`	`}`
`1691`	`1691`
`1692`		`-struct libdivide_s64_branchfree_t libdivide_s64_branchfree_gen(int64_t d) {`
	`1692`	`+static LIBDIVIDE_INLINE struct libdivide_s64_branchfree_t libdivide_s64_branchfree_gen(int64_t d) {`
`1693`	`1693`	`struct libdivide_s64_t tmp = libdivide_internal_s64_gen(d, 1);`
`1694`	`1694`	`struct libdivide_s64_branchfree_t ret = {tmp.magic, tmp.more};`
`1695`	`1695`	`return ret;`
`1696`	`1696`	`}`
`1697`	`1697`
`1698`		`-int64_t libdivide_s64_do_raw(int64_t numer, int64_t magic, uint8_t more) {`
	`1698`	`+static LIBDIVIDE_INLINE int64_t libdivide_s64_do_raw(int64_t numer, int64_t magic, uint8_t more) {`
`1699`	`1699`	`uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;`
`1700`	`1700`
`1701`	`1701`	`if (!magic) { // shift path`
`@@ -1723,11 +1723,11 @@ int64_t libdivide_s64_do_raw(int64_t numer, int64_t magic, uint8_t more) {`
`1723`	`1723`	`}`
`1724`	`1724`	`}`
`1725`	`1725`
`1726`		`-int64_t libdivide_s64_do(int64_t numer, const struct libdivide_s64_t *denom) {`
	`1726`	`+static LIBDIVIDE_INLINE int64_t libdivide_s64_do(int64_t numer, const struct libdivide_s64_t *denom) {`
`1727`	`1727`	`return libdivide_s64_do_raw(numer, denom->magic, denom->more);`
`1728`	`1728`	`}`
`1729`	`1729`
`1730`		`-int64_t libdivide_s64_branchfree_do(int64_t numer, const struct libdivide_s64_branchfree_t *denom) {`
	`1730`	`+static LIBDIVIDE_INLINE int64_t libdivide_s64_branchfree_do(int64_t numer, const struct libdivide_s64_branchfree_t *denom) {`
`1731`	`1731`	`uint8_t more = denom->more;`
`1732`	`1732`	`uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;`
`1733`	`1733`	`// must be arithmetic shift and then sign extend`
`@@ -1751,7 +1751,7 @@ int64_t libdivide_s64_branchfree_do(int64_t numer, const struct libdivide_s64_br`
`1751`	`1751`	`return q;`
`1752`	`1752`	`}`
`1753`	`1753`
`1754`		`-int64_t libdivide_s64_recover(const struct libdivide_s64_t *denom) {`
	`1754`	`+static LIBDIVIDE_INLINE int64_t libdivide_s64_recover(const struct libdivide_s64_t *denom) {`
`1755`	`1755`	`uint8_t more = denom->more;`
`1756`	`1756`	`uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;`
`1757`	`1757`	`if (denom->magic == 0) { // shift path`
`@@ -1777,7 +1777,7 @@ int64_t libdivide_s64_recover(const struct libdivide_s64_t *denom) {`
`1777`	`1777`	`}`
`1778`	`1778`	`}`
`1779`	`1779`
`1780`		`-int64_t libdivide_s64_branchfree_recover(const struct libdivide_s64_branchfree_t *denom) {`
	`1780`	`+static LIBDIVIDE_INLINE int64_t libdivide_s64_branchfree_recover(const struct libdivide_s64_branchfree_t *denom) {`
`1781`	`1781`	`const struct libdivide_s64_t den = {denom->magic, denom->more};`
`1782`	`1782`	`return libdivide_s64_recover(&den);`
`1783`	`1783`	`}`