Windows/clang-cl: error linking static FLAC.lib

[solbjorn]

Several functions in the FLAC library are declared like this:

https://github.com/xiph/flac/blob/master/src/libFLAC/include/private/bitwriter.h#L59

but then defined like this (note inline):

https://github.com/xiph/flac/blob/master/src/libFLAC/bitwriter.c#L357

It also has a comment at the bottom of the file:

https://github.com/xiph/flac/blob/master/src/libFLAC/bitwriter.c#L944

They are refering to the C standard that the way these functions are declared and defined is "valid".

When the library gets linked, the linker is unable to find these symbols. They get inlined and the out-of-line function bodies are not emitted.

The full bitwriter.c build rule on my setup (from ninja.build):

build src\libFLAC\CMakeFiles\FLAC.dir\bitwriter.c.obj: C_COMPILER__FLAC_unscanned_Release D$:\modding\nlc\engine\reaper-engine\3rd_party\Src\Xiph\flac\flac\src\libFLAC\bitwriter.c || cmake_object_order_depends_target_FLAC
  CONFIG = Release
  DEFINES = -DFLAC__NO_DLL -DHAVE_CONFIG_H -D_CRT_SECURE_NO_WARNINGS -D_DARWIN_C_SOURCE -D_POSIX_PTHREAD_SEMANTICS -D_TANDEM_SOURCE -D_USE_MATH_DEFINES -D__STDC_WANT_IEC_60559_BFP_EXT__ -D__STDC_WANT_IEC_60559_DFP_EXT__ -D__STDC_WANT_IEC_60559_FUNCS_EXT__ -D__STDC_WANT_IEC_60559_TYPES_EXT__ -D__STDC_WANT_LIB_EXT2__ -D__STDC_WANT_MATH_SPEC_FUNCS__
  FLAGS = -Wall -Wextra -Wstrict-prototypes -Wmissing-prototypes -Waggregate-return -Wcast-align -Wnested-externs -Wshadow -Wundef -Wmissing-declarations -Winline /DWIN32 /D_WINDOWS /O2 /Ob2 /Oi /Ot /Oy /DNDEBUG -DNDEBUG /O2 /Ob2 /DNDEBUG /MP /O2 /Ob2 /Oi /Oy /Ot /GL /Gy /Gw /W4 /GF /GS /Zi /GT /Brepro /bigobj /permissive- /volatile:iso /Zc:inline /Zc:preprocessor /Zc:enumTypes /Zc:lambda /Zc:__STDC__ /Zc:__cplusplus /Zc:externConstexpr /Zc:throwingNew /Zc:checkGwOdr /Zc:templateScope /DNOMINMAX -fno-delayed-template-parsing -fstrict-aliasing /D_CRT_STDIO_ISO_WIDE_SPECIFIERS -fno-ms-compatibility -fgnuc-version=0 /utf-8 -DS_IWRITE=_S_IWRITE -Dfileno=_fileno -Dgetenv=getenv -Doff_t=_off_t -Dstrdup=_strdup -Dutimbuf=_utimbuf -march=skylake -mavx2 -mvpclmulqdq /FIintrin.h -flto -fmerge-all-constants -fforce-emit-vtables -fwhole-program-vtables /clang:-fcoro-aligned-allocation /clang:-fopenmp -Wextra -Wmost -Wno-error=unused-command-line-argument -Werror=format -Wformat-nonliteral -Werror=format-pedantic -Werror=format-signedness -Werror=format-type-confusion -Werror=microsoft -Werror=move -Werror=nan-infinity-disabled -Werror=parentheses -Werror=strict-aliasing -Werror=tautological-compare -Werror=typename-missing -Werror=weak-vtables /D_WIN32_WINNT=0x0A00 /DWINVER=0x0A00 /D_MSVC_STL_HARDENING=1 /DNDEBUG /D_ITERATOR_DEBUG_LEVEL=0 -clang:-std=c23 -MD /fp:fast /wd4267 /wd4996 -Wdeclaration-after-statement
  INCLUDES = -ID:\modding\nlc\engine\reaper-engine\3rd_party\Src\Xiph\flac\flac\include -ID:\modding\nlc\engine\reaper-engine\3rd_party\Src\Xiph\flac\_Build -ID:\modding\nlc\engine\reaper-engine\3rd_party\Src\Xiph\flac\flac\src\libFLAC\include -imsvcD:\modding\nlc\engine\reaper-engine\3rd_party\Src\Xiph\ogg\_Build\Release\x64\include

I don't see anything illegal here. All other libraries and my whole project compile and work.

I tried adding -fgnu89-inline and defining inline as inline __attirubte__((__gnu_inline__)), but the symbols still don't get emitted.

To me it looks like incorrectly written library code. On the other hand, I don't see any similar issue reports here.
So first of all, I'd like to understand whether it's a compiler problem or a library problem. I've filed the same issue to the LLVM repo to be completely fair: llvm/llvm-project#187759

[ktmf01]

What kind of errors are you getting? Because the function you're referring to is private, meaning it isn't accesible outside of libFLAC, and you shouldn't try to use it in your code. It isn't part of the API

[solbjorn]

@ktmf01, nah, I don't use them. The library itself can't find them:

42>lld-link : error : undefined symbol: FLAC__bitreader_is_consumed_byte_aligned
42>  >>> referenced by D:\modding\nlc\engine\reaper-engine\3rd_party\Src\Xiph\flac\flac\src\libFLAC\stream_decoder.c
42>  >>>               FLAC.lib(stream_decoder.c.obj)
42>
42>lld-link : error : undefined symbol: FLAC__bitreader_read_uint32_little_endian
42>  >>> referenced by D:\modding\nlc\engine\reaper-engine\3rd_party\Src\Xiph\flac\flac\src\libFLAC\stream_decoder.c
42>  >>>               FLAC.lib(stream_decoder.c.obj)
42>
42>lld-link : error : undefined symbol: FLAC__bitreader_bits_left_for_byte_alignment
42>  >>> referenced by D:\modding\nlc\engine\reaper-engine\3rd_party\Src\Xiph\flac\flac\src\libFLAC\stream_decoder.c
42>  >>>               FLAC.lib(stream_decoder.c.obj)
42>
42>lld-link : error : undefined symbol: FLAC__bitreader_get_input_bits_unconsumed
42>  >>> referenced by D:\modding\nlc\engine\reaper-engine\3rd_party\Src\Xiph\flac\flac\src\libFLAC\stream_decoder.c
42>  >>>               FLAC.lib(stream_decoder.c.obj)
42>
42>lld-link : error : undefined symbol: FLAC__bitwriter_write_raw_uint32
42>  >>> referenced by D:\modding\nlc\engine\reaper-engine\3rd_party\Src\Xiph\flac\flac\src\libFLAC\stream_encoder.c
42>  >>>               FLAC.lib(stream_encoder.c.obj)
42>  >>> referenced by D:\modding\nlc\engine\reaper-engine\3rd_party\Src\Xiph\flac\flac\src\libFLAC\stream_encoder_framing.c
42>  >>>               FLAC.lib(stream_encoder_framing.c.obj)
42>
42>lld-link : error : undefined symbol: FLAC__bitwriter_write_raw_uint64
42>  >>> referenced by D:\modding\nlc\engine\reaper-engine\3rd_party\Src\Xiph\flac\flac\src\libFLAC\stream_encoder_framing.c
42>  >>>               FLAC.lib(stream_encoder_framing.c.obj)
42>
42>lld-link : error : undefined symbol: FLAC__bitwriter_write_byte_block
42>  >>> referenced by D:\modding\nlc\engine\reaper-engine\3rd_party\Src\Xiph\flac\flac\src\libFLAC\stream_encoder_framing.c
42>  >>>               FLAC.lib(stream_encoder_framing.c.obj)
42>
42>lld-link : error : undefined symbol: FLAC__bitwriter_write_raw_uint32_little_endian
42>  >>> referenced by D:\modding\nlc\engine\reaper-engine\3rd_party\Src\Xiph\flac\flac\src\libFLAC\stream_encoder_framing.c
42>  >>>               FLAC.lib(stream_encoder_framing.c.obj)
42>
42>lld-link : error : undefined symbol: FLAC__bitwriter_write_raw_int64
42>  >>> referenced by D:\modding\nlc\engine\reaper-engine\3rd_party\Src\Xiph\flac\flac\src\libFLAC\stream_encoder_framing.c
42>  >>>               FLAC.lib(stream_encoder_framing.c.obj)
42>
42>lld-link : error : undefined symbol: FLAC__bitwriter_write_raw_int32
42>  >>> referenced by D:\modding\nlc\engine\reaper-engine\3rd_party\Src\Xiph\flac\flac\src\libFLAC\stream_encoder_framing.c
42>  >>>               FLAC.lib(stream_encoder_framing.c.obj)

as they get inlined to the callsites inside bitwriter.c without emitting out-of-lines versions, so that other libFLAC sources can't find these symbols.

I think we can't rely on extern inline behaviour. The best way would be to define them as static inline in bitwriter.c and use these inline versions there, but also provide extern non-inline oneliner wrappers for other source files (or move them to the header files completely if possible).

[solbjorn]

This links fine:

diff --git a/src/libFLAC/bitreader.c b/src/libFLAC/bitreader.c
index 3ebe37c86b5a..ac912f2a1b46 100644
--- a/src/libFLAC/bitreader.c
+++ b/src/libFLAC/bitreader.c
@@ -378,17 +378,17 @@ FLAC__uint16 FLAC__bitreader_get_read_crc16(FLAC__BitReader *br)
 	return br->read_crc16;
 }
 
-inline FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br)
+static inline FLAC__bool __FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br)
 {
 	return ((br->consumed_bits & 7) == 0);
 }
 
-inline uint32_t FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br)
+static inline uint32_t __FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br)
 {
 	return 8 - (br->consumed_bits & 7);
 }
 
-inline uint32_t FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br)
+static inline uint32_t __FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br)
 {
 	return (br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits;
 }
@@ -552,7 +552,7 @@ FLAC__bool FLAC__bitreader_read_raw_int64(FLAC__BitReader *br, FLAC__int64 *val,
 	return true;
 }
 
-inline FLAC__bool FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val)
+static inline FLAC__bool __FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val)
 {
 	FLAC__uint32 x8, x32 = 0;
 
@@ -618,7 +618,7 @@ FLAC__bool FLAC__bitreader_skip_byte_block_aligned_no_crc(FLAC__BitReader *br, u
 
 	FLAC__ASSERT(0 != br);
 	FLAC__ASSERT(0 != br->buffer);
-	FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br));
+	FLAC__ASSERT(__FLAC__bitreader_is_consumed_byte_aligned(br));
 
 	if(br->read_limit_set && br->read_limit < (uint32_t)-1){
 		if(br->read_limit < nvals*8){
@@ -663,7 +663,7 @@ FLAC__bool FLAC__bitreader_read_byte_block_aligned_no_crc(FLAC__BitReader *br, F
 
 	FLAC__ASSERT(0 != br);
 	FLAC__ASSERT(0 != br->buffer);
-	FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br));
+	FLAC__ASSERT(__FLAC__bitreader_is_consumed_byte_aligned(br));
 
 	if(br->read_limit_set && br->read_limit < (uint32_t)-1){
 		if(br->read_limit < nvals*8){
@@ -1038,15 +1038,22 @@ FLAC__bool FLAC__bitreader_read_utf8_uint64(FLAC__BitReader *br, FLAC__uint64 *v
 	return true;
 }
 
-/* These functions are declared inline in this file but are also callable as
- * externs from elsewhere.
- * According to the C99 spec, section 6.7.4, simply providing a function
- * prototype in a header file without 'inline' and making the function inline
- * in this file should be sufficient.
- * Unfortunately, the Microsoft VS compiler doesn't pick them up externally. To
- * fix that we add extern declarations here.
- */
-extern FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br);
-extern uint32_t FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br);
-extern uint32_t FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br);
-extern FLAC__bool FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val);
+FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br)
+{
+	return __FLAC__bitreader_is_consumed_byte_aligned(br);
+}
+
+uint32_t FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br)
+{
+	return __FLAC__bitreader_bits_left_for_byte_alignment(br);
+}
+
+uint32_t FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br)
+{
+	return __FLAC__bitreader_get_input_bits_unconsumed(br);
+}
+
+FLAC__bool FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val)
+{
+	return __FLAC__bitreader_read_uint32_little_endian(br, val);
+}
diff --git a/src/libFLAC/bitwriter.c b/src/libFLAC/bitwriter.c
index c8b1cb05d8bd..ea543fe7f107 100644
--- a/src/libFLAC/bitwriter.c
+++ b/src/libFLAC/bitwriter.c
@@ -275,7 +275,7 @@ void FLAC__bitwriter_release_buffer(FLAC__BitWriter *bw)
 	(void)bw;
 }
 
-inline FLAC__bool FLAC__bitwriter_write_zeroes(FLAC__BitWriter *bw, uint32_t bits)
+static inline FLAC__bool __FLAC__bitwriter_write_zeroes(FLAC__BitWriter *bw, uint32_t bits)
 {
 	uint32_t n;
 
@@ -354,7 +354,7 @@ static inline FLAC__bool FLAC__bitwriter_write_raw_uint32_nocheck(FLAC__BitWrite
 	return true;
 }
 
-inline FLAC__bool FLAC__bitwriter_write_raw_uint32(FLAC__BitWriter *bw, FLAC__uint32 val, uint32_t bits)
+static inline FLAC__bool __FLAC__bitwriter_write_raw_uint32(FLAC__BitWriter *bw, FLAC__uint32 val, uint32_t bits)
 {
 	/* check that unused bits are unset */
 	if((bits < 32) && (val>>bits != 0))
@@ -363,7 +363,7 @@ inline FLAC__bool FLAC__bitwriter_write_raw_uint32(FLAC__BitWriter *bw, FLAC__ui
 	return FLAC__bitwriter_write_raw_uint32_nocheck(bw, val, bits);
 }
 
-inline FLAC__bool FLAC__bitwriter_write_raw_int32(FLAC__BitWriter *bw, FLAC__int32 val, uint32_t bits)
+static inline FLAC__bool __FLAC__bitwriter_write_raw_int32(FLAC__BitWriter *bw, FLAC__int32 val, uint32_t bits)
 {
 	/* zero-out unused bits */
 	if(bits < 32)
@@ -372,28 +372,28 @@ inline FLAC__bool FLAC__bitwriter_write_raw_int32(FLAC__BitWriter *bw, FLAC__int
 	return FLAC__bitwriter_write_raw_uint32_nocheck(bw, (FLAC__uint32)val, bits);
 }
 
-inline FLAC__bool FLAC__bitwriter_write_raw_uint64(FLAC__BitWriter *bw, FLAC__uint64 val, uint32_t bits)
+static inline FLAC__bool __FLAC__bitwriter_write_raw_uint64(FLAC__BitWriter *bw, FLAC__uint64 val, uint32_t bits)
 {
 	/* this could be a little faster but it's not used for much */
 	if(bits > 32) {
 		return
-			FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)(val>>32), bits-32) &&
+			__FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)(val>>32), bits-32) &&
 			FLAC__bitwriter_write_raw_uint32_nocheck(bw, (FLAC__uint32)val, 32);
 	}
 	else
-		return FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)val, bits);
+		return __FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)val, bits);
 }
 
-inline FLAC__bool FLAC__bitwriter_write_raw_int64(FLAC__BitWriter *bw, FLAC__int64 val, uint32_t bits)
+static inline FLAC__bool __FLAC__bitwriter_write_raw_int64(FLAC__BitWriter *bw, FLAC__int64 val, uint32_t bits)
 {
 	FLAC__uint64 uval = val;
 	/* zero-out unused bits */
 	if(bits < 64)
 		uval &= (~(UINT64_MAX << bits));
-	return FLAC__bitwriter_write_raw_uint64(bw, uval, bits);
+	return __FLAC__bitwriter_write_raw_uint64(bw, uval, bits);
 }
 
-inline FLAC__bool FLAC__bitwriter_write_raw_uint32_little_endian(FLAC__BitWriter *bw, FLAC__uint32 val)
+static inline FLAC__bool __FLAC__bitwriter_write_raw_uint32_little_endian(FLAC__BitWriter *bw, FLAC__uint32 val)
 {
 	/* this doesn't need to be that fast as currently it is only used for vorbis comments */
 
@@ -409,7 +409,7 @@ inline FLAC__bool FLAC__bitwriter_write_raw_uint32_little_endian(FLAC__BitWriter
 	return true;
 }
 
-inline FLAC__bool FLAC__bitwriter_write_byte_block(FLAC__BitWriter *bw, const FLAC__byte vals[], uint32_t nvals)
+static inline FLAC__bool __FLAC__bitwriter_write_byte_block(FLAC__BitWriter *bw, const FLAC__byte vals[], uint32_t nvals)
 {
 	uint32_t i;
 
@@ -432,7 +432,7 @@ FLAC__bool FLAC__bitwriter_write_unary_unsigned(FLAC__BitWriter *bw, uint32_t va
 		return FLAC__bitwriter_write_raw_uint32_nocheck(bw, 1, ++val);
 	else
 		return
-			FLAC__bitwriter_write_zeroes(bw, val) &&
+			__FLAC__bitwriter_write_zeroes(bw, val) &&
 			FLAC__bitwriter_write_raw_uint32_nocheck(bw, 1, 1);
 }
 
@@ -534,11 +534,11 @@ FLAC__bool FLAC__bitwriter_write_rice_signed(FLAC__BitWriter *bw, FLAC__int32 va
 	pattern |= (uval & ((1<<parameter)-1)); /* the binary LSBs */
 
 	if(total_bits <= 32)
-		return FLAC__bitwriter_write_raw_uint32(bw, pattern, total_bits);
+		return __FLAC__bitwriter_write_raw_uint32(bw, pattern, total_bits);
 	else
 		return
-			FLAC__bitwriter_write_zeroes(bw, msbs) && /* write the unary MSBs */
-			FLAC__bitwriter_write_raw_uint32(bw, pattern, interesting_bits); /* write the unary end bit and binary LSBs */
+			__FLAC__bitwriter_write_zeroes(bw, msbs) && /* write the unary MSBs */
+			__FLAC__bitwriter_write_raw_uint32(bw, pattern, interesting_bits); /* write the unary end bit and binary LSBs */
 }
 #endif /* UNUSED */
 
@@ -733,15 +733,15 @@ FLAC__bool FLAC__bitwriter_write_golomb_signed(FLAC__BitWriter *bw, int val, uin
 		pattern |= (uval & ((1u<<k)-1)); /* the binary LSBs */
 
 		if(total_bits <= 32) {
-			if(!FLAC__bitwriter_write_raw_uint32(bw, pattern, total_bits))
+			if(!__FLAC__bitwriter_write_raw_uint32(bw, pattern, total_bits))
 				return false;
 		}
 		else {
 			/* write the unary MSBs */
-			if(!FLAC__bitwriter_write_zeroes(bw, msbs))
+			if(!__FLAC__bitwriter_write_zeroes(bw, msbs))
 				return false;
 			/* write the unary end bit and binary LSBs */
-			if(!FLAC__bitwriter_write_raw_uint32(bw, pattern, k+1))
+			if(!__FLAC__bitwriter_write_raw_uint32(bw, pattern, k+1))
 				return false;
 		}
 	}
@@ -752,18 +752,18 @@ FLAC__bool FLAC__bitwriter_write_golomb_signed(FLAC__BitWriter *bw, int val, uin
 		q = uval / parameter;
 		r = uval - (q * parameter);
 		/* write the unary MSBs */
-		if(!FLAC__bitwriter_write_zeroes(bw, q))
+		if(!__FLAC__bitwriter_write_zeroes(bw, q))
 			return false;
 		/* write the unary end bit */
-		if(!FLAC__bitwriter_write_raw_uint32(bw, 1, 1))
+		if(!__FLAC__bitwriter_write_raw_uint32(bw, 1, 1))
 			return false;
 		/* write the binary LSBs */
 		if(r >= d) {
-			if(!FLAC__bitwriter_write_raw_uint32(bw, r+d, k+1))
+			if(!__FLAC__bitwriter_write_raw_uint32(bw, r+d, k+1))
 				return false;
 		}
 		else {
-			if(!FLAC__bitwriter_write_raw_uint32(bw, r, k))
+			if(!__FLAC__bitwriter_write_raw_uint32(bw, r, k))
 				return false;
 		}
 	}
@@ -791,15 +791,15 @@ FLAC__bool FLAC__bitwriter_write_golomb_unsigned(FLAC__BitWriter *bw, uint32_t u
 		pattern |= (uval & ((1u<<k)-1)); /* the binary LSBs */
 
 		if(total_bits <= 32) {
-			if(!FLAC__bitwriter_write_raw_uint32(bw, pattern, total_bits))
+			if(!__FLAC__bitwriter_write_raw_uint32(bw, pattern, total_bits))
 				return false;
 		}
 		else {
 			/* write the unary MSBs */
-			if(!FLAC__bitwriter_write_zeroes(bw, msbs))
+			if(!__FLAC__bitwriter_write_zeroes(bw, msbs))
 				return false;
 			/* write the unary end bit and binary LSBs */
-			if(!FLAC__bitwriter_write_raw_uint32(bw, pattern, k+1))
+			if(!__FLAC__bitwriter_write_raw_uint32(bw, pattern, k+1))
 				return false;
 		}
 	}
@@ -810,18 +810,18 @@ FLAC__bool FLAC__bitwriter_write_golomb_unsigned(FLAC__BitWriter *bw, uint32_t u
 		q = uval / parameter;
 		r = uval - (q * parameter);
 		/* write the unary MSBs */
-		if(!FLAC__bitwriter_write_zeroes(bw, q))
+		if(!__FLAC__bitwriter_write_zeroes(bw, q))
 			return false;
 		/* write the unary end bit */
-		if(!FLAC__bitwriter_write_raw_uint32(bw, 1, 1))
+		if(!__FLAC__bitwriter_write_raw_uint32(bw, 1, 1))
 			return false;
 		/* write the binary LSBs */
 		if(r >= d) {
-			if(!FLAC__bitwriter_write_raw_uint32(bw, r+d, k+1))
+			if(!__FLAC__bitwriter_write_raw_uint32(bw, r+d, k+1))
 				return false;
 		}
 		else {
-			if(!FLAC__bitwriter_write_raw_uint32(bw, r, k))
+			if(!__FLAC__bitwriter_write_raw_uint32(bw, r, k))
 				return false;
 		}
 	}
@@ -936,23 +936,42 @@ FLAC__bool FLAC__bitwriter_zero_pad_to_byte_boundary(FLAC__BitWriter *bw)
 {
 	/* 0-pad to byte boundary */
 	if(bw->bits & 7u)
-		return FLAC__bitwriter_write_zeroes(bw, 8 - (bw->bits & 7u));
+		return __FLAC__bitwriter_write_zeroes(bw, 8 - (bw->bits & 7u));
 	else
 		return true;
 }
 
-/* These functions are declared inline in this file but are also callable as
- * externs from elsewhere.
- * According to the C99 spec, section 6.7.4, simply providing a function
- * prototype in a header file without 'inline' and making the function inline
- * in this file should be sufficient.
- * Unfortunately, the Microsoft VS compiler doesn't pick them up externally. To
- * fix that we add extern declarations here.
- */
-extern FLAC__bool FLAC__bitwriter_write_zeroes(FLAC__BitWriter *bw, uint32_t bits);
-extern FLAC__bool FLAC__bitwriter_write_raw_uint32(FLAC__BitWriter *bw, FLAC__uint32 val, uint32_t bits);
-extern FLAC__bool FLAC__bitwriter_write_raw_int32(FLAC__BitWriter *bw, FLAC__int32 val, uint32_t bits);
-extern FLAC__bool FLAC__bitwriter_write_raw_uint64(FLAC__BitWriter *bw, FLAC__uint64 val, uint32_t bits);
-extern FLAC__bool FLAC__bitwriter_write_raw_int64(FLAC__BitWriter *bw, FLAC__int64 val, uint32_t bits);
-extern FLAC__bool FLAC__bitwriter_write_raw_uint32_little_endian(FLAC__BitWriter *bw, FLAC__uint32 val);
-extern FLAC__bool FLAC__bitwriter_write_byte_block(FLAC__BitWriter *bw, const FLAC__byte vals[], uint32_t nvals);
+FLAC__bool FLAC__bitwriter_write_zeroes(FLAC__BitWriter *bw, uint32_t bits)
+{
+	return __FLAC__bitwriter_write_zeroes(bw, bits);
+}
+
+FLAC__bool FLAC__bitwriter_write_raw_uint32(FLAC__BitWriter *bw, FLAC__uint32 val, uint32_t bits)
+{
+	return __FLAC__bitwriter_write_raw_uint32(bw, val, bits);
+}
+
+FLAC__bool FLAC__bitwriter_write_raw_int32(FLAC__BitWriter *bw, FLAC__int32 val, uint32_t bits)
+{
+	return __FLAC__bitwriter_write_raw_int32(bw, val, bits);
+}
+
+FLAC__bool FLAC__bitwriter_write_raw_uint64(FLAC__BitWriter *bw, FLAC__uint64 val, uint32_t bits)
+{
+	return __FLAC__bitwriter_write_raw_uint64(bw, val, bits);
+}
+
+FLAC__bool FLAC__bitwriter_write_raw_int64(FLAC__BitWriter *bw, FLAC__int64 val, uint32_t bits)
+{
+	return __FLAC__bitwriter_write_raw_int64(bw, val, bits);
+}
+
+FLAC__bool FLAC__bitwriter_write_raw_uint32_little_endian(FLAC__BitWriter *bw, FLAC__uint32 val)
+{
+	return __FLAC__bitwriter_write_raw_uint32_little_endian(bw, val);
+}
+
+FLAC__bool FLAC__bitwriter_write_byte_block(FLAC__BitWriter *bw, const FLAC__byte vals[], uint32_t nvals)
+{
+	return __FLAC__bitwriter_write_byte_block(bw, vals, nvals);
+}

I could submit a PR if you prefer. Or you could fix it yourself in a way you'd like to choose.

[solbjorn]

In the meantime, we'll figure out in the linked issue in the LLVM repo whether Clang behaves fully according to the C standard.

[ktmf01]

The code you're referring is probably well over 10 years old. It has been compiled by a lot of people with a lot of different toolsets. So, I need to have a very good explanation before changing anything

[frederick-vs-ja]

IIUC, function declarations in these parts need to be extern inline (instead of plain extern) to be external definitions.

flac/src/libFLAC/bitreader.c

Lines 1041 to 1052 in 3f1ecff

	/* These functions are declared inline in this file but are also callable as
	* externs from elsewhere.
	* According to the C99 spec, section 6.7.4, simply providing a function
	* prototype in a header file without 'inline' and making the function inline
	* in this file should be sufficient.
	* Unfortunately, the Microsoft VS compiler doesn't pick them up externally. To
	* fix that we add extern declarations here.
	*/
	extern FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br);
	extern uint32_t FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br);
	extern uint32_t FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br);
	extern FLAC__bool FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val);

flac/src/libFLAC/bitwriter.c

Lines 944 to 958 in 3f1ecff

	/* These functions are declared inline in this file but are also callable as
	* externs from elsewhere.
	* According to the C99 spec, section 6.7.4, simply providing a function
	* prototype in a header file without 'inline' and making the function inline
	* in this file should be sufficient.
	* Unfortunately, the Microsoft VS compiler doesn't pick them up externally. To
	* fix that we add extern declarations here.
	*/
	extern FLAC__bool FLAC__bitwriter_write_zeroes(FLAC__BitWriter *bw, uint32_t bits);
	extern FLAC__bool FLAC__bitwriter_write_raw_uint32(FLAC__BitWriter *bw, FLAC__uint32 val, uint32_t bits);
	extern FLAC__bool FLAC__bitwriter_write_raw_int32(FLAC__BitWriter *bw, FLAC__int32 val, uint32_t bits);
	extern FLAC__bool FLAC__bitwriter_write_raw_uint64(FLAC__BitWriter *bw, FLAC__uint64 val, uint32_t bits);
	extern FLAC__bool FLAC__bitwriter_write_raw_int64(FLAC__BitWriter *bw, FLAC__int64 val, uint32_t bits);
	extern FLAC__bool FLAC__bitwriter_write_raw_uint32_little_endian(FLAC__BitWriter *bw, FLAC__uint32 val);
	extern FLAC__bool FLAC__bitwriter_write_byte_block(FLAC__BitWriter *bw, const FLAC__byte vals[], uint32_t nvals);

This original author (@erikd) of 9edb817 seemingly overlooked something in C99.

Per N1256 (C99 + TC1, TC2, TC3) 6.7.4/6:

6 Any function with internal linkage can be an inline function. For a function with external linkage, the following restrictions apply: If a function is declared with an inline function specifier, then it shall also be defined in the same translation unit. If all of the file scope declarations for a function in a translation unit include the inline function specifier without extern, then the definition in that translation unit is an inline definition. An inline definition does not provide an external definition for the function, and does not forbid an external definition in another translation unit. An inline definition provides an alternative to an external definition, which a translator may use to implement any call to the function in the same translation unit. It is unspecified whether a call to the function uses the inline definition or the external definition.¹²²⁾

and 6.9/5

5 An external definition is an external declaration that is also a definition of a function (other than an inline definition) or an object. If an identifier declared with external linkage is used in an expression (other than as part of the operand of a sizeof operator whose result is an integer constant), somewhere in the entire program there shall be exactly one external definition for the identifier; otherwise, there shall be no more than one.¹⁴⁰⁾

Currently these functions only have inline definitions but no external definitions, which causes undefined behavior (or "ill-formed, no diagnostic required" in C++-style wording).

[solbjorn]

@ktmf01, is this explanation "very good" enough? Should I proceed with a PR or you'd like to fix this yourself?

[ktmf01]

No, not really. It doesn't explain why it just works pretty much everywhere else.

I'd rather not touch anything related to linking if not strictly necessary.

[solbjorn]

If you look at my patch, it has absolutely no functional changes and won't break anything. It just defines inlines as separate inlines + external entrypoints-wrappers, that's it.

There are plenty of different options why it may fail linking on my setup: optimization flags, LTO, whatever. I have 44 external open source libraries in my project + nearly 1 mln locs of code and this is the only place that fails.
As the LLVM developer said, such declarations are not strictly conformant with ANSI C.