Changeset 3341 in CLRX


Ignore:
Timestamp:
Sep 8, 2017, 5:29:33 PM (15 months ago)
Author:
matszpk
Message:

CLRadeonExtender: Yet another killing code lines by macros (in asm formats and pseudo-ops code).

Location:
CLRadeonExtender/trunk/amdasm
Files:
5 edited

Legend:

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

    r3338 r3341  
    580580            {
    581581                if (sectionAlign!=0 && (1ULL<<(63-CLZ64(sectionAlign))) != sectionAlign)
    582                 {
    583                     asmr.printError(valuePtr, "Alignment must be power of two or zero");
    584                     good = false;
    585                 }
     582                    ASM_NOTGOOD_BY_ERROR(valuePtr, "Alignment must be power of two or zero")
    586583            }
    587584            else
     
    589586        }
    590587        else
    591         {
    592             asmr.printError(linePtr, "Expected '=' after 'align'");
    593             good = false;
    594         }
     588            ASM_NOTGOOD_BY_ERROR(linePtr, "Expected '=' after 'align'")
    595589    }
    596590   
     
    788782                        snprintf(buf, 64,
    789783                                 "Used SGPRs number out of range (0-%u)", maxSGPRsNum);
    790                         asmr.printError(valuePlace, buf);
    791                         good = false;
     784                        ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    792785                    }
    793786                    break;
     
    803796                        snprintf(buf, 64,
    804797                                 "Used VGPRs number out of range (0-%u)", maxVGPRsNum);
    805                         asmr.printError(valuePlace, buf);
    806                         good = false;
     798                        ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    807799                    }
    808800                    break;
     
    832824                        char buf[64];
    833825                        snprintf(buf, 64, "LocalSize out of range (0-%u)", maxLocalSize);
    834                         asmr.printError(valuePlace, buf);
    835                         good = false;
     826                        ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    836827                    }
    837828                    break;
     
    846837                        char buf[64];
    847838                        snprintf(buf, 64, "GDSSize out of range (0-%u)", maxGDSSize);
    848                         asmr.printError(valuePlace, buf);
    849                         good = false;
     839                        ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    850840                    }
    851841                    break;
  • CLRadeonExtender/trunk/amdasm/AsmAmdFormat.cpp

    r3338 r3341  
    704704                    char buf[64];
    705705                    snprintf(buf, 64, "Used SGPRs number out of range (0-%u)", maxSGPRsNum);
    706                     asmr.printError(valuePlace, buf);
    707                     good = false;
     706                    ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    708707                }
    709708                break;
     
    718717                    char buf[64];
    719718                    snprintf(buf, 64, "Used VGPRs number out of range (0-%u)", maxVGPRsNum);
    720                     asmr.printError(valuePlace, buf);
    721                     good = false;
     719                    ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    722720                }
    723721                break;
     
    732730                    char buf[64];
    733731                    snprintf(buf, 64, "HWLocalSize out of range (0-%u)", maxLocalSize);
    734                     asmr.printError(valuePlace, buf);
    735                     good = false;
     732                    ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    736733                }
    737734                break;
     
    749746            case AMDCVAL_UAVID:
    750747                if (value != BINGEN_NOTSUPPLIED && value >= 1024)
    751                 {
    752                     asmr.printError(valuePlace, "UAVId out of range (0-1023)");
    753                     good = false;
    754                 }
     748                    ASM_NOTGOOD_BY_ERROR(valuePlace, "UAVId out of range (0-1023)")
    755749                break;
    756750            case AMDCVAL_CBID:
    757751                if (value != BINGEN_NOTSUPPLIED && value >= 1024)
    758                 {
    759                     asmr.printError(valuePlace, "ConstBufferId out of range (0-1023)");
    760                     good = false;
    761                 }
     752                    ASM_NOTGOOD_BY_ERROR(valuePlace, "ConstBufferId out of range (0-1023)")
    762753                break;
    763754            case AMDCVAL_PRINTFID:
    764755                if (value != BINGEN_NOTSUPPLIED && value >= 1024)
    765                 {
    766                     asmr.printError(valuePlace, "PrintfId out of range (0-1023)");
    767                     good = false;
    768                 }
     756                    ASM_NOTGOOD_BY_ERROR(valuePlace, "PrintfId out of range (0-1023)")
    769757                break;
    770758            case AMDCVAL_PRIVATEID:
    771759                if (value != BINGEN_NOTSUPPLIED && value >= 1024)
    772                 {
    773                     asmr.printError(valuePlace, "PrivateId out of range (0-1023)");
    774                     good = false;
    775                 }
     760                    ASM_NOTGOOD_BY_ERROR(valuePlace, "PrivateId out of range (0-1023)")
    776761                break;
    777762            case AMDCVAL_CONDOUT:
     
    1004989    {
    1005990        if (regStart > 15)
    1006         {
    1007             asmr.printError(regStartPlace, "RegStart out of range (0-15)");
    1008             good = false;
    1009         }
     991            ASM_NOTGOOD_BY_ERROR(regStartPlace, "RegStart out of range (0-15)")
    1010992    }
    1011993    else
     
    10181000    {
    10191001        if (usumGt(regStart, regSize, 16U))
    1020         {
    1021             asmr.printError(regStartPlace, "RegStart+RegSize out of range (0-16)");
    1022             good = false;
    1023         }
     1002            ASM_NOTGOOD_BY_ERROR(regStartPlace, "RegStart+RegSize out of range (0-16)")
    10241003    }
    10251004    else
     
    11681147    bool good = getNameArg(asmr, argName, linePtr, "argument name", true);
    11691148    if (argNamesSet.find(argName) != argNamesSet.end())
    1170     {   // if found kernel arg with this same name
    1171         asmr.printError(argNamePlace, (std::string("Kernel argument '")+argName.c_str()+
    1172                     "' is already defined").c_str());
    1173         good = false;
    1174     }
     1149        // if found kernel arg with this same name
     1150        ASM_NOTGOOD_BY_ERROR(argNamePlace, (std::string("Kernel argument '")+
     1151                    argName.c_str()+"' is already defined").c_str())
    11751152   
    11761153    if (!skipRequiredComma(asmr, linePtr))
     
    12101187        {   // if not OpenCL 2.0 and argument type only present in OpenCL 2.0
    12111188            skipSpacesToEnd(linePtr, end);
    1212             asmr.printError(linePtr, "Unknown argument type");
    1213             good = false;
     1189            ASM_NOTGOOD_BY_ERROR(linePtr, "Unknown argument type")
    12141190        }
    12151191    }
     
    12181194   
    12191195    if (!pointer && argType == KernelArgType::COUNTER64)
    1220     {
    1221         asmr.printError(argTypePlace, "Unsupported counter64 type");
    1222         good = false;
    1223     }
     1196        ASM_NOTGOOD_BY_ERROR(argTypePlace, "Unsupported counter64 type")
    12241197    if (pointer && (isKernelArgImage(argType) ||
    12251198            argType == KernelArgType::SAMPLER || argType == KernelArgType::POINTER ||
    12261199            argType == KernelArgType::COUNTER32 || argType == KernelArgType::COUNTER64))
    1227     {
    1228         asmr.printError(argTypePlace, "Illegal pointer type");
    1229         good = false;
    1230     }
     1200        ASM_NOTGOOD_BY_ERROR(argTypePlace, "Illegal pointer type")
    12311201   
    12321202    if (!typeNameDefined)
     
    12751245            else if (::strcmp(name, "constant")==0)
    12761246                ptrSpace = KernelPtrSpace::CONSTANT;
    1277             else
    1278             {   // not known or not given
    1279                 asmr.printError(ptrSpacePlace, "Unknown pointer space");
    1280                 good = false;
    1281             }
     1247            else // not known or not given
     1248                ASM_NOTGOOD_BY_ERROR(ptrSpacePlace, "Unknown pointer space")
    12821249        }
    12831250        else
     
    13031270                        ptrAccess |= KARG_PTR_VOLATILE;
    13041271                    else
    1305                     {
    1306                         asmr.printError(ptrAccessPlace, "Unknown access qualifier");
    1307                         good = false;
    1308                     }
     1272                        ASM_NOTGOOD_BY_ERROR(ptrAccessPlace, "Unknown access qualifier")
    13091273                }
    13101274                else
     
    13511315                            char buf[80];
    13521316                            snprintf(buf, 80, "UAVId out of range (0-%u)", maxUavId);
    1353                             asmr.printError(place, buf);
    1354                             good = false;
     1317                            ASM_NOTGOOD_BY_ERROR(place, buf)
    13551318                        }
    13561319                    }
     
    13791342                else if (::strcmp(name, "write_only")==0 || ::strcmp(name, "wronly")==0)
    13801343                    ptrAccess = KARG_PTR_WRITE_ONLY;
    1381                 else if (*name!=0)
    1382                 {   // unknown
    1383                     asmr.printError(ptrAccessPlace, "Unknown access qualifier");
    1384                     good = false;
    1385                 }
     1344                else if (*name!=0) // unknown
     1345                    ASM_NOTGOOD_BY_ERROR(ptrAccessPlace, "Unknown access qualifier")
    13861346            }
    13871347            else
     
    14021362                        char buf[80];
    14031363                        snprintf(buf, 80, "Resource Id out of range (0-%u)", maxResId);
    1404                         asmr.printError(place, buf);
    1405                         good = false;
     1364                        ASM_NOTGOOD_BY_ERROR(place, buf)
    14061365                    }
    14071366                }
     
    14241383            {
    14251384                if (resIdVal!=BINGEN_DEFAULT && (!cl20 && resIdVal > 7))
    1426                 {
    1427                     asmr.printError(place, "Resource Id out of range (0-7)");
    1428                     good = false;
    1429                 }
     1385                    ASM_NOTGOOD_BY_ERROR(place, "Resource Id out of range (0-7)")
    14301386                else if (resIdVal!=BINGEN_DEFAULT && cl20 && resIdVal > 15)
    1431                 {
    1432                     asmr.printError(place, "Sampler Id out of range (0-15)");
    1433                     good = false;
    1434                 }
     1387                    ASM_NOTGOOD_BY_ERROR(place, "Sampler Id out of range (0-15)")
    14351388            }
    14361389            else
     
    14721425                usedArg = 2;
    14731426            else
    1474             {
    1475                 asmr.printError(place, "This is not 'unused' specifier");
    1476                 good = false;
    1477             }
     1427                ASM_NOTGOOD_BY_ERROR(place, "This is not 'unused' specifier")
    14781428        }
    14791429    }
  • CLRadeonExtender/trunk/amdasm/AsmGalliumFormat.cpp

    r3338 r3341  
    571571                    char buf[64];
    572572                    snprintf(buf, 64, "Used SGPRs number out of range (0-%u)", maxSGPRsNum);
    573                     asmr.printError(valuePlace, buf);
    574                     good = false;
     573                    ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    575574                }
    576575                break;
     
    585584                    char buf[64];
    586585                    snprintf(buf, 64, "Used VGPRs number out of range (0-%u)", maxVGPRsNum);
    587                     asmr.printError(valuePlace, buf);
    588                     good = false;
     586                    ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    589587                }
    590588                break;
     
    600598                    snprintf(buf, 64, "Spilled SGPRs number out of range (0-%u)",
    601599                             maxSGPRsNum);
    602                     asmr.printError(valuePlace, buf);
    603                     good = false;
     600                    ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    604601                }
    605602                break;
     
    615612                    snprintf(buf, 64, "Spilled VGPRs number out of range (0-%u)",
    616613                             maxVGPRsNum);
    617                     asmr.printError(valuePlace, buf);
    618                     good = false;
     614                    ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    619615                }
    620616                break;
     
    644640                    char buf[64];
    645641                    snprintf(buf, 64, "LocalSize out of range (0-%u)", maxLocalSize);
    646                     asmr.printError(valuePlace, buf);
    647                     good = false;
     642                    ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    648643                }
    649644                break;
     
    651646            case GALLIUMCVAL_USERDATANUM:
    652647                if (value > 16)
    653                 {
    654                     asmr.printError(valuePlace, "UserDataNum out of range (0-16)");
    655                     good = false;
    656                 }
     648                    ASM_NOTGOOD_BY_ERROR(valuePlace, "UserDataNum out of range (0-16)")
    657649                break;
    658650            case GALLIUMCVAL_PGMRSRC1:
     
    965957                argType = galliumArgTypesMap[index].second;
    966958            else
    967             {
    968                 asmr.printError(nameStringPlace, "Unknown argument type");
    969                 good = false;
    970             }
     959                ASM_NOTGOOD_BY_ERROR(nameStringPlace, "Unknown argument type")
    971960        }
    972961    }
     
    10181007                                      "Target alignment of argument out of range");
    10191008                if (targetAlign==0 || targetAlign != (1ULL<<(63-CLZ64(targetAlign))))
    1020                 {
    1021                     asmr.printError(targetAlignPlace, "Target alignment is not power of 2");
    1022                     good = false;
    1023                 }
     1009                    ASM_NOTGOOD_BY_ERROR(targetAlignPlace,
     1010                                    "Target alignment is not power of 2");
    10241011            }
    10251012            else
     
    10381025                        sext = true;
    10391026                    else if (::strcmp(name, "zext")!=0 && *name!=0)
    1040                     {
    1041                         asmr.printError(numExtPlace, "Unknown numeric extension");
    1042                         good = false;
    1043                     }
     1027                        ASM_NOTGOOD_BY_ERROR(numExtPlace, "Unknown numeric extension")
    10441028                }
    10451029                else
  • CLRadeonExtender/trunk/amdasm/AsmPseudoOps.cpp

    r3339 r3341  
    331331                    sectFlags |= ASMELFSECT_WRITEABLE;
    332332                else if (flagsStrIsGood)
    333                 {
    334                     asmr.printError(flagsStrPlace,
    335                             "Only 'a', 'w', 'x' is accepted in flags string");
    336                     flagsStrIsGood = good = false;
    337                 }
     333                    ASM_NOTGOOD_BY_ERROR1(flagsStrIsGood = good, flagsStrPlace,
     334                            "Only 'a', 'w', 'x' is accepted in flags string")
    338335        }
    339336        else
     
    361358                        sectType = AsmSectionType::EXTRA_NOBITS;
    362359                    else
    363                     {
    364                         asmr.printError(typePlace, "Unknown section type");
    365                         good = false;
    366                     }
     360                        ASM_NOTGOOD_BY_ERROR(typePlace, "Unknown section type")
    367361                }
    368362                else
     
    370364            }
    371365            else
    372             {
    373                 asmr.printError(typePlace, "Section type was not preceded by '@'");
    374                 good = false;
    375             }
     366                ASM_NOTGOOD_BY_ERROR(typePlace, "Section type was not preceded by '@'")
    376367        }
    377368    }
     
    389380            {
    390381                if (sectionAlign!=0 && (1ULL<<(63-CLZ64(sectionAlign))) != sectionAlign)
    391                 {
    392                     asmr.printError(valuePtr, "Alignment must be power of two or zero");
    393                     good = false;
    394                 }
     382                    ASM_NOTGOOD_BY_ERROR(valuePtr, "Alignment must be power of two or zero")
    395383            }
    396384            else
     
    398386        }
    399387        else
    400         {
    401             asmr.printError(linePtr, "Expected '=' after 'align'");
    402             good = false;
    403         }
     388            ASM_NOTGOOD_BY_ERROR(linePtr, "Expected '=' after 'align'")
    404389    }
    405390   
     
    496481        {
    497482            if (int64_t(offset) < 0)
    498             {
    499                 asmr.printError(offsetPlace, "Offset is negative!");
    500                 good = false;
    501             }
     483                ASM_NOTGOOD_BY_ERROR(offsetPlace, "Offset is negative!")
    502484        }
    503485        else
     
    512494            good &= getAbsoluteValueArg(asmr, count, linePtr);
    513495            if (int64_t(count) < 0)
    514             {
    515                 asmr.printError(countPlace, "Count bytes is negative!");
    516                 good = false;
    517             }
     496                ASM_NOTGOOD_BY_ERROR(countPlace, "Count bytes is negative!")
    518497        }
    519498    }
     
    867846    bool good = true;
    868847    if (symName.empty())
    869     {
    870         asmr.printError(linePtr, "Expected symbol");
    871         good = false;
    872     }
     848        ASM_NOTGOOD_BY_ERROR(linePtr, "Expected symbol")
    873849    if (!skipRequiredComma(asmr, linePtr))
    874850        return;
     
    887863        bool good = (state != Assembler::ParseState::FAILED);
    888864        if (symEntry == nullptr)
    889         {
    890             asmr.printError(symNamePlace, "Expected symbol name");
    891             good = false;
    892         }
     865            ASM_NOTGOOD_BY_ERROR(symNamePlace, "Expected symbol name")
    893866        else if (symEntry->second.regRange)
    894         {
    895             asmr.printError(symNamePlace, "Symbol must not be register symbol");
    896             good = false;
    897         }
     867            ASM_NOTGOOD_BY_ERROR(symNamePlace, "Symbol must not be register symbol")
    898868        else if (symEntry->second.base)
    899         {
    900             asmr.printError(symNamePlace,
    901                 "Symbol must not be set by .eqv pseudo-op or must be constant");
    902             good = false;
    903         }
     869            ASM_NOTGOOD_BY_ERROR(symNamePlace,
     870                "Symbol must not be set by .eqv pseudo-op or must be constant")
    904871       
    905872        if (good)
     
    925892    bool good = (state != Assembler::ParseState::FAILED);
    926893    if (symEntry == nullptr)
    927     {
    928         asmr.printError(symNamePlace, "Expected symbol name");
    929         good = false;
    930     }
     894        ASM_NOTGOOD_BY_ERROR(symNamePlace, "Expected symbol name")
    931895    if (!skipRequiredComma(asmr, linePtr))
    932896        return;
     
    938902    {
    939903        if (symEntry->second.base)
    940         {
    941             asmr.printError(symNamePlace,
    942                     "Symbol must not be set by .eqv pseudo-op or must be constant");
    943             good = false;
    944         }
     904            ASM_NOTGOOD_BY_ERROR(symNamePlace,
     905                    "Symbol must not be set by .eqv pseudo-op or must be constant")
    945906        else if (symEntry->second.regRange)
    946         {
    947             asmr.printError(symNamePlace, "Symbol must not be register symbol");
    948             good = false;
    949         }
     907            ASM_NOTGOOD_BY_ERROR(symNamePlace, "Symbol must not be register symbol")
    950908        else if (symEntry->first == ".")
    951909        {
     
    1017975    }
    1018976    if (int64_t(size) > 0 && int64_t(repeat) > 0 && SSIZE_MAX/size < repeat)
    1019     {
    1020         asmr.printError(pseudoOpPlace, "Product of repeat and size is too big");
    1021         good = false;
    1022     }
     977        ASM_NOTGOOD_BY_ERROR(pseudoOpPlace, "Product of repeat and size is too big")
    1023978   
    1024979    cxuint truncBits = std::min(uint64_t(8), size)<<3;
     
    11141069        {
    11151070            if (alignment > 63)
    1116             {
    1117                 asmr.printError(alignPlace, "Power of 2 of alignment is greater than 63");
    1118                 good = false;
    1119             }
     1071                ASM_NOTGOOD_BY_ERROR(alignPlace, "Power of 2 of alignment is "
     1072                            "greater than 63")
    11201073            else
    11211074                alignment = (1ULL<<alignment);
    11221075        }
    11231076        else if (alignment == 0 || (1ULL<<(63-CLZ64(alignment))) != alignment)
    1124         {
    1125             asmr.printError(alignPlace, "Alignment is not power of 2");
    1126             good = false;
    1127         }
     1077            ASM_NOTGOOD_BY_ERROR(alignPlace, "Alignment is not power of 2")
    11281078    }
    11291079   
     
    11871137    bool good = getAbsoluteValueArg(asmr, alignment, linePtr, true);
    11881138    if (good && alignment != 0 && (1ULL<<(63-CLZ64(alignment))) != alignment)
    1189     {
    1190         asmr.printError(alignPlace, "Alignment is not power of 2");
    1191         good = false;
    1192     }
     1139        ASM_NOTGOOD_BY_ERROR(alignPlace, "Alignment is not power of 2")
    11931140   
    11941141    bool haveValue = false;
     
    13471294        return;
    13481295    if (state == Assembler::ParseState::MISSING)
    1349     {
    1350         asmr.printError(symNamePlace, "Expected symbol");
    1351         good = false;
    1352     }
     1296        ASM_NOTGOOD_BY_ERROR(symNamePlace, "Expected symbol")
    13531297    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
    13541298        return;
     
    16561600   
    16571601    if (asmr.macroMap.find(macroName) != asmr.macroMap.end())
    1658     {
    1659         asmr.printError(macroNamePlace, (std::string("Macro '") + macroName.c_str() +
     1602        ASM_NOTGOOD_BY_ERROR(macroNamePlace, (std::string("Macro '") + macroName.c_str() +
    16601603                "' is already defined").c_str());
    1661         good = false;
    1662     }
    16631604   
    16641605    {
     
    16791620       
    16801621        if (!macroArgSet.insert(argName).second)
    1681         {   // duplicate!
    1682             asmr.printError(argPlace, (std::string("Duplicated macro argument '")+
    1683                     argName.c_str()+'\'').c_str());
    1684             argGood = false;
    1685         }
     1622            // duplicate!
     1623            ASM_NOTGOOD_BY_ERROR1(argGood, argPlace, (std::string(
     1624                    "Duplicated macro argument '")+ argName.c_str()+'\'').c_str())
    16861625       
    16871626        skipSpacesToEnd(linePtr, end);
     
    17011640                linePtr += 6;
    17021641            }
    1703             else
    1704             {   // otherwise
    1705                 asmr.printError(linePtr, "Expected qualifier 'req' or 'vararg'");
    1706                 argGood = false;
    1707             }
     1642            else // otherwise
     1643                ASM_NOTGOOD_BY_ERROR1(argGood, linePtr,
     1644                        "Expected qualifier 'req' or 'vararg'")
    17081645        }
    17091646        skipSpacesToEnd(linePtr, end);
     
    17261663        {
    17271664            if (haveVarArg)
    1728             {
    1729                 asmr.printError(argPlace, "Variadic argument must be last");
    1730                 good = false;
    1731             }
     1665                ASM_NOTGOOD_BY_ERROR(argPlace, "Variadic argument must be last")
    17321666            else
    17331667                haveVarArg = argVarArgs;
     
    18801814    bool good = true;
    18811815    if (asmr.scopeStack.size() == 1000)
    1882     {
    1883         asmr.printError(pseudoOpPlace, "Scope level is greater than 1000");
    1884         good = false;
    1885     }
     1816        ASM_NOTGOOD_BY_ERROR(pseudoOpPlace, "Scope level is greater than 1000")
    18861817    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
    18871818        return;
     
    18971828    bool good = true;
    18981829    if (asmr.scopeStack.empty())
    1899     {
    1900         asmr.printError(pseudoOpPlace, "Closing global scope is illegal");
    1901         good = false;
    1902     }
     1830        ASM_NOTGOOD_BY_ERROR(pseudoOpPlace, "Closing global scope is illegal")
    19031831    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
    19041832        return;
     
    19151843    bool good = true;
    19161844    if (scopePath.empty() || scopePath == "::")
    1917     {
    1918         asmr.printError(scopePathPlace, "Expected scope path");
    1919         good = false;
    1920     }
     1845        ASM_NOTGOOD_BY_ERROR(scopePathPlace, "Expected scope path")
    19211846    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
    19221847        return;
     
    19861911    bool good = true;
    19871912    if (scopePath == "::")
    1988     {
    1989         asmr.printError(scopePathPlace, "Expected scope path");
    1990         good = false;
    1991     }
     1913        ASM_NOTGOOD_BY_ERROR(scopePathPlace, "Expected scope path")
    19921914    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
    19931915        return;
     
    20071929    bool good = true;
    20081930    if (symName.empty())
    2009     {
    2010         asmr.printError(symNamePlace, "Expected symbol name");
    2011         good = false;
    2012     }
     1931        ASM_NOTGOOD_BY_ERROR(symNamePlace, "Expected symbol name")
    20131932    else if (symName == ".")
    2014     {
    2015         asmr.printError(symNamePlace, "Symbol '.' can not be undefined");
    2016         good = false;
    2017     }
     1933        ASM_NOTGOOD_BY_ERROR(symNamePlace, "Symbol '.' can not be undefined")
    20181934    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
    20191935        return;
     
    20561972        bool good = true;
    20571973        if (name.empty())
    2058         {
    2059             asmr.printError(regNamePlace, "Expected reg-var name");
    2060             good = false;
    2061         }
     1974            ASM_NOTGOOD_BY_ERROR(regNamePlace, "Expected reg-var name")
    20621975        skipSpacesToEnd(linePtr, end);
    20631976        if (linePtr==end || *linePtr!=':')
     
    20691982        AsmRegVar var = { 0, 1 };
    20701983        if (!asmr.isaAssembler->parseRegisterType(linePtr, end, var.type))
    2071         {
    2072             asmr.printError(linePtr, "Expected name of register type");
    2073             good = false;
    2074         }
     1984            ASM_NOTGOOD_BY_ERROR(linePtr, "Expected name of register type")
    20751985        skipSpacesToEnd(linePtr, end);
    20761986       
     
    20881998                continue;
    20891999            if (regSize==0)
    2090             {
    2091                 asmr.printError(linePtr, "Size of reg-var is zero");
    2092                 good = false;
    2093             }
     2000                ASM_NOTGOOD_BY_ERROR(linePtr, "Size of reg-var is zero")
    20942001            if (regSize>UINT16_MAX)
    2095             {
    2096                 asmr.printError(linePtr, "Size of reg-var out of range");
    2097                 good = false;
    2098             }
     2002                ASM_NOTGOOD_BY_ERROR(linePtr, "Size of reg-var out of range")
    20992003            var.size = regSize;
    21002004        }
     
    21622066    size_t symNameLength = symName.size();
    21632067    if (symNameLength >= 3 && symName.compare(symNameLength-3, 3, "::.")==0)
    2164     {
    2165         asmr.printError(symNamePlace, "Symbol '.' can be only in global scope");
    2166         return;
    2167     }
     2068        ASM_RETURN_BY_ERROR(symNamePlace, "Symbol '.' can be only in global scope")
    21682069    if (!checkGarbagesAtEnd(asmr, linePtr))
    21692070        return;
  • CLRadeonExtender/trunk/amdasm/AsmROCmFormat.cpp

    r3338 r3341  
    406406                char buf[64];
    407407                snprintf(buf, 64, "Used SGPRs number out of range (0-%u)", maxSGPRsNum);
    408                 asmr.printError(valuePlace, buf);
    409                 good = false;
     408                ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    410409            }
    411410            break;
     
    420419                char buf[64];
    421420                snprintf(buf, 64, "Used VGPRs number out of range (0-%u)", maxVGPRsNum);
    422                 asmr.printError(valuePlace, buf);
    423                 good = false;
     421                ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    424422            }
    425423            break;
     
    452450                char buf[64];
    453451                snprintf(buf, 64, "LocalSize out of range (0-%u)", maxLocalSize);
    454                 asmr.printError(valuePlace, buf);
    455                 good = false;
     452                ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    456453            }
    457454            break;
     
    459456        case ROCMCVAL_USERDATANUM:
    460457            if (value > 16)
    461             {
    462                 asmr.printError(valuePlace, "UserDataNum out of range (0-16)");
    463                 good = false;
    464             }
     458                ASM_NOTGOOD_BY_ERROR(valuePlace, "UserDataNum out of range (0-16)")
    465459            break;
    466460        case ROCMCVAL_PRIVATE_ELEM_SIZE:
    467461            if (value==0 || 1ULL<<(63-CLZ64(value)) != value)
    468             {
    469                 asmr.printError(valuePlace,
    470                                 "Private element size must be power of two");
    471                 good = false;
    472             }
     462                ASM_NOTGOOD_BY_ERROR(valuePlace,
     463                                "Private element size must be power of two")
    473464            else if (value < 2 || value > 16)
    474             {
    475                 asmr.printError(valuePlace, "Private element size out of range");
    476                 good = false;
    477             }
     465                ASM_NOTGOOD_BY_ERROR(valuePlace, "Private element size out of range")
    478466            break;
    479467        case ROCMCVAL_KERNARG_SEGMENT_ALIGN:
     
    481469        case ROCMCVAL_PRIVATE_SEGMENT_ALIGN:
    482470            if (value==0 || 1ULL<<(63-CLZ64(value)) != value)
    483             {
    484                 asmr.printError(valuePlace, "Alignment must be power of two");
    485                 good = false;
    486             }
     471                ASM_NOTGOOD_BY_ERROR(valuePlace, "Alignment must be power of two")
    487472            else if (value < 16)
    488             {
    489                 asmr.printError(valuePlace, "Alignment must be not smaller than 16");
    490                 good = false;
    491             }
     473                ASM_NOTGOOD_BY_ERROR(valuePlace, "Alignment must be not smaller than 16")
    492474            break;
    493475        case ROCMCVAL_WAVEFRONT_SIZE:
    494476            if (value==0 || 1ULL<<(63-CLZ64(value)) != value)
    495             {
    496                 asmr.printError(valuePlace, "Wavefront size must be power of two");
    497                 good = false;
    498             }
     477                ASM_NOTGOOD_BY_ERROR(valuePlace, "Wavefront size must be power of two")
    499478            else if (value > 256)
    500             {
    501                 asmr.printError(valuePlace,
    502                             "Wavefront size must be not greater than 256");
    503                 good = false;
    504             }
     479                ASM_NOTGOOD_BY_ERROR(valuePlace,
     480                            "Wavefront size must be not greater than 256")
    505481            break;
    506482        case ROCMCVAL_WORKITEM_PRIVATE_SEGMENT_SIZE:
     
    520496            cxuint maxSGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_SGPR, 0);
    521497            if (value >= maxSGPRsNum)
    522             {
    523                 asmr.printError(valuePlace, "SGPR register out of range");
    524                 good = false;
    525             }
     498                ASM_NOTGOOD_BY_ERROR(valuePlace, "SGPR register out of range")
    526499            break;
    527500        }
     
    900873        snprintf(buf, 64, "First reserved %s register out of range (0-%u)",
    901874                 inVgpr ? "VGPR" : "SGPR",  maxGPRsNum-1);
    902         asmr.printError(valuePlace, buf);
    903         good = false;
     875        ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    904876    }
    905877    if (!skipRequiredComma(asmr, linePtr))
     
    914886        snprintf(buf, 64, "Last reserved %s register out of range (0-%u)",
    915887                 inVgpr ? "VGPR" : "SGPR", maxGPRsNum-1);
    916         asmr.printError(valuePlace, buf);
    917         good = false;
     888        ASM_NOTGOOD_BY_ERROR(valuePlace, buf)
    918889    }
    919890    if (haveFirstReg && haveLastReg && firstReg > lastReg)
    920     {
    921         asmr.printError(valuePlace, "Wrong register range");
    922         good = false;
    923     }
     891        ASM_NOTGOOD_BY_ERROR(valuePlace, "Wrong register range")
    924892   
    925893    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
Note: See TracChangeset for help on using the changeset viewer.