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 28
 * 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 28
 *    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 28
 * 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 28
 * 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 28
 * 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 28
        struct token            *t;
52
        struct proc             *fm;
53
};
54
55
struct procuse {
56
        VTAILQ_ENTRY(procuse)   list;
57 28
        const struct token      *t1;
58
        const struct token      *t2;
59
        const struct symbol     *sym;
60
        const struct xrefuse    *use;
61 28
        unsigned                mask;
62
        struct proc             *fm;
63
};
64
65 28
/*--------------------------------------------------------------------*/
66
67
static void
68 9771188
vcc_checkref(struct vcc *tl, const struct symbol *sym)
69 28
{
70
71 9771188
        if (sym->noref)
72 8720894
                return;
73 1050322
        if (sym->ndef == 0 && sym->nref != 0) {
74 42
                AN(sym->ref_b);
75 84
                VSB_printf(tl->sb, "Undefined %s %.*s, first reference:\n",
76 42
                    sym->kind->name, PF(sym->ref_b));
77 42
                vcc_ErrWhere(tl, sym->ref_b);
78 1050322
        } else if (sym->ndef != 0 && sym->nref == 0) {
79 1778
                AN(sym->def_b);
80 3556
                VSB_printf(tl->sb, "Unused %s %.*s, defined:\n",
81 1778
                    sym->kind->name, PF(sym->def_b));
82 1778
                vcc_ErrWhere(tl, sym->def_b);
83 1778
                if (!tl->err_unref)
84 1694
                        vcc_Warn(tl);
85 1806
        }
86 9771188
}
87
88
int
89 40026
vcc_CheckReferences(struct vcc *tl)
90 28
{
91
92 40026
        VCC_WalkSymbols(tl, vcc_checkref, SYM_MAIN, SYM_NONE);
93 40026
        return (tl->err);
94 28
}
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 28
105
void
106 2635710
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 28
111 2635710
        AN(tl->curproc);
112 2635710
        pu = TlAlloc(tl, sizeof *pu);
113 2635710
        AN(pu);
114 2635710
        AN(sym);
115 2635710
        AN(use);
116 2635710
        AN(use->name);
117 2635710
        pu->t1 = t1;
118 2635710
        pu->t2 = t2;
119 2635710
        if (pu->t2 == NULL) {
120 2114518
                pu->t2 = vcc_PeekTokenFrom(tl, t1);
121 2114490
                AN(pu->t2);
122 2114490
        }
123 2635710
        pu->sym = sym;
124 2635710
        pu->use = use;
125 2635710
        pu->fm = tl->curproc;
126
127 2635710
        if (pu->use == XREF_READ)
128 1991220
                pu->mask = sym->r_methods;
129 644490
        else if (pu->use == XREF_WRITE)
130 440258
                pu->mask = sym->w_methods;
131 204232
        else if (pu->use == XREF_UNSET)
132 80962
                pu->mask = sym->u_methods;
133 123270
        else if (pu->use == XREF_ACTION)
134 123270
                pu->mask = sym->action_mask;
135
        else
136 0
                WRONG("wrong xref use");
137
138 2635710
        VTAILQ_INSERT_TAIL(&tl->curproc->uses, pu, list);
139 2635710
}
140
141
void
142 1162672
vcc_AddCall(struct vcc *tl, struct token *t, struct symbol *sym)
143
{
144
        struct proccall *pc;
145
146 1162672
        AN(sym);
147 1162672
        pc = TlAlloc(tl, sizeof *pc);
148 1162672
        AN(pc);
149 1162672
        pc->sym = sym;
150 1162672
        pc->t = t;
151 1162672
        pc->fm = tl->curproc;
152 1162672
        VTAILQ_INSERT_TAIL(&tl->curproc->calls, pc, list);
153 1162672
}
154
155
void
156 1009540
vcc_ProcAction(struct proc *p, unsigned returns, unsigned mask, struct token *t)
157
{
158
159 1009540
        assert(returns < VCL_RET_MAX);
160 1009540
        p->ret_bitmap |= (1U << returns);
161 1009540
        p->okmask &= mask;
162
        /* Record the first instance of this return */
163 1009540
        if (p->return_tok[returns] == NULL)
164 1007020
                p->return_tok[returns] = t;
165 1009540
}
166
167
static int
168 3591546
vcc_CheckActionRecurse(struct vcc *tl, struct proc *p, unsigned bitmap)
169
{
170
        unsigned u;
171
        struct proccall *pc;
172
173 3591546
        AN(p);
174 3591546
        if (p->active) {
175 28
                VSB_cat(tl->sb, "Subroutine recurses on\n");
176 28
                vcc_ErrWhere(tl, p->name);
177 28
                return (1);
178
        }
179 3591518
        u = p->ret_bitmap & ~bitmap;
180 3591518
        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 3591504
        u = (p->sym->nref > p->called);
197
198 3591504
        p->active = 1;
199 5547374
        VTAILQ_FOREACH(pc, &p->calls, list) {
200 1955926
                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 1955926
                pc->sym->proc->calledfrom |= p->calledfrom;
207 1955926
                pc->sym->proc->called++;
208 1955926
                pc->sym->nref += u;
209 1955926
                if (vcc_CheckActionRecurse(tl, pc->sym->proc, bitmap)) {
210 112
                        VSB_printf(tl->sb, "\n...called from \"%.*s\"\n",
211 56
                            PF(p->name));
212 56
                        vcc_ErrWhere(tl, pc->t);
213 56
                        return (1);
214
                }
215 1955870
                p->okmask &= pc->sym->proc->okmask;
216 1955870
        }
217 3591448
        p->active = 0;
218 3591448
        return (0);
219 3591546
}
220
221
/*--------------------------------------------------------------------*/
222
223
static void
224 1635620
vcc_checkaction(struct vcc *tl, const struct symbol *sym)
225
{
226
        struct proc *p;
227
        unsigned bitmap;
228
229 1635620
        p = sym->proc;
230 1635620
        AN(p);
231 1635620
        AN(p->name);
232
233 1635620
        if (p->method == NULL) {
234 1037554
                bitmap = ~0U;
235 1037554
        } else {
236 598066
                bitmap = p->method->ret_bitmap;
237 598066
                p->calledfrom = p->method->bitval;
238
        }
239
240 1635620
        if (! vcc_CheckActionRecurse(tl, p, bitmap))
241 1635578
                return;
242
243 42
        tl->err = 1;
244 42
        if (p->method == NULL)
245 28
                return;
246
247 28
        VSB_printf(tl->sb,
248 14
                   "\n...which is the \"%s\" subroutine\n", p->method->name);
249 14
        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 39900
vcc_CheckAction(struct vcc *tl)
260
{
261
262 39900
        VCC_WalkSymbols(tl, vcc_checkaction, SYM_MAIN, SYM_SUB);
263 39900
        return (tl->err);
264
}
265
266
/*--------------------------------------------------------------------*/
267
268
static struct procuse *
269 3073868
vcc_illegal_write(struct vcc *tl, struct procuse *pu, const struct method *m)
270
{
271
272 3073868
        if (pu->mask || pu->use != XREF_WRITE)
273 3073686
                return (NULL);
274
275 182
        if (pu->sym->r_methods == 0) {
276 14
                vcc_ErrWhere2(tl, pu->t1, pu->t2);
277 14
                VSB_cat(tl->sb, "Variable cannot be set.\n");
278 14
                return (NULL);
279
        }
280
281 168
        if (!(pu->sym->r_methods & m->bitval)) {
282 28
                pu->use = XREF_READ; /* NB: change the error message. */
283 28
                return (pu);
284
        }
285
286 140
        vcc_ErrWhere2(tl, pu->t1, pu->t2);
287 140
        VSB_cat(tl->sb, "Variable is read only.\n");
288 140
        return (NULL);
289 3073868
}
290
291
static struct procuse *
292 5197668
vcc_FindIllegalUse(struct vcc *tl, struct proc *p, const struct method *m)
293
{
294 5197668
        struct procuse *pu, *pw, *r = NULL;
295
296 15493212
        VTAILQ_FOREACH(pu, &p->uses, list) {
297 10295544
                p->okmask &= pu->mask;
298 10295544
                if (m == NULL)
299 7221676
                        continue;
300 3073868
                pw = vcc_illegal_write(tl, pu, m);
301 3073868
                if (r != NULL)
302 98
                        continue;
303 3073770
                if (tl->err)
304 154
                        r = pw;
305 3073616
                else if (!(pu->mask & m->bitval))
306 406
                        r = pu;
307 3073770
        }
308 5197668
        return (r);
309
}
310
311
static int
312 3571750
vcc_CheckUseRecurse(struct vcc *tl, struct proc *p,
313
    const struct method *m)
314
{
315
        struct proccall *pc;
316
        struct procuse *pu;
317
318 3571750
        pu = vcc_FindIllegalUse(tl, p, m);
319 3571750
        if (pu != NULL) {
320 42
                vcc_ErrWhere2(tl, pu->t1, pu->t2);
321 84
                VSB_printf(tl->sb, "%s from subroutine '%s'.\n",
322 42
                    pu->use->err, m->name);
323 84
                VSB_printf(tl->sb, "\n...in subroutine \"%.*s\"\n",
324 42
                    PF(pu->fm->name));
325 42
                vcc_ErrWhere(tl, p->name);
326 42
                return (1);
327
        }
328 3571708
        if (tl->err)
329 14
                return (1);
330 5517960
        VTAILQ_FOREACH(pc, &p->calls, list) {
331 1946336
                if (vcc_CheckUseRecurse(tl, pc->sym->proc, m)) {
332 140
                        VSB_printf(tl->sb, "\n...called from \"%.*s\"\n",
333 70
                            PF(p->name));
334 70
                        vcc_ErrWhere(tl, pc->t);
335 70
                        return (1);
336
                }
337 1946266
                p->okmask &= pc->sym->proc->okmask;
338 1946266
        }
339 3571624
        return (0);
340 3571750
}
341
342
static void
343 1625918
vcc_checkuses(struct vcc *tl, const struct symbol *sym)
344
{
345
        struct proc *p;
346
        struct procuse *pu;
347
348 1625918
        p = sym->proc;
349 1625918
        AN(p);
350 1625918
        pu = vcc_FindIllegalUse(tl, p, p->method);
351 1625918
        if (pu != NULL) {
352 364
                vcc_ErrWhere2(tl, pu->t1, pu->t2);
353 728
                VSB_printf(tl->sb, "%s in subroutine '%.*s'.",
354 364
                    pu->use->err, PF(p->name));
355 364
                VSB_cat(tl->sb, "\nAt: ");
356 364
                return;
357
        }
358 1625554
        ERRCHK(tl);
359 1625414
        if (vcc_CheckUseRecurse(tl, p, p->method)) {
360 112
                VSB_printf(tl->sb,
361 56
                    "\n...which is the \"%s\" subroutine\n", p->method->name);
362 56
                return;
363
        }
364 1625918
}
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 1610938
vcc_checkpossible(struct vcc *tl, const struct symbol *sym)
373
{
374
        struct proc *p;
375
376 1610938
        p = sym->proc;
377 1610938
        AN(p);
378
379 1610938
        if (p->okmask != 0)
380 1610910
                return;
381
382 28
        VSB_cat(tl->sb, "Impossible Subroutine");
383 28
        vcc_ErrWhere(tl, p->name);
384 1610938
}
385
386
int
387 39858
vcc_CheckUses(struct vcc *tl)
388
{
389
390 39858
        VCC_WalkSymbols(tl, vcc_checkuses, SYM_MAIN, SYM_SUB);
391 39858
        if (tl->err)
392 560
                return (tl->err);
393 39298
        VCC_WalkSymbols(tl, vcc_checkpossible, SYM_MAIN, SYM_SUB);
394 39298
        return (tl->err);
395 39858
}
396
397
/*---------------------------------------------------------------------*/
398
399
static void v_matchproto_(symwalk_f)
400 2716
vcc_instance_info(struct vcc *tl, const struct symbol *sym)
401
{
402
403 2716
        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
404 2716
        AN(sym->rname);
405 2716
        Fc(tl, 0, "\t{ .p = (uintptr_t *)&%s, .name = \"", sym->rname);
406 2716
        VCC_SymName(tl->fc, sym);
407 2716
        Fc(tl, 0, "\" },\n");
408 2716
}
409
410
void
411 17570
VCC_InstanceInfo(struct vcc *tl)
412
{
413 17570
        Fc(tl, 0, "\nstatic const struct vpi_ii VGC_instance_info[] = {\n");
414 17570
        VCC_WalkSymbols(tl, vcc_instance_info, SYM_MAIN, SYM_INSTANCE);
415 17570
        Fc(tl, 0, "\t{ .p = NULL, .name = \"\" }\n");
416 17570
        Fc(tl, 0, "};\n");
417 17570
}
418
419
/*---------------------------------------------------------------------*/
420
421
static int sym_type_len;
422
423
static void v_matchproto_(symwalk_f)
424 4658626
vcc_xreftable_len(struct vcc *tl, const struct symbol *sym)
425
{
426
        int len;
427
428 4658626
        (void)tl;
429 4658626
        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
430 4658626
        CHECK_OBJ_NOTNULL(sym->type, TYPE_MAGIC);
431 4658626
        len = strlen(sym->type->name);
432 4658626
        if (sym_type_len < len)
433 109760
                sym_type_len = len;
434 4658626
}
435
436
static void v_matchproto_(symwalk_f)
437 4658626
vcc_xreftable(struct vcc *tl, const struct symbol *sym)
438
{
439
440 4658626
        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
441 4658626
        CHECK_OBJ_NOTNULL(sym->kind, KIND_MAGIC);
442 4658626
        CHECK_OBJ_NOTNULL(sym->type, TYPE_MAGIC);
443 4658626
        Fc(tl, 0, " * %-8s ", sym->kind->name);
444 4658626
        Fc(tl, 0, " %-*s ", sym_type_len, sym->type->name);
445 4658626
        Fc(tl, 0, " %2u %2u ", sym->lorev, sym->hirev);
446 4658626
        VCC_SymName(tl->fc, sym);
447 4658626
        if (sym->wildcard != NULL)
448 122990
                Fc(tl, 0, "*");
449 4658626
        Fc(tl, 0, "\n");
450 4658626
}
451
452
void
453 17570
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
}