shithub: libvpx

Info  •  Files  •  Log  •  Branches

[CFI] Remove function pointer casts

Control Flow Integrity [1] indirect call checking verifies that function
pointers only call valid functions with a matching type signature. This
change eliminates function pointer casts to make libvpx CFI-safe.

[1] https://www.chromium.org/developers/testing/control-flow-integrity

Change-Id: I7e08522d195a43c88cda06fa20414426c8c4372c

--- a/vp9/common/vp9_loopfilter.c

+++ b/vp9/common/vp9_loopfilter.c

@@ -1618,7 +1618,8 @@

   }

 }

-int vp9_loop_filter_worker(LFWorkerData *const lf_data, void *unused) {

+int vp9_loop_filter_worker(void *arg1, void *unused) {

+  LFWorkerData *const lf_data = (LFWorkerData *)arg1;

   (void)unused;

   loop_filter_rows(lf_data->frame_buffer, lf_data->cm, lf_data->planes,

                    lf_data->start, lf_data->stop, lf_data->y_only);

--- a/vp9/common/vp9_loopfilter.h

+++ b/vp9/common/vp9_loopfilter.h

@@ -151,8 +151,8 @@

     LFWorkerData *lf_data, YV12_BUFFER_CONFIG *frame_buffer,

     struct VP9Common *cm, const struct macroblockd_plane planes[MAX_MB_PLANE]);

-// Operates on the rows described by 'lf_data'.

-int vp9_loop_filter_worker(LFWorkerData *const lf_data, void *unused);

+// Operates on the rows described by 'arg1' (cast to LFWorkerData *).

+int vp9_loop_filter_worker(void *arg1, void *unused);

 #ifdef __cplusplus

 }  // extern "C"

 #endif

--- a/vp9/common/vp9_thread_common.c

+++ b/vp9/common/vp9_thread_common.c

@@ -140,8 +140,9 @@

 }

 // Row-based multi-threaded loopfilter hook

-static int loop_filter_row_worker(VP9LfSync *const lf_sync,

-                                  LFWorkerData *const lf_data) {

+static int loop_filter_row_worker(void *arg1, void *arg2) {

+  VP9LfSync *const lf_sync = (VP9LfSync *)arg1;

+  LFWorkerData *const lf_data = (LFWorkerData *)arg2;

   thread_loop_filter_rows(lf_data->frame_buffer, lf_data->cm, lf_data->planes,

                           lf_data->start, lf_data->stop, lf_data->y_only,

                           lf_sync);

@@ -183,7 +184,7 @@

     VPxWorker *const worker = &workers[i];

     LFWorkerData *const lf_data = &lf_sync->lfdata[i];

-    worker->hook = (VPxWorkerHook)loop_filter_row_worker;

+    worker->hook = loop_filter_row_worker;

     worker->data1 = lf_sync;

     worker->data2 = lf_data;

--- a/vp9/decoder/vp9_decodeframe.c

+++ b/vp9/decoder/vp9_decodeframe.c

@@ -1364,7 +1364,7 @@

       pbi->lf_worker.data1 == NULL) {

     CHECK_MEM_ERROR(cm, pbi->lf_worker.data1,

                     vpx_memalign(32, sizeof(LFWorkerData)));

-    pbi->lf_worker.hook = (VPxWorkerHook)vp9_loop_filter_worker;

+    pbi->lf_worker.hook = vp9_loop_filter_worker;

     if (pbi->max_threads > 1 && !winterface->reset(&pbi->lf_worker)) {

       vpx_internal_error(&cm->error, VPX_CODEC_ERROR,

                          "Loop filter thread creation failed");

@@ -1474,8 +1474,10 @@

 // On entry 'tile_data->data_end' points to the end of the input frame, on exit

 // it is updated to reflect the bitreader position of the final tile column if

 // present in the tile buffer group or NULL otherwise.

-static int tile_worker_hook(TileWorkerData *const tile_data,

-                            VP9Decoder *const pbi) {

+static int tile_worker_hook(void *arg1, void *arg2) {

+  TileWorkerData *const tile_data = (TileWorkerData *)arg1;

+  VP9Decoder *const pbi = (VP9Decoder *)arg2;

+

   TileInfo *volatile tile = &tile_data->xd.tile;

   const int final_col = (1 << pbi->common.log2_tile_cols) - 1;

   const uint8_t *volatile bit_reader_end = NULL;

@@ -1569,7 +1571,7 @@

     tile_data->xd = pbi->mb;

     tile_data->xd.counts =

         cm->frame_parallel_decoding_mode ? NULL : &tile_data->counts;

-    worker->hook = (VPxWorkerHook)tile_worker_hook;

+    worker->hook = tile_worker_hook;

     worker->data1 = tile_data;

     worker->data2 = pbi;

   }

--- a/vp9/encoder/vp9_bitstream.c

+++ b/vp9/encoder/vp9_bitstream.c

@@ -919,7 +919,9 @@

   }

 }

-static int encode_tile_worker(VP9_COMP *cpi, VP9BitstreamWorkerData *data) {

+static int encode_tile_worker(void *arg1, void *arg2) {

+  VP9_COMP *cpi = (VP9_COMP *)arg1;

+  VP9BitstreamWorkerData *data = (VP9BitstreamWorkerData *)arg2;

   MACROBLOCKD *const xd = &data->xd;

   const int tile_row = 0;

   vpx_start_encode(&data->bit_writer, data->dest);

@@ -995,7 +997,7 @@

       }

       worker->data1 = cpi;

       worker->data2 = data;

-      worker->hook = (VPxWorkerHook)encode_tile_worker;

+      worker->hook = encode_tile_worker;

       worker->had_error = 0;

       if (i < num_workers - 1) {

--- a/vp9/encoder/vp9_ethread.c

+++ b/vp9/encoder/vp9_ethread.c

@@ -35,7 +35,8 @@

                   td_t->rd_counts.coef_counts[i][j][k][l][m][n];

 }

-static int enc_worker_hook(EncWorkerData *const thread_data, void *unused) {

+static int enc_worker_hook(void *arg1, void *unused) {

+  EncWorkerData *const thread_data = (EncWorkerData *)arg1;

   VP9_COMP *const cpi = thread_data->cpi;

   const VP9_COMMON *const cm = &cpi->common;

   const int tile_cols = 1 << cm->log2_tile_cols;

@@ -142,7 +143,7 @@

   for (i = 0; i < num_workers; i++) {

     VPxWorker *const worker = &cpi->workers[i];

-    worker->hook = (VPxWorkerHook)hook;

+    worker->hook = hook;

     worker->data1 = &cpi->tile_thr_data[i];

     worker->data2 = data2;

   }

@@ -210,7 +211,7 @@

     }

   }

-  launch_enc_workers(cpi, (VPxWorkerHook)enc_worker_hook, NULL, num_workers);

+  launch_enc_workers(cpi, enc_worker_hook, NULL, num_workers);

   for (i = 0; i < num_workers; i++) {

     VPxWorker *const worker = &cpi->workers[i];