Fix GCC 15 build errors: Vulkan pointer types, unused variables

- tq_vulkan_init.c: change shader table from `const uint32_t**` to
  `const uint32_t*` — arrays decay to pointers, fixes incompatible
  pointer type errors on GCC 15 (stricter -Wincompatible-pointer-types)
- tq_vulkan_dispatch.c: use memcpy for function pointer → void* cast
  to avoid -Wpedantic on strict ISO C compilers
- tq_ops.c: guard tq_quantize_row_1bit against n<=0 (fixes GCC
  stringop-overflow warning), suppress unused vsum variable
- tq_model.c: remove unused mlocked variable, suppress unused qg_dim
  and inter variables in GGUF Q4 conversion path

Fixes #3

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: unamedkr

src/backend/vulkan/tq_vulkan_dispatch.c

@@ -505,14 +505,20 @@ static tq_vk_dispatch_entry_t g_vk_dispatch[7] = {
     { tq_uniform_2b_quantize_vk_wrap, NULL },
 };
 
+/* POSIX guarantees function pointer <-> void* round-trip.
+ * Use memcpy to avoid -Wpedantic on strict ISO C compilers (GCC 15+). */
 void* tq_vulkan_get_quantize_fn(int type_id) {
     if (type_id < 0 || type_id >= 7) return NULL;
-    return (void*)g_vk_dispatch[type_id].quantize;
+    void* p;
+    memcpy(&p, &g_vk_dispatch[type_id].quantize, sizeof(p));
+    return p;
 }
 
 void* tq_vulkan_get_attention_fn(int type_id) {
     if (type_id < 0 || type_id >= 7) return NULL;
-    return (void*)g_vk_dispatch[type_id].attention;
+    void* p;
+    memcpy(&p, &g_vk_dispatch[type_id].attention, sizeof(p));
+    return p;
 }
 
 #endif /* TQ_BUILD_VULKAN */

src/backend/vulkan/tq_vulkan_init.c

@@ -53,20 +53,22 @@ extern const size_t   tq_value_quant_2b_spv_size;
 extern const uint32_t tq_value_dequant_matmul_4b_spv[];
 extern const size_t   tq_value_dequant_matmul_4b_spv_size;
 
-/* SPIR-V lookup table */
+/* SPIR-V lookup table.
+ * Arrays decay to pointers, so we store const uint32_t* directly.
+ * The size externs are scalar — take their address for uniform access. */
 static const struct {
-    const uint32_t** code;
-    const size_t*    size;
+    const uint32_t* code;
+    const size_t*   size;
 } g_shader_table[TQ_VK_PIPE_COUNT] = {
-    { &tq_polar_quantize_spv,          &tq_polar_quantize_spv_size },
-    { &tq_polar_attention_spv,         &tq_polar_attention_spv_size },
-    { &tq_qjl_quantize_spv,           &tq_qjl_quantize_spv_size },
-    { &tq_qjl_attention_spv,          &tq_qjl_attention_spv_size },
-    { &tq_turbo_quantize_spv,         &tq_turbo_quantize_spv_size },
-    { &tq_turbo_attention_spv,        &tq_turbo_attention_spv_size },
-    { &tq_value_quant_4b_spv,         &tq_value_quant_4b_spv_size },
-    { &tq_value_quant_2b_spv,         &tq_value_quant_2b_spv_size },
-    { &tq_value_dequant_matmul_4b_spv,&tq_value_dequant_matmul_4b_spv_size },
+    { tq_polar_quantize_spv,          &tq_polar_quantize_spv_size },
+    { tq_polar_attention_spv,         &tq_polar_attention_spv_size },
+    { tq_qjl_quantize_spv,           &tq_qjl_quantize_spv_size },
+    { tq_qjl_attention_spv,          &tq_qjl_attention_spv_size },
+    { tq_turbo_quantize_spv,         &tq_turbo_quantize_spv_size },
+    { tq_turbo_attention_spv,        &tq_turbo_attention_spv_size },
+    { tq_value_quant_4b_spv,         &tq_value_quant_4b_spv_size },
+    { tq_value_quant_2b_spv,         &tq_value_quant_2b_spv_size },
+    { tq_value_dequant_matmul_4b_spv,&tq_value_dequant_matmul_4b_spv_size },
 };
 
 /* ============================================================
@@ -410,7 +412,7 @@ static int tq_vk_create_pipeline_layout(void) {
 
 static int tq_vk_create_pipelines(void) {
     for (int i = 0; i < TQ_VK_PIPE_COUNT; i++) {
-        const uint32_t* code = *g_shader_table[i].code;
+        const uint32_t* code = g_shader_table[i].code;
         size_t code_size     = *g_shader_table[i].size;
 
         if (!code || code_size == 0) {

src/engine/tq_model.c

@@ -2017,7 +2017,7 @@ void tq_quantize_weights_q4(tq_model_t* model) {
     int full_kv_dim = (c->full_n_kv_heads > 0 && c->full_head_dim > 0)
         ? c->full_n_kv_heads * c->full_head_dim : kv_dim;
     int inter = c->intermediate_dim;
-    int qg_dim = c->attn_output_gate ? q_dim * 2 : q_dim;
+    (void)inter;
 
     /* DeltaNet dimensions */
     int delta_nkv = c->delta_n_kv_heads > 0 ? c->delta_n_kv_heads : c->delta_n_heads;
@@ -3606,7 +3606,7 @@ tq_model_t* tq_load_gguf(const char* path) {
         int full_kv_dim = (c->full_n_kv_heads > 0 && c->full_head_dim > 0)
             ? c->full_n_kv_heads * c->full_head_dim : kv_dim;
         int inter = c->intermediate_dim;
-        int qg_dim = c->attn_output_gate ? q_dim * 2 : q_dim;
+        (void)inter;
         int delta_nkv = c->delta_n_kv_heads > 0 ? c->delta_n_kv_heads : c->delta_n_heads;
         int delta_qkv_dim = delta_nkv * c->delta_key_head_dim * 2
                           + c->delta_n_heads * c->delta_value_head_dim;
@@ -3927,9 +3927,7 @@ skip_q4_conversion: ;
                      * Without mlock, expert weights get evicted by OS memory pressure,
                      * causing 100x+ slowdown from SSD page faults.
                      * mlock may fail if ulimit is too low — fall back to MADV_WILLNEED. */
-                    int mlocked = 0;
                     if (mlock(gctx->mmap_data, gctx->mmap_size) == 0) {
-                        mlocked = 1;
                         fprintf(stderr, "tq_load_gguf: mlock(%.1f GB) — expert weights pinned in RAM\n",
                                 (double)gctx->mmap_size / (1024.0 * 1024.0 * 1024.0));
                     } else {

src/engine/tq_ops.c

@@ -1747,10 +1747,11 @@ void tq_matmul_q4q2_preq(float* out,
 
 /* Per-row 1-bit quantize: store sign bits + L2 norm */
 void tq_quantize_row_1bit(const float* src, uint8_t* sign_bits, float* norm_out, int n) {
+    if (n <= 0) { *norm_out = 0; return; }
     float norm_sq = 0;
     for (int j = 0; j < n; j++) norm_sq += src[j] * src[j];
     *norm_out = sqrtf(norm_sq);
-    
+
     int n_bytes = (n + 7) / 8;
     memset(sign_bits, 0, (size_t)n_bytes);
     for (int j = 0; j < n; j++) {
@@ -1772,7 +1773,7 @@ void tq_matmul_1bit(float* out, const float* x,
 #ifdef __ARM_NEON
         /* NEON: process 16 bytes (128 bits) at a time */
         int b = 0;
-        float32x4_t vsum = vdupq_n_f32(0);
+        float32x4_t vsum = vdupq_n_f32(0); (void)vsum; /* TODO: vectorize */
         for (; b + 15 < n_bytes; b += 16) {
             for (int k = 0; k < 16; k++) {
                 uint8_t s = signs[b + k];