remove unused variables

In some places move variables in the scope of the CPP define where they
are used.

Signed-off-by: Loic Dachary <loic@dachary.org>
(cherry picked from commit f043479e3c9d3f7296d49c0d5d9547ec3e73631f)

10 files changed, 45 insertions, 122 deletions

diff --git a/src/gf.c b/src/gf.c
index a443f17..2f33af5 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -179,13 +179,11 @@ uint64_t gf_composite_get_default_poly(gf_t *base)
 int gf_error_check(int w, int mult_type, int region_type, int divide_type,
                    int arg1, int arg2, uint64_t poly, gf_t *base)
 {
-  int sse4 = 0;
   int sse3 = 0;
   int sse2 = 0;
   int pclmul = 0;
   int rdouble, rquad, rlazy, rsse, rnosse, raltmap, rcauchy, tmp;
-  uint64_t pp;
-  gf_internal_t *sub, *subsub, *subsubsub;
+  gf_internal_t *sub;
 
   rdouble = (region_type & GF_REGION_DOUBLE_TABLE);
   rquad   = (region_type & GF_REGION_QUAD_TABLE);
@@ -214,10 +212,6 @@ int gf_error_check(int w, int mult_type, int region_type, int divide_type,
   sse3 = 1;
 #endif
 
-#ifdef INTEL_SSE4
-  sse4 = 1;
-#endif
-
 #ifdef INTEL_SSE4_PCLMUL
   pclmul = 1;
 #endif
@@ -525,7 +519,7 @@ void gf_alignment_error(char *s, int a)
 
 static 
 void gf_invert_binary_matrix(uint32_t *mat, uint32_t *inv, int rows) {
-  int cols, i, j, k;
+  int cols, i, j;
   uint32_t tmp;
 
   cols = rows;
@@ -594,7 +588,7 @@ uint32_t gf_bitmatrix_inverse(uint32_t y, int w, uint32_t pp)
 void gf_two_byte_region_table_multiply(gf_region_data *rd, uint16_t *base)
 {
   uint64_t a, prod;
-  int j, xor;
+  int xor;
   uint64_t *s64, *d64, *top;
 
   s64 = rd->s_start;
@@ -773,7 +767,6 @@ void gf_set_region_data(gf_region_data *rd,
   int xor,
   int align)
 {
-  uint8_t *s8, *d8;
   gf_internal_t *h;
   int wb;
   uint32_t a;
@@ -897,9 +890,8 @@ void gf_multby_one(void *src, void *dest, int bytes, int xor)
   __m128i ms, md;
 #endif
   unsigned long uls, uld;
-  uint8_t *s8, *d8, *dtop8;
+  uint8_t *s8, *d8;
   uint64_t *s64, *d64, *dtop64;
-  int abytes;
   gf_region_data rd;
 
   if (!xor) {
@@ -910,6 +902,7 @@ void gf_multby_one(void *src, void *dest, int bytes, int xor)
   uld = (unsigned long) dest;
 
 #ifdef   INTEL_SSE2
+  int abytes;
   s8 = (uint8_t *) src;
   d8 = (uint8_t *) dest;
   if (uls % 16 == uld % 16) {
diff --git a/src/gf_general.c b/src/gf_general.c
index d9d1700..7da8883 100644
--- a/src/gf_general.c
+++ b/src/gf_general.c
@@ -267,7 +267,6 @@ void gf_general_do_region_check(gf_t *gf, gf_general_t *a, void *orig_a, void *o
   int w, words, i;
   gf_general_t oa, ot, ft, sb;
   char sa[50], soa[50], sot[50], sft[50], ssb[50];
-  uint8_t *p;
 
   h = (gf_internal_t *) gf->scratch;
   w = h->w;
diff --git a/src/gf_method.c b/src/gf_method.c
index 36ec3c4..a7bcacf 100644
--- a/src/gf_method.c
+++ b/src/gf_method.c
@@ -21,10 +21,9 @@
 int create_gf_from_argv(gf_t *gf, int w, int argc, char **argv, int starting)
 {
   int mult_type, divide_type, region_type;
-  int arg1, arg2, subrg_size;
+  int arg1, arg2;
   uint64_t prim_poly;
   gf_t *base;
-  char *crt, *x, *y;
 
   mult_type = GF_MULT_DEFAULT;
   region_type = GF_REGION_DEFAULT;
diff --git a/src/gf_w128.c b/src/gf_w128.c
index fae9f5c..363fce6 100644
--- a/src/gf_w128.c
+++ b/src/gf_w128.c
@@ -886,7 +886,7 @@ gf_w128_split_8_128_multiply_region(gf_t *gf, void *src, void *dest, gf_val_128_
 void
 gf_w128_bytwo_b_multiply_region(gf_t *gf, void *src, void *dest, gf_val_128_t val, int bytes, int xor)
 {
-  uint64_t bmask, pp, vmask;
+  uint64_t bmask, pp;
   gf_internal_t *h;
   uint64_t a[2], c[2], b[2], *s64, *d64, *top;
   gf_region_data rd;
@@ -987,7 +987,7 @@ void gf_w128_group_m_init(gf_t *gf, gf_val_128_t b128)
 void
 gf_w128_group_multiply(GFP gf, gf_val_128_t a128, gf_val_128_t b128, gf_val_128_t c128)
 {
-  int i,j;
+  int i;
   /* index_r, index_m, total_m (if g_r > g_m) */
   int i_r, i_m, t_m;
   int mask_m, mask_r;
@@ -1162,7 +1162,6 @@ gf_w128_euclid(GFP gf, gf_val_128_t a128, gf_val_128_t b128)
   uint64_t c_i[2];
   uint64_t *b;
   uint64_t one = 1;
-  uint64_t buf, buf1;
 
   /* This needs to return some sort of error (in b128?) */
   if (a128[0] == 0 && a128[1] == 0) return;
@@ -1326,7 +1325,6 @@ static
   void
 gf_w128_composite_multiply_region(gf_t *gf, void *src, void *dest, gf_val_128_t val, int bytes, int xor)
 {
-  unsigned long uls, uld;
   gf_internal_t *h = (gf_internal_t *) gf->scratch;
   gf_t *base_gf = h->base_gf;
   uint64_t b0 = val[1];
@@ -1381,7 +1379,6 @@ gf_w128_composite_multiply_region_alt(gf_t *gf, void *src, void *dest, gf_val_12
   gf_internal_t *h = (gf_internal_t *) gf->scratch;  gf_t *base_gf = h->base_gf;
   gf_val_64_t val0 = val[1];
   gf_val_64_t val1 = val[0];
-  uint64_t *l, *hi;
   uint8_t *slow, *shigh;
   uint8_t *dlow, *dhigh, *top;
   int sub_reg_size;
@@ -1419,8 +1416,6 @@ int gf_w128_composite_init(gf_t *gf)
     gf->multiply_region.w128 = gf_w128_composite_multiply_region;
   }
 
-  gf_internal_t *base_h = (gf_internal_t *) h->base_gf->scratch;
-
   gf->multiply.w128 = gf_w128_composite_multiply;
   gf->divide.w128 = gf_w128_divide_from_inverse;
   gf->inverse.w128 = gf_w128_composite_inverse;
@@ -1444,8 +1439,6 @@ int gf_w128_cfm_init(gf_t *gf)
 static
 int gf_w128_shift_init(gf_t *gf)
 {
-  gf_internal_t *h;
-  h = (gf_internal_t*) gf->scratch;
   gf->multiply.w128 = gf_w128_shift_multiply;
   gf->inverse.w128 = gf_w128_euclid;
   gf->multiply_region.w128 = gf_w128_multiply_region_from_single;
@@ -1587,12 +1580,10 @@ int gf_w128_group_init(gf_t *gf)
 {
   gf_internal_t *scratch;
   gf_group_tables_t *gt;
-  int g_m, g_r, size_r;
-  long tmp;
+  int g_r, size_r;
 
   scratch = (gf_internal_t *) gf->scratch;
   gt = scratch->private;
-  g_m = scratch->arg1;
   g_r = scratch->arg2;
   size_r = (1 << g_r);
 
@@ -1690,7 +1681,6 @@ void gf_w128_composite_extract_word(gf_t *gf, void *start, int bytes, int index,
 int gf_w128_scratch_size(int mult_type, int region_type, int divide_type, int arg1, int arg2)
 {
   int size_m, size_r;
-  int w = 128;
   if (divide_type==GF_DIVIDE_MATRIX) return 0;
 
   switch(mult_type)
@@ -1739,7 +1729,7 @@ int gf_w128_scratch_size(int mult_type, int region_type, int divide_type, int ar
 
 int gf_w128_init(gf_t *gf)
 {
-  gf_internal_t *h, *h_base, *h_base_base, *h_base_base_base;
+  gf_internal_t *h;
   int no_default_flag = 0;
 
   h = (gf_internal_t *) gf->scratch;
diff --git a/src/gf_w16.c b/src/gf_w16.c
index 454c6cc..75cad50 100644
--- a/src/gf_w16.c
+++ b/src/gf_w16.c
@@ -774,9 +774,8 @@ static
 void
 gf_w16_split_4_16_lazy_nosse_altmap_multiply_region(gf_t *gf, void *src, void *dest, gf_val_32_t val, int bytes, int xor)
 {
-  uint64_t i, j, a, b, c, prod;
+  uint64_t i, j, c, prod;
   uint8_t *s8, *d8, *top;
-  gf_internal_t *h;
   uint16_t table[4][16];
   gf_region_data rd;
 
@@ -786,8 +785,6 @@ gf_w16_split_4_16_lazy_nosse_altmap_multiply_region(gf_t *gf, void *src, void *d
   gf_set_region_data(&rd, gf, src, dest, bytes, val, xor, 32);
   gf_do_initial_region_alignment(&rd);    
 
-  h = (gf_internal_t *) gf->scratch;
-
   /*Ben: Constructs lazy multiplication table*/
 
   for (j = 0; j < 16; j++) {
@@ -840,7 +837,6 @@ gf_w16_split_4_16_lazy_multiply_region(gf_t *gf, void *src, void *dest, gf_val_3
 {
   uint64_t i, j, a, c, prod;
   uint16_t *s16, *d16, *top;
-  gf_internal_t *h;
   uint16_t table[4][16];
   gf_region_data rd;
 
@@ -850,8 +846,6 @@ gf_w16_split_4_16_lazy_multiply_region(gf_t *gf, void *src, void *dest, gf_val_3
   gf_set_region_data(&rd, gf, src, dest, bytes, val, xor, 2);
   gf_do_initial_region_alignment(&rd);    
 
-  h = (gf_internal_t *) gf->scratch;
-
   for (j = 0; j < 16; j++) {
     for (i = 0; i < 4; i++) {
       c = (j << (i*4));
@@ -880,7 +874,7 @@ static
 void
 gf_w16_split_8_16_lazy_multiply_region(gf_t *gf, void *src, void *dest, gf_val_32_t val, int bytes, int xor)
 {
-  uint64_t j, k, v, a, c, prod, *s64, *d64, *top64;
+  uint64_t j, k, v, a, prod, *s64, *d64, *top64;
   gf_internal_t *h;
   uint64_t htable[256], ltable[256];
   gf_region_data rd;
@@ -966,7 +960,7 @@ gf_w16_split_8_16_lazy_multiply_region(gf_t *gf, void *src, void *dest, gf_val_3
 static void
 gf_w16_table_lazy_multiply_region(gf_t *gf, void *src, void *dest, gf_val_32_t val, int bytes, int xor)
 {
-  uint64_t j, a, c, pp;
+  uint64_t c;
   gf_internal_t *h;
   struct gf_w16_lazytable_data *ltd;
   gf_region_data rd;
@@ -1358,11 +1352,8 @@ issse3 = 0;
 static 
 int gf_w16_table_init(gf_t *gf)
 {
-  gf_internal_t *h;
   gf_w16_log_init(gf);
 
-  h = (gf_internal_t *) gf->scratch;
-
   gf->multiply_region.w32 = gf_w16_table_lazy_multiply_region; 
   return 1;
 }
@@ -1735,7 +1726,6 @@ static
 void 
 gf_w16_bytwo_b_nosse_multiply_region(gf_t *gf, void *src, void *dest, gf_val_32_t val, int bytes, int xor)
 {
-  int i;
   uint64_t *s64, *d64, t1, t2, ta, tb, prod;
   struct gf_w16_bytwo_data *btd;
   gf_region_data rd;
@@ -1988,7 +1978,6 @@ gf_val_32_t
 gf_w16_composite_multiply_inline(gf_t *gf, gf_val_32_t a, gf_val_32_t b)
 {
   gf_internal_t *h = (gf_internal_t *) gf->scratch;
-  gf_t *base_gf = h->base_gf;
   uint8_t b0 = b & 0x00ff;
   uint8_t b1 = (b & 0xff00) >> 8;
   uint8_t a0 = a & 0x00ff;
@@ -2072,7 +2061,6 @@ static
 void
 gf_w16_composite_multiply_region(gf_t *gf, void *src, void *dest, gf_val_32_t val, int bytes, int xor)
 {
-  unsigned long uls, uld;
   gf_internal_t *h = (gf_internal_t *) gf->scratch;
   gf_t *base_gf = h->base_gf;
   uint8_t b0 = val & 0x00ff;
@@ -2080,7 +2068,6 @@ gf_w16_composite_multiply_region(gf_t *gf, void *src, void *dest, gf_val_32_t va
   uint16_t *s16, *d16, *top;
   uint8_t a0, a1, a1b1, *mt;
   gf_region_data rd;
-  struct gf_w16_logtable_data *ltd;
   struct gf_w16_composite_data *cd;
 
   cd = (struct gf_w16_composite_data *) h->private;
@@ -2237,7 +2224,6 @@ inline
 gf_val_32_t
 gf_w16_group_4_4_multiply(gf_t *gf, gf_val_32_t a, gf_val_32_t b)
 {
-  int i;
   uint16_t p, l, ind, r, a16;
 
   struct gf_w16_group_4_4_data *d44;
@@ -2270,7 +2256,6 @@ gf_w16_group_4_4_multiply(gf_t *gf, gf_val_32_t a, gf_val_32_t b)
 static
 void gf_w16_group_4_4_region_multiply(gf_t *gf, void *src, void *dest, gf_val_32_t val, int bytes, int xor)
 {
-  int i;
   uint16_t p, l, ind, r, a16, p16;
   struct gf_w16_group_4_4_data *d44;
   gf_region_data rd;
@@ -2475,10 +2460,8 @@ int gf_w16_init(gf_t *gf)
 
 uint16_t *gf_w16_get_log_table(gf_t *gf)
 {
-  gf_internal_t *h;
   struct gf_w16_logtable_data *ltd;
 
-  h = (gf_internal_t *) gf->scratch;
   if (gf->multiply.w32 == gf_w16_log_multiply) {
     ltd = (struct gf_w16_logtable_data *) ((gf_internal_t *) gf->scratch)->private;
     return (uint16_t *) ltd->log_tbl;
diff --git a/src/gf_w32.c b/src/gf_w32.c
index 03f285f..f472e02 100644
--- a/src/gf_w32.c
+++ b/src/gf_w32.c
@@ -555,10 +555,6 @@ gf_w32_shift_multiply (gf_t *gf, uint32_t a32, uint32_t b32)
   static 
 int gf_w32_cfm_init(gf_t *gf)
 {
-  gf_internal_t *h;
-
-  h = (gf_internal_t *) gf->scratch;
-
   gf->inverse.w32 = gf_w32_euclid;
   gf->multiply_region.w32 = gf_w32_multiply_region_from_single;
   
@@ -566,6 +562,10 @@ int gf_w32_cfm_init(gf_t *gf)
   /*Ben: Check to see how many reduction steps it will take*/
 
 #if defined(INTEL_SSE4_PCLMUL)
+  gf_internal_t *h;
+
+  h = (gf_internal_t *) gf->scratch;
+
   if ((0xfffe0000 & h->prim_poly) == 0){ 
     gf->multiply.w32 = gf_w32_clm_multiply_2;
     gf->multiply_region.w32 = gf_w32_clm_multiply_region_from_single_2;
@@ -616,9 +616,8 @@ gf_w32_group_set_shift_tables(uint32_t *shift, uint32_t val, gf_internal_t *h)
   static
 void gf_w32_group_s_equals_r_multiply_region(gf_t *gf, void *src, void *dest, gf_val_32_t val, int bytes, int xor)
 {
-  int i;
   int leftover, rs;
-  uint32_t p, l, ind, r, a32;
+  uint32_t p, l, ind, a32;
   int bits_left;
   int g_s;
   gf_region_data rd;
@@ -741,9 +740,8 @@ inline
 gf_val_32_t
 gf_w32_group_s_equals_r_multiply(gf_t *gf, gf_val_32_t a, gf_val_32_t b)
 {
-  int i;
   int leftover, rs;
-  uint32_t p, l, ind, r, a32;
+  uint32_t p, l, ind, a32;
   int bits_left;
   int g_s;
 
@@ -781,8 +779,7 @@ inline
 gf_val_32_t
 gf_w32_group_4_4_multiply(gf_t *gf, gf_val_32_t a, gf_val_32_t b)
 {
-  int i;
-  uint32_t p, l, ind, r, a32;
+  uint32_t p, l, ind, a32;
 
   struct gf_w32_group_data *d44;
   gf_internal_t *h = (gf_internal_t *) gf->scratch;
@@ -832,7 +829,7 @@ gf_w32_group_multiply(gf_t *gf, gf_val_32_t a, gf_val_32_t b)
 {
   int i;
   int leftover;
-  uint64_t p, l, r, mask;
+  uint64_t p, l, r;
   uint32_t a32, ind;
   int g_s, g_r;
   struct gf_w32_group_data *gd;
@@ -1046,7 +1043,6 @@ static
 void
 gf_w32_bytwo_b_nosse_multiply_region(gf_t *gf, void *src, void *dest, gf_val_32_t val, int bytes, int xor)
 {
-  int i;
   uint64_t *s64, *d64, t1, t2, ta, tb, prod;
   struct gf_w32_bytwo_data *btd;
   gf_region_data rd;
@@ -2378,7 +2374,6 @@ uint32_t
 gf_w32_composite_multiply_inline(gf_t *gf, uint32_t a, uint32_t b)
 {
   gf_internal_t *h = (gf_internal_t *) gf->scratch;
-  gf_t *base_gf = h->base_gf;
   uint32_t b0 = b & 0x0000ffff;
   uint32_t b1 = b >> 16;
   uint32_t a0 = a & 0x0000ffff;
@@ -2620,11 +2615,8 @@ int gf_w32_composite_init(gf_t *gf)
 
 int gf_w32_scratch_size(int mult_type, int region_type, int divide_type, int arg1, int arg2)
 {
-  int ss;
   int issse3 = 0;
 
-  ss = (GF_REGION_SSE | GF_REGION_NOSSE);
-
 #ifdef INTEL_SSSE3
   issse3 = 1;
 #endif
diff --git a/src/gf_w4.c b/src/gf_w4.c
index 2504ec6..9a0dfb5 100644
--- a/src/gf_w4.c
+++ b/src/gf_w4.c
@@ -468,7 +468,7 @@ int gf_w4_single_table_init(gf_t *gf)
 {
   gf_internal_t *h;
   struct gf_single_table_data *std;
-  int a, b, prod, loga, logb;
+  int a, b, prod;
 
 
   h = (gf_internal_t *) gf->scratch;
@@ -531,7 +531,6 @@ static
 void 
 gf_w4_double_table_multiply_region(gf_t *gf, void *src, void *dest, gf_val_32_t val, int bytes, int xor)
 {
-  unsigned long uls, uld;
   int i;
   uint8_t *s8, *d8, *base;
   gf_region_data rd;
@@ -560,7 +559,7 @@ int gf_w4_double_table_init(gf_t *gf)
 {
   gf_internal_t *h;
   struct gf_double_table_data *std;
-  int a, b, c, prod, loga, logb, ab;
+  int a, b, c, prod, ab;
   uint8_t mult[GF_FIELD_SIZE][GF_FIELD_SIZE];
 
   h = (gf_internal_t *) gf->scratch;
@@ -687,7 +686,7 @@ int gf_w4_quad_table_init(gf_t *gf)
 {
   gf_internal_t *h;
   struct gf_quad_table_data *std;
-  int prod, loga, logb, ab, val, a, b, c, d, va, vb, vc, vd;
+  int prod, val, a, b, c, d, va, vb, vc, vd;
   uint8_t mult[GF_FIELD_SIZE][GF_FIELD_SIZE];
 
   h = (gf_internal_t *) gf->scratch;
@@ -731,10 +730,9 @@ int gf_w4_quad_table_lazy_init(gf_t *gf)
 {
   gf_internal_t *h;
   struct gf_quad_table_lazy_data *std;
-  int a, b, c, prod, loga, logb, ab;
+  int a, b, prod, loga, logb;
   uint8_t log_tbl[GF_FIELD_SIZE];
   uint8_t antilog_tbl[GF_FIELD_SIZE*2];
-  uint8_t mult[GF_FIELD_SIZE][GF_FIELD_SIZE];
 
   h = (gf_internal_t *) gf->scratch;
   std = (struct gf_quad_table_lazy_data *)h->private;
@@ -1498,9 +1496,6 @@ static
 void 
 gf_w4_bytwo_b_nosse_multiply_region(gf_t *gf, void *src, void *dest, gf_val_32_t val, int bytes, int xor)
 {
-  unsigned long uls, uld;
-  int i;
-  uint8_t *s8, *d8, *top;
   uint64_t *s64, *d64, t1, t2, ta, tb, prod;
   struct gf_bytwo_data *btd;
   gf_region_data rd;
@@ -1963,10 +1958,6 @@ int gf_w4_bytwo_init(gf_t *gf)
 static 
 int gf_w4_cfm_init(gf_t *gf)
 {
-  gf_internal_t *h;
-
-  h = (gf_internal_t *) gf->scratch;
-
 #if defined(INTEL_SSE4_PCLMUL)
   gf->multiply.w32 = gf_w4_clm_multiply;
   return 1;
@@ -1987,7 +1978,6 @@ int gf_w4_shift_init(gf_t *gf)
 int gf_w4_scratch_size(int mult_type, int region_type, int divide_type, int arg1, int arg2)
 {
   int region_tbl_size;
-  int ss;
   int issse3 = 0;
 
 #ifdef INTEL_SSSE3
diff --git a/src/gf_w64.c b/src/gf_w64.c
index 73bf164..332bd5d 100644
--- a/src/gf_w64.c
+++ b/src/gf_w64.c
@@ -321,7 +321,7 @@ inline
 gf_val_64_t
 gf_w64_shift_multiply (gf_t *gf, gf_val_64_t a64, gf_val_64_t b64)
 {
-  uint64_t pl, pr, ppl, ppr, i, pp, a, bl, br, one, lbit;
+  uint64_t pl, pr, ppl, ppr, i, a, bl, br, one, lbit;
   gf_internal_t *h;
 
   h = (gf_internal_t *) gf->scratch;
@@ -741,8 +741,6 @@ gf_w64_split_16_64_lazy_multiply_region(gf_t *gf, void *src, void *dest, uint64_
 static 
 int gf_w64_shift_init(gf_t *gf)
 {
-  gf_internal_t *h;
-
   gf->multiply.w64 = gf_w64_shift_multiply;
   gf->inverse.w64 = gf_w64_euclid;
   gf->multiply_region.w64 = gf_w64_multiply_region_from_single;
@@ -752,14 +750,14 @@ int gf_w64_shift_init(gf_t *gf)
 static 
 int gf_w64_cfm_init(gf_t *gf)
 {
-  gf_internal_t *h;
-
-  h = (gf_internal_t *) gf->scratch;
-
   gf->inverse.w64 = gf_w64_euclid;
   gf->multiply_region.w64 = gf_w64_multiply_region_from_single;
 
 #if defined(INTEL_SSE4_PCLMUL) 
+  gf_internal_t *h;
+
+  h = (gf_internal_t *) gf->scratch;
+
   if ((0xfffffffe00000000ULL & h->prim_poly) == 0){ 
     gf->multiply.w64 = gf_w64_clm_multiply_2;
     gf->multiply_region.w64 = gf_w64_clm_multiply_region_from_single_2; 
@@ -803,7 +801,6 @@ inline
 gf_val_64_t
 gf_w64_group_multiply(gf_t *gf, gf_val_64_t a, gf_val_64_t b)
 {
-  int i;
   uint64_t top, bot, mask, tp;
   int g_s, g_r, lshift, rshift;
   struct gf_w64_group_data *gd;
@@ -854,7 +851,7 @@ static
 void gf_w64_group_multiply_region(gf_t *gf, void *src, void *dest, gf_val_64_t val, int bytes, int xor)
 {
   int i, fzb;
-  uint64_t a64, smask, rmask, top, bot, tp, one;
+  uint64_t a64, smask, rmask, top, bot, tp;
   int lshift, rshift, g_s, g_r;
   gf_region_data rd;
   uint64_t *s64, *d64, *dtop;
@@ -936,9 +933,8 @@ inline
 gf_val_64_t
 gf_w64_group_s_equals_r_multiply(gf_t *gf, gf_val_64_t a, gf_val_64_t b)
 {
-  int i;
   int leftover, rs;
-  uint64_t p, l, ind, r, a64;
+  uint64_t p, l, ind, a64;
   int bits_left;
   int g_s;
 
@@ -974,9 +970,8 @@ gf_w64_group_s_equals_r_multiply(gf_t *gf, gf_val_64_t a, gf_val_64_t b)
 static
 void gf_w64_group_s_equals_r_multiply_region(gf_t *gf, void *src, void *dest, gf_val_64_t val, int bytes, int xor)
 {
-  int i;
   int leftover, rs;
-  uint64_t p, l, ind, r, a64;
+  uint64_t p, l, ind, a64;
   int bits_left;
   int g_s;
   gf_region_data rd;
@@ -1189,7 +1184,7 @@ static
 void
 gf_w64_bytwo_p_nosse_multiply_region(gf_t *gf, void *src, void *dest, gf_val_64_t val, int bytes, int xor)
 {
-  uint64_t *s64, *d64, t1, t2, ta, prod, amask, pmask, pp;
+  uint64_t *s64, *d64, ta, prod, amask, pmask, pp;
   gf_region_data rd;
   gf_internal_t *h;
 
@@ -1243,7 +1238,7 @@ static
 void
 gf_w64_bytwo_b_nosse_multiply_region(gf_t *gf, void *src, void *dest, gf_val_64_t val, int bytes, int xor)
 {
-  uint64_t *s64, *d64, t1, t2, ta, tb, prod, amask, bmask, pp;
+  uint64_t *s64, *d64, ta, tb, prod, bmask, pp;
   gf_region_data rd;
   gf_internal_t *h;
 
@@ -1620,17 +1615,13 @@ static
 void
 gf_w64_composite_multiply_region(gf_t *gf, void *src, void *dest, gf_val_64_t val, int bytes, int xor)
 {
-  unsigned long uls, uld;
   gf_internal_t *h = (gf_internal_t *) gf->scratch;
   gf_t *base_gf = h->base_gf;
-  int i=0;
   uint32_t b0 = val & 0x00000000ffffffff;
   uint32_t b1 = (val & 0xffffffff00000000) >> 32;
   uint64_t *s64, *d64;
   uint64_t *top;
   uint64_t a0, a1, a1b1;
-  int num_syms = bytes / 8;
-  int sym_divisible = bytes % 4;
   gf_region_data rd;
 
   if (val == 0) { gf_multby_zero(dest, bytes, xor); return; }
@@ -2141,8 +2132,6 @@ int gf_w64_split_init(gf_t *gf)
 
 int gf_w64_scratch_size(int mult_type, int region_type, int divide_type, int arg1, int arg2)
 {
-  int issse4;
-
   switch(mult_type)
   {
     case GF_MULT_SHIFT:
@@ -2162,11 +2151,9 @@ int gf_w64_scratch_size(int mult_type, int region_type, int divide_type, int arg
        * then fall through to split table scratch size code. */
 
 #ifdef INTEL_SSE4
-      issse4 = 1;
       arg1 = 64;
       arg2 = 4;
 #else
-      issse4 = 0;
       arg1 = 64;
       arg2 = 8;
 #endif
@@ -2202,7 +2189,7 @@ int gf_w64_scratch_size(int mult_type, int region_type, int divide_type, int arg
 
 int gf_w64_init(gf_t *gf)
 {
-  gf_internal_t *h, *h_base, *h_base_base, *h_base_base_base;
+  gf_internal_t *h;
   int no_default_flag = 0;
 
   h = (gf_internal_t *) gf->scratch;
diff --git a/src/gf_w8.c b/src/gf_w8.c
index 7661aad..d2c0c1f 100644
--- a/src/gf_w8.c
+++ b/src/gf_w8.c
@@ -731,7 +731,7 @@ static
 gf_w8_log_multiply_region(gf_t *gf, void *src, void *dest, uint32_t val, int bytes, int xor)
 {
   int i;
-  uint8_t lv, b, c;
+  uint8_t lv;
   uint8_t *s8, *d8;
   struct gf_w8_logtable_data *ltd;
 
@@ -760,7 +760,7 @@ static
 gf_w8_logzero_multiply_region(gf_t *gf, void *src, void *dest, uint32_t val, int bytes, int xor)
 {
   int i;
-  uint8_t lv, b, c;
+  uint8_t lv;
   uint8_t *s8, *d8;
   struct gf_w8_logzero_table_data *ltd;
   struct gf_w8_logzero_small_table_data *std;
@@ -976,7 +976,7 @@ static
 gf_w8_double_table_multiply_region(gf_t *gf, void *src, void *dest, gf_val_32_t val, int bytes, int xor)
 {
   uint16_t *base;
-  uint32_t b, c, prod, vc, vb;
+  uint32_t b, c, vc, vb;
   gf_internal_t *h;
   struct gf_w8_double_table_data  *dtd;
   struct gf_w8_double_table_lazy_data  *ltd;
@@ -1033,7 +1033,6 @@ static
 gf_w8_table_multiply_region(gf_t *gf, void *src, void *dest, gf_val_32_t val, int bytes, int xor)
 {
   int i;
-  uint8_t lv, b, c;
   uint8_t *s8, *d8;
   struct gf_w8_single_table_data *ftd;
 
@@ -1137,9 +1136,7 @@ static
   void
 gf_w8_split_multiply_region(gf_t *gf, void *src, void *dest, gf_val_32_t val, int bytes, int xor)
 {
-  unsigned long uls, uld;
   int i;
-  uint8_t lv, b, c;
   uint8_t *s8, *d8;
   struct gf_w8_half_table_data *htd;
 
@@ -1167,11 +1164,10 @@ int gf_w8_split_init(gf_t *gf)
 {
   gf_internal_t *h;
   struct gf_w8_half_table_data *htd;
-  int a, b, pp;
+  int a, b;
 
   h = (gf_internal_t *) gf->scratch;
   htd = (struct gf_w8_half_table_data *)h->private;
-  pp = h->prim_poly;
 
   bzero(htd->high, sizeof(uint8_t)*GF_FIELD_SIZE*GF_HALF_SIZE);
   bzero(htd->low, sizeof(uint8_t)*GF_FIELD_SIZE*GF_HALF_SIZE);
@@ -1361,7 +1357,6 @@ gf_val_32_t
 gf_w8_composite_multiply_inline(gf_t *gf, gf_val_32_t a, gf_val_32_t b)
 {
   gf_internal_t *h = (gf_internal_t *) gf->scratch;
-  gf_t *base_gf = h->base_gf;
   uint8_t b0 = b & 0x0f; 
   uint8_t b1 = (b & 0xf0) >> 4; 
   uint8_t a0 = a & 0x0f; 
@@ -1844,8 +1839,6 @@ static
   void 
 gf_w8_bytwo_b_nosse_multiply_region(gf_t *gf, void *src, void *dest, gf_val_32_t val, int bytes, int xor)
 {
-  int i;
-  uint8_t *s8, *d8, *top;
   uint64_t *s64, *d64, t1, t2, ta, tb, prod;
   struct gf_w8_bytwo_data *btd;
   gf_region_data rd;
@@ -2362,7 +2355,7 @@ int gf_w8_scratch_size(int mult_type, int region_type, int divide_type, int arg1
 
 int gf_w8_init(gf_t *gf)
 {
-  gf_internal_t *h, *h_base;
+  gf_internal_t *h;
 
   h = (gf_internal_t *) gf->scratch;
 
@@ -2454,11 +2447,9 @@ uint8_t *gf_w8_get_mult_table(gf_t *gf)
 
 uint8_t *gf_w8_get_div_table(gf_t *gf)
 {
-  gf_internal_t *h;
   struct gf_w8_default_data *ftd;
   struct gf_w8_single_table_data *std;
 
-  h = (gf_internal_t *) gf->scratch;
   if (gf->multiply.w32 == gf_w8_default_multiply) {
     ftd = (struct gf_w8_default_data *) ((gf_internal_t *) gf->scratch)->private;
     return (uint8_t *) ftd->divtable;
diff --git a/src/gf_wgen.c b/src/gf_wgen.c
index f5e22e0..8d65e0c 100644
--- a/src/gf_wgen.c
+++ b/src/gf_wgen.c
@@ -284,9 +284,8 @@ inline
 gf_val_32_t
 gf_wgen_group_s_equals_r_multiply(gf_t *gf, gf_val_32_t a, gf_val_32_t b)
 {
-  int i;
   int leftover, rs;
-  uint32_t p, l, ind, r, a32;
+  uint32_t p, l, ind, a32;
   int bits_left;
   int g_s;
   int w;
@@ -362,7 +361,7 @@ gf_wgen_group_multiply(gf_t *gf, gf_val_32_t a, gf_val_32_t b)
 {
   int i;
   int leftover;
-  uint64_t p, l, r, mask;
+  uint64_t p, l, r;
   uint32_t a32, ind;
   int g_s, g_r;
   struct gf_wgen_group_data *gd;
@@ -496,7 +495,7 @@ int gf_wgen_table_8_init(gf_t *gf)
   gf_internal_t *h;
   int w;
   struct gf_wgen_table_w8_data *std;
-  uint32_t a, b, p, pp;
+  uint32_t a, b, p;
   
   h = (gf_internal_t *) gf->scratch;
   w = h->w;
@@ -557,7 +556,7 @@ int gf_wgen_table_16_init(gf_t *gf)
   gf_internal_t *h;
   int w;
   struct gf_wgen_table_w16_data *std;
-  uint32_t a, b, p, pp;
+  uint32_t a, b, p;
   
   h = (gf_internal_t *) gf->scratch;
   w = h->w;