Use macros for the likely/unlikely attributes

The syntax parser for GCC 8 (and earlier?) fails when these attributes are in
certain places.

10 files changed, 32 insertions, 32 deletions

diff --git a/core/ambdec.cpp b/core/ambdec.cpp
index 5e2de6af..8ca182c4 100644
--- a/core/ambdec.cpp
+++ b/core/ambdec.cpp
@@ -61,7 +61,7 @@ al::optional<std::string> make_error(size_t linenum, const char *fmt, ...)
     va_start(args, fmt);
     va_copy(args2, args);
     const int msglen{std::vsnprintf(&str[plen], str.size()-plen, fmt, args)};
-    if(msglen >= 0 && static_cast<size_t>(msglen) >= str.size()-plen) [[unlikely]]
+    if(msglen >= 0 && static_cast<size_t>(msglen) >= str.size()-plen)
     {
         str.resize(static_cast<size_t>(msglen) + plen + 1u);
         std::vsnprintf(&str[plen], str.size()-plen, fmt, args2);
diff --git a/core/converter.cpp b/core/converter.cpp
index c69bada7..a5141448 100644
--- a/core/converter.cpp
+++ b/core/converter.cpp
@@ -140,7 +140,7 @@ void Multi2Mono(uint chanmask, const size_t step, const float scale, float *REST
     std::fill_n(dst, frames, 0.0f);
     for(size_t c{0};chanmask;++c)
     {
-        if((chanmask&1)) [[likely]]
+        if((chanmask&1)) LIKELY
         {
             for(size_t i{0u};i < frames;i++)
                 dst[i] += LoadSample<T>(ssrc[i*step + c]);
diff --git a/core/device.h b/core/device.h
index 32cf04c3..9aaf7adb 100644
--- a/core/device.h
+++ b/core/device.h
@@ -310,7 +310,7 @@ struct DeviceBase {
     void ProcessBs2b(const size_t SamplesToDo);
 
     inline void postProcess(const size_t SamplesToDo)
-    { if(PostProcess) [[likely]] (this->*PostProcess)(SamplesToDo); }
+    { if(PostProcess) LIKELY (this->*PostProcess)(SamplesToDo); }
 
     void renderSamples(const al::span<float*> outBuffers, const uint numSamples);
     void renderSamples(void *outBuffer, const uint numSamples, const size_t frameStep);
diff --git a/core/except.cpp b/core/except.cpp
index ba4759a3..45fd4eb5 100644
--- a/core/except.cpp
+++ b/core/except.cpp
@@ -18,7 +18,7 @@ void base_exception::setMessage(const char* msg, std::va_list args)
     std::va_list args2;
     va_copy(args2, args);
     int msglen{std::vsnprintf(nullptr, 0, msg, args)};
-    if(msglen > 0) [[likely]]
+    if(msglen > 0) LIKELY
     {
         mMessage.resize(static_cast<size_t>(msglen)+1);
         std::vsnprintf(const_cast<char*>(mMessage.data()), mMessage.length(), msg, args2);
diff --git a/core/logging.cpp b/core/logging.cpp
index ec53e5f6..34a95e5a 100644
--- a/core/logging.cpp
+++ b/core/logging.cpp
@@ -45,7 +45,7 @@ void al_print(LogLevel level, FILE *logfile, const char *fmt, ...)
     va_start(args, fmt);
     va_copy(args2, args);
     const int msglen{std::vsnprintf(msg.data(), msg.size(), fmt, args)};
-    if(msglen >= 0 && static_cast<size_t>(msglen) >= msg.size()) [[unlikely]]
+    if(msglen >= 0 && static_cast<size_t>(msglen) >= msg.size()) UNLIKELY
     {
         dynmsg.resize(static_cast<size_t>(msglen)+prefix.size() + 1u);
 
diff --git a/core/logging.h b/core/logging.h
index c729ef4e..f4b6ab56 100644
--- a/core/logging.h
+++ b/core/logging.h
@@ -25,17 +25,17 @@ void al_print(LogLevel level, FILE *logfile, const char *fmt, ...);
 
 #if (!defined(_WIN32) || defined(NDEBUG)) && !defined(__ANDROID__)
 #define TRACE(...) do {                                                       \
-    if(gLogLevel >= LogLevel::Trace) [[unlikely]]                             \
+    if(gLogLevel >= LogLevel::Trace) UNLIKELY                                 \
         al_print(LogLevel::Trace, gLogFile, __VA_ARGS__);                     \
 } while(0)
 
 #define WARN(...) do {                                                        \
-    if(gLogLevel >= LogLevel::Warning) [[unlikely]]                           \
+    if(gLogLevel >= LogLevel::Warning) UNLIKELY                               \
         al_print(LogLevel::Warning, gLogFile, __VA_ARGS__);                   \
 } while(0)
 
 #define ERR(...) do {                                                         \
-    if(gLogLevel >= LogLevel::Error) [[unlikely]]                             \
+    if(gLogLevel >= LogLevel::Error) UNLIKELY                                 \
         al_print(LogLevel::Error, gLogFile, __VA_ARGS__);                     \
 } while(0)
 
diff --git a/core/mastering.cpp b/core/mastering.cpp
index cff162da..97a4008e 100644
--- a/core/mastering.cpp
+++ b/core/mastering.cpp
@@ -295,7 +295,7 @@ void SignalDelay(Compressor *Comp, const uint SamplesToDo, FloatBufferLine *OutB
         float *delaybuf{al::assume_aligned<16>(Comp->mDelay[c].data())};
 
         auto inout_end = inout + SamplesToDo;
-        if(SamplesToDo >= lookAhead) [[likely]]
+        if(SamplesToDo >= lookAhead) LIKELY
         {
             auto delay_end = std::rotate(inout, inout_end - lookAhead, inout_end);
             std::swap_ranges(inout, delay_end, delaybuf);
diff --git a/core/mixer/hrtfbase.h b/core/mixer/hrtfbase.h
index 656b9445..36f88e49 100644
--- a/core/mixer/hrtfbase.h
+++ b/core/mixer/hrtfbase.h
@@ -50,7 +50,7 @@ inline void MixHrtfBlendBase(const float *InSamples, float2 *RESTRICT AccumSampl
     const ConstHrirSpan NewCoeffs{newparams->Coeffs};
     const float newGainStep{newparams->GainStep};
 
-    if(oldparams->Gain > GainSilenceThreshold) [[likely]]
+    if(oldparams->Gain > GainSilenceThreshold) LIKELY
     {
         size_t ldelay{HrtfHistoryLength - oldparams->Delay[0]};
         size_t rdelay{HrtfHistoryLength - oldparams->Delay[1]};
@@ -66,7 +66,7 @@ inline void MixHrtfBlendBase(const float *InSamples, float2 *RESTRICT AccumSampl
         }
     }
 
-    if(newGainStep*static_cast<float>(BufferSize) > GainSilenceThreshold) [[likely]]
+    if(newGainStep*static_cast<float>(BufferSize) > GainSilenceThreshold) LIKELY
     {
         size_t ldelay{HrtfHistoryLength+1 - newparams->Delay[0]};
         size_t rdelay{HrtfHistoryLength+1 - newparams->Delay[1]};
diff --git a/core/uhjfilter.cpp b/core/uhjfilter.cpp
index d6a60271..df50956a 100644
--- a/core/uhjfilter.cpp
+++ b/core/uhjfilter.cpp
@@ -67,7 +67,7 @@ void UhjAllPassFilter::process(const al::span<const float,4> coeffs,
         return x;
     };
     std::transform(src.begin(), src.end(), dst, proc_sample);
-    if(updateState) [[likely]] mState = state;
+    if(updateState) LIKELY mState = state;
 }
 
 
@@ -133,7 +133,7 @@ void UhjEncoder<N>::encode(float *LeftOut, float *RightOut,
 
         float *inout{al::assume_aligned<16>(buffer)};
         auto inout_end = inout + SamplesToDo;
-        if(SamplesToDo >= sFilterDelay) [[likely]]
+        if(SamplesToDo >= sFilterDelay) LIKELY
         {
             auto delay_end = std::rotate(inout, inout_end - sFilterDelay, inout_end);
             std::swap_ranges(inout, delay_end, distbuf);
@@ -270,7 +270,7 @@ void UhjDecoder<N>::decode(const al::span<float*> samples, const size_t samplesT
     auto tmpiter = std::copy(mDTHistory.cbegin(), mDTHistory.cend(), mTemp.begin());
     std::transform(mD.cbegin(), mD.cbegin()+samplesToDo+sInputPadding, mT.cbegin(), tmpiter,
         [](const float d, const float t) noexcept { return 0.828331f*d + 0.767820f*t; });
-    if(updateState) [[likely]]
+    if(updateState) LIKELY
         std::copy_n(mTemp.cbegin()+samplesToDo, mDTHistory.size(), mDTHistory.begin());
     PShift.process({xoutput, samplesToDo}, mTemp.data());
 
@@ -284,7 +284,7 @@ void UhjDecoder<N>::decode(const al::span<float*> samples, const size_t samplesT
     /* Precompute j*S and store in youtput. */
     tmpiter = std::copy(mSHistory.cbegin(), mSHistory.cend(), mTemp.begin());
     std::copy_n(mS.cbegin(), samplesToDo+sInputPadding, tmpiter);
-    if(updateState) [[likely]]
+    if(updateState) LIKELY
         std::copy_n(mTemp.cbegin()+samplesToDo, mSHistory.size(), mSHistory.begin());
     PShift.process({youtput, samplesToDo}, mTemp.data());
 
@@ -333,7 +333,7 @@ void UhjDecoderIIR::decode(const al::span<float*> samples, const size_t samplesT
     /* Apply filter1 to S and store in mTemp. */
     mTemp[0] = mDelayS;
     mFilter1S.process(Filter1Coeff, {mS.data(), samplesToDo}, updateState, mTemp.data()+1);
-    if(updateState) [[likely]] mDelayS = mTemp[samplesToDo];
+    if(updateState) LIKELY mDelayS = mTemp[samplesToDo];
 
     /* W = 0.981532*S + 0.197484*j(0.828331*D + 0.767820*T) */
     for(size_t i{0};i < samplesToDo;++i)
@@ -348,7 +348,7 @@ void UhjDecoderIIR::decode(const al::span<float*> samples, const size_t samplesT
         [](const float d, const float t) noexcept { return 0.795968f*d - 0.676392f*t; });
     mTemp[0] = mDelayDT;
     mFilter1DT.process(Filter1Coeff, {youtput, samplesToDo}, updateState, mTemp.data()+1);
-    if(updateState) [[likely]] mDelayDT = mTemp[samplesToDo];
+    if(updateState) LIKELY mDelayDT = mTemp[samplesToDo];
 
     /* Precompute j*S and store in youtput. */
     mFilter2S.process(Filter2Coeff, {mS.data(), samplesToDo}, updateState, youtput);
@@ -365,7 +365,7 @@ void UhjDecoderIIR::decode(const al::span<float*> samples, const size_t samplesT
         /* Apply filter1 to Q and store in mTemp. */
         mTemp[0] = mDelayQ;
         mFilter1Q.process(Filter1Coeff, {zoutput, samplesToDo}, updateState, mTemp.data()+1);
-        if(updateState) [[likely]] mDelayQ = mTemp[samplesToDo];
+        if(updateState) LIKELY mDelayQ = mTemp[samplesToDo];
 
         /* Z = 1.023332*Q */
         for(size_t i{0};i < samplesToDo;++i)
@@ -436,7 +436,7 @@ void UhjStereoDecoder<N>::decode(const al::span<float*> samples, const size_t sa
     /* Precompute j*D and store in xoutput. */
     auto tmpiter = std::copy(mDTHistory.cbegin(), mDTHistory.cend(), mTemp.begin());
     std::copy_n(mD.cbegin(), samplesToDo+sInputPadding, tmpiter);
-    if(updateState) [[likely]]
+    if(updateState) LIKELY
         std::copy_n(mTemp.cbegin()+samplesToDo, mDTHistory.size(), mDTHistory.begin());
     PShift.process({xoutput, samplesToDo}, mTemp.data());
 
@@ -450,7 +450,7 @@ void UhjStereoDecoder<N>::decode(const al::span<float*> samples, const size_t sa
     /* Precompute j*S and store in youtput. */
     tmpiter = std::copy(mSHistory.cbegin(), mSHistory.cend(), mTemp.begin());
     std::copy_n(mS.cbegin(), samplesToDo+sInputPadding, tmpiter);
-    if(updateState) [[likely]]
+    if(updateState) LIKELY
         std::copy_n(mTemp.cbegin()+samplesToDo, mSHistory.size(), mSHistory.begin());
     PShift.process({youtput, samplesToDo}, mTemp.data());
 
@@ -504,7 +504,7 @@ void UhjStereoDecoderIIR::decode(const al::span<float*> samples, const size_t sa
     /* Apply filter1 to S and store in mTemp. */
     mTemp[0] = mDelayS;
     mFilter1S.process(Filter1Coeff, {mS.data(), samplesToDo}, updateState, mTemp.data()+1);
-    if(updateState) [[likely]] mDelayS = mTemp[samplesToDo];
+    if(updateState) LIKELY mDelayS = mTemp[samplesToDo];
 
     /* Precompute j*D and store in xoutput. */
     mFilter2D.process(Filter2Coeff, {mD.data(), samplesToDo}, updateState, xoutput);
@@ -522,7 +522,7 @@ void UhjStereoDecoderIIR::decode(const al::span<float*> samples, const size_t sa
     /* Apply filter1 to D and store in mTemp. */
     mTemp[0] = mDelayD;
     mFilter1D.process(Filter1Coeff, {mD.data(), samplesToDo}, updateState, mTemp.data()+1);
-    if(updateState) [[likely]] mDelayD = mTemp[samplesToDo];
+    if(updateState) LIKELY mDelayD = mTemp[samplesToDo];
 
     /* Y = 1.6822415*w*D - 0.2156194*j*S */
     for(size_t i{0};i < samplesToDo;++i)
diff --git a/core/voice.cpp b/core/voice.cpp
index d6708f6d..ee5f6ae6 100644
--- a/core/voice.cpp
+++ b/core/voice.cpp
@@ -493,7 +493,7 @@ void LoadBufferStatic(VoiceBufferItem *buffer, VoiceBufferItem *bufferLoopItem,
     if(!bufferLoopItem)
     {
         /* Load what's left to play from the buffer */
-        if(buffer->mSampleLen > dataPosInt) [[likely]]
+        if(buffer->mSampleLen > dataPosInt) LIKELY
         {
             const size_t buffer_remaining{buffer->mSampleLen - dataPosInt};
             const size_t remaining{minz(samplesToLoad-samplesLoaded, buffer_remaining)};
@@ -539,7 +539,7 @@ void LoadBufferCallback(VoiceBufferItem *buffer, const size_t dataPosInt,
     const size_t srcStep, size_t samplesLoaded, const size_t samplesToLoad, float *voiceSamples)
 {
     /* Load what's left to play from the buffer */
-    if(numCallbackSamples > dataPosInt) [[likely]]
+    if(numCallbackSamples > dataPosInt) LIKELY
     {
         const size_t remaining{minz(samplesToLoad-samplesLoaded, numCallbackSamples-dataPosInt)};
         LoadSamples(voiceSamples+samplesLoaded, buffer->mSamples, srcChannel, dataPosInt,
@@ -603,7 +603,7 @@ void DoHrtfMix(const float *samples, const uint DstBufferSize, DirectParams &par
         std::begin(HrtfSamples));
     std::copy_n(samples, DstBufferSize, src_iter);
     /* Copy the last used samples back into the history buffer for later. */
-    if(IsPlaying) [[likely]]
+    if(IsPlaying) LIKELY
         std::copy_n(std::begin(HrtfSamples) + DstBufferSize, parms.Hrtf.History.size(),
             parms.Hrtf.History.begin());
 
@@ -710,7 +710,7 @@ void Voice::mix(const State vstate, ContextBase *Context, const nanoseconds devi
     VoiceBufferItem *BufferListItem{mCurrentBuffer.load(std::memory_order_relaxed)};
     VoiceBufferItem *BufferLoopItem{mLoopBuffer.load(std::memory_order_relaxed)};
     const uint increment{mStep};
-    if(increment < 1) [[unlikely]]
+    if(increment < 1) UNLIKELY
     {
         /* If the voice is supposed to be stopping but can't be mixed, just
          * stop it before bailing.
@@ -863,7 +863,7 @@ void Voice::mix(const State vstate, ContextBase *Context, const nanoseconds devi
             else
             {
                 size_t srcSampleDelay{0};
-                if(intPos < 0) [[unlikely]]
+                if(intPos < 0) UNLIKELY
                 {
                     /* If the current position is negative, there's that many
                      * silent samples to load before using the buffer.
@@ -922,13 +922,13 @@ void Voice::mix(const State vstate, ContextBase *Context, const nanoseconds devi
                 {MixingSamples[chan]+samplesLoaded, dstBufferSize});
 
             /* Store the last source samples used for next time. */
-            if(vstate == Playing) [[likely]]
+            if(vstate == Playing) LIKELY
             {
                 /* Only store samples for the end of the mix, excluding what
                  * gets loaded for decoder padding.
                  */
                 const uint loadEnd{samplesLoaded + dstBufferSize};
-                if(samplesToMix > samplesLoaded && samplesToMix <= loadEnd) [[likely]]
+                if(samplesToMix > samplesLoaded && samplesToMix <= loadEnd) LIKELY
                 {
                     const size_t dstOffset{samplesToMix - samplesLoaded};
                     const size_t srcOffset{(dstOffset*increment + fracPos) >> MixerFracBits};
@@ -1046,7 +1046,7 @@ void Voice::mix(const State vstate, ContextBase *Context, const nanoseconds devi
     mFlags.set(VoiceIsFading);
 
     /* Don't update positions and buffers if we were stopping. */
-    if(vstate == Stopping) [[unlikely]]
+    if(vstate == Stopping) UNLIKELY
     {
         mPlayState.store(Stopped, std::memory_order_release);
         return;
@@ -1059,7 +1059,7 @@ void Voice::mix(const State vstate, ContextBase *Context, const nanoseconds devi
     DataPosFrac &= MixerFracMask;
 
     uint buffers_done{0u};
-    if(BufferListItem && DataPosInt >= 0) [[likely]]
+    if(BufferListItem && DataPosInt >= 0) LIKELY
     {
         if(mFlags.test(VoiceIsStatic))
         {
@@ -1168,7 +1168,7 @@ void Voice::prepare(DeviceBase *device)
      */
     uint num_channels{(mFmtChannels == FmtUHJ2 || mFmtChannels == FmtSuperStereo) ? 3 :
         ChannelsFromFmt(mFmtChannels, minu(mAmbiOrder, device->mAmbiOrder))};
-    if(num_channels > device->mSampleData.size()) [[unlikely]]
+    if(num_channels > device->mSampleData.size()) UNLIKELY
     {
         ERR("Unexpected channel count: %u (limit: %zu, %d:%d)\n", num_channels,
             device->mSampleData.size(), mFmtChannels, mAmbiOrder);