Changeset 3340 in CLRX


Ignore:
Timestamp:
Sep 8, 2017, 5:03:48 PM (4 months ago)
Author:
matszpk
Message:

CLRadeonExtender: Yet another killing code lines by macros (in Assembler.cpp and AsmExpression?.cpp).

Location:
CLRadeonExtender/trunk/amdasm
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/amdasm/AsmExpression.cpp

    r2858 r3340  
    9696}
    9797
     98#define ASMX_FAILED_BY_ERROR(PLACE, STRING) \
     99    { \
     100        assembler.printError(PLACE, STRING); \
     101        failed = true; \
     102    }
     103
     104#define ASMX_NOTGOOD_BY_ERROR(PLACE, STRING) \
     105    { \
     106        assembler.printError(PLACE, STRING); \
     107        good = false; \
     108    }
     109
    98110bool AsmExpression::evaluate(Assembler& assembler, size_t opStart, size_t opEnd,
    99111                 uint64_t& outValue, cxuint& outSectionId) const
     
    168180                        else // error
    169181                        {
    170                             assembler.printError(getSourcePos(messagePosIndex),
    171                                    "Division by zero");
    172                             failed = true;
     182                            ASMX_FAILED_BY_ERROR(getSourcePos(messagePosIndex),
     183                                   "Division by zero")
    173184                            value = 0;
    174185                        }
     
    180191                        else // error
    181192                        {
    182                             assembler.printError(getSourcePos(messagePosIndex),
    183                                    "Division by zero");
    184                             failed = true;
     193                            ASMX_FAILED_BY_ERROR(getSourcePos(messagePosIndex),
     194                                   "Division by zero")
    185195                            value = 0;
    186196                        }
     
    192202                        else // error
    193203                        {
    194                             assembler.printError(getSourcePos(messagePosIndex),
    195                                    "Division by zero");
    196                             failed = true;
     204                            ASMX_FAILED_BY_ERROR(getSourcePos(messagePosIndex),
     205                                   "Division by zero")
    197206                            value = 0;
    198207                        }
     
    204213                        else // error
    205214                        {
    206                             assembler.printError(getSourcePos(messagePosIndex),
    207                                    "Division by zero");
    208                             failed = true;
     215                            ASMX_FAILED_BY_ERROR(getSourcePos(messagePosIndex),
     216                                   "Division by zero")
    209217                            value = 0;
    210218                        }
     
    422430                    case AsmExprOp::MULTIPLY:
    423431                        if (!relatives.empty() && !relatives2.empty())
    424                         {
    425                             assembler.printError(sourcePos,
    426                                  "Multiplication is not allowed for two relative values");
    427                             failed = true;
    428                         }
     432                            ASMX_FAILED_BY_ERROR(sourcePos,
     433                                 "Multiplication is not allowed for two relative values")
    429434                        if (relatives2.empty())
    430435                        {   // multiply relatives
     
    448453                    case AsmExprOp::DIVISION:
    449454                        if (!relatives.empty() || !relatives2.empty())
    450                         {
    451                             assembler.printError(sourcePos,
    452                                  "Division is not allowed for any relative value");
    453                             failed = true;
    454                         }
     455                            ASMX_FAILED_BY_ERROR(sourcePos,
     456                                 "Division is not allowed for any relative value")
    455457                        if (value != 0)
    456458                            value = value2 / value;
     
    466468                    case AsmExprOp::SIGNED_DIVISION:
    467469                        if (!relatives.empty() || !relatives2.empty())
    468                         {
    469                             assembler.printError(sourcePos,
    470                                  "Signed division is not allowed for any relative value");
    471                             failed = true;
    472                         }
     470                            ASMX_FAILED_BY_ERROR(sourcePos,
     471                                 "Signed division is not allowed for any relative value")
    473472                        if (value != 0)
    474473                            value = int64_t(value2) / int64_t(value);
    475474                        else // error
    476475                        {
    477                             assembler.printError(getSourcePos(messagePosIndex),
    478                                    "Division by zero");
    479                             failed = true;
     476                            ASMX_FAILED_BY_ERROR(getSourcePos(messagePosIndex),
     477                                   "Division by zero")
    480478                            value = 0;
    481479                        }
     
    484482                    case AsmExprOp::MODULO:
    485483                        if (!relatives.empty() || !relatives2.empty())
    486                         {
    487                             assembler.printError(sourcePos,
    488                                  "Modulo is not allowed for any relative value");
    489                             failed = true;
    490                         }
     484                            ASMX_FAILED_BY_ERROR(sourcePos,
     485                                 "Modulo is not allowed for any relative value")
    491486                        if (value != 0)
    492487                            value = value2 % value;
    493488                        else // error
    494489                        {
    495                             assembler.printError(getSourcePos(messagePosIndex),
    496                                    "Division by zero");
    497                             failed = true;
     490                            ASMX_FAILED_BY_ERROR(getSourcePos(messagePosIndex),
     491                                   "Division by zero")
    498492                            value = 0;
    499493                        }
     
    502496                    case AsmExprOp::SIGNED_MODULO:
    503497                        if (!relatives.empty() || !relatives2.empty())
    504                         {
    505                             assembler.printError(sourcePos,
    506                                  "Signed Modulo is not allowed for any relative value");
    507                             failed = true;
    508                         }
     498                            ASMX_FAILED_BY_ERROR(sourcePos,
     499                                 "Signed Modulo is not allowed for any relative value")
    509500                        if (value != 0)
    510501                            value = int64_t(value2) % int64_t(value);
    511502                        else // error
    512503                        {
    513                             assembler.printError(getSourcePos(messagePosIndex),
    514                                    "Division by zero");
    515                             failed = true;
     504                            ASMX_FAILED_BY_ERROR(getSourcePos(messagePosIndex),
     505                                   "Division by zero")
    516506                            value = 0;
    517507                        }
     
    520510                    case AsmExprOp::BIT_AND:
    521511                        if (!relatives.empty() || !relatives2.empty())
    522                         {
    523                             assembler.printError(sourcePos,
    524                                  "Binary AND is not allowed for any relative value");
    525                             failed = true;
    526                         }
     512                            ASMX_FAILED_BY_ERROR(sourcePos,
     513                                 "Binary AND is not allowed for any relative value")
    527514                        value = value2 & value;
    528515                        break;
    529516                    case AsmExprOp::BIT_OR:
    530517                        if (!relatives.empty() || !relatives2.empty())
    531                         {
    532                             assembler.printError(sourcePos,
    533                                  "Binary OR is not allowed for any relative value");
    534                             failed = true;
    535                         }
     518                            ASMX_FAILED_BY_ERROR(sourcePos,
     519                                 "Binary OR is not allowed for any relative value")
    536520                        value = value2 | value;
    537521                        break;
    538522                    case AsmExprOp::BIT_XOR:
    539523                        if (!relatives.empty() || !relatives2.empty())
    540                         {
    541                             assembler.printError(sourcePos,
    542                                  "Binary XOR is not allowed for any relative value");
    543                             failed = true;
    544                         }
     524                            ASMX_FAILED_BY_ERROR(sourcePos,
     525                                 "Binary XOR is not allowed for any relative value")
    545526                        value = value2 ^ value;
    546527                        break;
    547528                    case AsmExprOp::BIT_ORNOT:
    548529                        if (!relatives.empty() || !relatives2.empty())
    549                         {
    550                             assembler.printError(sourcePos,
    551                                  "Binary ORNOT is not allowed for any relative value");
    552                             failed = true;
    553                         }
     530                            ASMX_FAILED_BY_ERROR(sourcePos,
     531                                 "Binary ORNOT is not allowed for any relative value")
    554532                        value = value2 | ~value;
    555533                        break;
    556534                    case AsmExprOp::SHIFT_LEFT:
    557535                        if (!relatives.empty())
    558                         {
    559                             assembler.printError(sourcePos, "Shift left is not allowed "
    560                                     "for any for relative second value");
    561                             failed = true;
    562                         }
     536                            ASMX_FAILED_BY_ERROR(sourcePos, "Shift left is not allowed "
     537                                    "for any for relative second value")
    563538                        else if (value < 64)
    564539                        {
     
    578553                    case AsmExprOp::SHIFT_RIGHT:
    579554                        if (!relatives.empty() || !relatives2.empty())
    580                         {
    581                             assembler.printError(sourcePos,
    582                                  "Shift right is not allowed for any relative value");
    583                             failed = true;
    584                         }
     555                            ASMX_FAILED_BY_ERROR(sourcePos,
     556                                 "Shift right is not allowed for any relative value")
    585557                        if (value < 64)
    586558                            value = value2 >> value;
     
    595567                    case AsmExprOp::SIGNED_SHIFT_RIGHT:
    596568                        if (!relatives.empty() || !relatives2.empty())
    597                         {
    598                             assembler.printError(sourcePos, "Signed shift right is not "
    599                                     "allowed for any relative value");
    600                             failed = true;
    601                         }
     569                            ASMX_FAILED_BY_ERROR(sourcePos, "Signed shift right is not "
     570                                    "allowed for any relative value")
    602571                        if (value < 64)
    603572                            value = int64_t(value2) >> value;
     
    612581                    case AsmExprOp::LOGICAL_AND:
    613582                        if (!relatives.empty() || !relatives2.empty())
    614                         {
    615                             assembler.printError(sourcePos,
    616                                  "Logical AND is not allowed for any relative value");
    617                             failed = true;
    618                         }
     583                            ASMX_FAILED_BY_ERROR(sourcePos,
     584                                 "Logical AND is not allowed for any relative value")
    619585                        value = value2 && value;
    620586                        break;
    621587                    case AsmExprOp::LOGICAL_OR:
    622588                        if (!relatives.empty() || !relatives2.empty())
    623                         {
    624                             assembler.printError(sourcePos,
    625                                  "Logical OR is not allowed for any relative value");
    626                             failed = true;
    627                         }
     589                            ASMX_FAILED_BY_ERROR(sourcePos,
     590                                 "Logical OR is not allowed for any relative value")
    628591                        value = value2 || value;
    629592                        break;
     
    641604                        size_t requals = 0;
    642605                        if (relatives2.size() != relatives.size())
    643                         {
    644                             assembler.printError(sourcePos, "For comparisons "
    645                                         "two values must have this same relatives!");
    646                             failed = true;
    647                         }
     606                            ASMX_FAILED_BY_ERROR(sourcePos, "For comparisons "
     607                                        "two values must have this same relatives!")
    648608                        else
    649609                        {
     
    658618                                    }
    659619                            if (requals != relatives.size())
    660                             {
    661                                 assembler.printError(sourcePos, "For comparisons "
    662                                         "two values must have this same relatives!");
    663                                 failed = true;
    664                             }
     620                                ASMX_FAILED_BY_ERROR(sourcePos, "For comparisons "
     621                                        "two values must have this same relatives!")
    665622                        }
    666623                        relatives.clear();
     
    717674                stack.pop();
    718675                if (!relatives3.empty())
    719                 {
    720                     assembler.printError(sourcePos,
    721                          "Choice is not allowed for first relative value");
    722                     failed = true;
    723                 }
     676                    ASMX_FAILED_BY_ERROR(sourcePos,
     677                         "Choice is not allowed for first relative value")
    724678                if (value3)
    725679                    relatives.assign(relatives2.begin(), relatives2.end());
     
    742696            sectionId = relatives.front().sectionId;
    743697        else
    744         {
    745             assembler.printError(sourcePos,
    746                      "Only one relative=1 (section) can be result of expression");
    747             failed = true;
    748         }
     698            ASMX_FAILED_BY_ERROR(sourcePos,
     699                     "Only one relative=1 (section) can be result of expression")
    749700    }
    750701    if (!failed)
     
    938889                    {   // put value to argument
    939890                        if (nextSymEntry->second.regRange)
    940                         {
    941                             assembler.printError(expr->getSourcePos(),
    942                                                  "Expression have register symbol");
    943                             good = false;
    944                         }
     891                            ASMX_NOTGOOD_BY_ERROR(expr->getSourcePos(),
     892                                                 "Expression have register symbol")
    945893                        ops[opIndex] = AsmExprOp::ARG_VALUE;
    946894                        args[argIndex].relValue.value = nextSymEntry->second.value;
     
    10971045            case '(':
    10981046                if (expectedToken == XT_OP)
    1099                 {
    1100                     assembler.printError(linePtr, "Expected operator");
    1101                     good = false;
    1102                 }
     1047                    ASMX_NOTGOOD_BY_ERROR(linePtr, "Expected operator")
    11031048                else
    11041049                {
     
    11101055            case ')':
    11111056                if (expectedToken != XT_OP)
    1112                 {
    1113                     assembler.printError(linePtr, "Expected operator or value or symbol");
    1114                     good = false;
    1115                 }
     1057                    ASMX_NOTGOOD_BY_ERROR(linePtr, "Expected operator or value or symbol")
    11161058                else
    11171059                {
     
    11951137                    op = AsmExprOp::BIT_NOT;
    11961138                else
    1197                 {
    1198                     assembler.printError(linePtr,
    1199                         "Expected non-unary operator, '(', or end of expression");
    1200                     good = false;
    1201                 }
     1139                    ASMX_NOTGOOD_BY_ERROR(linePtr,
     1140                        "Expected non-unary operator, '(', or end of expression")
    12021141                linePtr++;
    12031142                break;
     
    13061245                    if (symEntry!=nullptr && symEntry->second.regRange)
    13071246                    {
    1308                         assembler.printError(linePtr, "Expression have register symbol");
    1309                         good = false;
     1247                        ASMX_NOTGOOD_BY_ERROR(linePtr, "Expression have register symbol")
    13101248                        continue;
    13111249                    }
     
    13271265                            errorMsg.append(linePtr, symEndStr);
    13281266                            errorMsg += '\'';
    1329                             assembler.printError(linePtr, errorMsg.c_str());
    1330                             good = false;
     1267                            ASMX_NOTGOOD_BY_ERROR(linePtr, errorMsg.c_str())
    13311268                        }
    13321269                        else
     
    13831320                    {
    13841321                        linePtr++;
    1385                         assembler.printError(linePtr, "Garbages at end of expression");
    1386                         good = false;
     1322                        ASMX_NOTGOOD_BY_ERROR(linePtr, "Garbages at end of expression")
    13871323                    }
    13881324                }
     
    13961332        if (expectedPrimaryExpr)
    13971333        {
    1398             assembler.printError(beforeToken,
    1399                      "Expected primary expression before operator");
    1400             good = false;
     1334            ASMX_NOTGOOD_BY_ERROR(beforeToken,
     1335                     "Expected primary expression before operator")
    14011336            continue;
    14021337        }
     
    14401375                        stack.top().priority != priority)
    14411376                {   // not found
    1442                     assembler.printError(beforeToken, "Missing '?' before ':'");
    1443                     good = false;
     1377                    ASMX_NOTGOOD_BY_ERROR(beforeToken, "Missing '?' before ':'")
    14441378                    continue; // do noy change stack and them entries
    14451379                }
     
    14601394                    if (entry.op == AsmExprOp::CHOICE_START)
    14611395                    {   // unfinished choice
    1462                         assembler.printError(messagePositions[entry.lineColPos],
    1463                                  "Missing ':' for '?'");
    14641396                        stack.pop();
    1465                         good = false;
     1397                        ASMX_NOTGOOD_BY_ERROR(messagePositions[entry.lineColPos],
     1398                                 "Missing ':' for '?'")
    14661399                        break;
    14671400                    }
     
    14791412            break;
    14801413    }
    1481     if (parenthesisCount != 0)
    1482     {   // print error
    1483         assembler.printError(linePtr, "Missing ')'");
    1484         good = false;
    1485     }
     1414    if (parenthesisCount != 0) // print error
     1415        ASMX_NOTGOOD_BY_ERROR(linePtr, "Missing ')'")
    14861416    if (expectedToken != XT_OP)
    14871417    {
    14881418        if (!ops.empty() || !stack.empty())
    1489         {
    1490             assembler.printError(linePtr, "Unterminated expression");
    1491             good = false;
    1492         }
     1419            ASMX_NOTGOOD_BY_ERROR(linePtr, "Unterminated expression")
    14931420    }
    14941421    else
     
    14991426            if (entry.op == AsmExprOp::CHOICE_START)
    15001427            {   // unfinished choice
    1501                 assembler.printError(messagePositions[entry.lineColPos],
    1502                          "Missing ':' for '?'");
    1503                 good = false;
     1428                ASMX_NOTGOOD_BY_ERROR(messagePositions[entry.lineColPos],
     1429                         "Missing ':' for '?'")
    15041430                break;
    15051431            }
  • CLRadeonExtender/trunk/amdasm/Assembler.cpp

    r3339 r3340  
    10541054bool Assembler::setSymbol(AsmSymbolEntry& symEntry, uint64_t value, cxuint sectionId)
    10551055{
     1056    Assembler& asmr = *this;
    10561057    symEntry.second.value = value;
    10571058    symEntry.second.expression = nullptr;
     
    11281129                    case ASMXTGT_DATA8:
    11291130                        if (sectionId != ASMSECT_ABS)
    1130                         {
    1131                             printError(expr->getSourcePos(),
    1132                                    "Relative value is illegal in data expressions");
    1133                             good = false;
    1134                         }
     1131                            ASM_NOTGOOD_BY_ERROR(expr->getSourcePos(),
     1132                                   "Relative value is illegal in data expressions")
    11351133                        else
    11361134                        {
     
    11421140                    case ASMXTGT_DATA16:
    11431141                        if (sectionId != ASMSECT_ABS)
    1144                         {
    1145                             printError(expr->getSourcePos(),
    1146                                    "Relative value is illegal in data expressions");
    1147                             good = false;
    1148                         }
     1142                            ASM_NOTGOOD_BY_ERROR(expr->getSourcePos(),
     1143                                   "Relative value is illegal in data expressions")
    11491144                        else
    11501145                        {
     
    11561151                    case ASMXTGT_DATA32:
    11571152                        if (sectionId != ASMSECT_ABS)
    1158                         {
    1159                             printError(expr->getSourcePos(),
    1160                                    "Relative value is illegal in data expressions");
    1161                             good = false;
    1162                         }
     1153                            ASM_NOTGOOD_BY_ERROR(expr->getSourcePos(),
     1154                                   "Relative value is illegal in data expressions")
    11631155                        else
    11641156                        {
     
    11701162                    case ASMXTGT_DATA64:
    11711163                        if (sectionId != ASMSECT_ABS)
    1172                         {
    1173                             printError(expr->getSourcePos(),
    1174                                    "Relative value is illegal in data expressions");
    1175                             good = false;
    1176                         }
     1164                            ASM_NOTGOOD_BY_ERROR(expr->getSourcePos(),
     1165                                   "Relative value is illegal in data expressions")
    11771166                        else
    11781167                            SULEV(*reinterpret_cast<uint64_t*>(sections[target.sectionId]
     
    11811170                    case ASMXTGT_CODEFLOW:
    11821171                        if (target.sectionId != sectionId)
    1183                         {
    1184                             printError(expr->getSourcePos(), "Jump over current section!");
    1185                             good = false;
    1186                         }
     1172                            ASM_NOTGOOD_BY_ERROR(expr->getSourcePos(),
     1173                                            "Jump over current section!")
    11871174                        else
    11881175                            sections[target.sectionId].
     
    12231210    size_t symNameLength = symbolName.size();
    12241211    if (symNameLength >= 3 && symbolName.compare(symNameLength-3, 3, "::.")==0)
    1225     {
    1226         printError(symbolPlace, "Symbol '.' can be only in global scope");
    1227         return false;
    1228     }
     1212        ASM_FAIL_BY_ERROR(symbolPlace, "Symbol '.' can be only in global scope")
    12291213   
    12301214    if (linePtr!=line+lineSize && *linePtr=='%')
Note: See TracChangeset for help on using the changeset viewer.