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