GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2011 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * This file contains code for two cross-reference or consistency checks.
 *
 * The first check is simply that all subroutine, acls and backends are
 * both defined and referenced.  Complaints about referenced but undefined
 * or defined but unreferenced objects will be emitted.
 *
 * The second check recursively descends through subroutine calls to make
 * sure that action actions are correct for the methods through which
 * they are called.
 */

#include "config.h"

#include <string.h>
#include "vcc_compile.h"

/*--------------------------------------------------------------------*/

struct proccall {
        VTAILQ_ENTRY(proccall)  list;
        struct symbol           *sym;
        struct token            *t;
        struct proc             *fm;
};

struct procuse {
        VTAILQ_ENTRY(procuse)   list;
        const struct token      *t1;
        const struct token      *t2;
        const struct symbol     *sym;
        const struct xrefuse    *use;
        unsigned                mask;
        struct proc             *fm;
};

/*--------------------------------------------------------------------*/

static void
vcc_checkref(struct vcc *tl, const struct symbol *sym)
{

        if (sym->noref)
                return;
        if (sym->ndef == 0 && sym->nref != 0) {
                AN(sym->ref_b);
                VSB_printf(tl->sb, "Undefined %s %.*s, first reference:\n",
                    sym->kind->name, PF(sym->ref_b));
                vcc_ErrWhere(tl, sym->ref_b);
        } else if (sym->ndef != 0 && sym->nref == 0) {
                AN(sym->def_b);
                VSB_printf(tl->sb, "Unused %s %.*s, defined:\n",
                    sym->kind->name, PF(sym->def_b));
                vcc_ErrWhere(tl, sym->def_b);
                if (!tl->err_unref)
                        vcc_Warn(tl);
        }
}

int
vcc_CheckReferences(struct vcc *tl)
{

        VCC_WalkSymbols(tl, vcc_checkref, SYM_MAIN, SYM_NONE);
        return (tl->err);
}

/*--------------------------------------------------------------------
 * Returns checks
 */

const struct xrefuse XREF_READ[1] = {{"xref_read", "Not available"}};
const struct xrefuse XREF_WRITE[1] = {{"xref_write", "Cannot be set"}};
const struct xrefuse XREF_UNSET[1] = {{"xref_unset", "Cannot be unset"}};
const struct xrefuse XREF_ACTION[1] = {{"xref_action", "Not a valid action"}};

void
vcc_AddUses(struct vcc *tl, const struct token *t1, const struct token *t2,
    const struct symbol *sym, const struct xrefuse *use)
{
        struct procuse *pu;

        AN(tl->curproc);
        pu = TlAlloc(tl, sizeof *pu);
        AN(pu);
        AN(sym);
        AN(use);
        AN(use->name);
        pu->t1 = t1;
        pu->t2 = t2;
        if (pu->t2 == NULL) {
                pu->t2 = vcc_PeekTokenFrom(tl, t1);
                AN(pu->t2);
        }
        pu->sym = sym;
        pu->use = use;
        pu->fm = tl->curproc;

        if (pu->use == XREF_READ)
                pu->mask = sym->r_methods;
        else if (pu->use == XREF_WRITE)
                pu->mask = sym->w_methods;
        else if (pu->use == XREF_UNSET)
                pu->mask = sym->u_methods;
        else if (pu->use == XREF_ACTION)
                pu->mask = sym->action_mask;
        else
                WRONG("wrong xref use");

        VTAILQ_INSERT_TAIL(&tl->curproc->uses, pu, list);
}

void
vcc_AddCall(struct vcc *tl, struct token *t, struct symbol *sym)
{
        struct proccall *pc;

        AN(sym);
        pc = TlAlloc(tl, sizeof *pc);
        AN(pc);
        pc->sym = sym;
        pc->t = t;
        pc->fm = tl->curproc;
        VTAILQ_INSERT_TAIL(&tl->curproc->calls, pc, list);
}

void
vcc_ProcAction(struct proc *p, unsigned returns, unsigned mask, struct token *t)
{

        assert(returns < VCL_RET_MAX);
        p->ret_bitmap |= (1U << returns);
        p->okmask &= mask;
        /* Record the first instance of this return */
        if (p->return_tok[returns] == NULL)
                p->return_tok[returns] = t;
}

static int
vcc_CheckActionRecurse(struct vcc *tl, struct proc *p, unsigned bitmap)
{
        unsigned u;
        struct proccall *pc;

        AN(p);
        if (p->active) {
                VSB_cat(tl->sb, "Subroutine recurses on\n");
                vcc_ErrWhere(tl, p->name);
                return (1);
        }
        u = p->ret_bitmap & ~bitmap;
        if (u) {

#define VCL_RET_MAC(l, U, B)                                            \
                if (u & (1 << (VCL_RET_##U))) {                         \
                        VSB_printf(tl->sb, "Invalid return \"" #l "\"\n");\
                        vcc_ErrWhere(tl, p->return_tok[VCL_RET_##U]);   \
                }
#include "tbl/vcl_returns.h"

                VSB_printf(tl->sb, "\n...in subroutine \"%.*s\"\n",
                    PF(p->name));
                vcc_ErrWhere(tl, p->name);
                return (1);
        }

        // more references than calls -> sub is referenced for dynamic calls
        u = (p->sym->nref > p->called);

        p->active = 1;
        VTAILQ_FOREACH(pc, &p->calls, list) {
                if (pc->sym->proc == NULL) {
                        VSB_printf(tl->sb, "Subroutine %s does not exist\n",
                            pc->sym->name);
                        vcc_ErrWhere(tl, pc->t);
                        return (1);
                }
                pc->sym->proc->calledfrom |= p->calledfrom;
                pc->sym->proc->called++;
                pc->sym->nref += u;
                if (vcc_CheckActionRecurse(tl, pc->sym->proc, bitmap)) {
                        VSB_printf(tl->sb, "\n...called from \"%.*s\"\n",
                            PF(p->name));
                        vcc_ErrWhere(tl, pc->t);
                        return (1);
                }
                p->okmask &= pc->sym->proc->okmask;
        }
        p->active = 0;
        return (0);
}

/*--------------------------------------------------------------------*/

static void
vcc_checkaction(struct vcc *tl, const struct symbol *sym)
{
        struct proc *p;
        unsigned bitmap;

        p = sym->proc;
        AN(p);
        AN(p->name);

        if (p->method == NULL) {
                bitmap = ~0U;
        } else {
                bitmap = p->method->ret_bitmap;
                p->calledfrom = p->method->bitval;
        }

        if (! vcc_CheckActionRecurse(tl, p, bitmap))
                return;

        tl->err = 1;
        if (p->method == NULL)
                return;

        VSB_printf(tl->sb,
                   "\n...which is the \"%s\" subroutine\n", p->method->name);
        VSB_cat(tl->sb, "Legal returns are:");
#define VCL_RET_MAC(l, U, B)                                            \
        if (p->method->ret_bitmap & ((1 << VCL_RET_##U)))               \
                VSB_printf(tl->sb, " \"%s\"", #l);

#include "tbl/vcl_returns.h"
        VSB_cat(tl->sb, "\n");
}

int
vcc_CheckAction(struct vcc *tl)
{

        VCC_WalkSymbols(tl, vcc_checkaction, SYM_MAIN, SYM_SUB);
        return (tl->err);
}

/*--------------------------------------------------------------------*/

static struct procuse *
vcc_illegal_write(struct vcc *tl, struct procuse *pu, const struct method *m)
{

        if (pu->mask || pu->use != XREF_WRITE)
                return (NULL);

        if (pu->sym->r_methods == 0) {
                vcc_ErrWhere2(tl, pu->t1, pu->t2);
                VSB_cat(tl->sb, "Variable cannot be set.\n");
                return (NULL);
        }

        if (!(pu->sym->r_methods & m->bitval)) {
                pu->use = XREF_READ; /* NB: change the error message. */
                return (pu);
        }

        vcc_ErrWhere2(tl, pu->t1, pu->t2);
        VSB_cat(tl->sb, "Variable is read only.\n");
        return (NULL);
}

static struct procuse *
vcc_FindIllegalUse(struct vcc *tl, struct proc *p, const struct method *m)
{
        struct procuse *pu, *pw, *r = NULL;

        VTAILQ_FOREACH(pu, &p->uses, list) {
                p->okmask &= pu->mask;
                if (m == NULL)
                        continue;
                pw = vcc_illegal_write(tl, pu, m);
                if (r != NULL)
                        continue;
                if (tl->err)
                        r = pw;
                else if (!(pu->mask & m->bitval))
                        r = pu;
        }
        return (r);
}

static int
vcc_CheckUseRecurse(struct vcc *tl, struct proc *p,
    const struct method *m)
{
        struct proccall *pc;
        struct procuse *pu;

        pu = vcc_FindIllegalUse(tl, p, m);
        if (pu != NULL) {
                vcc_ErrWhere2(tl, pu->t1, pu->t2);
                VSB_printf(tl->sb, "%s from subroutine '%s'.\n",
                    pu->use->err, m->name);
                VSB_printf(tl->sb, "\n...in subroutine \"%.*s\"\n",
                    PF(pu->fm->name));
                vcc_ErrWhere(tl, p->name);
                return (1);
        }
        if (tl->err)
                return (1);
        VTAILQ_FOREACH(pc, &p->calls, list) {
                if (vcc_CheckUseRecurse(tl, pc->sym->proc, m)) {
                        VSB_printf(tl->sb, "\n...called from \"%.*s\"\n",
                            PF(p->name));
                        vcc_ErrWhere(tl, pc->t);
                        return (1);
                }
                p->okmask &= pc->sym->proc->okmask;
        }
        return (0);
}

static void
vcc_checkuses(struct vcc *tl, const struct symbol *sym)
{
        struct proc *p;
        struct procuse *pu;

        p = sym->proc;
        AN(p);
        pu = vcc_FindIllegalUse(tl, p, p->method);
        if (pu != NULL) {
                vcc_ErrWhere2(tl, pu->t1, pu->t2);
                VSB_printf(tl->sb, "%s in subroutine '%.*s'.",
                    pu->use->err, PF(p->name));
                VSB_cat(tl->sb, "\nAt: ");
                return;
        }
        ERRCHK(tl);
        if (vcc_CheckUseRecurse(tl, p, p->method)) {
                VSB_printf(tl->sb,
                    "\n...which is the \"%s\" subroutine\n", p->method->name);
                return;
        }
}

/*
 * Used from a second symbol walk because vcc_checkuses is more precise for
 * subroutines called from methods. We catch here subs used for dynamic calls
 * and with vcc_err_unref = off
 */
static void
vcc_checkpossible(struct vcc *tl, const struct symbol *sym)
{
        struct proc *p;

        p = sym->proc;
        AN(p);

        if (p->okmask != 0)
                return;

        VSB_cat(tl->sb, "Impossible Subroutine");
        vcc_ErrWhere(tl, p->name);
}

int
vcc_CheckUses(struct vcc *tl)
{

        VCC_WalkSymbols(tl, vcc_checkuses, SYM_MAIN, SYM_SUB);
        if (tl->err)
                return (tl->err);
        VCC_WalkSymbols(tl, vcc_checkpossible, SYM_MAIN, SYM_SUB);
        return (tl->err);
}

/*---------------------------------------------------------------------*/

static void v_matchproto_(symwalk_f)
vcc_instance_info(struct vcc *tl, const struct symbol *sym)
{

        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
        AN(sym->rname);
        Fc(tl, 0, "\t{ .p = (uintptr_t *)&%s, .name = \"", sym->rname);
        VCC_SymName(tl->fc, sym);
        Fc(tl, 0, "\" },\n");
}

void
VCC_InstanceInfo(struct vcc *tl)
{
        Fc(tl, 0, "\nstatic const struct vpi_ii VGC_instance_info[] = {\n");
        VCC_WalkSymbols(tl, vcc_instance_info, SYM_MAIN, SYM_INSTANCE);
        Fc(tl, 0, "\t{ .p = NULL, .name = \"\" }\n");
        Fc(tl, 0, "};\n");
}

/*---------------------------------------------------------------------*/

static int sym_type_len;

static void v_matchproto_(symwalk_f)
vcc_xreftable_len(struct vcc *tl, const struct symbol *sym)
{
        int len;

        (void)tl;
        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
        CHECK_OBJ_NOTNULL(sym->type, TYPE_MAGIC);
        len = strlen(sym->type->name);
        if (sym_type_len < len)
                sym_type_len = len;
}

static void v_matchproto_(symwalk_f)
vcc_xreftable(struct vcc *tl, const struct symbol *sym)
{

        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
        CHECK_OBJ_NOTNULL(sym->kind, KIND_MAGIC);
        CHECK_OBJ_NOTNULL(sym->type, TYPE_MAGIC);
        Fc(tl, 0, " * %-8s ", sym->kind->name);
        Fc(tl, 0, " %-*s ", sym_type_len, sym->type->name);
        Fc(tl, 0, " %2u %2u ", sym->lorev, sym->hirev);
        VCC_SymName(tl->fc, sym);
        if (sym->wildcard != NULL)
                Fc(tl, 0, "*");
        Fc(tl, 0, "\n");
}

void
VCC_XrefTable(struct vcc *tl)
{

#define VCC_NAMESPACE(U, l)                                             \
        Fc(tl, 0, "\n/*\n * Symbol Table " #U "\n *\n");                \
        sym_type_len = 0;                                               \
        VCC_WalkSymbols(tl, vcc_xreftable_len, SYM_##U, SYM_NONE);      \
        VCC_WalkSymbols(tl, vcc_xreftable, SYM_##U, SYM_NONE);          \
        Fc(tl, 0, "*/\n\n");
#include "vcc_namespace.h"
}

		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		}