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 MonetDB Foundation;
       9             :  * Copyright August 2008 - 2023 MonetDB B.V.;
      10             :  * Copyright 1997 - July 2008 CWI.
      11             :  */
      12             : 
      13             : #include "monetdb_config.h"
      14             : #include "mal_instruction.h"
      15             : #include "opt_aliases.h"
      16             : 
      17             : /* an alias is recognized by a simple assignment */
      18             : #define OPTisAlias(X) (X->argc == 2 && X->token == ASSIGNsymbol && X->barrier == 0 )
      19             : 
      20             : str
      21     1451954 : OPTaliasesImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
      22             : {
      23     1451954 :         int i, j, k = 1, limit, actions = 0;
      24     1451954 :         int *alias = 0;
      25     1451954 :         str msg = MAL_SUCCEED;
      26     1451954 :         InstrPtr p;
      27             : 
      28     1451954 :         (void) stk;
      29     1451954 :         (void) cntxt;
      30             : 
      31     1451954 :         limit = mb->stop;
      32    43389492 :         for (i = 1; i < limit; i++) {
      33    42458189 :                 p = getInstrPtr(mb, i);
      34    42458189 :                 if (OPTisAlias(p))
      35             :                         break;
      36             :         }
      37     1451954 :         if (i == limit) {
      38             :                 // we didn't found a simple assignment that warrants a rewrite
      39      931303 :                 goto wrapup;
      40             :         }
      41      520651 :         k = i;
      42      520651 :         if (i < limit) {
      43      520651 :                 alias = GDKzalloc(sizeof(int) * mb->vtop);
      44      520651 :                 if (alias == NULL)
      45           0 :                         throw(MAL, "optimizer.aliases", SQLSTATE(HY013) MAL_MALLOC_FAIL);
      46      520651 :                 setVariableScope(mb);
      47    49083632 :                 for (j = 1; j < mb->vtop; j++)
      48    48042334 :                         alias[j] = j;
      49             :         }
      50    28007318 :         for (; i < limit; i++) {
      51    27486647 :                 p = getInstrPtr(mb, i);
      52    27486647 :                 mb->stmt[k++] = p;
      53    27486647 :                 if (OPTisAlias(p) && getLastUpdate(mb, getArg(p, 0)) == i
      54     3142853 :                         && getBeginScope(mb, getArg(p, 0)) == i
      55     3141726 :                         && getLastUpdate(mb, getArg(p, 1)) <= i) {
      56     3141314 :                         alias[getArg(p, 0)] = alias[getArg(p, 1)];
      57     3141314 :                         freeInstruction(p);
      58     3141338 :                         actions++;
      59     3141338 :                         k--;
      60     3141338 :                         mb->stmt[k] = 0;
      61             :                 } else {
      62    83570718 :                         for (int i = 0; i < p->argc; i++)
      63    59225385 :                                 getArg(p, i) = alias[getArg(p, i)];
      64             :                 }
      65             :         }
      66             : 
      67     3661998 :         for (i = k; i < limit; i++)
      68     3141327 :                 mb->stmt[i] = NULL;
      69             : 
      70      520671 :         mb->stop = k;
      71      520671 :         GDKfree(alias);
      72             : 
      73             :         /* Defense line against incorrect plans */
      74             :         /* Plan is unaffected */
      75             :         // msg = chkTypes(cntxt->usermodule, mb, FALSE);
      76             :         // if ( msg == MAL_SUCCEED)
      77             :         //      msg = chkFlow(mb);
      78             :         // if ( msg == MAL_SUCCEED)
      79             :         //      msg = chkDeclarations(mb);
      80     1451953 :   wrapup:
      81             :         /* keep actions taken as a fake argument */
      82     1451953 :         (void) pushInt(mb, pci, actions);
      83     1451953 :         return msg;
      84             : }