varnish-cache/lib/libvcc/vcc_xref.c
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2011 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6
 *
7
 * SPDX-License-Identifier: BSD-2-Clause
8
 *
9 4
 * Redistribution and use in source and binary forms, with or without
10
 * modification, are permitted provided that the following conditions
11
 * are met:
12
 * 1. Redistributions of source code must retain the above copyright
13
 *    notice, this list of conditions and the following disclaimer.
14
 * 2. Redistributions in binary form must reproduce the above copyright
15
 *    notice, this list of conditions and the following disclaimer in the
16 4
 *    documentation and/or other materials provided with the distribution.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 4
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 4
 * SUCH DAMAGE.
29
 *
30
 * This file contains code for two cross-reference or consistency checks.
31
 *
32
 * The first check is simply that all subroutine, acls and backends are
33
 * both defined and referenced.  Complaints about referenced but undefined
34 4
 * or defined but unreferenced objects will be emitted.
35
 *
36
 * The second check recursively descends through subroutine calls to make
37
 * sure that action actions are correct for the methods through which
38
 * they are called.
39
 */
40
41
#include "config.h"
42
43
#include <string.h>
44
#include "vcc_compile.h"
45
46
/*--------------------------------------------------------------------*/
47
48
struct proccall {
49
        VTAILQ_ENTRY(proccall)  list;
50
        struct symbol           *sym;
51 4
        struct token            *t;
52
        struct proc             *fm;
53
};
54
55
struct procuse {
56
        VTAILQ_ENTRY(procuse)   list;
57 4
        const struct token      *t1;
58
        const struct token      *t2;
59
        const struct symbol     *sym;
60
        const struct xrefuse    *use;
61 4
        unsigned                mask;
62
        struct proc             *fm;
63
};
64
65 4
/*--------------------------------------------------------------------*/
66
67
static void
68 1385000
vcc_checkref(struct vcc *tl, const struct symbol *sym)
69 4
{
70
71 1385000
        if (sym->noref)
72 1235488
                return;
73 149516
        if (sym->ndef == 0 && sym->nref != 0) {
74 6
                AN(sym->ref_b);
75 12
                VSB_printf(tl->sb, "Undefined %s %.*s, first reference:\n",
76 6
                    sym->kind->name, PF(sym->ref_b));
77 6
                vcc_ErrWhere(tl, sym->ref_b);
78 149516
        } else if (sym->ndef != 0 && sym->nref == 0) {
79 254
                AN(sym->def_b);
80 508
                VSB_printf(tl->sb, "Unused %s %.*s, defined:\n",
81 254
                    sym->kind->name, PF(sym->def_b));
82 254
                vcc_ErrWhere(tl, sym->def_b);
83 254
                if (!tl->err_unref)
84 242
                        vcc_Warn(tl);
85 258
        }
86 1385000
}
87
88
int
89 5698
vcc_CheckReferences(struct vcc *tl)
90 4
{
91
92 5698
        VCC_WalkSymbols(tl, vcc_checkref, SYM_MAIN, SYM_NONE);
93 5698
        return (tl->err);
94 4
}
95
96
/*--------------------------------------------------------------------
97
 * Returns checks
98
 */
99
100
const struct xrefuse XREF_READ[1] = {{"xref_read", "Not available"}};
101
const struct xrefuse XREF_WRITE[1] = {{"xref_write", "Cannot be set"}};
102
const struct xrefuse XREF_UNSET[1] = {{"xref_unset", "Cannot be unset"}};
103
const struct xrefuse XREF_ACTION[1] = {{"xref_action", "Not a valid action"}};
104 4
105
void
106 375212
vcc_AddUses(struct vcc *tl, const struct token *t1, const struct token *t2,
107
    const struct symbol *sym, const struct xrefuse *use)
108
{
109
        struct procuse *pu;
110 4
111 375212
        AN(tl->curproc);
112 375212
        pu = TlAlloc(tl, sizeof *pu);
113 375212
        AN(pu);
114 375212
        AN(sym);
115 375212
        AN(use);
116 375212
        AN(use->name);
117 375212
        pu->t1 = t1;
118 375212
        pu->t2 = t2;
119 375212
        if (pu->t2 == NULL) {
120 301026
                pu->t2 = vcc_PeekTokenFrom(tl, t1);
121 301022
                AN(pu->t2);
122 301022
        }
123 375212
        pu->sym = sym;
124 375212
        pu->use = use;
125 375212
        pu->fm = tl->curproc;
126
127 375212
        if (pu->use == XREF_READ)
128 283472
                pu->mask = sym->r_methods;
129 91740
        else if (pu->use == XREF_WRITE)
130 62664
                pu->mask = sym->w_methods;
131 29076
        else if (pu->use == XREF_UNSET)
132 11526
                pu->mask = sym->u_methods;
133 17550
        else if (pu->use == XREF_ACTION)
134 17550
                pu->mask = sym->action_mask;
135
        else
136 0
                WRONG("wrong xref use");
137
138 375212
        VTAILQ_INSERT_TAIL(&tl->curproc->uses, pu, list);
139 375212
}
140
141
void
142 165516
vcc_AddCall(struct vcc *tl, struct token *t, struct symbol *sym)
143
{
144
        struct proccall *pc;
145
146 165516
        AN(sym);
147 165516
        pc = TlAlloc(tl, sizeof *pc);
148 165516
        AN(pc);
149 165516
        pc->sym = sym;
150 165516
        pc->t = t;
151 165516
        pc->fm = tl->curproc;
152 165516
        VTAILQ_INSERT_TAIL(&tl->curproc->calls, pc, list);
153 165516
}
154
155
void
156 143714
vcc_ProcAction(struct proc *p, unsigned returns, unsigned mask, struct token *t)
157
{
158
159 143714
        assert(returns < VCL_RET_MAX);
160 143714
        p->ret_bitmap |= (1U << returns);
161 143714
        p->okmask &= mask;
162
        /* Record the first instance of this return */
163 143714
        if (p->return_tok[returns] == NULL)
164 143354
                p->return_tok[returns] = t;
165 143714
}
166
167
static int
168 511276
vcc_CheckActionRecurse(struct vcc *tl, struct proc *p, unsigned bitmap)
169
{
170
        unsigned u;
171
        struct proccall *pc;
172
173 511276
        AN(p);
174 511276
        if (p->active) {
175 4
                VSB_cat(tl->sb, "Subroutine recurses on\n");
176 4
                vcc_ErrWhere(tl, p->name);
177 4
                return (1);
178
        }
179 511272
        u = p->ret_bitmap & ~bitmap;
180 511272
        if (u) {
181
182
#define VCL_RET_MAC(l, U, B)                                            \
183
                if (u & (1 << (VCL_RET_##U))) {                         \
184
                        VSB_printf(tl->sb, "Invalid return \"" #l "\"\n");\
185
                        vcc_ErrWhere(tl, p->return_tok[VCL_RET_##U]);   \
186
                }
187
#include "tbl/vcl_returns.h"
188
189
                VSB_printf(tl->sb, "\n...in subroutine \"%.*s\"\n",
190
                    PF(p->name));
191
                vcc_ErrWhere(tl, p->name);
192
                return (1);
193
        }
194
195
        // more references than calls -> sub is referenced for dynamic calls
196 511270
        u = (p->sym->nref > p->called);
197
198 511270
        p->active = 1;
199 789700
        VTAILQ_FOREACH(pc, &p->calls, list) {
200 278438
                if (pc->sym->proc == NULL) {
201 0
                        VSB_printf(tl->sb, "Subroutine %s does not exist\n",
202 0
                            pc->sym->name);
203 0
                        vcc_ErrWhere(tl, pc->t);
204 0
                        return (1);
205
                }
206 278438
                pc->sym->proc->calledfrom |= p->calledfrom;
207 278438
                pc->sym->proc->called++;
208 278438
                pc->sym->nref += u;
209 278438
                if (vcc_CheckActionRecurse(tl, pc->sym->proc, bitmap)) {
210 16
                        VSB_printf(tl->sb, "\n...called from \"%.*s\"\n",
211 8
                            PF(p->name));
212 8
                        vcc_ErrWhere(tl, pc->t);
213 8
                        return (1);
214
                }
215 278430
                p->okmask &= pc->sym->proc->okmask;
216 278430
        }
217 511262
        p->active = 0;
218 511262
        return (0);
219 511276
}
220
221
/*--------------------------------------------------------------------*/
222
223
static void
224 232838
vcc_checkaction(struct vcc *tl, const struct symbol *sym)
225
{
226
        struct proc *p;
227
        unsigned bitmap;
228
229 232838
        p = sym->proc;
230 232838
        AN(p);
231 232838
        AN(p->name);
232
233 232838
        if (p->method == NULL) {
234 147700
                bitmap = ~0U;
235 147700
        } else {
236 85138
                bitmap = p->method->ret_bitmap;
237 85138
                p->calledfrom = p->method->bitval;
238
        }
239
240 232838
        if (! vcc_CheckActionRecurse(tl, p, bitmap))
241 232832
                return;
242
243 6
        tl->err = 1;
244 6
        if (p->method == NULL)
245 4
                return;
246
247 4
        VSB_printf(tl->sb,
248 2
                   "\n...which is the \"%s\" subroutine\n", p->method->name);
249 2
        VSB_cat(tl->sb, "Legal returns are:");
250
#define VCL_RET_MAC(l, U, B)                                            \
251
        if (p->method->ret_bitmap & ((1 << VCL_RET_##U)))               \
252
                VSB_printf(tl->sb, " \"%s\"", #l);
253
254
#include "tbl/vcl_returns.h"
255
        VSB_cat(tl->sb, "\n");
256
}
257
258
int
259 5680
vcc_CheckAction(struct vcc *tl)
260
{
261
262 5680
        VCC_WalkSymbols(tl, vcc_checkaction, SYM_MAIN, SYM_SUB);
263 5680
        return (tl->err);
264
}
265
266
/*--------------------------------------------------------------------*/
267
268
static struct procuse *
269 437572
vcc_illegal_write(struct vcc *tl, struct procuse *pu, const struct method *m)
270
{
271
272 437572
        if (pu->mask || pu->use != XREF_WRITE)
273 437546
                return (NULL);
274
275 26
        if (pu->sym->r_methods == 0) {
276 2
                vcc_ErrWhere2(tl, pu->t1, pu->t2);
277 2
                VSB_cat(tl->sb, "Variable cannot be set.\n");
278 2
                return (NULL);
279
        }
280
281 24
        if (!(pu->sym->r_methods & m->bitval)) {
282 4
                pu->use = XREF_READ; /* NB: change the error message. */
283 4
                return (pu);
284
        }
285
286 20
        vcc_ErrWhere2(tl, pu->t1, pu->t2);
287 20
        VSB_cat(tl->sb, "Variable is read only.\n");
288 20
        return (NULL);
289 437572
}
290
291
static struct procuse *
292 739900
vcc_FindIllegalUse(struct vcc *tl, struct proc *p, const struct method *m)
293
{
294 739900
        struct procuse *pu, *pw, *r = NULL;
295
296 2205496
        VTAILQ_FOREACH(pu, &p->uses, list) {
297 1465596
                p->okmask &= pu->mask;
298 1465596
                if (m == NULL)
299 1028024
                        continue;
300 437572
                pw = vcc_illegal_write(tl, pu, m);
301 437572
                if (r != NULL)
302 14
                        continue;
303 437558
                if (tl->err)
304 22
                        r = pw;
305 437536
                else if (!(pu->mask & m->bitval))
306 58
                        r = pu;
307 437558
        }
308 739900
        return (r);
309
}
310
311
static int
312 508448
vcc_CheckUseRecurse(struct vcc *tl, struct proc *p,
313
    const struct method *m)
314
{
315
        struct proccall *pc;
316
        struct procuse *pu;
317
318 508448
        pu = vcc_FindIllegalUse(tl, p, m);
319 508448
        if (pu != NULL) {
320 6
                vcc_ErrWhere2(tl, pu->t1, pu->t2);
321 12
                VSB_printf(tl->sb, "%s from subroutine '%s'.\n",
322 6
                    pu->use->err, m->name);
323 12
                VSB_printf(tl->sb, "\n...in subroutine \"%.*s\"\n",
324 6
                    PF(pu->fm->name));
325 6
                vcc_ErrWhere(tl, p->name);
326 6
                return (1);
327
        }
328 508442
        if (tl->err)
329 2
                return (1);
330 785498
        VTAILQ_FOREACH(pc, &p->calls, list) {
331 277068
                if (vcc_CheckUseRecurse(tl, pc->sym->proc, m)) {
332 20
                        VSB_printf(tl->sb, "\n...called from \"%.*s\"\n",
333 10
                            PF(p->name));
334 10
                        vcc_ErrWhere(tl, pc->t);
335 10
                        return (1);
336
                }
337 277058
                p->okmask &= pc->sym->proc->okmask;
338 277058
        }
339 508430
        return (0);
340 508448
}
341
342
static void
343 231452
vcc_checkuses(struct vcc *tl, const struct symbol *sym)
344
{
345
        struct proc *p;
346
        struct procuse *pu;
347
348 231452
        p = sym->proc;
349 231452
        AN(p);
350 231452
        pu = vcc_FindIllegalUse(tl, p, p->method);
351 231452
        if (pu != NULL) {
352 52
                vcc_ErrWhere2(tl, pu->t1, pu->t2);
353 104
                VSB_printf(tl->sb, "%s in subroutine '%.*s'.",
354 52
                    pu->use->err, PF(p->name));
355 52
                VSB_cat(tl->sb, "\nAt: ");
356 52
                return;
357
        }
358 231400
        ERRCHK(tl);
359 231380
        if (vcc_CheckUseRecurse(tl, p, p->method)) {
360 16
                VSB_printf(tl->sb,
361 8
                    "\n...which is the \"%s\" subroutine\n", p->method->name);
362 8
                return;
363
        }
364 231452
}
365
366
/*
367
 * Used from a second symbol walk because vcc_checkuses is more precise for
368
 * subroutines called from methods. We catch here subs used for dynamic calls
369
 * and with vcc_err_unref = off
370
 */
371
static void
372 229312
vcc_checkpossible(struct vcc *tl, const struct symbol *sym)
373
{
374
        struct proc *p;
375
376 229312
        p = sym->proc;
377 229312
        AN(p);
378
379 229312
        if (p->okmask != 0)
380 229308
                return;
381
382 4
        VSB_cat(tl->sb, "Impossible Subroutine");
383 4
        vcc_ErrWhere(tl, p->name);
384 229312
}
385
386
int
387 5674
vcc_CheckUses(struct vcc *tl)
388
{
389
390 5674
        VCC_WalkSymbols(tl, vcc_checkuses, SYM_MAIN, SYM_SUB);
391 5674
        if (tl->err)
392 80
                return (tl->err);
393 5594
        VCC_WalkSymbols(tl, vcc_checkpossible, SYM_MAIN, SYM_SUB);
394 5594
        return (tl->err);
395 5674
}
396
397
/*---------------------------------------------------------------------*/
398
399
static void v_matchproto_(symwalk_f)
400 388
vcc_instance_info(struct vcc *tl, const struct symbol *sym)
401
{
402
403 388
        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
404 388
        AN(sym->rname);
405 388
        Fc(tl, 0, "\t{ .p = (uintptr_t *)&%s, .name = \"", sym->rname);
406 388
        VCC_SymName(tl->fc, sym);
407 388
        Fc(tl, 0, "\" },\n");
408 388
}
409
410
void
411 2500
VCC_InstanceInfo(struct vcc *tl)
412
{
413 2500
        Fc(tl, 0, "\nstatic const struct vpi_ii VGC_instance_info[] = {\n");
414 2500
        VCC_WalkSymbols(tl, vcc_instance_info, SYM_MAIN, SYM_INSTANCE);
415 2500
        Fc(tl, 0, "\t{ .p = NULL, .name = \"\" }\n");
416 2500
        Fc(tl, 0, "};\n");
417 2500
}
418
419
/*---------------------------------------------------------------------*/
420
421
static int sym_type_len;
422
423
static void v_matchproto_(symwalk_f)
424 660076
vcc_xreftable_len(struct vcc *tl, const struct symbol *sym)
425
{
426
        int len;
427
428 660076
        (void)tl;
429 660076
        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
430 660076
        CHECK_OBJ_NOTNULL(sym->type, TYPE_MAGIC);
431 660076
        len = strlen(sym->type->name);
432 660076
        if (sym_type_len < len)
433 15612
                sym_type_len = len;
434 660076
}
435
436
static void v_matchproto_(symwalk_f)
437 660076
vcc_xreftable(struct vcc *tl, const struct symbol *sym)
438
{
439
440 660076
        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
441 660076
        CHECK_OBJ_NOTNULL(sym->kind, KIND_MAGIC);
442 660076
        CHECK_OBJ_NOTNULL(sym->type, TYPE_MAGIC);
443 660076
        Fc(tl, 0, " * %-8s ", sym->kind->name);
444 660076
        Fc(tl, 0, " %-*s ", sym_type_len, sym->type->name);
445 660076
        Fc(tl, 0, " %2u %2u ", sym->lorev, sym->hirev);
446 660076
        VCC_SymName(tl->fc, sym);
447 660076
        if (sym->wildcard != NULL)
448 17500
                Fc(tl, 0, "*");
449 660076
        Fc(tl, 0, "\n");
450 660076
}
451
452
void
453 2500
VCC_XrefTable(struct vcc *tl)
454
{
455
456
#define VCC_NAMESPACE(U, l)                                             \
457
        Fc(tl, 0, "\n/*\n * Symbol Table " #U "\n *\n");                \
458
        sym_type_len = 0;                                               \
459
        VCC_WalkSymbols(tl, vcc_xreftable_len, SYM_##U, SYM_NONE);      \
460
        VCC_WalkSymbols(tl, vcc_xreftable, SYM_##U, SYM_NONE);          \
461
        Fc(tl, 0, "*/\n\n");
462
#include "vcc_namespace.h"
463
}