Code Coverage: vinyl-cache/lib/libvcc/vcc_compile.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2015 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
 * 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
 *    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
 * 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
 * SUCH DAMAGE.
29
 */
30
31
/*
32
 * XXX:
33
 *      Better error messages, throughout.
34
 *      >It also occurred to me that we could link the errors to the error
35
 *      >documentation.
36
 *      >
37
 *      >Unreferenced  function 'request_policy', first mention is
38
 *      >         Line 8 Pos 4
39
 *      >         sub request_policy {
40
 *      >         ----##############--
41
 *      >Read more about this type of error:
42
 *      >http://vinyl/doc/error.html#Unreferenced%20function
43
 *      >
44
 *      >
45
 *      >         Unknown variable 'obj.bandwidth'
46
 *      >         At: Line 88 Pos 12
47
 *      >                 if (obj.bandwidth < 1 kb/h) {
48
 *      >         ------------#############------------
49
 *      >Read more about this type of error:
50
 *      >http://vinyl/doc/error.html#Unknown%20variable
51
 *
52
 */
53
54
#include "config.h"
55
56
#include <fcntl.h>
57
#include <stdarg.h>
58
#include <stdlib.h>
59
#include <string.h>
60
#include <unistd.h>
61
62
#include "vcc_compile.h"
63
64
#include "libvcc.h"
65
#include "vfil.h"
66
#include "vct.h"
67
68
static const struct method method_tab[] = {
69
        { "none", 0U, 0},
70
#define VCL_MET_MAC(l,U,t,b)    { "vcl_"#l, b, VCL_MET_##U },
71
#include "tbl/vcl_returns.h"
72
        { NULL, 0U, 0}
73
};
74
75
struct vcc *vcc_builtin;
76
77
/*--------------------------------------------------------------------*/
78
79
static void
80
vcc_vcl_met2c(struct vsb *vsb, unsigned method)
81 58549
{
82 58549
        int d = 0;
83
84
        //lint -e{774} Boolean within 'if' always evaluates to False
85 58549
#define VCL_MET_MAC(l,U,t,b)                            \
86 878235
        do {                                            \
87 878235
                if (method & VCL_MET_##U) {             \
88 223908
                        if (d)                          \
89 223908
                                VSB_putc(vsb, '|');     \
90 223908
                        VSB_cat(vsb, "VCL_MET_" #U);    \
91 223908
                        d = 1;                          \
92 223908
                }                                       \
93 878235
        } while (0);
94 58549
#include "tbl/vcl_returns.h"
95 58549
        AN(d);
96 58549
}
97
98
99
/*--------------------------------------------------------------------*/
100
101
void * v_matchproto_(TlAlloc)
102
TlAlloc(struct vcc *tl, unsigned len)
103 4885753
{
104 4885753
        void *p;
105
106 4885753
        (void)tl;
107 4885753
        p = calloc(1, len);
108 4885753
        assert(p != NULL);
109 4885753
        return (p);
110 4885753
}
111
112
char *
113
TlDup(struct vcc *tl, const char *s)
114 239193
{
115 239193
        char *p;
116
117 239193
        p = TlAlloc(tl, vstrlen(s) + 1);
118 239193
        AN(p);
119 239193
        strcpy(p, s);
120 239193
        return (p);
121 239193
}
122
123
static int
124
TLWriteVSB(struct vcc *tl, const char *fn, const struct vsb *vsb,
125
    const char *what)
126 2658
{
127 2658
        int fo;
128 2658
        int i;
129
130 2658
        fo = open(fn, O_WRONLY|O_TRUNC|O_CREAT, 0600);
131 2658
        if (fo < 0) {
132 0
                VSB_printf(tl->sb,
133 0
                    "Could not open %s file %s: %s\n",
134 0
                    what, fn, strerror(errno));
135 0
                return (-1);
136 0
        }
137 2658
        i = VSB_tofile(vsb, fo);
138 2658
        if (i) {
139 0
                VSB_printf(tl->sb,
140 0
                    "Could not write %s to %s: %s\n",
141 0
                    what, fn, strerror(errno));
142 0
        }
143 2658
        closefd(&fo);
144 2658
        return (i);
145 2658
}
146
147
/*--------------------------------------------------------------------*/
148
149
static void
150
vcc_refUnusedProbes(struct vcc *tl, const struct symbol *sym)
151 14
{
152 14
        if (sym->ndef != 0 && sym->nref == 0)
153 1
                Fc(tl, 0, "\t(void)%s;\n", sym->rname);
154 14
}
155
156
struct proc *
157
vcc_NewProc(struct vcc *tl, struct symbol *sym)
158 137193
{
159 137193
        struct proc *p;
160
161 137193
        ALLOC_OBJ(p, PROC_MAGIC);
162 137193
        AN(p);
163 137193
        VTAILQ_INIT(&p->calls);
164 137193
        VTAILQ_INIT(&p->uses);
165 137193
        VTAILQ_INSERT_TAIL(&tl->procs, p, list);
166 137193
        p->prologue = VSB_new_auto();
167 137193
        AN(p->prologue);
168 137193
        p->body = VSB_new_auto();
169 137193
        AN(p->body);
170 137193
        p->cname = VSB_new_auto();
171 137193
        AN(p->cname);
172 137193
        p->okmask = VCL_MET_TASK_ALL;
173 137193
        sym->proc = p;
174 137193
        p->sym = sym;
175 137193
        return (p);
176 137193
}
177
178
static void
179
vcc_EmitProc(struct vcc *tl, struct proc *p)
180 58549
{
181 58549
        struct vsb *vsbm;
182 58549
        unsigned mask, nsub;
183 58549
        const char *maskcmp;
184 58549
        const char *cc_adv;
185 58549
        int dyn = (p->sym->nref > p->called);
186
187 58549
        AN(p->okmask);
188 58549
        AZ(VSB_finish(p->cname));
189 58549
        AZ(VSB_finish(p->prologue));
190 58549
        AZ(VSB_finish(p->body));
191 58549
        AN(p->sym);
192
193 58549
        if (p->method) {
194 19935
                mask = p->method->bitval;
195 19935
                maskcmp = "==";
196 38614
        } else {
197 38614
                mask = p->okmask;
198 38614
                maskcmp = "&";
199 38614
        }
200
201 58549
        if (dyn == 0 && (p->calledfrom & VCL_MET_TASK_H) == p->calledfrom)
202 2671
                cc_adv = "v_dont_optimize ";
203 55878
        else
204 55878
                cc_adv = "";
205
206 58549
        nsub = tl->nsub++;
207
208 58549
        Fh(tl, 1, "vcl_func_f %s;\n", VSB_data(p->cname));
209 58549
        Fh(tl, 1, "extern const struct vcl_sub sub_%s[1];\n",
210 58549
            VSB_data(p->cname));
211 58549
        Fh(tl, 1, "const struct vcl_sub sub_%s[1] = {{\n", VSB_data(p->cname));
212 58549
        Fh(tl, 1, "\t.magic\t\t= VCL_SUB_MAGIC,\n");
213 58549
        Fh(tl, 1, "\t.methods\t= 0x%x,\n", p->okmask);
214 58549
        Fh(tl, 1, "\t.name\t\t= \"%.*s\",\n", PF(p->name));
215 58549
        Fh(tl, 1, "\t.vcl_conf\t= &VCL_conf,\n");
216 58549
        Fh(tl, 1, "\t.func\t\t= %s,\n", VSB_data(p->cname));
217 58549
        Fh(tl, 1, "\t.n\t\t= %d,\n", nsub);
218 58549
        Fh(tl, 1, "\t.nref\t\t= %d,\n", p->sym->nref);
219 58549
        Fh(tl, 1, "\t.called\t\t= %d\n", p->called);
220 58549
        Fh(tl, 1, "\t// calledfrom\t  0x%x\n", p->calledfrom);
221 58549
        Fh(tl, 1, "}};\n");
222
223 58549
        if (dyn) {
224 34
                Fc(tl, 1, "\nstatic inline void %s\n", cc_adv);
225 34
                Fc(tl, 1, "%s_checked(VRT_CTX)\n{\n", VSB_data(p->cname));
226 58515
        } else {
227 58515
                Fc(tl, 1, "\nvoid %sv_matchproto_(vcl_func_f)\n", cc_adv);
228 58515
                Fc(tl, 1, "%s(VRT_CTX, enum vcl_func_call_e call,\n",
229 58515
                    VSB_data(p->cname));
230 58515
                Fc(tl, 1, "    enum vcl_func_fail_e *failp)\n{\n");
231 58515
                Fc(tl, 1, "  assert(call == VSUB_STATIC);\n");
232 58515
                Fc(tl, 1, "  assert(failp == NULL);\n");
233 58515
        }
234
235 58549
        vsbm = VSB_new_auto();
236 58549
        AN(vsbm);
237 58549
        vcc_vcl_met2c(vsbm, mask);
238 58549
        AZ(VSB_finish(vsbm));
239 58549
        Fc(tl, 1, "  assert(ctx->method %s (%s));\n", maskcmp, VSB_data(vsbm));
240 58549
        VSB_destroy(&vsbm);
241 58549
        Fc(tl, 1, "%s\n%s}\n", VSB_data(p->prologue), VSB_data(p->body));
242 58549
        VSB_destroy(&p->body);
243 58549
        VSB_destroy(&p->prologue);
244
245 58549
        if (! dyn) {
246 58515
                VSB_destroy(&p->cname);
247 58515
                return;
248 58515
        }
249
250
        /* wrapper to call the actual (_checked) function */
251 34
        Fc(tl, 1, "\nvoid v_matchproto_(vcl_func_f)\n");
252 34
        Fc(tl, 1, "%s(VRT_CTX, enum vcl_func_call_e call,\n",
253 34
            VSB_data(p->cname));
254 34
        Fc(tl, 1, "    enum vcl_func_fail_e *failp)\n{\n");
255 34
        Fc(tl, 1, "  enum vcl_func_fail_e fail;\n\n");
256 34
        Fc(tl, 1, "  fail = VPI_Call_Check(ctx, &VCL_conf, 0x%x, %d);\n",
257 34
            mask, nsub);
258 34
        Fc(tl, 1, "  if (failp)\n");
259 34
        Fc(tl, 1, "    *failp = fail;\n");
260 34
        Fc(tl, 1, "  else if (fail == VSUB_E_METHOD)\n");
261 34
        Fc(tl, 1, "    VRT_fail(ctx, \"call to \\\"sub %.*s{}\\\""
262 34
            " not allowed from here\");\n", PF(p->name));
263 34
        Fc(tl, 1, "  else if (fail == VSUB_E_RECURSE)\n");
264 34
        Fc(tl, 1, "    VRT_fail(ctx, \"Recursive call to "
265 34
            "\\\"sub %.*s{}\\\"\");\n", PF(p->name));
266 34
        Fc(tl, 1, "  else\n");
267 34
        Fc(tl, 1, "    assert (fail == VSUB_E_OK);\n");
268 34
        Fc(tl, 1, "  if (fail != VSUB_E_OK || call == VSUB_CHECK)\n");
269 34
        Fc(tl, 1, "    return;\n");
270 34
        Fc(tl, 1, "  VPI_Call_Begin(ctx, %d);\n", nsub);
271 34
        Fc(tl, 1, "  %s_checked(ctx);\n", VSB_data(p->cname));
272 34
        Fc(tl, 1, "  VPI_Call_End(ctx, %d);\n", nsub);
273 34
        Fc(tl, 1, "}\n");
274 34
        VSB_destroy(&p->cname);
275 34
}
276
277
/*--------------------------------------------------------------------*/
278
279
struct inifin *
280
New_IniFin(struct vcc *tl)
281 22781
{
282 22781
        struct inifin *p;
283
284 22781
        ALLOC_OBJ(p, INIFIN_MAGIC);
285 22781
        AN(p);
286 22781
        p->ini = VSB_new_auto();
287 22781
        AN(p->ini);
288 22781
        p->fin = VSB_new_auto();
289 22781
        AN(p->fin);
290 22781
        p->final = VSB_new_auto();
291 22781
        AN(p->final);
292 22781
        p->event = VSB_new_auto();
293 22781
        AN(p->event);
294 22781
        p->n = ++tl->ninifin;
295 22781
        VTAILQ_INSERT_TAIL(&tl->inifin, p, list);
296 22781
        return (p);
297 22781
}
298
299
/*--------------------------------------------------------------------
300
 * Printf output to the vsbs, possibly indented
301
 */
302
303
void
304
Fh(const struct vcc *tl, int indent, const char *fmt, ...)
305 1045123
{
306 1045123
        va_list ap;
307
308 1045123
        if (indent)
309 762470
                VSB_printf(tl->fh, "%*.*s", tl->hindent, tl->hindent, "");
310 1045123
        va_start(ap, fmt);
311 1045123
        VSB_vprintf(tl->fh, fmt, ap);
312 1045123
        va_end(ap);
313 1045123
}
314
315
void
316
Fb(const struct vcc *tl, int indent, const char *fmt, ...)
317 2747181
{
318 2747181
        va_list ap;
319
320 2747181
        assert(tl->fb != NULL);
321 2747181
        if (indent)
322 2433896
                VSB_printf(tl->fb, "%*.*s", tl->indent, tl->indent, "");
323 2747181
        va_start(ap, fmt);
324 2747181
        VSB_vprintf(tl->fb, fmt, ap);
325 2747181
        va_end(ap);
326 2747181
}
327
328
void
329
Fc(const struct vcc *tl, int indent, const char *fmt, ...)
330 2124098
{
331 2124098
        va_list ap;
332
333 2124098
        if (indent)
334 410387
                VSB_printf(tl->fc, "%*.*s", tl->indent, tl->indent, "");
335 2124098
        va_start(ap, fmt);
336 2124098
        VSB_vprintf(tl->fc, fmt, ap);
337 2124098
        va_end(ap);
338 2124098
}
339
340
/*--------------------------------------------------------------------*/
341
342
void
343
EncToken(struct vsb *sb, const struct token *t)
344 127968
{
345
346 127968
        assert(t->tok == CSTR);
347 127968
        VSB_quote(sb, t->dec, -1, VSB_QUOTE_CSTR);
348 127968
}
349
350
/*--------------------------------------------------------------------
351
 * Output the location/profiling table.  For each counted token, we
352
 * record source+line+charpos for the first character in the token.
353
 */
354
355
static void
356
EmitCoordinates(const struct vcc *tl, struct vsb *vsb)
357 1329
{
358 1329
        struct token *t;
359 1329
        unsigned lin, pos;
360 1329
        const struct source *sp;
361 1329
        const char *p;
362
363 1329
        VSB_cat(vsb, "/* ---===### Source Code ###===---*/\n");
364
365 1329
        VSB_printf(vsb, "\n#define VGC_NSRCS %u\n", tl->nsources);
366
367 1329
        VSB_cat(vsb, "\nstatic const char *srcname[VGC_NSRCS] = {\n");
368 2691
        VTAILQ_FOREACH(sp, &tl->sources, list) {
369 2691
                VSB_cat(vsb, "\t");
370 2691
                VSB_quote(vsb, sp->name, -1, VSB_QUOTE_CSTR);
371 2691
                VSB_cat(vsb, ",\n");
372 2691
        }
373 1329
        VSB_cat(vsb, "};\n");
374
375 1329
        VSB_printf(vsb, "\nstatic const char *srcbody[%u] = {\n", tl->nsources);
376 2691
        VTAILQ_FOREACH(sp, &tl->sources, list) {
377 2691
                VSB_cat(vsb, "    /* ");
378 2691
                VSB_quote(vsb, sp->name, -1, VSB_QUOTE_CSTR);
379 2691
                VSB_cat(vsb, " */\n");
380 2691
                VSB_quote_pfx(vsb, "\t", sp->b, sp->e - sp->b, VSB_QUOTE_CSTR);
381 2691
                VSB_cat(vsb, ",\n");
382 2691
        }
383 1329
        VSB_cat(vsb, "};\n\n");
384
385 1329
        VSB_cat(vsb, "/* ---===### Location Counters ###===---*/\n");
386
387 1329
        VSB_printf(vsb, "\n#define VGC_NREFS %u\n\n", tl->cnt + 1);
388
389 1329
        VSB_cat(vsb, "static const struct vpi_ref VGC_ref[VGC_NREFS] = {\n");
390 1329
        lin = 1;
391 1329
        pos = 0;
392 1329
        sp = 0;
393 1329
        p = NULL;
394 1406509
        VTAILQ_FOREACH(t, &tl->tokens, list) {
395 1406509
                if (t->cnt == 0)
396 1288760
                        continue;
397 117749
                assert(t->src != NULL);
398 117749
                if (t->src != sp) {
399 2261
                        lin = 1;
400 2261
                        pos = 0;
401 2261
                        sp = t->src;
402 2261
                        p = sp->b;
403 2261
                }
404 117749
                assert(sp != NULL);
405 117749
                assert(p != NULL);
406 12158719
                for (;p < t->b; p++) {
407 12040970
                        if (*p == '\n') {
408 511398
                                lin++;
409 511398
                                pos = 0;
410 11529572
                        } else if (*p == '\t') {
411 263295
                                pos &= ~7;
412 263295
                                pos += 8;
413 263295
                        } else
414 11266277
                                pos++;
415
416 12040970
                }
417 117749
                VSB_printf(vsb, "  [%3u] = { VPI_REF_MAGIC, %u, %8tu, %4u, %3u, ",
418 117749
                    t->cnt, sp->idx, t->b - sp->b, lin, pos + 1);
419 117749
                if (t->tok == CSRC)
420 7
                        VSB_cat(vsb, " \"C{\"},\n");
421 117742
                else
422 117742
                        VSB_printf(vsb, " \"%.*s\" },\n", PF(t));
423 117749
        }
424 1329
        VSB_cat(vsb, "};\n\n");
425 1329
}
426
427
/*--------------------------------------------------------------------
428
 * Init/Fini/Event
429
 *
430
 * We call DISCARD and COLD events in the opposite order of LOAD and
431
 * WARM.
432
 */
433
434
static void
435
EmitInitFini(struct vcc *tl)
436 1329
{
437 1329
        struct inifin *p, *q = NULL;
438 1329
        unsigned has_event = 0;
439 1329
        struct symbol *sy;
440
441 1329
        Fh(tl, 0, "\n");
442 1329
        Fh(tl, 0, "static unsigned vgc_inistep;\n");
443 1329
        Fh(tl, 0, "static unsigned vgc_warmupstep;\n");
444
445
        /*
446
         * LOAD
447
         */
448 1329
        Fc(tl, 0, "\nstatic int\nVGC_Load(VRT_CTX)\n{\n\n");
449 1329
        Fc(tl, 0, "\tvgc_inistep = 0;\n");
450 1329
        Fc(tl, 0, "\tsize_t ndirector = %dUL;\n", tl->ndirector);
451 1329
        Fc(tl, 0, "\n");
452 12094
        VTAILQ_FOREACH(p, &tl->inifin, list) {
453 12094
                AZ(VSB_finish(p->ini));
454 12094
                assert(p->n > 0);
455 12094
                if (VSB_len(p->ini))
456 11877
                        Fc(tl, 0, "\t/* %u */\n%s\n", p->n, VSB_data(p->ini));
457 12094
                if (p->ignore_errors == 0) {
458 10760
                        Fc(tl, 0, "\tif (ctx->vpi->handling == VCL_RET_FAIL)\n");
459 10760
                        Fc(tl, 0, "\t\treturn(1);\n");
460 10760
                }
461 12094
                Fc(tl, 0, "\tvgc_inistep = %u;\n\n", p->n);
462 12094
                VSB_destroy(&p->ini);
463
464 12094
                AZ(VSB_finish(p->event));
465 12094
                if (VSB_len(p->event))
466 216
                        has_event = 1;
467 12094
        }
468
469
        /* Handle failures from vcl_init */
470 1329
        Fc(tl, 0, "\n");
471 1329
        Fc(tl, 0, "\tif (ctx->vpi->handling != VCL_RET_OK)\n");
472 1329
        Fc(tl, 0, "\t\treturn(1);\n");
473 1329
        Fc(tl, 0, "\tctx->vpi->handling = 0;\n");
474
475 1329
        VTAILQ_FOREACH(sy, &tl->sym_objects, sideways) {
476 190
                Fc(tl, 0, "\tif (!%s) {\n", sy->rname);
477 190
                Fc(tl, 0, "\t\tVRT_fail(ctx, "
478 190
                    "\"Object %s not initialized\");\n" , sy->name);
479 190
                Fc(tl, 0, "\t\treturn(1);\n");
480 190
                Fc(tl, 0, "\t}\n");
481 190
        }
482
483 1329
        Fc(tl, 0, "\treturn(0);\n");
484 1329
        Fc(tl, 0, "}\n");
485
486
        /*
487
         * DISCARD
488
         */
489 1329
        Fc(tl, 0, "\nstatic int\nVGC_Discard(VRT_CTX)\n{\n\n");
490
491 1329
        Fc(tl, 0, "\tswitch (vgc_inistep) {\n");
492 12094
        VTAILQ_FOREACH_REVERSE(p, &tl->inifin, inifinhead, list) {
493 12094
                AZ(VSB_finish(p->fin));
494 12094
                if (q)
495 10765
                        assert(q->n > p->n);
496 12094
                q = p;
497 12094
                Fc(tl, 0, "\t\tcase %u:\n", p->n);
498 12094
                if (VSB_len(p->fin))
499 12087
                        Fc(tl, 0, "\t%s\n", VSB_data(p->fin));
500 12094
                Fc(tl, 0, "\t\t\t/* FALLTHROUGH */\n");
501 12094
                VSB_destroy(&p->fin);
502 12094
        }
503 1329
        Fc(tl, 0, "\t\tdefault:\n\t\t\tbreak;\n");
504 1329
        Fc(tl, 0, "\t}\n\n");
505 1329
        Fc(tl, 0, "\tswitch (vgc_inistep) {\n");
506 12094
        VTAILQ_FOREACH_REVERSE(p, &tl->inifin, inifinhead, list) {
507 12094
                AZ(VSB_finish(p->final));
508 12094
                Fc(tl, 0, "\t\tcase %u:\n", p->n);
509 12094
                if (VSB_len(p->final))
510 553
                        Fc(tl, 0, "\t%s\n", VSB_data(p->final));
511 12094
                Fc(tl, 0, "\t\t\t/* FALLTHROUGH */\n");
512 12094
                VSB_destroy(&p->final);
513 12094
        }
514 1329
        Fc(tl, 0, "\t\tdefault:\n\t\t\tbreak;\n");
515 1329
        Fc(tl, 0, "\t}\n\n");
516
517 1329
        Fc(tl, 0, "\treturn (0);\n");
518 1329
        Fc(tl, 0, "}\n");
519
520 1329
        if (has_event) {
521
                /*
522
                 * WARM
523
                 */
524 204
                Fc(tl, 0, "\nstatic int\n");
525 204
                Fc(tl, 0, "VGC_Warmup(VRT_CTX, enum vcl_event_e ev)\n{\n\n");
526
527 204
                Fc(tl, 0, "\tvgc_warmupstep = 0;\n\n");
528 2285
                VTAILQ_FOREACH(p, &tl->inifin, list) {
529 2285
                        assert(p->n > 0);
530 2285
                        if (VSB_len(p->event)) {
531 216
                                Fc(tl, 0, "\t/* %u */\n", p->n);
532 216
                                Fc(tl, 0, "\tif (%s)\n", VSB_data(p->event));
533 216
                                Fc(tl, 0, "\t\treturn (1);\n");
534 216
                                Fc(tl, 0, "\tvgc_warmupstep = %u;\n\n", p->n);
535 216
                        }
536 2285
                }
537
538 204
                Fc(tl, 0, "\treturn (0);\n");
539 204
                Fc(tl, 0, "}\n");
540
541
                /*
542
                 * COLD
543
                 */
544 204
                Fc(tl, 0, "\nstatic int\n");
545 204
                Fc(tl, 0, "VGC_Cooldown(VRT_CTX, enum vcl_event_e ev)\n{\n");
546 204
                Fc(tl, 0, "\tint retval = 0;\n\n");
547
548 2285
                VTAILQ_FOREACH_REVERSE(p, &tl->inifin, inifinhead, list) {
549 2285
                        if (VSB_len(p->event)) {
550 216
                                Fc(tl, 0, "\t/* %u */\n", p->n);
551 216
                                Fc(tl, 0,
552 216
                                    "\tif (vgc_warmupstep >= %u &&\n", p->n);
553 216
                                Fc(tl, 0,
554 216
                                    "\t    %s != 0)\n", VSB_data(p->event));
555 216
                                Fc(tl, 0, "\t\tretval = 1;\n\n");
556 216
                        }
557 2285
                        VSB_destroy(&p->event);
558 2285
                }
559
560 204
                Fc(tl, 0, "\treturn (retval);\n");
561 204
                Fc(tl, 0, "}\n");
562 204
        }
563
564
        /*
565
         * EVENTS
566
         */
567 1329
        Fc(tl, 0, "\nstatic int\n");
568 1329
        Fc(tl, 0, "VGC_Event(VRT_CTX, enum vcl_event_e ev)\n");
569 1329
        Fc(tl, 0, "{\n");
570 1329
        Fc(tl, 0, "\tif (ev == VCL_EVENT_LOAD)\n");
571 1329
        Fc(tl, 0, "\t\treturn (VGC_Load(ctx));\n");
572 1329
        if (has_event) {
573 204
                Fc(tl, 0, "\tif (ev == VCL_EVENT_WARM)\n");
574 204
                Fc(tl, 0, "\t\treturn (VGC_Warmup(ctx, ev));\n");
575 204
                Fc(tl, 0, "\tif (ev == VCL_EVENT_COLD)\n");
576 204
                Fc(tl, 0, "\t\treturn (VGC_Cooldown(ctx, ev));\n");
577 204
        }
578 1329
        Fc(tl, 0, "\tif (ev == VCL_EVENT_DISCARD)\n");
579 1329
        Fc(tl, 0, "\t\treturn (VGC_Discard(ctx));\n");
580 1329
        Fc(tl, 0, "\tassert(ev != VDI_EVENT_SICK);\n");
581 1329
        Fc(tl, 0, "\n");
582 1329
        if (!has_event)
583 1125
                Fc(tl, 0, "\t(void)vgc_warmupstep;\n");
584 1329
        VCC_WalkSymbols(tl, vcc_refUnusedProbes, SYM_MAIN, SYM_PROBE);
585 1329
        Fc(tl, 0, "\treturn (%d);\n", has_event ? 1 : 0);
586 1329
        Fc(tl, 0, "}\n");
587 1329
}
588
589
/*--------------------------------------------------------------------*/
590
591
static void
592
EmitStruct(const struct vcc *tl)
593 1329
{
594 1329
        Fc(tl, 0, "\nconst struct VCL_conf VCL_conf = {\n");
595 1329
        Fc(tl, 0, "\t.magic = VCL_CONF_MAGIC,\n");
596 1329
        Fc(tl, 0, "\t.syntax = %u,\n", tl->syntax);
597 1329
        Fc(tl, 0, "\t.event_vcl = VGC_Event,\n");
598 1329
        Fc(tl, 0, "\t.default_director = &%s,\n", tl->default_director);
599 1329
        if (tl->default_probe != NULL)
600 10
                Fc(tl, 0, "\t.default_probe = %s,\n", tl->default_probe);
601 1329
        Fc(tl, 0, "\t.ref = VGC_ref,\n");
602 1329
        Fc(tl, 0, "\t.nref = VGC_NREFS,\n");
603 1329
        Fc(tl, 0, "\t.nsrc = VGC_NSRCS,\n");
604 1329
        Fc(tl, 0, "\t.nsub = %d,\n", tl->subref > 0 ? tl->nsub : 0);
605 1329
        Fc(tl, 0, "\t.srcname = srcname,\n");
606 1329
        Fc(tl, 0, "\t.srcbody = srcbody,\n");
607 1329
        Fc(tl, 0, "\t.nvmod = %u,\n", tl->vmod_count);
608 1329
#define VCL_MET_MAC(l,u,t,b) \
609 19935
        Fc(tl, 0, "\t." #l "_func = VGC_function_vcl_" #l ",\n");
610 1329
#include "tbl/vcl_returns.h"
611 1329
        Fc(tl, 0, "\t.instance_info = VGC_instance_info\n");
612 1329
        Fc(tl, 0, "};\n");
613 1329
}
614
615
/*--------------------------------------------------------------------
616
 * Compile the VCL code from the given source and return the C-source
617
 */
618
619
static struct vsb *
620
vcc_CompileSource(struct vcc *tl, struct source *sp, const char *jfile)
621 3283
{
622 3283
        struct proc *p;
623 3283
        struct vsb *vsb;
624 3283
        struct inifin *ifp;
625
626 3283
        Fh(tl, 0, "/* ---===### VCC generated .h code ###===---*/\n");
627 3283
        Fc(tl, 0, "\n/* ---===### VCC generated .c code ###===---*/\n");
628
629 3283
        Fc(tl, 0, "\n#define END_ if (ctx->vpi->handling) return\n");
630
631 3283
        vcc_Parse_Init(tl);
632
633 3283
        vcc_Expr_Init(tl);
634
635 3283
        vcc_Action_Init(tl);
636
637 3283
        vcc_Backend_Init(tl);
638
639 3283
        vcc_Var_Init(tl);
640
641 3283
        vcc_Type_Init(tl);
642
643 3283
        Fh(tl, 0, "\nextern const struct VCL_conf VCL_conf;\n");
644
645
        /* Register and lex the main source */
646 3283
        if (sp != NULL) {
647 1641
                AN(vcc_builtin);
648 1641
                vcc_lex_source(tl, sp, 0);
649 1641
                if (tl->err)
650 38
                        return (NULL);
651 1641
        }
652
653
        /* Register and lex the builtin VCL */
654 3245
        sp = vcc_new_source(tl->builtin_vcl, "builtin", "<builtin>");
655 3245
        assert(sp != NULL);
656 3245
        vcc_lex_source(tl, sp, 1);
657 3245
        if (tl->err)
658 0
                return (NULL);
659
660
        /* Parse the token string */
661 3245
        tl->t = VTAILQ_FIRST(&tl->tokens);
662 3245
        vcc_Parse(tl);
663 3245
        if (tl->err)
664 216
                return (NULL);
665
666
        /* Check for orphans */
667 3029
        if (vcc_CheckReferences(tl))
668 11
                return (NULL);
669
670
        /* Check that all action returns are legal */
671 3018
        if (vcc_CheckAction(tl) || tl->err)
672 3
                return (NULL);
673
674
        /* Check that all variable uses are legal */
675 3015
        if (vcc_CheckUses(tl) || tl->err)
676 42
                return (NULL);
677
678 2973
        if (vcc_builtin == NULL)
679 1642
                return (NULL);
680
681
        /* Check if we have any backends at all */
682 1331
        if (tl->default_director == NULL) {
683 2
                VSB_cat(tl->sb,
684 2
                    "No backends or directors found in VCL program, "
685 2
                    "at least one is necessary.\n");
686 2
                tl->err = 1;
687 2
                return (NULL);
688 2
        }
689
690
        /* Tie vcl_init/fini in */
691 1329
        ifp = New_IniFin(tl);
692 1329
        VSB_cat(ifp->ini, "\tVGC_function_vcl_init(ctx, VSUB_STATIC, NULL);\n");
693
        /*
694
         * Because the failure could be half way into vcl_init{} so vcl_fini{}
695
         * must always be called, also on failure.
696
         */
697 1329
        ifp->ignore_errors = 1;
698 1329
        VSB_cat(ifp->fin, "\t\tVGC_function_vcl_fini(ctx, VSUB_STATIC, NULL);\n");
699 1329
        VSB_cat(ifp->fin, "\t\t\tVPI_vcl_fini(ctx);");
700
701
        /* Emit method functions */
702 1329
        Fh(tl, 1, "\n");
703 1329
        VTAILQ_FOREACH(p, &tl->procs, list)
704 58549
                if (p->method == NULL)
705 38614
                        vcc_EmitProc(tl, p);
706 1329
        VTAILQ_FOREACH(p, &tl->procs, list)
707 58549
                if (p->method != NULL)
708 19935
                        vcc_EmitProc(tl, p);
709
710 1329
        EmitInitFini(tl);
711
712 1329
        VCC_InstanceInfo(tl);
713
714 1329
        EmitStruct(tl);
715
716 1329
        VCC_XrefTable(tl);
717
718 1329
        VSB_cat(tl->symtab, "\n]\n");
719 1329
        AZ(VSB_finish(tl->symtab));
720 1329
        if (TLWriteVSB(tl, jfile, tl->symtab, "Symbol table"))
721 0
                return (NULL);
722
723
        /* Combine it all */
724
725 1329
        vsb = VSB_new_auto();
726 1329
        AN(vsb);
727
728 1329
        vcl_output_lang_h(vsb);
729
730 1329
        EmitCoordinates(tl, vsb);
731
732 1329
        AZ(VSB_finish(tl->fh));
733 1329
        VSB_cat(vsb, VSB_data(tl->fh));
734
735 1329
        AZ(VSB_finish(tl->fc));
736 1329
        VSB_cat(vsb, VSB_data(tl->fc));
737
738 1329
        AZ(VSB_finish(vsb));
739 1329
        return (vsb);
740 1329
}
741
742
static struct vcc *
743
vcc_ParseBuiltin(struct vcc *tl)
744 1642
{
745 1642
        struct vcc *tl_builtin;
746
747 1642
        CHECK_OBJ_NOTNULL(tl, VCC_MAGIC);
748 1642
        tl_builtin = VCC_New();
749 1642
        AN(tl_builtin);
750 1642
        VCC_Builtin_VCL(tl_builtin, tl->builtin_vcl);
751 1642
        AZ(vcc_CompileSource(tl_builtin, NULL, NULL));
752 1642
        return (tl_builtin);
753 1642
}
754
755
/*--------------------------------------------------------------------
756
 * Report the range of VCL language we support
757
 */
758
void
759
VCC_VCL_Range(unsigned *lo, unsigned *hi)
760 1121
{
761
762 1121
        AN(lo);
763 1121
        *lo = VCL_LOW;
764 1121
        AN(hi);
765 1121
        *hi = VCL_HIGH;
766 1121
}
767
768
/*--------------------------------------------------------------------
769
 * Compile the VCL code in the argument.  Error messages, if any are
770
 * formatted into the vsb.
771
 */
772
773
int
774
VCC_Compile(struct vcc *tl, struct vsb **sb,
775
    const char *vclsrc, const char *vclsrcfile,
776
    const char *ofile, const char *jfile)
777 1642
{
778 1642
        struct source *sp;
779 1642
        struct vsb *r = NULL;
780 1642
        int retval = 0;
781
782 1642
        CHECK_OBJ_NOTNULL(tl, VCC_MAGIC);
783 1642
        AN(sb);
784 1642
        AN(vclsrcfile);
785 1642
        AN(ofile);
786 1642
        AN(jfile);
787
788 1642
        AZ(vcc_builtin);
789 1642
        vcc_builtin = vcc_ParseBuiltin(tl);
790 1642
        AN(vcc_builtin);
791 1642
        if (vcc_builtin->err) {
792 0
                AZ(VSB_finish(vcc_builtin->sb));
793 0
                *sb = vcc_builtin->sb;
794 0
                return (-1);
795 0
        }
796
797 1642
        if (vclsrc != NULL)
798 1627
                sp = vcc_new_source(vclsrc, "vcl.inline", vclsrcfile);
799 15
        else
800 15
                sp = vcc_file_source(tl, vclsrcfile);
801
802 1642
        if (sp != NULL)
803 1641
                r = vcc_CompileSource(tl, sp, jfile);
804
805 1642
        if (r != NULL) {
806 1329
                retval = TLWriteVSB(tl, ofile, r, "C-source");
807 1329
                VSB_destroy(&r);
808 1329
        } else {
809 313
                retval = -1;
810 313
        }
811 1642
        AZ(VSB_finish(tl->sb));
812 1642
        *sb = tl->sb;
813 1642
        return (retval);
814 1642
}
815
816
/*--------------------------------------------------------------------
817
 * Allocate a compiler instance
818
 */
819
820
struct vcc *
821
VCC_New(void)
822 3284
{
823 3284
        struct vcc *tl;
824 3284
        struct symbol *sym;
825 3284
        struct proc *p;
826 3284
        struct vsb *vsb;
827 3284
        int i;
828
829 3284
        ALLOC_OBJ(tl, VCC_MAGIC);
830 3284
        AN(tl);
831 3284
        VTAILQ_INIT(&tl->inifin);
832 3284
        VTAILQ_INIT(&tl->tokens);
833 3284
        VTAILQ_INIT(&tl->sources);
834 3284
        VTAILQ_INIT(&tl->procs);
835 3284
        VTAILQ_INIT(&tl->sym_objects);
836 3284
        VTAILQ_INIT(&tl->sym_vmods);
837 3284
        VTAILQ_INIT(&tl->vmod_objects);
838
839 3284
        tl->nsources = 0;
840
841 3284
        tl->symtab = VSB_new_auto();
842 3284
        assert(tl->symtab != NULL);
843 3284
        VSB_cat(tl->symtab, "[\n    {\"version\": 0}");
844
845 3284
        tl->fc = VSB_new_auto();
846 3284
        assert(tl->fc != NULL);
847
848 3284
        tl->fh = VSB_new_auto();
849 3284
        assert(tl->fh != NULL);
850
851 52544
        for (i = 1; i < VCL_MET_MAX; i++) {
852 49260
                sym = VCC_MkSym(tl, method_tab[i].name,
853 49260
                    SYM_MAIN, SYM_SUB, VCL_LOW, VCL_HIGH);
854 49260
                p = vcc_NewProc(tl, sym);
855 49260
                p->method = &method_tab[i];
856
857
                // see also VCC_GlobalSymbol()
858 49260
                vsb = VSB_new_auto();
859 49260
                AN(vsb);
860 49260
                VSB_printf(vsb, "%s_%s", SUB->global_pfx, p->method->name);
861 49260
                AZ(VSB_finish(vsb));
862
863 49260
                AZ(VSB_bcat(p->cname, VSB_data(vsb), VSB_len(vsb)));
864
865 49260
                sym->lname = strdup(VSB_data(vsb));
866 49260
                AN(sym->lname);
867
868 49260
                VSB_clear(vsb);
869 49260
                VSB_printf(vsb, "sub_%s", sym->lname);
870 49260
                AZ(VSB_finish(vsb));
871
872 49260
                sym->rname = strdup(VSB_data(vsb));
873 49260
                AN(sym->rname);
874 49260
                VSB_destroy(&vsb);
875
876 49260
                sym->type = SUB;
877 49260
                sym->kind = VCC_HandleKind(SUB);
878 49260
                AZ(VCT_invalid_name(sym->rname, NULL));
879 49260
                sym->eval = vcc_Eval_Sub;
880 49260
        }
881 3284
        tl->sb = VSB_new_auto();
882 3284
        AN(tl->sb);
883 3284
        return (tl);
884 3284
}
885
886
/*--------------------------------------------------------------------
887
 * Configure builtin VCL source code
888
 */
889
890
void
891
VCC_Builtin_VCL(struct vcc *vcc, const char *str)
892 3284
{
893
894 3284
        CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
895 3284
        REPLACE(vcc->builtin_vcl, str);
896 3284
}
897
898
/*--------------------------------------------------------------------
899
 * Configure default VCL source path
900
 */
901
902
void
903
VCC_VCL_path(struct vcc *vcc, const char *str)
904 1642
{
905
906 1642
        CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
907 1642
        VFIL_setpath(&vcc->vcl_path, str);
908 1642
}
909
910
/*--------------------------------------------------------------------
911
 * Configure default VMOD path
912
 */
913
914
void
915
VCC_VMOD_path(struct vcc *vcc, const char *str)
916 1642
{
917
918 1642
        CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
919 1642
        VFIL_setpath(&vcc->vmod_path, str);
920 1642
}
921
922
/*--------------------------------------------------------------------
923
 * Configure settings
924
 */
925
926
#define VCC_FEATURE_BIT(U, l, d)                                \
927
        void VCC_Opt_ ## l(struct vcc *vcc, unsigned val)       \
928 4926
        {                                                       \
929 4926
                CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);              \
930 4926
                vcc->l = val;                                   \
931 4926
        }
932
#include "tbl/vcc_feature_bits.h"
933
934
/*--------------------------------------------------------------------
935
 * Configure settings
936
 */
937
938
static void
939
vcc_predef_vcl(struct vcc *vcc, const char *name)
940 42
{
941 42
        struct symbol *sym;
942
943 42
        sym = VCC_MkSym(vcc, name, SYM_MAIN, SYM_VCL, VCL_LOW, VCL_HIGH);
944 42
        AN(sym);
945 42
        sym->type = VCL;
946 42
        sym->r_methods = VCL_MET_RECV;
947 42
}
948
949
void
950
VCC_Predef(struct vcc *vcc, const char *type, const char *name)
951 4972
{
952
953 4972
        CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
954 4972
        if (!vstrcmp(type, "VCL_STEVEDORE"))
955 4930
                vcc_stevedore(vcc, name);
956 42
        else if (!vstrcmp(type, "VCL_VCL"))
957 42
                vcc_predef_vcl(vcc, name);
958 0
        else
959 0
                WRONG("Unknown VCC predef type");
960 4972
}
961
962
void
963
VCC_VEXT(struct vcc *vcc, const char *filename)
964 2
{
965 2
        CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
966 2
        vcc_ImportVext(vcc, filename);
967 2
}