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 1383092
vcc_checkref(struct vcc *tl, const struct symbol *sym)
69 4
{
70
71 1383092
        if (sym->noref)
72 1233788
                return;
73 149308
        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 149308
        } 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 1383092
}
87
88
int
89 5690
vcc_CheckReferences(struct vcc *tl)
90 4
{
91
92 5690
        VCC_WalkSymbols(tl, vcc_checkref, SYM_MAIN, SYM_NONE);
93 5690
        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 374630
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 374630
        AN(tl->curproc);
112 374630
        pu = TlAlloc(tl, sizeof *pu);
113 374630
        AN(pu);
114 374630
        AN(sym);
115 374630
        AN(use);
116 374630
        AN(use->name);
117 374630
        pu->t1 = t1;
118 374630
        pu->t2 = t2;
119 374630
        if (pu->t2 == NULL) {
120 300572
                pu->t2 = vcc_PeekTokenFrom(tl, t1);
121 300568
                AN(pu->t2);
122 300568
        }
123 374630
        pu->sym = sym;
124 374630
        pu->use = use;
125 374630
        pu->fm = tl->curproc;
126
127 374630
        if (pu->use == XREF_READ)
128 283044
                pu->mask = sym->r_methods;
129 91586
        else if (pu->use == XREF_WRITE)
130 62564
                pu->mask = sym->w_methods;
131 29022
        else if (pu->use == XREF_UNSET)
132 11498
                pu->mask = sym->u_methods;
133 17524
        else if (pu->use == XREF_ACTION)
134 17524
                pu->mask = sym->action_mask;
135
        else
136 0
                WRONG("wrong xref use");
137
138 374630
        VTAILQ_INSERT_TAIL(&tl->curproc->uses, pu, list);
139 374630
}
140
141
void
142 165284
vcc_AddCall(struct vcc *tl, struct token *t, struct symbol *sym)
143
{
144
        struct proccall *pc;
145
146 165284
        AN(sym);
147 165284
        pc = TlAlloc(tl, sizeof *pc);
148 165284
        AN(pc);
149 165284
        pc->sym = sym;
150 165284
        pc->t = t;
151 165284
        pc->fm = tl->curproc;
152 165284
        VTAILQ_INSERT_TAIL(&tl->curproc->calls, pc, list);
153 165284
}
154
155
void
156 143510
vcc_ProcAction(struct proc *p, unsigned returns, unsigned mask, struct token *t)
157
{
158
159 143510
        assert(returns < VCL_RET_MAX);
160 143510
        p->ret_bitmap |= (1U << returns);
161 143510
        p->okmask &= mask;
162
        /* Record the first instance of this return */
163 143510
        if (p->return_tok[returns] == NULL)
164 143150
                p->return_tok[returns] = t;
165 143510
}
166
167
static int
168 510556
vcc_CheckActionRecurse(struct vcc *tl, struct proc *p, unsigned bitmap)
169
{
170
        unsigned u;
171
        struct proccall *pc;
172
173 510556
        AN(p);
174 510556
        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 510552
        u = p->ret_bitmap & ~bitmap;
180 510552
        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 510550
        u = (p->sym->nref > p->called);
197
198 510550
        p->active = 1;
199 788588
        VTAILQ_FOREACH(pc, &p->calls, list) {
200 278046
                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 278046
                pc->sym->proc->calledfrom |= p->calledfrom;
207 278046
                pc->sym->proc->called++;
208 278046
                pc->sym->nref += u;
209 278046
                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 278038
                p->okmask &= pc->sym->proc->okmask;
216 278038
        }
217 510542
        p->active = 0;
218 510542
        return (0);
219 510556
}
220
221
/*--------------------------------------------------------------------*/
222
223
static void
224 232510
vcc_checkaction(struct vcc *tl, const struct symbol *sym)
225
{
226
        struct proc *p;
227
        unsigned bitmap;
228
229 232510
        p = sym->proc;
230 232510
        AN(p);
231 232510
        AN(p->name);
232
233 232510
        if (p->method == NULL) {
234 147492
                bitmap = ~0U;
235 147492
        } else {
236 85018
                bitmap = p->method->ret_bitmap;
237 85018
                p->calledfrom = p->method->bitval;
238
        }
239
240 232510
        if (! vcc_CheckActionRecurse(tl, p, bitmap))
241 232504
                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 5672
vcc_CheckAction(struct vcc *tl)
260
{
261
262 5672
        VCC_WalkSymbols(tl, vcc_checkaction, SYM_MAIN, SYM_SUB);
263 5672
        return (tl->err);
264
}
265
266
/*--------------------------------------------------------------------*/
267
268
static struct procuse *
269 436840
vcc_illegal_write(struct vcc *tl, struct procuse *pu, const struct method *m)
270
{
271
272 436840
        if (pu->mask || pu->use != XREF_WRITE)
273 436814
                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 436840
}
290
291
static struct procuse *
292 738852
vcc_FindIllegalUse(struct vcc *tl, struct proc *p, const struct method *m)
293
{
294 738852
        struct procuse *pu, *pw, *r = NULL;
295
296 2202260
        VTAILQ_FOREACH(pu, &p->uses, list) {
297 1463408
                p->okmask &= pu->mask;
298 1463408
                if (m == NULL)
299 1026568
                        continue;
300 436840
                pw = vcc_illegal_write(tl, pu, m);
301 436840
                if (r != NULL)
302 14
                        continue;
303 436826
                if (tl->err)
304 22
                        r = pw;
305 436804
                else if (!(pu->mask & m->bitval))
306 58
                        r = pu;
307 436826
        }
308 738852
        return (r);
309
}
310
311
static int
312 507728
vcc_CheckUseRecurse(struct vcc *tl, struct proc *p,
313
    const struct method *m)
314
{
315
        struct proccall *pc;
316
        struct procuse *pu;
317
318 507728
        pu = vcc_FindIllegalUse(tl, p, m);
319 507728
        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 507722
        if (tl->err)
329 2
                return (1);
330 784386
        VTAILQ_FOREACH(pc, &p->calls, list) {
331 276676
                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 276666
                p->okmask &= pc->sym->proc->okmask;
338 276666
        }
339 507710
        return (0);
340 507728
}
341
342
static void
343 231124
vcc_checkuses(struct vcc *tl, const struct symbol *sym)
344
{
345
        struct proc *p;
346
        struct procuse *pu;
347
348 231124
        p = sym->proc;
349 231124
        AN(p);
350 231124
        pu = vcc_FindIllegalUse(tl, p, p->method);
351 231124
        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 231072
        ERRCHK(tl);
359 231052
        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 231124
}
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 228984
vcc_checkpossible(struct vcc *tl, const struct symbol *sym)
373
{
374
        struct proc *p;
375
376 228984
        p = sym->proc;
377 228984
        AN(p);
378
379 228984
        if (p->okmask != 0)
380 228980
                return;
381
382 4
        VSB_cat(tl->sb, "Impossible Subroutine");
383 4
        vcc_ErrWhere(tl, p->name);
384 228984
}
385
386
int
387 5666
vcc_CheckUses(struct vcc *tl)
388
{
389
390 5666
        VCC_WalkSymbols(tl, vcc_checkuses, SYM_MAIN, SYM_SUB);
391 5666
        if (tl->err)
392 80
                return (tl->err);
393 5586
        VCC_WalkSymbols(tl, vcc_checkpossible, SYM_MAIN, SYM_SUB);
394 5586
        return (tl->err);
395 5666
}
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 2496
VCC_InstanceInfo(struct vcc *tl)
412
{
413 2496
        Fc(tl, 0, "\nstatic const struct vpi_ii VGC_instance_info[] = {\n");
414 2496
        VCC_WalkSymbols(tl, vcc_instance_info, SYM_MAIN, SYM_INSTANCE);
415 2496
        Fc(tl, 0, "\t{ .p = NULL, .name = \"\" }\n");
416 2496
        Fc(tl, 0, "};\n");
417 2496
}
418
419
/*---------------------------------------------------------------------*/
420
421
static int sym_type_len;
422
423
static void v_matchproto_(symwalk_f)
424 659068
vcc_xreftable_len(struct vcc *tl, const struct symbol *sym)
425
{
426
        int len;
427
428 659068
        (void)tl;
429 659068
        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
430 659068
        CHECK_OBJ_NOTNULL(sym->type, TYPE_MAGIC);
431 659068
        len = strlen(sym->type->name);
432 659068
        if (sym_type_len < len)
433 15588
                sym_type_len = len;
434 659068
}
435
436
static void v_matchproto_(symwalk_f)
437 659068
vcc_xreftable(struct vcc *tl, const struct symbol *sym)
438
{
439
440 659068
        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
441 659068
        CHECK_OBJ_NOTNULL(sym->kind, KIND_MAGIC);
442 659068
        CHECK_OBJ_NOTNULL(sym->type, TYPE_MAGIC);
443 659068
        Fc(tl, 0, " * %-8s ", sym->kind->name);
444 659068
        Fc(tl, 0, " %-*s ", sym_type_len, sym->type->name);
445 659068
        Fc(tl, 0, " %2u %2u ", sym->lorev, sym->hirev);
446 659068
        VCC_SymName(tl->fc, sym);
447 659068
        if (sym->wildcard != NULL)
448 17472
                Fc(tl, 0, "*");
449 659068
        Fc(tl, 0, "\n");
450 659068
}
451
452
void
453 2496
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
}