From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from localhost (localhost [127.0.0.1]) by turing.freelists.org (Avenir Technologies Mail Multiplex) with ESMTP id 86B0C28498 for ; Fri, 23 Aug 2019 11:50:02 -0400 (EDT) Received: from turing.freelists.org ([127.0.0.1]) by localhost (turing.freelists.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 4GR3fH3bfLRQ for ; Fri, 23 Aug 2019 11:50:02 -0400 (EDT) Received: from mail-lj1-f170.google.com (mail-lj1-f170.google.com [209.85.208.170]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by turing.freelists.org (Avenir Technologies Mail Multiplex) with ESMTPS id 23D2927951 for ; Fri, 23 Aug 2019 11:50:02 -0400 (EDT) Received: by mail-lj1-f170.google.com with SMTP id l14so9301367ljj.9 for ; Fri, 23 Aug 2019 08:50:01 -0700 (PDT) From: Alexey Zavodchenkov Subject: [tarantool-patches] [PATCH] sql: Change token/opcode relation assertions to static Date: Fri, 23 Aug 2019 18:49:58 +0300 Message-Id: <20190823154958.20837-1-zavodchen@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: tarantool-patches-bounce@freelists.org Errors-to: tarantool-patches-bounce@freelists.org Reply-To: tarantool-patches@freelists.org List-Help: List-Unsubscribe: List-software: Ecartis version 1.0.0 List-Id: tarantool-patches List-Subscribe: List-Owner: List-post: List-Archive: To: tarantool-patches@freelists.org Cc: Alexey Zavodchenkov There are several token/opcode relative positions assertions in the sql codebase and those tokens/opcodes are defined before the source compilation. So it is possible to change those assertions to static ones. Closes: #4240 Issue: https://github.com/tarantool/tarantool/issues/4240 Commit in the fork: https://github.com/Separador/tarantool/commit/d36d7c8080 --- src/box/sql/expr.c | 105 ++++++++++++++++++++++++++-------------- src/box/sql/vdbe.c | 33 ++++++++----- src/box/sql/whereexpr.c | 29 +++++++---- 3 files changed, 111 insertions(+), 56 deletions(-) diff --git a/src/box/sql/expr.c b/src/box/sql/expr.c index 1f9d91705..668562896 100644 --- a/src/box/sql/expr.c +++ b/src/box/sql/expr.c @@ -3839,22 +3839,28 @@ sqlExprCodeTarget(Parse * pParse, Expr * pExpr, int target) ®Free2); codeCompare(pParse, pLeft, pExpr->pRight, op, r1, r2, inReg, SQL_STOREP2); - assert(TK_LT == OP_Lt); + static_assert(TK_LT == OP_Lt, + "inconsistent token/opcode definition"); testcase(op == OP_Lt); VdbeCoverageIf(v, op == OP_Lt); - assert(TK_LE == OP_Le); + static_assert(TK_LE == OP_Le, + "inconsistent token/opcode definition"); testcase(op == OP_Le); VdbeCoverageIf(v, op == OP_Le); - assert(TK_GT == OP_Gt); + static_assert(TK_GT == OP_Gt, + "inconsistent token/opcode definition"); testcase(op == OP_Gt); VdbeCoverageIf(v, op == OP_Gt); - assert(TK_GE == OP_Ge); + static_assert(TK_GE == OP_Ge, + "inconsistent token/opcode definition"); testcase(op == OP_Ge); VdbeCoverageIf(v, op == OP_Ge); - assert(TK_EQ == OP_Eq); + static_assert(TK_EQ == OP_Eq, + "inconsistent token/opcode definition"); testcase(op == OP_Eq); VdbeCoverageIf(v, op == OP_Eq); - assert(TK_NE == OP_Ne); + static_assert(TK_NE == OP_Ne, + "inconsistent token/opcode definition"); testcase(op == OP_Ne); VdbeCoverageIf(v, op == OP_Ne); testcase(regFree1 == 0); @@ -3874,27 +3880,38 @@ sqlExprCodeTarget(Parse * pParse, Expr * pExpr, int target) case TK_LSHIFT: case TK_RSHIFT: case TK_CONCAT:{ - assert(TK_AND == OP_And); + static_assert(TK_AND == OP_And, + "inconsistent token/opcode definition"); testcase(op == TK_AND); - assert(TK_OR == OP_Or); + static_assert(TK_OR == OP_Or, + "inconsistent token/opcode definition"); testcase(op == TK_OR); - assert(TK_PLUS == OP_Add); + static_assert(TK_PLUS == OP_Add, + "inconsistent token/opcode definition"); testcase(op == TK_PLUS); - assert(TK_MINUS == OP_Subtract); + static_assert(TK_MINUS == OP_Subtract, + "inconsistent token/opcode definition"); testcase(op == TK_MINUS); - assert(TK_REM == OP_Remainder); + static_assert(TK_REM == OP_Remainder, + "inconsistent token/opcode definition"); testcase(op == TK_REM); - assert(TK_BITAND == OP_BitAnd); + static_assert(TK_BITAND == OP_BitAnd, + "inconsistent token/opcode definition"); testcase(op == TK_BITAND); - assert(TK_BITOR == OP_BitOr); + static_assert(TK_BITOR == OP_BitOr, + "inconsistent token/opcode definition"); testcase(op == TK_BITOR); - assert(TK_SLASH == OP_Divide); + static_assert(TK_SLASH == OP_Divide, + "inconsistent token/opcode definition"); testcase(op == TK_SLASH); - assert(TK_LSHIFT == OP_ShiftLeft); + static_assert(TK_LSHIFT == OP_ShiftLeft, + "inconsistent token/opcode definition"); testcase(op == TK_LSHIFT); - assert(TK_RSHIFT == OP_ShiftRight); + static_assert(TK_RSHIFT == OP_ShiftRight, + "inconsistent token/opcode definition"); testcase(op == TK_RSHIFT); - assert(TK_CONCAT == OP_Concat); + static_assert(TK_CONCAT == OP_Concat, + "inconsistent token/opcode definition"); testcase(op == TK_CONCAT); r1 = sqlExprCodeTemp(pParse, pExpr->pLeft, ®Free1); @@ -3931,9 +3948,11 @@ sqlExprCodeTarget(Parse * pParse, Expr * pExpr, int target) } case TK_BITNOT: case TK_NOT:{ - assert(TK_BITNOT == OP_BitNot); + static_assert(TK_BITNOT == OP_BitNot, + "inconsistent token/opcode definition"); testcase(op == TK_BITNOT); - assert(TK_NOT == OP_Not); + static_assert(TK_NOT == OP_Not, + "inconsistent token/opcode definition"); testcase(op == TK_NOT); r1 = sqlExprCodeTemp(pParse, pExpr->pLeft, ®Free1); @@ -3944,9 +3963,11 @@ sqlExprCodeTarget(Parse * pParse, Expr * pExpr, int target) case TK_ISNULL: case TK_NOTNULL:{ int addr; - assert(TK_ISNULL == OP_IsNull); + static_assert(TK_ISNULL == OP_IsNull, + "inconsistent token/opcode definition"); testcase(op == TK_ISNULL); - assert(TK_NOTNULL == OP_NotNull); + static_assert(TK_NOTNULL == OP_NotNull, + "inconsistent token/opcode definition"); testcase(op == TK_NOTNULL); sqlVdbeAddOp2(v, OP_Bool, true, target); r1 = sqlExprCodeTemp(pParse, pExpr->pLeft, @@ -4759,25 +4780,31 @@ sqlExprIfTrue(Parse * pParse, Expr * pExpr, int dest, int jumpIfNull) ®Free2); codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, r1, r2, dest, jumpIfNull); - assert(TK_LT == OP_Lt); + static_assert(TK_LT == OP_Lt, + "inconsistent token/opcode definition"); testcase(op == OP_Lt); VdbeCoverageIf(v, op == OP_Lt); - assert(TK_LE == OP_Le); + static_assert(TK_LE == OP_Le, + "inconsistent token/opcode definition"); testcase(op == OP_Le); VdbeCoverageIf(v, op == OP_Le); - assert(TK_GT == OP_Gt); + static_assert(TK_GT == OP_Gt, + "inconsistent token/opcode definition"); testcase(op == OP_Gt); VdbeCoverageIf(v, op == OP_Gt); - assert(TK_GE == OP_Ge); + static_assert(TK_GE == OP_Ge, + "inconsistent token/opcode definition"); testcase(op == OP_Ge); VdbeCoverageIf(v, op == OP_Ge); - assert(TK_EQ == OP_Eq); + static_assert(TK_EQ == OP_Eq, + "inconsistent token/opcode definition"); testcase(op == OP_Eq); VdbeCoverageIf(v, op == OP_Eq && jumpIfNull == SQL_NULLEQ); VdbeCoverageIf(v, op == OP_Eq && jumpIfNull != SQL_NULLEQ); - assert(TK_NE == OP_Ne); + static_assert(TK_NE == OP_Ne, + "inconsistent token/opcode definition"); testcase(op == OP_Ne); VdbeCoverageIf(v, op == OP_Ne && jumpIfNull == SQL_NULLEQ); @@ -4789,9 +4816,11 @@ sqlExprIfTrue(Parse * pParse, Expr * pExpr, int dest, int jumpIfNull) } case TK_ISNULL: case TK_NOTNULL:{ - assert(TK_ISNULL == OP_IsNull); + static_assert(TK_ISNULL == OP_IsNull, + "inconsistent token/opcode definition"); testcase(op == TK_ISNULL); - assert(TK_NOTNULL == OP_NotNull); + static_assert(TK_NOTNULL == OP_NotNull, + "inconsistent token/opcode definition"); testcase(op == TK_NOTNULL); r1 = sqlExprCodeTemp(pParse, pExpr->pLeft, ®Free1); @@ -4952,25 +4981,31 @@ sqlExprIfFalse(Parse * pParse, Expr * pExpr, int dest, int jumpIfNull) ®Free2); codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, r1, r2, dest, jumpIfNull); - assert(TK_LT == OP_Lt); + static_assert(TK_LT == OP_Lt, + "inconsistent token/opcode definition"); testcase(op == OP_Lt); VdbeCoverageIf(v, op == OP_Lt); - assert(TK_LE == OP_Le); + static_assert(TK_LE == OP_Le, + "inconsistent token/opcode definition"); testcase(op == OP_Le); VdbeCoverageIf(v, op == OP_Le); - assert(TK_GT == OP_Gt); + static_assert(TK_GT == OP_Gt, + "inconsistent token/opcode definition"); testcase(op == OP_Gt); VdbeCoverageIf(v, op == OP_Gt); - assert(TK_GE == OP_Ge); + static_assert(TK_GE == OP_Ge, + "inconsistent token/opcode definition"); testcase(op == OP_Ge); VdbeCoverageIf(v, op == OP_Ge); - assert(TK_EQ == OP_Eq); + static_assert(TK_EQ == OP_Eq, + "inconsistent token/opcode definition"); testcase(op == OP_Eq); VdbeCoverageIf(v, op == OP_Eq && jumpIfNull != SQL_NULLEQ); VdbeCoverageIf(v, op == OP_Eq && jumpIfNull == SQL_NULLEQ); - assert(TK_NE == OP_Ne); + static_assert(TK_NE == OP_Ne, + "inconsistent token/opcode definition"); testcase(op == OP_Ne); VdbeCoverageIf(v, op == OP_Ne && jumpIfNull != SQL_NULLEQ); diff --git a/src/box/sql/vdbe.c b/src/box/sql/vdbe.c index dced8fc73..8560e51a1 100644 --- a/src/box/sql/vdbe.c +++ b/src/box/sql/vdbe.c @@ -1847,7 +1847,8 @@ case OP_ShiftRight: { /* same as TK_RSHIFT, in1, in2, out3 */ /* If shifting by a negative amount, shift in the other direction */ if (iB<0) { - assert(OP_ShiftRight==OP_ShiftLeft+1); + static_assert(OP_ShiftRight==OP_ShiftLeft+1, + "inconsistent opcode definition"); op = 2*OP_ShiftLeft + 1 - op; iB = iB>(-64) ? -iB : 64; } @@ -3280,9 +3281,12 @@ case OP_SeekGT: { /* jump, in3 */ pC = p->apCsr[pOp->p1]; assert(pC!=0); assert(pC->eCurType==CURTYPE_TARANTOOL); - assert(OP_SeekLE == OP_SeekLT+1); - assert(OP_SeekGE == OP_SeekLT+2); - assert(OP_SeekGT == OP_SeekLT+3); + static_assert(OP_SeekLE == OP_SeekLT+1, + "inconsistent opcode definition"); + static_assert(OP_SeekGE == OP_SeekLT+2, + "inconsistent opcode definition"); + static_assert(OP_SeekGT == OP_SeekLT+3, + "inconsistent opcode definition"); assert(pC->uc.pCursor!=0); oc = pOp->opcode; eqOnly = 0; @@ -3352,9 +3356,12 @@ case OP_SeekGT: { /* jump, in3 */ * (x <= 4.9) -> (x < 5) */ if (pIn3->u.r<(double)iKey) { - assert(OP_SeekGE==(OP_SeekGT-1)); - assert(OP_SeekLT==(OP_SeekLE-1)); - assert((OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001)); + static_assert(OP_SeekGE==(OP_SeekGT-1), + "inconsistent opcode definition"); + static_assert(OP_SeekLT==(OP_SeekLE-1), + "inconsistent opcode definition"); + static_assert((OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001), + "inconsistent opcode definition"); if ((oc & 0x0001)==(OP_SeekGT & 0x0001)) oc--; } @@ -3362,9 +3369,12 @@ case OP_SeekGT: { /* jump, in3 */ * term, substitute <= for < and > for >=. */ else if (pIn3->u.r>(double)iKey) { - assert(OP_SeekLE==(OP_SeekLT+1)); - assert(OP_SeekGT==(OP_SeekGE+1)); - assert((OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001)); + static_assert(OP_SeekLE==(OP_SeekLT+1), + "inconsistent opcode definition"); + static_assert(OP_SeekGT==(OP_SeekGE+1), + "inconsistent opcode definition"); + static_assert((OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001), + "inconsistent opcode definition"); if ((oc & 0x0001)==(OP_SeekLT & 0x0001)) oc++; } } @@ -4529,7 +4539,8 @@ case OP_IdxGE: { /* jump */ { int i; for(i=0; iuc.pCursor, &r); - assert((OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1)); + static_assert((OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1), + "inconsistent opcode definition"); if ((pOp->opcode&1)==(OP_IdxLT&1)) { assert(pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT); res = -res; diff --git a/src/box/sql/whereexpr.c b/src/box/sql/whereexpr.c index 8adf6a5f1..2d29c0bc7 100644 --- a/src/box/sql/whereexpr.c +++ b/src/box/sql/whereexpr.c @@ -132,10 +132,14 @@ whereClauseInsert(WhereClause * pWC, Expr * p, u16 wtFlags) static int allowedOp(int op) { - assert(TK_GT > TK_EQ && TK_GT < TK_GE); - assert(TK_LT > TK_EQ && TK_LT < TK_GE); - assert(TK_LE > TK_EQ && TK_LE < TK_GE); - assert(TK_GE == TK_EQ + 4); + static_assert(TK_GT > TK_EQ && TK_GT < TK_GE, + "inconsistent token definition"); + static_assert(TK_LT > TK_EQ && TK_LT < TK_GE, + "inconsistent token definition"); + static_assert(TK_LE > TK_EQ && TK_LE < TK_GE, + "inconsistent token definition"); + static_assert(TK_GE == TK_EQ + 4, + "inconsistent token definition"); return op == TK_IN || (op >= TK_EQ && op <= TK_GE) || op == TK_ISNULL; } @@ -186,10 +190,14 @@ exprCommute(Parse * pParse, Expr * pExpr) } SWAP(pExpr->pRight, pExpr->pLeft); if (pExpr->op >= TK_GT) { - assert(TK_LT == TK_GT + 2); - assert(TK_GE == TK_LE + 2); - assert(TK_GT > TK_EQ); - assert(TK_GT < TK_LE); + static_assert(TK_LT == TK_GT + 2, + "inconsistent token definition"); + static_assert(TK_GE == TK_LE + 2, + "inconsistent token definition"); + static_assert(TK_GT > TK_EQ, + "inconsistent token definition"); + static_assert(TK_GT < TK_LE, + "inconsistent token definition"); assert(pExpr->op >= TK_GT && pExpr->op <= TK_GE); pExpr->op = ((pExpr->op - TK_GT) ^ 2) + TK_GT; } @@ -945,8 +953,9 @@ exprMightBeIndexed(int op, /* The specific comparison operator */ * inequality constraint (>, <, >= or <=), perform the processing * on the first element of the vector. */ - assert(TK_GT + 1 == TK_LE && TK_GT + 2 == TK_LT && TK_GT + 3 == TK_GE); - assert(TK_IN < TK_GE); + static_assert(TK_GT + 1 == TK_LE && TK_GT + 2 == TK_LT && TK_GT + 3 == TK_GE, + "inconsistent token definition"); + static_assert(TK_IN < TK_GE, "inconsistent token definition"); assert(op <= TK_GE || op == TK_ISNULL || op == TK_NOTNULL); if (pExpr->op == TK_VECTOR && (op >= TK_GT && op <= TK_GE)) { pExpr = pExpr->x.pList->a[0].pExpr; -- 2.21.0