Line data Source code
1 : /*
2 : * SPDX-License-Identifier: MPL-2.0
3 : *
4 : * This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 : *
8 : * Copyright 2024, 2025 MonetDB Foundation;
9 : * Copyright August 2008 - 2023 MonetDB B.V.;
10 : * Copyright 1997 - July 2008 CWI.
11 : */
12 :
13 : /*
14 : * (author) Author M. Kersten
15 : * For documentation see website
16 : */
17 : #include "monetdb_config.h"
18 : #include "mal_instruction.h"
19 : #include "mal_function.h" /* for getPC() */
20 : #include "mal_utils.h"
21 : #include "mal_exception.h"
22 : #include "mal_private.h"
23 :
24 : /* to avoid memory fragmentation stmt and var blocks are allocated in chunks */
25 : #define MALCHUNK 256
26 :
27 : /* If we encounter an error it can be left behind in the MalBlk
28 : * for the upper layers to abandon the track
29 : */
30 : void
31 0 : addMalException(MalBlkPtr mb, str msg)
32 : {
33 0 : if (msg == NULL)
34 : return;
35 0 : if (mb->errors) {
36 0 : mb->errors = concatErrors(mb->errors, msg);
37 : } else {
38 0 : mb->errors = dupError(msg);
39 : }
40 : }
41 :
42 : Symbol
43 3688147 : newSymbol(const char *nme, int kind)
44 : {
45 3688147 : Symbol cur;
46 :
47 3688147 : assert(kind == COMMANDsymbol || kind == PATTERNsymbol || kind == FUNCTIONsymbol);
48 3688147 : if (nme == NULL)
49 : return NULL;
50 3688147 : cur = (Symbol) GDKmalloc(sizeof(SymRecord));
51 3688146 : if (cur == NULL)
52 : return NULL;
53 7376293 : *cur = (SymRecord) {
54 3688146 : .name = putName(nme),
55 : .kind = kind,
56 : };
57 3688147 : if (cur->name == NULL) {
58 0 : GDKfree(cur);
59 0 : return NULL;
60 : }
61 3688147 : if (kind == FUNCTIONsymbol) {
62 50599 : cur->def = newMalBlk(STMT_INCREMENT);
63 50599 : if (cur->def == NULL) {
64 0 : GDKfree(cur);
65 0 : return NULL;
66 : }
67 : }
68 : return cur;
69 : }
70 :
71 : void
72 3668161 : freeSymbol(Symbol s)
73 : {
74 3668161 : if (s == NULL)
75 : return;
76 3668161 : if (s->def) {
77 50598 : freeMalBlk(s->def);
78 50598 : s->def = NULL;
79 3617563 : } else if (s->allocated && s->func) {
80 1772537 : GDKfree((char*)s->func->comment);
81 1772537 : GDKfree((char*)s->func->cname);
82 1772537 : GDKfree(s->func->args);
83 1772537 : GDKfree(s->func);
84 : }
85 3668161 : GDKfree(s);
86 : }
87 :
88 : void
89 205691 : freeSymbolList(Symbol s)
90 : {
91 205691 : Symbol t = s;
92 :
93 3873329 : while (s) {
94 3667638 : t = s->peer;
95 3667638 : s->peer = NULL;
96 3667638 : freeSymbol(s);
97 3667638 : s = t;
98 : }
99 205691 : }
100 :
101 : int
102 4388947 : newMalBlkStmt(MalBlkPtr mb, int maxstmts)
103 : {
104 4388947 : InstrPtr *p;
105 4388947 : maxstmts = maxstmts % MALCHUNK == 0 ? maxstmts : ((maxstmts / MALCHUNK) + 1) * MALCHUNK;
106 :
107 4388947 : p = (InstrPtr *) GDKzalloc(sizeof(InstrPtr) * maxstmts);
108 4390288 : if (p == NULL)
109 : return -1;
110 4390288 : mb->stmt = p;
111 4390288 : mb->stop = 0;
112 4390288 : mb->ssize = maxstmts;
113 4390288 : return 0;
114 : }
115 :
116 : MalBlkPtr
117 63597 : newMalBlk(int elements)
118 : {
119 63597 : MalBlkPtr mb;
120 63597 : VarRecord *v;
121 :
122 63597 : mb = (MalBlkPtr) GDKmalloc(sizeof(MalBlkRecord));
123 63601 : if (mb == NULL)
124 : return NULL;
125 :
126 : /* each MAL instruction implies at least one variable
127 : * we reserve some extra for constants */
128 63601 : assert(elements >= 0);
129 63601 : elements += 8;
130 63601 : if (elements % MALCHUNK != 0)
131 63601 : elements = (elements / MALCHUNK + 1) * MALCHUNK;
132 63601 : v = (VarRecord *) GDKzalloc(sizeof(VarRecord) * elements);
133 63602 : if (v == NULL) {
134 0 : GDKfree(mb);
135 0 : return NULL;
136 : }
137 63602 : *mb = (MalBlkRecord) {
138 : .var = v,
139 : .vsize = elements,
140 : .maxarg = MAXARG, /* the minimum for each instruction */
141 : .workers = ATOMIC_VAR_INIT(1),
142 : };
143 63602 : if (newMalBlkStmt(mb, elements) < 0) {
144 0 : GDKfree(mb->var);
145 0 : GDKfree(mb);
146 0 : return NULL;
147 : }
148 : return mb;
149 : }
150 :
151 : int
152 81085 : resizeMalBlk(MalBlkPtr mb, int elements)
153 : {
154 81085 : int i;
155 81085 : assert(elements >= 0);
156 81085 : if (elements % MALCHUNK != 0)
157 10520 : elements = (elements / MALCHUNK + 1) * MALCHUNK;
158 :
159 81085 : if (elements > mb->ssize) {
160 70564 : InstrPtr *ostmt = mb->stmt;
161 70564 : mb->stmt = GDKrealloc(mb->stmt, elements * sizeof(InstrPtr));
162 70564 : if (mb->stmt) {
163 18017615 : for (i = mb->ssize; i < elements; i++)
164 17947051 : mb->stmt[i] = 0;
165 70564 : mb->ssize = elements;
166 : } else {
167 0 : mb->stmt = ostmt; /* reinstate old pointer */
168 0 : mb->errors = createMalException(mb, 0, TYPE,
169 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
170 0 : return -1;
171 : }
172 : }
173 : return 0;
174 : }
175 :
176 : /* For a MAL session we have to keep the variables around
177 : * and only need to reset the instruction pointer
178 : */
179 : void
180 630406 : resetMalTypes(MalBlkPtr mb, int stop)
181 : {
182 630406 : int i;
183 :
184 30300343 : for (i = 0; i < stop; i++)
185 29669937 : mb->stmt[i]->typeresolved = false;
186 630406 : mb->stop = stop;
187 630406 : mb->errors = NULL;
188 630406 : }
189 :
190 : /* For SQL operations we have to cleanup variables and trim the space
191 : * A portion is retained for the next query */
192 : void
193 615792 : resetMalBlk(MalBlkPtr mb)
194 : {
195 615792 : int i;
196 615792 : InstrPtr *new;
197 615792 : VarRecord *vnew;
198 :
199 166840484 : for (i = 1/*MALCHUNK*/; i < mb->ssize; i++) {
200 166224663 : freeInstruction(mb->stmt[i]);
201 166224692 : mb->stmt[i] = NULL;
202 : }
203 615821 : if (mb->ssize != MALCHUNK) {
204 19310 : new = GDKrealloc(mb->stmt, sizeof(InstrPtr) * MALCHUNK);
205 19310 : if (new == NULL) {
206 : /* the only place to return an error signal at this stage. */
207 : /* The Client context should be passed around more deeply */
208 0 : mb->errors = createMalException(mb, 0, TYPE,
209 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
210 0 : return;
211 : }
212 19310 : mb->stmt = new;
213 19310 : mb->ssize = MALCHUNK;
214 : }
215 : /* Reuse the initial function statement */
216 615821 : mb->stop = 1;
217 :
218 69772295 : for (i = 0; i < mb->vtop; i++) {
219 69156505 : if (mb->var[i].name)
220 361243 : GDKfree(mb->var[i].name);
221 69156322 : mb->var[i].name = NULL;
222 69156322 : if (isVarConstant(mb, i))
223 19614385 : VALclear(&getVarConstant(mb, i));
224 : }
225 :
226 615790 : if (mb->vsize != MALCHUNK) {
227 27477 : vnew = GDKrealloc(mb->var, sizeof(VarRecord) * MALCHUNK);
228 27477 : if (vnew == NULL) {
229 : /* the only place to return an error signal at this stage. */
230 : /* The Client context should be passed around more deeply */
231 0 : mb->errors = createMalException(mb, 0, TYPE,
232 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
233 0 : return;
234 : }
235 27477 : mb->var = vnew;
236 27477 : mb->vsize = MALCHUNK;
237 : }
238 615790 : mb->vtop = 0;
239 : }
240 :
241 :
242 : /* The freeMalBlk code is quite defensive. It is used to localize an
243 : * illegal reuse of a MAL blk. */
244 : void
245 63831 : freeMalBlk(MalBlkPtr mb)
246 : {
247 63831 : int i;
248 :
249 16502731 : for (i = 0; i < mb->ssize; i++)
250 16438890 : if (mb->stmt[i]) {
251 179100 : freeInstruction(mb->stmt[i]);
252 179110 : mb->stmt[i] = NULL;
253 : }
254 63841 : mb->stop = 0;
255 353169 : for (i = 0; i < mb->vtop; i++) {
256 289327 : if (mb->var[i].name)
257 10244 : GDKfree(mb->var[i].name);
258 289328 : mb->var[i].name = NULL;
259 289328 : if (isVarConstant(mb, i))
260 62049 : VALclear(&getVarConstant(mb, i));
261 : }
262 63842 : mb->vtop = 0;
263 63842 : GDKfree(mb->stmt);
264 63843 : mb->stmt = 0;
265 63843 : GDKfree(mb->var);
266 63842 : mb->var = 0;
267 :
268 63842 : mb->binding[0] = 0;
269 63842 : mb->tag = 0;
270 63842 : mb->memory = 0;
271 63842 : if (mb->help)
272 0 : GDKfree(mb->help);
273 63842 : mb->help = 0;
274 63842 : mb->inlineProp = 0;
275 63842 : mb->unsafeProp = 0;
276 63842 : freeException(mb->errors);
277 63838 : GDKfree(mb);
278 63843 : }
279 :
280 : /* The routine below should assure that all referenced structures are
281 : * private. The copying is memory conservative. */
282 : MalBlkPtr
283 241 : copyMalBlk(MalBlkPtr old)
284 : {
285 241 : MalBlkPtr mb;
286 241 : int i;
287 :
288 241 : mb = (MalBlkPtr) GDKzalloc(sizeof(MalBlkRecord));
289 241 : if (mb == NULL)
290 : return NULL;
291 :
292 241 : mb->var = (VarRecord *) GDKzalloc(sizeof(VarRecord) * old->vsize);
293 241 : if (mb->var == NULL) {
294 0 : GDKfree(mb);
295 0 : return NULL;
296 : }
297 :
298 241 : mb->vsize = old->vsize;
299 :
300 : /* copy all variable records */
301 12288 : for (i = 0; i < old->vtop; i++) {
302 12047 : mb->var[i] = old->var[i];
303 12047 : if (mb->var[i].name) {
304 639 : mb->var[i].name = GDKstrdup(mb->var[i].name);
305 639 : if (!mb->var[i].name)
306 0 : goto bailout;
307 : }
308 12047 : if (VALcopy(&(mb->var[i].value), &(old->var[i].value)) == NULL) {
309 0 : mb->vtop = i;
310 0 : goto bailout;
311 : }
312 : }
313 241 : mb->vtop = old->vtop;
314 :
315 241 : mb->stmt = (InstrPtr *) GDKzalloc(sizeof(InstrPtr) * old->ssize);
316 241 : if (mb->stmt == NULL) {
317 0 : goto bailout;
318 : }
319 :
320 241 : mb->ssize = old->ssize;
321 241 : assert(old->stop < old->ssize);
322 11369 : for (i = 0; i < old->stop; i++) {
323 11128 : mb->stmt[i] = copyInstruction(old->stmt[i]);
324 11128 : if (mb->stmt[i] == NULL) {
325 0 : mb->stop = i;
326 0 : goto bailout;
327 : }
328 : }
329 241 : mb->stop = old->stop;
330 241 : if (old->help && (mb->help = GDKstrdup(old->help)) == NULL) {
331 0 : goto bailout;
332 : }
333 :
334 241 : strcpy_len(mb->binding, old->binding, sizeof(mb->binding));
335 241 : mb->errors = old->errors ? GDKstrdup(old->errors) : 0;
336 241 : mb->tag = old->tag;
337 241 : mb->runtime = old->runtime;
338 241 : mb->calls = old->calls;
339 241 : mb->optimize = old->optimize;
340 241 : mb->maxarg = old->maxarg;
341 241 : mb->inlineProp = old->inlineProp;
342 241 : mb->unsafeProp = old->unsafeProp;
343 241 : return mb;
344 :
345 : bailout:
346 0 : for (i = 0; i < old->stop; i++)
347 0 : freeInstruction(mb->stmt[i]);
348 0 : for (i = 0; i < old->vtop; i++) {
349 0 : if (mb->var[i].name)
350 0 : GDKfree(mb->var[i].name);
351 0 : VALclear(&mb->var[i].value);
352 : }
353 0 : GDKfree(mb->var);
354 0 : GDKfree(mb->stmt);
355 0 : GDKfree(mb);
356 0 : return NULL;
357 : }
358 :
359 : /* The MAL records should be managed from a pool to
360 : * avoid repeated alloc/free and reduce probability of
361 : * memory fragmentation. (todo)
362 : * The complicating factor is their variable size,
363 : * which leads to growing records as a result of pushArguments
364 : * Allocation of an instruction should always succeed.
365 : */
366 : InstrPtr
367 36398178 : newInstructionArgs(MalBlkPtr mb, const char *modnme, const char *fcnnme,
368 : int args)
369 : {
370 36398178 : InstrPtr p;
371 :
372 36398178 : if (mb && mb->errors)
373 : return NULL;
374 36398163 : if (args <= 0)
375 : args = 1;
376 36398163 : p = GDKmalloc(args * sizeof(p->argv[0]) + offsetof(InstrRecord, argv));
377 36403968 : if (p == NULL) {
378 0 : if (mb)
379 0 : mb->errors = createMalException(mb, 0, TYPE,
380 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
381 0 : return NULL;
382 : }
383 36403968 : *p = (InstrRecord) {
384 : .maxarg = args,
385 : .typeresolved = false,
386 : .modname = modnme,
387 : .fcnname = fcnnme,
388 : .argc = 1,
389 : .retc = 1,
390 : /* Flow of control instructions are always marked as an assignment
391 : * with modifier */
392 : .token = ASSIGNsymbol,
393 : };
394 36403968 : memset(p->argv, 0, args * sizeof(p->argv[0]));
395 36403968 : p->argv[0] = -1;
396 36403968 : return p;
397 : }
398 :
399 : InstrPtr
400 4683050 : newInstruction(MalBlkPtr mb, const char *modnme, const char *fcnnme)
401 : {
402 4683050 : return newInstructionArgs(mb, modnme, fcnnme, MAXARG);
403 : }
404 :
405 : InstrPtr
406 25728949 : copyInstructionArgs(const InstrRecord *p, int args)
407 : {
408 25728949 : if (args < p->maxarg)
409 : args = p->maxarg;
410 25728949 : InstrPtr new = (InstrPtr) GDKmalloc(offsetof(InstrRecord, argv) +
411 : args * sizeof(p->argv[0]));
412 25729804 : if (new == NULL)
413 : return new;
414 25729804 : memcpy(new, p,
415 25729804 : offsetof(InstrRecord, argv) + p->maxarg * sizeof(p->argv[0]));
416 25729804 : if (args > p->maxarg)
417 3312183 : memset(new->argv + p->maxarg, 0,
418 3312183 : (args - p->maxarg) * sizeof(new->argv[0]));
419 25729804 : new->typeresolved = false;
420 25729804 : new->maxarg = args;
421 25729804 : return new;
422 : }
423 :
424 : InstrPtr
425 18224271 : copyInstruction(const InstrRecord *p)
426 : {
427 18224271 : return copyInstructionArgs(p, p->maxarg);
428 : }
429 :
430 : void
431 722879 : clrFunction(InstrPtr p)
432 : {
433 722879 : p->token = ASSIGNsymbol;
434 722879 : p->fcn = 0;
435 722879 : p->blk = 0;
436 722879 : p->typeresolved = false;
437 722879 : setModuleId(p, NULL);
438 722924 : setFunctionId(p, NULL);
439 722995 : }
440 :
441 : void
442 0 : clrInstruction(InstrPtr p)
443 : {
444 0 : clrFunction(p);
445 0 : memset(p, 0, offsetof(InstrRecord, argv) + p->maxarg * sizeof(p->argv[0]));
446 0 : }
447 :
448 : void
449 195097288 : freeInstruction(InstrPtr p)
450 : {
451 195097288 : GDKfree(p);
452 194994715 : }
453 :
454 : /* Query optimizers walk their way through a MAL program block. They
455 : * require some primitives to move instructions around and to remove
456 : * superfluous instructions. The removal is based on the assumption
457 : * that indeed the instruction belonged to the block. */
458 : void
459 0 : removeInstruction(MalBlkPtr mb, InstrPtr p)
460 : {
461 0 : int i;
462 0 : for (i = 0; i < mb->stop - 1; i++)
463 0 : if (mb->stmt[i] == p)
464 : break;
465 0 : if (i == mb->stop)
466 : return;
467 0 : for (; i < mb->stop - 1; i++)
468 0 : mb->stmt[i] = mb->stmt[i + 1];
469 0 : mb->stmt[i] = 0;
470 0 : mb->stop--;
471 0 : assert(i == mb->stop); /* move statement after stop */
472 0 : mb->stmt[i] = p;
473 : }
474 :
475 : void
476 0 : removeInstructionBlock(MalBlkPtr mb, int pc, int cnt)
477 : {
478 0 : int i;
479 0 : InstrPtr p;
480 0 : for (i = pc; i < pc + cnt; i++) {
481 0 : p = getInstrPtr(mb, i);
482 0 : freeInstruction(p);
483 0 : mb->stmt[i] = NULL;
484 0 : } for (i = pc; i < mb->stop - cnt; i++)
485 0 : mb->stmt[i] = mb->stmt[i + cnt];
486 0 : mb->stop -= cnt;
487 0 : for (; i < mb->stop; i++)
488 : mb->stmt[i] = 0;
489 0 : }
490 :
491 : void
492 0 : moveInstruction(MalBlkPtr mb, int pc, int target)
493 : {
494 0 : InstrPtr p;
495 0 : int i;
496 0 : p = getInstrPtr(mb, pc);
497 0 : if (pc > target) {
498 0 : for (i = pc; i > target; i--)
499 0 : mb->stmt[i] = mb->stmt[i - 1];
500 0 : mb->stmt[i] = p;
501 : } else {
502 0 : for (i = target; i > pc; i--)
503 0 : mb->stmt[i] = mb->stmt[i - 1];
504 0 : mb->stmt[i] = p;
505 : }
506 0 : }
507 :
508 : /* Beware that the first argument of a signature is reserved for the
509 : * function return type , which should be equal to the destination
510 : * variable type.
511 : */
512 : int
513 680179 : findVariable(MalBlkPtr mb, const char *name)
514 : {
515 680179 : int i;
516 680179 : if (name == NULL)
517 : return -1;
518 5979786 : for (i = mb->vtop - 1; i >= 0; i--)
519 5655352 : if (mb->var[i].name && idcmp(name, mb->var[i].name) == 0)
520 355745 : return i;
521 : return -1;
522 : }
523 :
524 : /* The second version of findVariable assumes you have not yet
525 : * allocated a private structure. This is particularly useful during
526 : * parsing, because most variables are already defined. This way we
527 : * safe GDKmalloc/GDKfree. */
528 : int
529 54920 : findVariableLength(MalBlkPtr mb, const char *name, int len)
530 : {
531 54920 : int i;
532 2636269 : for (i = mb->vtop - 1; i >= 0; i--) {
533 2592644 : const char *s = mb->var[i].name;
534 2592644 : if (s && strncmp(name, s, len) == 0 && s[len] == 0)
535 11295 : return i;
536 : }
537 : return -1;
538 : }
539 :
540 : str
541 174 : getArgDefault(MalBlkPtr mb, InstrPtr p, int idx)
542 : {
543 174 : ValPtr v = &getVarConstant(mb, getArg(p, idx));
544 174 : if (v->vtype == TYPE_str)
545 174 : return v->val.sval;
546 : return NULL;
547 : }
548 :
549 : /* Beware, the symbol table structure assumes that it is relatively
550 : * cheap to perform a linear search to a variable or constant. */
551 : static int
552 69157154 : makeVarSpace(MalBlkPtr mb)
553 : {
554 69157154 : if (mb->vtop >= mb->vsize) {
555 105380 : VarRecord *new;
556 105380 : int s = (mb->vtop / MALCHUNK + 1) * MALCHUNK;
557 105380 : new = (VarRecord *) GDKrealloc(mb->var, s * sizeof(VarRecord));
558 105380 : if (new == NULL) {
559 : /* the only place to return an error signal at this stage. */
560 : /* The Client context should be passed around more deeply */
561 0 : mb->errors = createMalException(mb, 0, TYPE, SQLSTATE(HY013) MAL_MALLOC_FAIL);
562 0 : return -1;
563 : }
564 105380 : memset(new + mb->vsize, 0, (s - mb->vsize) * sizeof(VarRecord));
565 105380 : mb->vsize = s;
566 105380 : mb->var = new;
567 : }
568 : return 0;
569 : }
570 :
571 : /* create and initialize a variable record*/
572 : void
573 69181417 : setVariableType(MalBlkPtr mb, const int n, malType type)
574 : {
575 69181417 : assert(n >= 0 && n < mb->vtop);
576 69181417 : setVarType(mb, n, type);
577 69181417 : setRowCnt(mb, n, 0);
578 69181417 : clrVarFixed(mb, n);
579 69181417 : clrVarUsed(mb, n);
580 69181417 : clrVarInit(mb, n);
581 69181417 : clrVarDisabled(mb, n);
582 69181417 : clrVarConstant(mb, n);
583 69181417 : clrVarCleanup(mb, n);
584 69181417 : }
585 :
586 : char *
587 26090 : getVarNameIntoBuffer(MalBlkPtr mb, int idx, char *buf)
588 : {
589 26090 : char *s = mb->var[idx].name;
590 26090 : if (s == NULL) {
591 25950 : char kind = getVarKind(mb, idx);
592 51904 : (void) snprintf(buf, IDLENGTH, "%c_%d", kind ? kind : REFMARKER, idx);
593 : } else {
594 140 : strcpy_len(buf, s, IDLENGTH);
595 : }
596 26090 : return buf;
597 : }
598 :
599 : int
600 69155217 : newVariable(MalBlkPtr mb, const char *name, size_t len, malType type)
601 : {
602 69155217 : int n;
603 69155217 : int kind = REFMARKER;
604 69155217 : if (mb->errors)
605 : return -1;
606 69155217 : if (len >= IDLENGTH) {
607 1 : mb->errors = createMalException(mb, 0, TYPE, "newVariable: id too long");
608 1 : return -1;
609 : }
610 69155216 : if (makeVarSpace(mb)) { /* no space for a new variable */
611 : return -1;
612 : }
613 69153127 : n = mb->vtop;
614 69153127 : mb->var[n] = (VarRecord) {
615 : .name = NULL,
616 : };
617 69153127 : if (name && len > 0) {
618 370844 : char *nme = GDKmalloc(len+1);
619 370848 : if (!nme) {
620 0 : mb->errors = createMalException(mb, 0, TYPE, SQLSTATE(HY013) MAL_MALLOC_FAIL);
621 0 : return -1;
622 : }
623 370848 : mb->var[n].name = nme;
624 3098197 : for (size_t i = 0; i < len; i++)
625 2727349 : nme[i] = name[i];
626 370848 : nme[len] = 0;
627 370848 : kind = nme[0];
628 : }
629 69153131 : mb->vtop++;
630 69153131 : setVarKind(mb, n, kind);
631 69153131 : setVariableType(mb, n, type);
632 69153131 : return n;
633 : }
634 :
635 : /* Simplified cloning. */
636 : int
637 0 : cloneVariable(MalBlkPtr tm, MalBlkPtr mb, int x)
638 : {
639 0 : int res;
640 0 : if (isVarConstant(mb, x))
641 0 : res = cpyConstant(tm, getVar(mb, x));
642 : else {
643 0 : res = newTmpVariable(tm, getVarType(mb, x));
644 0 : if (mb->var[x].name)
645 0 : tm->var[x].name = GDKstrdup(mb->var[x].name);
646 : }
647 0 : if (res < 0)
648 : return res;
649 0 : if (isVarFixed(mb, x))
650 0 : setVarFixed(tm, res);
651 0 : if (isVarUsed(mb, x))
652 0 : setVarUsed(tm, res);
653 0 : if (isVarInit(mb, x))
654 0 : setVarInit(tm, res);
655 0 : if (isVarDisabled(mb, x))
656 0 : setVarDisabled(tm, res);
657 0 : if (isVarCleanup(mb, x))
658 0 : setVarCleanup(tm, res);
659 0 : getVarSTC(tm, x) = getVarSTC(mb, x);
660 0 : setVarKind(tm, x, getVarKind(mb, x));
661 0 : return res;
662 : }
663 :
664 : int
665 68787595 : newTmpVariable(MalBlkPtr mb, malType type)
666 : {
667 68787595 : return newVariable(mb, 0, 0, type);
668 : }
669 :
670 : int
671 273 : newTypeVariable(MalBlkPtr mb, malType type)
672 : {
673 273 : int n, i;
674 1308 : for (i = 0; i < mb->vtop; i++)
675 1073 : if (isVarTypedef(mb, i) && getVarType(mb, i) == type)
676 : break;
677 273 : if (i < mb->vtop)
678 : return i;
679 235 : n = newTmpVariable(mb, type);
680 235 : if (n >= 0)
681 235 : setVarTypedef(mb, n);
682 : return n;
683 : }
684 :
685 : void
686 72807 : clearVariable(MalBlkPtr mb, int varid)
687 : {
688 72807 : VarPtr v;
689 72807 : v = getVar(mb, varid);
690 72807 : if (isVarConstant(mb, varid) || isVarDisabled(mb, varid))
691 27953 : VALclear(&v->value);
692 72807 : if (v->name)
693 0 : GDKfree(v->name);
694 72807 : v->name = NULL;
695 72807 : v->type = 0;
696 72807 : v->constant = 0;
697 72807 : v->typevar = 0;
698 72807 : v->fixedtype = 0;
699 72807 : v->cleanup = 0;
700 72807 : v->initialized = 0;
701 72807 : v->used = 0;
702 72807 : v->rowcnt = 0;
703 72807 : v->eolife = 0;
704 72807 : v->stc = 0;
705 72807 : }
706 :
707 : void
708 83 : freeVariable(MalBlkPtr mb, int varid)
709 : {
710 83 : clearVariable(mb, varid);
711 83 : }
712 :
713 : /* A special action is to reduce the variable space by removing all
714 : * that do not contribute.
715 : * All temporary variables are renamed in the process to trim the varid.
716 : */
717 : void
718 3 : trimMalVariables_(MalBlkPtr mb, MalStkPtr glb)
719 : {
720 3 : int *alias, cnt = 0, i, j;
721 3 : InstrPtr q;
722 3 : if (mb->vtop == 0)
723 : return;
724 3 : alias = (int *) GDKzalloc(mb->vtop * sizeof(int));
725 3 : if (alias == NULL)
726 : return; /* forget it if we run out of memory *//* build the alias table */
727 680 : for (i = 0; i < mb->vtop; i++) {
728 677 : if (isVarUsed(mb, i) == 0) {
729 83 : if (glb && i < glb->stktop && isVarConstant(mb, i))
730 0 : VALclear(&glb->stk[i]);
731 83 : freeVariable(mb, i);
732 83 : continue;
733 : }
734 594 : if (i > cnt) { /* remap temporary variables */
735 534 : VarRecord t = mb->var[cnt];
736 534 : mb->var[cnt] = mb->var[i];
737 534 : mb->var[i] = t;
738 : } /* valgrind finds a leak when we move these variable record * pointers around. */
739 594 : alias[i] = cnt;
740 594 : if (glb && i < glb->stktop && i != cnt) {
741 0 : glb->stk[cnt] = glb->stk[i];
742 0 : VALempty(&glb->stk[i]);
743 : }
744 594 : cnt++;
745 : } /* remap all variable references to their new position. */
746 3 : if (cnt < mb->vtop) {
747 385 : for (i = 0; i < mb->stop; i++) {
748 382 : q = getInstrPtr(mb, i);
749 2272 : for (j = 0; j < q->argc; j++) {
750 1890 : getArg(q, j) = alias[getArg(q, j)];
751 : }
752 : }
753 3 : mb->vtop = cnt;
754 : }
755 3 : GDKfree(alias);
756 : }
757 :
758 : void
759 3 : trimMalVariables(MalBlkPtr mb, MalStkPtr stk)
760 : {
761 3 : int i, j;
762 3 : InstrPtr q; /* reset the use bit for all non-signature arguments */
763 680 : for (i = 0; i < mb->vtop; i++)
764 677 : clrVarUsed(mb, i); /* build the use table */
765 385 : for (i = 0; i < mb->stop; i++) {
766 382 : q = getInstrPtr(mb, i);
767 2272 : for (j = 0; j < q->argc; j++)
768 1890 : setVarUsed(mb, getArg(q, j));
769 : }
770 3 : trimMalVariables_(mb, stk);
771 3 : }
772 :
773 : /* MAL constants
774 : * Constants are stored in the symbol table and referenced by a
775 : * variable identifier. This means that per MAL instruction, we may
776 : * end up with MAXARG entries in the symbol table. This may lead to
777 : * long searches for variables. An optimization strategy deployed in
778 : * the current implementation is to look around for a similar
779 : * (constant) definition and to reuse its identifier. This avoids an
780 : * exploding symbol table with a lot of temporary variables (as in
781 : * tst400cHuge)
782 : *
783 : * But then the question becomes how far to search? Searching through
784 : * all variables is only useful when the list remains short or when
785 : * the constant-variable-name is easily derivable from its literal
786 : * value and a hash-based index leads you quickly to it.
787 : *
788 : * For the time being, we use a MAL system parameter, MAL_VAR_WINDOW,
789 : * to indicate the number of symbol table entries to consider. Setting
790 : * it to >= MAXARG will at least capture repeated use of a constant
791 : * within a single function call or repeated use within a small block
792 : * of code.
793 : *
794 : * The final step is to prepare a GDK value record, from which the
795 : * internal representation can be obtained during MAL interpretation.
796 : *
797 : * The constant values are linked together to improve searching
798 : * them. This start of the constant list is kept in the MalBlk.
799 : *
800 : * Conversion of a constant to another type is limited to well-known
801 : * coercion rules. Errors are reported and the nil value is set. */
802 :
803 : /* Converts the constant in vr to the MAL type type. Conversion is
804 : * done in the vr struct. */
805 : str
806 281740 : convertConstant(int type, ValPtr vr)
807 : {
808 281740 : if (type > GDKatomcnt)
809 0 : throw(SYNTAX, "convertConstant", "type index out of bound");
810 281740 : if (vr->vtype == type)
811 : return MAL_SUCCEED;
812 281724 : if (isaBatType(type)) { /* BAT variables can only be set to nil */
813 0 : if (vr->vtype != TYPE_void)
814 0 : throw(SYNTAX, "convertConstant", "BAT conversion error");
815 0 : VALclear(vr);
816 0 : vr->vtype = getBatType(type);
817 0 : vr->bat = true;
818 0 : vr->val.bval = bat_nil;
819 0 : return MAL_SUCCEED;
820 : }
821 281724 : if (type == TYPE_ptr) { /* all coercions should be avoided to protect against memory probing */
822 32 : if (vr->vtype == TYPE_void) {
823 32 : VALclear(vr);
824 32 : vr->vtype = type;
825 32 : vr->val.pval = NULL;
826 32 : return MAL_SUCCEED;
827 : }
828 0 : if (vr->vtype != type)
829 0 : throw(SYNTAX, "convertConstant", "pointer conversion error");
830 : return MAL_SUCCEED;
831 : }
832 281692 : if (type == TYPE_any) {
833 : #ifndef DEBUG_MAL_INSTR
834 : assert(0);
835 : #endif
836 0 : throw(SYNTAX, "convertConstant", "missing type");
837 : }
838 281692 : if (VALconvert(type, vr) == NULL) {
839 3 : if (vr->vtype == TYPE_str)
840 0 : throw(SYNTAX, "convertConstant", "parse error in '%s'", vr->val.sval);
841 3 : throw(SYNTAX, "convertConstant", "coercion failed");
842 : }
843 : return MAL_SUCCEED;
844 : }
845 :
846 : int
847 55649700 : fndConstant(MalBlkPtr mb, const ValRecord *cst, int depth)
848 : {
849 55649700 : int i, k;
850 55649700 : const void *p; /* pointers never match */
851 55649700 : if (ATOMstorage(cst->vtype) == TYPE_ptr)
852 : return -1;
853 55489128 : p = VALptr(cst);
854 55489128 : k = mb->vtop - depth;
855 55489128 : if (k < 0)
856 : k = 0;
857 626943804 : for (i = k; i < mb->vtop - 1; i++) {
858 605828885 : VarPtr v = getVar(mb, i);
859 605828885 : if (v->constant) {
860 213066568 : if (v && v->type == cst->vtype &&
861 123581526 : v->value.len == cst->len &&
862 205744523 : isaBatType(v->type) == cst->bat &&
863 102880747 : ATOMcmp(cst->vtype, VALptr(&v->value), p) == 0)
864 34362998 : return i;
865 : }
866 : }
867 : return -1;
868 : }
869 :
870 : int
871 3388 : cpyConstant(MalBlkPtr mb, VarPtr vr)
872 : {
873 3388 : int i;
874 3388 : ValRecord cst;
875 3388 : if (VALcopy(&cst, &vr->value) == NULL)
876 : return -1;
877 3388 : i = defConstant(mb, vr->type, &cst);
878 3388 : if (i < 0)
879 : return -1;
880 : return i;
881 : }
882 :
883 : int
884 50281598 : defConstant(MalBlkPtr mb, int type, ValPtr cst)
885 : {
886 50281598 : int k;
887 50281598 : str msg;
888 :
889 50281598 : assert(!isaBatType(type) || cst->bat);
890 50281598 : cst->bat = false;
891 50281598 : if (isaBatType(type)) {
892 512837 : if (cst->vtype == TYPE_void) {
893 512836 : cst->vtype = getBatType(type);
894 512836 : cst->bat = true;
895 512836 : cst->val.bval = bat_nil;
896 : } else {
897 1 : mb->errors = createMalException(mb, 0, TYPE, "BAT coercion error");
898 1 : VALclear(cst); // it could contain allocated space
899 1 : return -1;
900 : }
901 49768761 : } else if (cst->vtype != type && !isPolyType(type)) {
902 1934 : int otype = cst->vtype;
903 1934 : assert(type != TYPE_any); /* help Coverity */
904 1934 : msg = convertConstant(getBatType(type), cst);
905 1933 : if (msg) {
906 3 : str ft, tt; /* free old value */
907 3 : ft = getTypeName(otype);
908 3 : tt = getTypeName(type);
909 3 : if (ft && tt)
910 3 : mb->errors = createMalException(mb, 0, TYPE,
911 : "constant coercion error from %s to %s",
912 : ft, tt);
913 : else
914 0 : mb->errors = createMalException(mb, 0, TYPE,
915 : "constant coercion error");
916 3 : GDKfree(ft);
917 3 : GDKfree(tt);
918 3 : freeException(msg);
919 3 : VALclear(cst); /* it could contain allocated space */
920 3 : return -1;
921 : } else {
922 1930 : assert(cst->vtype == type);
923 : }
924 : }
925 50281593 : if (cst->vtype != TYPE_any) {
926 50282792 : k = fndConstant(mb, cst, MAL_VAR_WINDOW);
927 50294800 : if (k >= 0) { /* protect against leaks coming from constant reuse */
928 30640261 : VALclear(cst);
929 30640261 : return k;
930 : }
931 : }
932 19653340 : k = newTmpVariable(mb, type);
933 19708312 : if (k < 0) {
934 0 : VALclear(cst);
935 0 : return -1;
936 : }
937 19708312 : setVarConstant(mb, k);
938 19708312 : setVarFixed(mb, k);
939 19708312 : if (type >= 0 && type < GDKatomcnt && ATOMextern(type))
940 4917017 : setVarCleanup(mb, k);
941 : else
942 14791295 : clrVarCleanup(mb, k); /* if cst is external, we give its allocated buffer away, so clear * it to avoid confusion */
943 19708312 : getVarConstant(mb, k) = *cst;
944 19708312 : VALempty(cst);
945 19708312 : return k;
946 : }
947 :
948 : /* Argument handling
949 : * The number of arguments for procedures is currently
950 : * limited. Furthermore, we should assure that no variable is
951 : * referenced before being assigned. Failure to obey should mark the
952 : * instruction as type-error. */
953 : static InstrPtr
954 60822 : extendInstruction(MalBlkPtr mb, InstrPtr p)
955 : {
956 60822 : InstrPtr pn = p;
957 60822 : if (p->argc == p->maxarg) {
958 60822 : int space = p->maxarg * sizeof(p->argv[0]) + offsetof(InstrRecord, argv);
959 60822 : pn = (InstrPtr) GDKrealloc(p, space + MAXARG * sizeof(p->argv[0]));
960 60835 : if (pn == NULL) { /* In the exceptional case we can not allocate more space * then we show an exception, mark the block as erroneous * and leave the instruction as is. */
961 0 : mb->errors = createMalException(mb, 0, TYPE,
962 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
963 0 : return p;
964 : }
965 60835 : memset(((char *) pn) + space, 0, MAXARG * sizeof(pn->argv[0]));
966 60835 : pn->maxarg += MAXARG;
967 : }
968 : return pn;
969 : }
970 :
971 : InstrPtr
972 179436443 : pushArgument(MalBlkPtr mb, InstrPtr p, int varid)
973 : {
974 179436443 : if (p == NULL || mb->errors)
975 : return p;
976 179436443 : if (varid < 0) { /* leave everything as is in this exceptional programming error */
977 0 : mb->errors = createMalException(mb, 0, TYPE, "improper variable id");
978 0 : return p;
979 : }
980 179436443 : if (p->argc == p->maxarg) {
981 : #ifndef NDEBUG
982 403486 : for (int i = 0; i < mb->stop; i++)
983 342664 : assert(mb->stmt[i] != p);
984 : #endif
985 60822 : p = extendInstruction(mb, p);
986 60835 : if (mb->errors)
987 : return p;
988 : } /* protect against the case that the instruction is malloced in isolation */
989 179436456 : if (mb->maxarg < p->maxarg)
990 48176 : mb->maxarg = p->maxarg;
991 179436456 : p->argv[p->argc++] = varid;
992 179436456 : return p;
993 : }
994 :
995 : InstrPtr
996 870712 : setArgument(MalBlkPtr mb, InstrPtr p, int idx, int varid)
997 : {
998 870712 : int i;
999 870712 : if (p == NULL || mb->errors)
1000 : return p;
1001 870726 : p = pushArgument(mb, p, varid); /* make space */
1002 874723 : for (i = p->argc - 1; i > idx; i--)
1003 3997 : getArg(p, i) = getArg(p, i - 1);
1004 870726 : getArg(p, i) = varid;
1005 870726 : return p;
1006 : }
1007 :
1008 : InstrPtr
1009 871662 : pushReturn(MalBlkPtr mb, InstrPtr p, int varid)
1010 : {
1011 871662 : if (p == NULL || mb->errors)
1012 : return p;
1013 871662 : if (p->retc == 1 && p->argv[0] == -1) {
1014 941 : p->argv[0] = varid;
1015 941 : return p;
1016 : }
1017 870721 : p = setArgument(mb, p, p->retc, varid);
1018 870741 : p->retc++;
1019 870741 : return p;
1020 : }
1021 :
1022 : /* Store the information of a destination variable in the signature
1023 : * structure of each instruction. This code is largely equivalent to
1024 : * pushArgument, but it is more efficient in searching and collecting
1025 : * the information.
1026 : * TODO */
1027 : /* swallows name argument */
1028 : InstrPtr
1029 5437 : pushArgumentId(MalBlkPtr mb, InstrPtr p, const char *name)
1030 : {
1031 5437 : int v;
1032 5437 : if (p == NULL || mb->errors)
1033 : return p;
1034 5437 : v = findVariable(mb, name);
1035 5437 : if (v < 0) {
1036 390 : size_t namelen = strlen(name);
1037 390 : if ((v = newVariable(mb, name, namelen, getAtomIndex(name, namelen, TYPE_any))) < 0) {
1038 : /* set the MAL block to erroneous and simply return without
1039 : * doing anything */
1040 : /* mb->errors already set */
1041 : return p;
1042 : }
1043 : }
1044 5436 : return pushArgument(mb, p, v);
1045 : }
1046 :
1047 : /* The alternative is to remove arguments from an instruction
1048 : * record. This is typically part of instruction constructions. */
1049 : void
1050 1483047 : delArgument(InstrPtr p, int idx)
1051 : {
1052 1483047 : int i;
1053 2265258 : for (i = idx; i < p->argc - 1; i++)
1054 782211 : p->argv[i] = p->argv[i + 1];
1055 1483047 : p->argc--;
1056 1483047 : if (idx < p->retc)
1057 184971 : p->retc--;
1058 1483047 : }
1059 :
1060 : void
1061 36650 : setArgType(MalBlkPtr mb, InstrPtr p, int i, int tpe)
1062 : {
1063 36650 : assert(p->argv[i] < mb->vsize);
1064 36650 : setVarType(mb, getArg(p, i), tpe);
1065 36650 : }
1066 :
1067 : void
1068 0 : setReturnArgument(InstrPtr p, int i)
1069 : {
1070 0 : setDestVar(p, i);
1071 0 : }
1072 :
1073 : malType
1074 0 : destinationType(MalBlkPtr mb, InstrPtr p)
1075 : {
1076 0 : if (p->argc > 0)
1077 0 : return getVarType(mb, getDestVar(p));
1078 : return TYPE_any;
1079 : }
1080 :
1081 : /* For polymorphic instructions we should keep around the maximal
1082 : * index to later allocate sufficient space for type resolutions maps.
1083 : * Beware, that we should only consider the instruction polymorphic if
1084 : * it has a positive index or belongs to the signature.
1085 : * BATs can only have a polymorphic type at the tail.
1086 : */
1087 : inline void
1088 9299 : setPolymorphic(InstrPtr p, int tpe, int force /* just any isn't polymorphic */)
1089 : {
1090 9299 : int any = isAnyExpression(tpe) || tpe == TYPE_any, index = 0;
1091 9299 : if ((force == FALSE && tpe == TYPE_any) || !any)
1092 : return;
1093 34 : if (getTypeIndex(tpe) > 0)
1094 : index = getTypeIndex(tpe);
1095 34 : if (any && (index + 1) >= p->polymorphic)
1096 31 : p->polymorphic = index + 1;
1097 : }
1098 :
1099 : /* Instructions are simply appended to a MAL block. It should always succeed.
1100 : * The assumption is to push it when you are completely done with its preparation.
1101 : */
1102 : void
1103 314530877 : pushInstruction(MalBlkPtr mb, InstrPtr p)
1104 : {
1105 314530877 : int i;
1106 314530877 : InstrPtr q;
1107 314530877 : if (p == NULL)
1108 : return;
1109 314530877 : if (mb->stop + 1 >= mb->ssize) {
1110 70564 : int s = (mb->ssize / MALCHUNK + 1) * MALCHUNK;
1111 70564 : if (resizeMalBlk(mb, s) < 0) {
1112 : /* we are now left with the situation that the new
1113 : * instruction is dangling. The hack is to take an
1114 : * instruction out of the block that is likely not
1115 : * referenced independently. The last resort is to take the
1116 : * first, which should always be there. This assumes that
1117 : * no references are kept elsewhere to the statement. */
1118 0 : assert(mb->errors != NULL);
1119 0 : for (i = 1; i < mb->stop; i++) {
1120 0 : q = getInstrPtr(mb, i);
1121 0 : if (q->token == REMsymbol) {
1122 0 : freeInstruction(q);
1123 0 : mb->stmt[i] = p;
1124 0 : return;
1125 : }
1126 : }
1127 0 : freeInstruction(getInstrPtr(mb, 0));
1128 0 : mb->stmt[0] = p;
1129 0 : return;
1130 : }
1131 : }
1132 314530877 : if (mb->stmt[mb->stop])
1133 19231 : freeInstruction(mb->stmt[mb->stop]);
1134 314552102 : p->pc = mb->stop;
1135 314552102 : mb->stmt[mb->stop++] = p;
1136 : }
|
