Some of the FATE instances have permanent failures due to bugs in toolchains, that have already been analyzed (and possibly reported) but won't be fixed, and probably won't be worked around in the source code.

MSVC 2013 ARM

Example: https://fate.libav.org/arm-msvc-12-wp

The filter-hqdn3d test fails due to broken autovectorization, reported at https://connect.microsoft.com/VisualStudio/feedback/details/1055795/arm-compiler-misoptimizes-certain-loops-with-neon.

Old XCode targeting i386

Examples: https://fate.libav.org/i386-apple-darwin-gcc-4.0 and https://fate.libav.org/i386-apple-darwin-gcc-4.2

The checkasm test fails due to a few VP8 MMXEXT functions - this isn't specific to the checkasm test, but also fails similarly if fate-vp8 is tested with CPUFLAGS=mmxext.

The linker seems to mess up some relocations to tables (that point to some bytes before the table) - see https://github.com/mstorsjo/libav/commit/vp8-fix-old-osx for a more thorough explanation.

clang 3.7 For Windows/ARM

Example: https://fate.libav.org/armv7-win32-clang-3.7

Clang prior to 3.9 (or possibly only after 3.9 branched, so 4.0) incorrectly used the smmls instruction in thumb mode, see https://llvm.org/bugs/show_bug.cgi?id=28701. When inline assembly is disabled (inline ARM assembly in clang MSVC mode doesn't work until clang/LLVM 4.0), the C code in dct32_fixed gets misoptimized due to this, resulting in failures in the following tests:

This issue is not present in the clang 4.0 fate instance at https://fate.libav.org/armv7-win32-clang-4.0, both since the actual bug has been fixed, and since inline assembly doesn't need to be disabled, avoiding (and not benefitting from!) the whole class of optimizations that clang/llvm did (including the valid optimizations that still are left, fusing smmul + add into smmla).

Remote filsystem induced spurious bugs

Many of the ARM FATE instances run with cross compilation, over a remote filesystem. These can sometimes cause spurious test failures that can disappear on the next run.

(Note, the MSVC 2015 ARM instances, https://fate.libav.org/arm-msvc-14-wp and https://fate.libav.org/arm-msvc-14-wp-binutils, often fail in the vsynth prores tests, but very seldom in any other tests. This could indicate that either the code relies on e.g. unintialized data or otherwise gets miscompiled.)

ARMCC 5.04

Example: https://fate.libav.org/armv7-hf-linux-armcc-5.0

The smc test and some lossless audio codecs are known to fail due to misoptimization. Forcing it to not optimize some parts can fix it, e.g. like this:

diff --git a/libavcodec/smc.c b/libavcodec/smc.c
index 46903ab..303274c 100644
--- a/libavcodec/smc.c
+++ b/libavcodec/smc.c
@@ -139,6 +139,7 @@ static void smc_decode_stream(SmcContext *s)
         case 0x00:
         case 0x10:
             n_blocks = GET_BLOCK_COUNT();
+            fprintf(stderr, "");
             while (n_blocks--) {
                 ADVANCE_BLOCK();
             }

diff --git a/libavcodec/bitstream.h b/libavcodec/bitstream.h
index 996e32e..8dd9713 100644
--- a/libavcodec/bitstream.h
+++ b/libavcodec/bitstream.h
@@ -131,9 +131,11 @@ static inline uint64_t get_val(BitstreamContext *bc, unsigned n)
 {
 #ifdef BITSTREAM_READER_LE
     uint64_t ret = bc->bits & ((UINT64_C(1) << n) - 1);
+    fprintf(stderr, "");
     bc->bits >>= n;
 #else
     uint64_t ret = bc->bits >> (64 - n);
+    fprintf(stderr, "");
     bc->bits <<= n;
 #endif
     bc->bits_left -= n;

RVCT 4.0

Example: https://fate.libav.org/armv7-hf-linux-rvct-4.0

This is known to fail a lot of tests, mostly due to misoptimization. Tests that are known to fail, that have been analyzed, are the following:

Hacks/workarounds:

diff --git a/libavcodec/xan.c b/libavcodec/xan.c
index c16c651..56c7412 100644
--- a/libavcodec/xan.c
+++ b/libavcodec/xan.c
@@ -558,6 +558,7 @@ static int xan_decode_frame(AVCodecContext *avctx,
                 int g = gamma_lookup[bytestream2_get_byteu(&ctx)];
                 int b = gamma_lookup[bytestream2_get_byteu(&ctx)];
 #endif
+                buf += 3;
                 *tmpptr++ = (r << 16) | (g << 8) | b;
             }
             s->palettes_count++;

diff --git a/libavcodec/vqavideo.c b/libavcodec/vqavideo.c
index 0d0d59a..7ef160e 100644
--- a/libavcodec/vqavideo.c
+++ b/libavcodec/vqavideo.c
@@ -421,6 +421,7 @@ static int vqa_decode_chunk(VqaContext *s, AVFrame *frame)
             r = bytestream2_get_byteu(&s->gb) * 4;
             g = bytestream2_get_byteu(&s->gb) * 4;
             b = bytestream2_get_byteu(&s->gb) * 4;
+            av_log(NULL, AV_LOG_DEBUG, "");
             s->palette[i] = (r << 16) | (g << 8) | (b);
         }
     }

diff --git a/libavcodec/pafvideo.c b/libavcodec/pafvideo.c
index b77f47e..d292486 100644
--- a/libavcodec/pafvideo.c
+++ b/libavcodec/pafvideo.c
@@ -297,6 +297,7 @@ static int paf_video_decode(AVCodecContext *avctx, void *dat
a,
             g = g << 2 | g >> 4;
             b = bytestream2_get_byteu(&c->gb);
             b = b << 2 | b >> 4;
+            fprintf(stderr, "");
             *out++ = (0xFFU << 24) | (r << 16) | (g << 8) | b;
         }
         c->pic->palette_has_changed = 1;

diff --git a/libavcodec/tiff.c b/libavcodec/tiff.c
index 97b9d6f..12b6c4c 100644
--- a/libavcodec/tiff.c
+++ b/libavcodec/tiff.c
@@ -238,6 +238,7 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t *dst, i
nt stride,
                 } else if (code != -128) { // -127..-1
                     code = (-code) + 1;
                     c    = bytestream2_get_byte(&s->gb);
+                    fprintf(stderr, "");
                     bytestream2_set_buffer(&pb, c, code);
                     pixels += code;
                 }

diff --git a/libavformat/movenc.c b/libavformat/movenc.c
index 31b940a..4e05a05 100644
--- a/libavformat/movenc.c
+++ b/libavformat/movenc.c
@@ -1973,6 +1973,7 @@ static int mov_write_itunes_hdlr_tag(AVIOContext *pb, MOVM
uxContext *mov,
 /* helper function to write a data tag with the specified string as data */
 static int mov_write_string_data_tag(AVIOContext *pb, const char *data, int lan
g, int long_style)
 {
+    av_log(NULL, AV_LOG_WARNING, "", long_style);
     if (long_style) {
         int size = 16 + strlen(data);
         avio_wb32(pb, size); /* size */

diff --git a/tests/checkasm/h264qpel.c b/tests/checkasm/h264qpel.c
index d92f223..a6c7c39 100644
--- a/tests/checkasm/h264qpel.c
+++ b/tests/checkasm/h264qpel.c
@@ -58,15 +58,17 @@ void checkasm_check_h264qpel(void)
     declare_func_emms(AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMXEXT, void, uint8_t *dst, const uint8_t *src, ptrdiff_t stride);
 
     for (op = 0; op < 2; op++) {
-        qpel_mc_func (*tab)[16] = op ? h.avg_h264_qpel_pixels_tab : h.put_h264_qpel_pixels_tab;
         const char *op_name = op ? "avg" : "put";
 
         for (bit_depth = 8; bit_depth <= 10; bit_depth++) {
             ff_h264qpel_init(&h, bit_depth);
             for (i = 0; i < (op ? 3 : 4); i++) {
                 int size = 16 >> i;
-                for (j = 0; j < 16; j++)
-                    if (check_func(tab[i][j], "%s_h264_qpel_%d_mc%d%d_%d", op_name, size, j & 3, j >> 2, bit_depth)) {
+                for (j = 0; j < 16; j++) {
+                    qpel_mc_func func = h.put_h264_qpel_pixels_tab[i][j];
+                    if (op)
+                        func = h.avg_h264_qpel_pixels_tab[i][j];
+                    if (check_func(func, "%s_h264_qpel_%d_mc%d%d_%d", op_name, size, j & 3, j >> 2, bit_depth)) {
                         randomize_buffers();
                         call_ref(dst0, src0, size * SIZEOF_PIXEL);
                         call_new(dst1, src1, size * SIZEOF_PIXEL);
@@ -74,6 +76,7 @@ void checkasm_check_h264qpel(void)
                             fail();
                         bench_new(dst1, src1, size * SIZEOF_PIXEL);
                     }
+                }
             }
         }
         report("%s", op_name);
diff --git a/tests/checkasm/vp8dsp.c b/tests/checkasm/vp8dsp.c
index 9733ff7..6a66897 100644
--- a/tests/checkasm/vp8dsp.c
+++ b/tests/checkasm/vp8dsp.c
@@ -274,7 +274,6 @@ static void check_mc(void)
     ff_vp78dsp_init(&d);
 
     for (type = 0; type < 2; type++) {
-        vp8_mc_func (*tab)[3][3] = type ? d.put_vp8_bilinear_pixels_tab : d.put_vp8_epel_pixels_tab;
         for (k = 1; k < 8; k++) {
             int hsize  = k / 3;
             int size   = 16 >> hsize;
@@ -282,6 +281,9 @@ static void check_mc(void)
             for (dy = 0; dy < 3; dy++) {
                 for (dx = 0; dx < 3; dx++) {
                     char str[100];
+                    vp8_mc_func func = d.put_vp8_epel_pixels_tab[hsize][dy][dx];
+                    if (type)
+                        func = d.put_vp8_bilinear_pixels_tab[hsize][dy][dx];
                     if (dx || dy) {
                         if (type == 0) {
                             static const char *dx_names[] = { "", "h4", "h6" };
@@ -293,7 +295,7 @@ static void check_mc(void)
                     } else {
                         snprintf(str, sizeof(str), "pixels%d", size);
                     }
-                    if (check_func(tab[hsize][dy][dx], "vp8_put_%s", str)) {
+                    if (check_func(func, "vp8_put_%s", str)) {
                         int mx, my;
                         int i;
                         if (type == 0) {

release 9

On x86_32, the --disable-inline-asm and --disable-mmx configurations fail a handful of tests for unknown reasons. Since 9 is an unsupported release, nobody bothered to investigate in detail.