Changeset 3343 in CLRX


Ignore:
Timestamp:
Sep 8, 2017, 6:15:45 PM (10 months ago)
Author:
matszpk
Message:

CLRadeonExtender: Yet another killing code lines by macros (GCNAsmHelpers.cpp).

File:
1 edited

Legend:

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

    r3305 r3343  
    104104                skipSpacesToEnd(linePtr, end);
    105105                if (linePtr == end || (*linePtr!=':' && *linePtr!=']'))
    106                 {   // error
    107                     asmr.printError(regVarPlace, "Unterminated register range");
    108                     return false;
    109                 }
     106                    // error
     107                    ASM_FAIL_BY_ERROR(regVarPlace, "Unterminated register range")
    110108                if (linePtr!=end && *linePtr==':')
    111109                {
     
    118116                skipSpacesToEnd(linePtr, end);
    119117                if (linePtr == end || *linePtr != ']')
    120                 {   // error
    121                     asmr.printError(regVarPlace, "Unterminated register range");
    122                     return false;
    123                 }
     118                    // error
     119                    ASM_FAIL_BY_ERROR(regVarPlace, "Unterminated register range")
    124120                ++linePtr;
    125121                if (value2 < value1)
    126                 {   // error (illegal register range)
    127                     asmr.printError(regVarPlace, "Illegal register range");
    128                     return false;
    129                 }
     122                    // error (illegal register range)
     123                    ASM_FAIL_BY_ERROR(regVarPlace, "Illegal register range")
    130124                if (value2 >= rend || value1 >= rend)
    131                 {
    132                     asmr.printError(regVarPlace, "Regvar range out of range");
    133                     return false;
    134                 }
     125                    ASM_FAIL_BY_ERROR(regVarPlace, "Regvar range out of range")
    135126                rend = value2+1;
    136127                rstart = value1;
     
    203194                skipSpacesToEnd(linePtr, end);
    204195                if (linePtr == end || (*linePtr!=':' && *linePtr!=']'))
    205                 {   // error
    206                     asmr.printError(regRangePlace, "Unterminated register range");
    207                     return false;
    208                 }
     196                    // error
     197                    ASM_FAIL_BY_ERROR(regRangePlace, "Unterminated register range")
    209198                if (linePtr!=end && *linePtr==':')
    210199                {
     
    217206                skipSpacesToEnd(linePtr, end);
    218207                if (linePtr == end || *linePtr != ']')
    219                 {   // error
    220                     asmr.printError(regRangePlace, "Unterminated register range");
    221                     return false;
    222                 }
     208                    // error
     209                    ASM_FAIL_BY_ERROR(regRangePlace, "Unterminated register range")
    223210                ++linePtr;
    224211                if (value2 < value1)
    225                 {   // error (illegal register range)
    226                     asmr.printError(regRangePlace, "Illegal register range");
    227                     return false;
    228                 }
     212                    // error (illegal register range)
     213                    ASM_FAIL_BY_ERROR(regRangePlace, "Illegal register range")
    229214                if (value2 >= rend-rstart || value1 >= rend-rstart)
    230                 {
    231                     asmr.printError(regRangePlace, "Register range out of range");
    232                     return false;
    233                 }
     215                    ASM_FAIL_BY_ERROR(regRangePlace, "Register range out of range")
    234216                rend = rstart + value2+1;
    235217                rstart += value1;
     
    248230                    if ((rend-rstart==2 && (rstart&1)!=0) ||
    249231                        (rend-rstart>2 && (rstart&3)!=0))
    250                     {
    251                         asmr.printError(regRangePlace, "Unaligned scalar register range");
    252                         return false;
    253                     }
     232                        ASM_FAIL_BY_ERROR(regRangePlace, "Unaligned scalar register range")
    254233                }   
    255234                else if ((flags & INSTROP_UNALIGNED) == INSTROP_SGPR_UNALIGNED)
    256235                    if ((rstart & 0xfc) != ((rend-1) & 0xfc))
    257                     { // unaligned, but some restrictions
    258                         asmr.printError(regRangePlace,
    259                                 "Scalar register range cross two register lines");
    260                         return false;
    261                     }
     236                      // unaligned, but some restrictions
     237                        ASM_FAIL_BY_ERROR(regRangePlace,
     238                                "Scalar register range cross two register lines")
    262239            }
    263240           
     
    360337        skipSpacesToEnd(linePtr, end);
    361338        if (linePtr == end || (*linePtr!=':' && *linePtr!=']'))
    362         {   // error
    363             asmr.printError(vgprRangePlace, "Unterminated vector register range");
    364             return false;
    365         }
     339            // error
     340            ASM_FAIL_BY_ERROR(vgprRangePlace, "Unterminated vector register range")
    366341        if (linePtr!=end && *linePtr==':')
    367342        {
     
    375350        skipSpacesToEnd(linePtr, end);
    376351        if (linePtr == end || *linePtr != ']')
    377         {   // error
    378             asmr.printError(vgprRangePlace, "Unterminated vector register range");
    379             return false;
    380         }
     352            // error
     353            ASM_FAIL_BY_ERROR(vgprRangePlace, "Unterminated vector register range")
    381354        ++linePtr;
    382355       
    383356        if (value2 < value1)
    384         {   // error (illegal register range)
    385             asmr.printError(vgprRangePlace, "Illegal vector register range");
    386             return false;
    387         }
     357            // error (illegal register range)
     358            ASM_FAIL_BY_ERROR(vgprRangePlace, "Illegal vector register range")
    388359        if (value1 >= 256 || value2 >= 256)
    389         {
    390             asmr.printError(vgprRangePlace, "Some vector register number out of range");
    391             return false;
    392         }
     360            ASM_FAIL_BY_ERROR(vgprRangePlace, "Some vector register number out of range")
    393361       
    394362        if (regsNum!=0 && regsNum != value2-value1+1)
     
    466434                {   // if scalar register
    467435                    if (value >= maxSGPRsNum)
    468                     {
    469                         asmr.printError(sgprRangePlace,
    470                                         "Scalar register number out of range");
    471                         return false;
    472                     }
     436                        ASM_FAIL_BY_ERROR(sgprRangePlace,
     437                                        "Scalar register number out of range")
    473438                }
    474439                else
    475440                {   // ttmp register
    476441                    if (value >= ttmpSize)
    477                     {
    478                         asmr.printError(sgprRangePlace,
     442                        ASM_FAIL_BY_ERROR(sgprRangePlace,
    479443                            isGCN14 ? "TTMPRegister number out of range (0-15)" :
    480                             "TTMPRegister number out of range (0-11)");
    481                         return false;
    482                     }
     444                            "TTMPRegister number out of range (0-11)")
    483445                }
    484446                if (regsNum!=0 && regsNum!=1)
     
    635597        skipSpacesToEnd(linePtr, end);
    636598        if (linePtr == end || (*linePtr!=':' && *linePtr!=']'))
    637         {   // error
    638             asmr.printError(sgprRangePlace, (!ttmpReg) ?
     599            // error
     600            ASM_FAIL_BY_ERROR(sgprRangePlace, (!ttmpReg) ?
    639601                        "Unterminated scalar register range" :
    640                         "Unterminated TTMPRegister range");
    641             return false;
    642         }
     602                        "Unterminated TTMPRegister range")
    643603        if (linePtr!=end && *linePtr==':')
    644604        {
     
    652612        skipSpacesToEnd(linePtr, end);
    653613        if (linePtr == end || *linePtr != ']')
    654         {   // error
    655             asmr.printError(sgprRangePlace, (!ttmpReg) ?
     614            // error
     615            ASM_FAIL_BY_ERROR(sgprRangePlace, (!ttmpReg) ?
    656616                        "Unterminated scalar register range" :
    657                         "Unterminated TTMPRegister range");
    658             return false;
    659         }
     617                        "Unterminated TTMPRegister range")
    660618        ++linePtr;
    661619       
     
    663621        {   // is scalar register
    664622            if (value2 < value1)
    665             {   // error (illegal register range)
    666                 asmr.printError(sgprRangePlace, "Illegal scalar register range");
    667                 return false;
    668             }
     623                // error (illegal register range)
     624                ASM_FAIL_BY_ERROR(sgprRangePlace, "Illegal scalar register range")
    669625            if (value1 >= maxSGPRsNum || value2 >= maxSGPRsNum)
    670             {
    671                 asmr.printError(sgprRangePlace,
    672                             "Some scalar register number out of range");
    673                 return false;
    674             }
     626                ASM_FAIL_BY_ERROR(sgprRangePlace,
     627                            "Some scalar register number out of range")
    675628        }
    676629        else
    677630        {   // is TTMP register
    678631            if (value2 < value1)
    679             {   // error (illegal register range)
    680                 asmr.printError(sgprRangePlace, "Illegal TTMPRegister range");
    681                 return false;
    682             }
     632                // error (illegal register range)
     633                ASM_FAIL_BY_ERROR(sgprRangePlace, "Illegal TTMPRegister range")
    683634            if (value1 >= ttmpSize || value2 >= ttmpSize)
    684             {
    685                 asmr.printError(sgprRangePlace,
     635                ASM_FAIL_BY_ERROR(sgprRangePlace,
    686636                            isGCN14 ? "Some TTMPRegister number out of range (0-15)" :
    687                             "Some TTMPRegister number out of range (0-11)");
    688                 return false;
    689             }
     637                            "Some TTMPRegister number out of range (0-11)")
    690638        }
    691639       
     
    703651                if ((value2-value1==1 && (value1&1)!=0) ||
    704652                    (value2-value1>1 && (value1&3)!=0))
    705                 {
    706                     asmr.printError(sgprRangePlace, "Unaligned scalar register range");
    707                     return false;
    708                 }
     653                    ASM_FAIL_BY_ERROR(sgprRangePlace, "Unaligned scalar register range")
    709654            }
    710655            else  if ((flags & INSTROP_UNALIGNED)==INSTROP_SGPR_UNALIGNED)
    711656                if ((value1 & 0xfc) != ((value2) & 0xfc))
    712                 { // unaligned, but some restrictions
    713                     asmr.printError(sgprRangePlace,
    714                             "Scalar register range cross two register lines");
    715                     return false;
    716                 }
     657                  // unaligned, but some restrictions
     658                    ASM_FAIL_BY_ERROR(sgprRangePlace,
     659                            "Scalar register range cross two register lines")
    717660            regPair = { value1, uint16_t(value2)+1 };
    718661            if (regField != ASMFIELD_NONE)
     
    745688        return false;
    746689    if (expr->isEmpty())
    747     {
    748         asmr.printError(exprPlace, "Expected expression");
    749         return false;
    750     }
     690        ASM_FAIL_BY_ERROR(exprPlace, "Expected expression")
    751691    if (expr->getSymOccursNum()==0)
    752692    {   // resolved now
     
    756696            return false;
    757697        else if (sectionId != ASMSECT_ABS)
    758         {   // if not absolute value
    759             asmr.printError(exprPlace, "Expression must be absolute!");
    760             return false;
    761         }
     698            // if not absolute value
     699            ASM_FAIL_BY_ERROR(exprPlace, "Expression must be absolute!")
    762700        if (bits != UINT_MAX)
    763701        {
     
    775713            *outTargetExpr = std::move(expr);
    776714        else
    777         {
    778             asmr.printError(exprPlace, "Unresolved expression is illegal in this place");
    779             return false;
    780         }
     715            ASM_FAIL_BY_ERROR(exprPlace, "Unresolved expression is illegal in this place")
    781716        return true;
    782717    }
     
    1020955            }
    1021956            else
    1022             {
    1023                 asmr.printError(linePtr, "Expected '(' after sext");
    1024                 return false;
    1025             }
     957                ASM_FAIL_BY_ERROR(linePtr, "Expected '(' after sext")
    1026958        }
    1027959       
     
    1045977            }
    1046978            else
    1047             {
    1048                 asmr.printError(linePtr, "Expected '(' after abs");
    1049                 return false;
    1050             }
     979                ASM_FAIL_BY_ERROR(linePtr, "Expected '(' after abs")
    1051980        }
    1052981        else if (linePtr<=end && linePtr[0]=='|')
     
    10761005                linePtr++;
    10771006            else
    1078             {
    1079                 asmr.printError(linePtr, "Unterminated abs() modifier");
    1080                 return false;
    1081             }
     1007                ASM_FAIL_BY_ERROR(linePtr, "Unterminated abs() modifier")
    10821008        }
    10831009        if (operand.vopMods & VOPOP_SEXT)
     
    10871013                linePtr++;
    10881014            else
    1089             {
    1090                 asmr.printError(linePtr, "Unterminated sext() modifier");
    1091                 return false;
    1092             }
     1015                ASM_FAIL_BY_ERROR(linePtr, "Unterminated sext() modifier")
    10931016        }
    10941017        return good;
     
    11851108        }
    11861109        if (linePtr==end || *linePtr==',')
    1187         {
    1188             asmr.printError(linePtr, "Expected instruction operand");
    1189             return false;
    1190         }
     1110            ASM_FAIL_BY_ERROR(linePtr, "Expected instruction operand")
    11911111        const char* exprPlace = linePtr;
    11921112       
     
    14271347                return false;
    14281348            if (expr->isEmpty())
    1429             {
    1430                 asmr.printError(exprPlace, "Expected expression");
    1431                 return false;
    1432             }
     1349                ASM_FAIL_BY_ERROR(exprPlace, "Expected expression")
    14331350            if (expr->getSymOccursNum()==0)
    14341351            {   // resolved now
     
    14371354                    return false;
    14381355                else if (sectionId != ASMSECT_ABS)
    1439                 {   // if not absolute value
    1440                     asmr.printError(exprPlace, "Expression must be absolute!");
    1441                     return false;
    1442                 }
     1356                    // if not absolute value
     1357                    ASM_FAIL_BY_ERROR(exprPlace, "Expression must be absolute!")
    14431358            }
    14441359            else
     
    14791394            skipSpacesToEnd(linePtr, end);
    14801395            if (linePtr==end || *linePtr!=')')
    1481             {
    1482                 asmr.printError(linePtr, "Expected ')' after expression at 'lit'");
    1483                 return false;
    1484             }
     1396                ASM_FAIL_BY_ERROR(linePtr, "Expected ')' after expression at 'lit'")
    14851397            else // skip end of lit
    14861398                linePtr++;
     
    15331445            if (linePtr==end || *linePtr!=',')
    15341446            {
    1535                 asmr.printError(linePtr, "Expected ',' before bit value");
    1536                 good = false;
     1447                ASM_NOTGOOD_BY_ERROR(linePtr, "Expected ',' before bit value")
    15371448                break;
    15381449            }
     
    15431454        {   // end of array, try parse ']'
    15441455            if (linePtr == end || *linePtr!=']')
    1545             {
    1546                 asmr.printError(linePtr, "Unterminated bit array");
    1547                 good = false;
    1548             }
     1456                ASM_NOTGOOD_BY_ERROR(linePtr, "Unterminated bit array")
    15491457            else
    15501458                ++linePtr;
     
    16421550                        }
    16431551                        else
    1644                         {
    1645                             asmr.printError(modPlace, "Unknown VOP3 mul:X modifier");
    1646                             good = false;
    1647                         }
     1552                            ASM_NOTGOOD_BY_ERROR(modPlace, "Unknown VOP3 mul:X modifier")
    16481553                    }
    16491554                    else
    1650                     {
    1651                         asmr.printError(linePtr, "Expected ':' before multiplier number");
    1652                         good = false;
    1653                     }
     1555                        ASM_NOTGOOD_BY_ERROR(linePtr,
     1556                                    "Expected ':' before multiplier number")
    16541557                }
    16551558                else if (!vop3p && ::strcmp(mod, "div")==0)
     
    16661569                        }
    16671570                        else
    1668                         {
    1669                             asmr.printError(modPlace, "Unknown VOP3 div:X modifier");
    1670                             good = false;
    1671                         }
     1571                            ASM_NOTGOOD_BY_ERROR(modPlace, "Unknown VOP3 div:X modifier")
    16721572                    }
    16731573                    else
    1674                     {
    1675                         asmr.printError(linePtr, "Expected ':' before divider number");
    1676                         good = false;
    1677                     }
     1574                        ASM_NOTGOOD_BY_ERROR(linePtr, "Expected ':' before divider number")
    16781575                }
    16791576                else if (!vop3p && ::strcmp(mod, "omod")==0)
     
    16901587                    }
    16911588                    else
    1692                     {
    1693                         asmr.printError(linePtr, "Expected ':' before omod");
    1694                         good = false;
    1695                     }
     1589                        ASM_NOTGOOD_BY_ERROR(linePtr, "Expected ':' before omod")
    16961590                }
    16971591                else if (::strcmp(mod, "clamp")==0) // clamp
     
    17021596                        mods = (mods & ~VOP3_CLAMP) | (clamp ? VOP3_CLAMP : 0);
    17031597                    else
    1704                     {
    1705                         asmr.printError(modPlace, "Modifier CLAMP in VOP3B is illegal");
    1706                         good = false;
    1707                     }
     1598                        ASM_NOTGOOD_BY_ERROR(modPlace, "Modifier CLAMP in VOP3B is illegal")
    17081599                }
    17091600                else if (!vop3p && modOperands>1 && ::strcmp(mod, "abs")==0)
     
    18691760                        }
    18701761                        else
    1871                         {
    1872                             asmr.printError(linePtr, "Expected ':' before dst_sel");
    1873                             good = false;
    1874                         }
     1762                            ASM_NOTGOOD_BY_ERROR(linePtr, "Expected ':' before dst_sel")
    18751763                    }
    18761764                    else if (withSDWAOperands>=1 && (flags&PARSEVOP_NODSTMODS)==0 &&
     
    18961784                                        unused = 2;
    18971785                                    else if (::strcmp(name+namePos, "pad")!=0)
    1898                                     {
    1899                                         asmr.printError(enumPlace, "Unknown dst_unused");
    1900                                         good = false;
    1901                                     }
     1786                                        ASM_NOTGOOD_BY_ERROR(enumPlace,
     1787                                                    "Unknown dst_unused");
    19021788                                    extraMods->dstUnused = unused;
    19031789                                    if (haveDstUnused)
     
    19261812                        }
    19271813                        else
    1928                         {
    1929                             asmr.printError(linePtr, "Expected ':' before dst_unused");
    1930                             good = false;
    1931                         }
     1814                            ASM_NOTGOOD_BY_ERROR(linePtr, "Expected ':' before dst_unused")
    19321815                    }
    19331816                    else if (withSDWAOperands>=2 && ::strcmp(mod, "src0_sel")==0)
     
    19701853                        }
    19711854                        else
    1972                         {
    1973                             asmr.printError(linePtr, "Expected ':' before src0_sel");
    1974                             good = false;
    1975                         }
     1855                            ASM_NOTGOOD_BY_ERROR(linePtr, "Expected ':' before src0_sel")
    19761856                    }
    19771857                    else if (withSDWAOperands>=3 && ::strcmp(mod, "src1_sel")==0)
     
    20141894                        }
    20151895                        else
    2016                         {
    2017                             asmr.printError(linePtr, "Expected ':' before src1_sel");
    2018                             good = false;
    2019                         }
     1896                            ASM_NOTGOOD_BY_ERROR(linePtr, "Expected ':' before src1_sel")
    20201897                    }
    20211898                    else if (::strcmp(mod, "quad_perm")==0)
     
    20281905                            if (linePtr==end || *linePtr!='[')
    20291906                            {
    2030                                 asmr.printError(linePtr,
    2031                                         "Expected '[' before quad_perm list");
    2032                                 goodMod = good = false;
     1907                                ASM_NOTGOOD_BY_ERROR1(goodMod = good, linePtr,
     1908                                        "Expected '[' before quad_perm list")
    20331909                                continue;
    20341910                            }
     
    20471923                                    if (linePtr==end || *linePtr!=',')
    20481924                                    {
    2049                                         asmr.printError(linePtr,
    2050                                             "Expected ',' before quad_perm component");
    2051                                         goodMod = good = false;
     1925                                        ASM_NOTGOOD_BY_ERROR1(goodMod = good, linePtr,
     1926                                            "Expected ',' before quad_perm component")
    20521927                                        break;
    20531928                                    }
     
    20731948                        }
    20741949                        else
    2075                         {
    2076                             asmr.printError(linePtr, "Expected ':' before quad_perm");
    2077                             good = false;
    2078                         }
     1950                            ASM_NOTGOOD_BY_ERROR(linePtr, "Expected ':' before quad_perm")
    20791951                    }
    20801952                    else if (::strcmp(mod, "bank_mask")==0)
     
    20971969                        }
    20981970                        else
    2099                         {
    2100                             asmr.printError(linePtr, "Expected ':' before bank_mask");
    2101                             good = false;
    2102                         }
     1971                            ASM_NOTGOOD_BY_ERROR(linePtr, "Expected ':' before bank_mask")
    21031972                    }
    21041973                    else if (::strcmp(mod, "row_mask")==0)
     
    21211990                        }
    21221991                        else
    2123                         {
    2124                             asmr.printError(linePtr, "Expected ':' before row_mask");
    2125                             good = false;
    2126                         }
     1992                            ASM_NOTGOOD_BY_ERROR(linePtr, "Expected ':' before row_mask")
    21271993                    }
    21281994                    else if (::strcmp(mod, "bound_ctrl")==0)
     
    21722038                                if (shift == 0)
    21732039                                {
    2174                                     asmr.printError(shiftPlace,
    2175                                             "Illegal zero shift for row_XXX shift");
    2176                                     good = false;
     2040                                    ASM_NOTGOOD_BY_ERROR(shiftPlace,
     2041                                            "Illegal zero shift for row_XXX shift")
    21772042                                    continue;
    21782043                                }
     
    21902055                        }
    21912056                        else
    2192                         {
    2193                             asmr.printError(linePtr, (std::string(
    2194                                         "Expected ':' before ")+mod).c_str());
    2195                             good = false;
    2196                         }
     2057                            ASM_NOTGOOD_BY_ERROR(linePtr, (std::string(
     2058                                        "Expected ':' before ")+mod).c_str())
    21972059                    }
    21982060                    else if (memcmp(mod, "wave_", 5)==0 &&
     
    22082070                                ++linePtr;
    22092071                            else
    2210                             {
    2211                                 asmr.printError(linePtr, "Value must be '1'");
    2212                                 modGood = good = false;
    2213                             }
     2072                                ASM_NOTGOOD_BY_ERROR1(modGood = good, linePtr,
     2073                                            "Value must be '1'")
    22142074                        }
    22152075                        if (mod[5]=='s')
     
    22562116                                    extraMods->dppCtrl = 0x142;
    22572117                                else
    2258                                 {
    2259                                     asmr.printError(numPlace, "Thread to broadcast must be"
    2260                                                 " 15 or 31");
    2261                                     modGood = good = false;
    2262                                 }
     2118                                    ASM_NOTGOOD_BY_ERROR1(modGood = good, numPlace,
     2119                                            "Thread to broadcast must be 15 or 31")
    22632120                            }
    22642121                            else
    2265                             {
    2266                                 asmr.printError(linePtr, "Expected ':' before row_bcast");
    2267                                 modGood = good = false;
    2268                             }
     2122                                ASM_NOTGOOD_BY_ERROR1(modGood = good, linePtr,
     2123                                            "Expected ':' before row_bcast")
    22692124                        }
    22702125                        if (modGood)
     
    22872142                        haveDPP = dpp;
    22882143                    }
    2289                     else
    2290                     {   /// unknown modifier
    2291                         asmr.printError(modPlace, "Unknown VOP modifier");
    2292                         good = false;
    2293                     }
    2294                 }
    2295                 else
    2296                 {   /// unknown modifier
    2297                     asmr.printError(modPlace, "Unknown VOP modifier");
    2298                     good = false;
    2299                 }
     2144                    else    /// unknown modifier
     2145                        ASM_NOTGOOD_BY_ERROR(modPlace, "Unknown VOP modifier")
     2146                }
     2147                else /// unknown modifier
     2148                    ASM_NOTGOOD_BY_ERROR(modPlace, "Unknown VOP modifier")
    23002149               
    23012150                if (alreadyModDefined)
     
    23272176                (isGCN14 && (mods & 3)!=0 && vopDPP) ||
    23282177                ((mods&VOP3_CLAMP)!=0 && vopDPP))
    2329     {
    2330         asmr.printError(modsPlace, "Mixing modifiers from different encodings is illegal");
    2331         return false;
    2332     }
     2178        ASM_FAIL_BY_ERROR(modsPlace, "Mixing modifiers from different encodings is illegal")
    23332179    return good;
    23342180}
     
    23542200            reg = { p0Code, p0Code+1 };
    23552201        else
    2356         {
    2357             asmr.printError(p0Place, "Unknown VINTRP parameter");
    2358             return false;
    2359         }
     2202            ASM_FAIL_BY_ERROR(p0Place, "Unknown VINTRP parameter")
    23602203        return true;
    23612204    }
     
    23712214    const char* attrPlace = linePtr;
    23722215    if (linePtr+4 > end)
    2373     {
    2374         asmr.printError(attrPlace, "Expected 'attr' keyword");
    2375         goodAttr = good = false;
    2376     }
     2216        ASM_NOTGOOD_BY_ERROR1(goodAttr = good, attrPlace, "Expected 'attr' keyword")
    23772217    char buf[5];
    23782218    if (goodAttr)
     
    23822222        {
    23832223            while (linePtr!=end && *linePtr!=' ') linePtr++;
    2384             asmr.printError(attrPlace, "Expected 'attr' keyword");
    2385             goodAttr = good = false;
     2224            ASM_NOTGOOD_BY_ERROR1(goodAttr = good, attrPlace, "Expected 'attr' keyword")
    23862225        }
    23872226        else
     
    24012240        }
    24022241        if (attrVal >= 64)
    2403         {
    2404             asmr.printError(attrNumPlace, "Attribute number out of range (0-63)");
    2405             goodAttr = good = false;
    2406         }
     2242            ASM_NOTGOOD_BY_ERROR1(goodAttr = good, attrNumPlace,
     2243                        "Attribute number out of range (0-63)")
    24072244    }
    24082245    if (goodAttr)
     
    24102247        skipSpacesToEnd(linePtr, end);
    24112248        if (linePtr==end || *linePtr!='.')
    2412         {
    2413             asmr.printError(linePtr, "Expected '.' after attribute number");
    2414             goodAttr = good = false;
    2415         }
     2249            ASM_NOTGOOD_BY_ERROR1(goodAttr = good, linePtr,
     2250                            "Expected '.' after attribute number")
    24162251        else
    24172252            ++linePtr;
     
    24212256        skipSpacesToEnd(linePtr, end);
    24222257        if (linePtr==end)
    2423         {
    2424             asmr.printError(linePtr, "Expected attribute component");
    2425             goodAttr = good = false;
    2426         }
     2258            ASM_NOTGOOD_BY_ERROR1(goodAttr = good, linePtr, "Expected attribute component")
    24272259    }
    24282260    char attrCmpName = 0;
     
    24312263        attrCmpName = toLower(*linePtr);
    24322264        if (attrCmpName!='x' && attrCmpName!='y' && attrCmpName!='z' && attrCmpName!='w')
    2433         {
    2434             asmr.printError(linePtr, "Expected attribute component");
    2435             good = false;
    2436         }
     2265            ASM_NOTGOOD_BY_ERROR(linePtr, "Expected attribute component")
    24372266        linePtr++;
    24382267    }
     
    24512280    skipSpacesToEnd(linePtr, end);
    24522281    if (linePtr == end)
    2453     {
    2454         asmr.printError(linePtr, (std::string("Expected ")+objName).c_str());
    2455         return false;
    2456     }
     2282        ASM_FAIL_BY_ERROR(linePtr, (std::string("Expected ")+objName).c_str())
    24572283    const char* nameStr = linePtr;
    24582284    if (isAlnum(*linePtr) || *linePtr == '_' || *linePtr == '.')
     
    24702296    }
    24712297    if (maxOutStrSize-1 < size_t(linePtr-nameStr))
    2472     {
    2473         asmr.printError(linePtr, (std::string(objName)+" is too long").c_str());
    2474         return false;
    2475     }
     2298        ASM_FAIL_BY_ERROR(linePtr, (std::string(objName)+" is too long").c_str())
    24762299    const size_t outStrSize = std::min(maxOutStrSize-1, size_t(linePtr-nameStr));
    24772300    std::copy(nameStr, nameStr+outStrSize, outStr);
     
    24842307{
    24852308    if (gcnEncSize==GCNEncSize::BIT32 && wordsNum!=1)
    2486     {
    2487         asmr.printError(insnPtr, "32-bit encoding specified when 64-bit encoding");
    2488         return false;
    2489     }
     2309        ASM_FAIL_BY_ERROR(insnPtr, "32-bit encoding specified when 64-bit encoding")
    24902310    if (gcnEncSize==GCNEncSize::BIT64 && wordsNum!=2)
    2491     {
    2492         asmr.printError(insnPtr, "64-bit encoding specified when 32-bit encoding");
    2493         return false;
    2494     }
     2311        ASM_FAIL_BY_ERROR(insnPtr, "64-bit encoding specified when 32-bit encoding")
    24952312    return true;
    24962313}
     
    25002317{
    25012318    if (vopEnc==GCNVOPEnc::DPP && !modifiers->needDPP)
    2502     {
    2503         asmr.printError(insnPtr, "DPP encoding specified when DPP not present");
    2504         return false;
    2505     }
     2319        ASM_FAIL_BY_ERROR(insnPtr, "DPP encoding specified when DPP not present")
    25062320    if (vopEnc==GCNVOPEnc::SDWA && !modifiers->needSDWA)
    2507     {
    2508         asmr.printError(insnPtr, "DPP encoding specified when DPP not present");
    2509         return false;
    2510     }
     2321        ASM_FAIL_BY_ERROR(insnPtr, "DPP encoding specified when DPP not present")
    25112322    return true;
    25122323}
     
    25172328{
    25182329    if (needImm)
    2519     {
    2520         asmr.printError(instrPlace, "Literal with SDWA or DPP word is illegal");
    2521         return false;
    2522     }
     2330        ASM_FAIL_BY_ERROR(instrPlace, "Literal with SDWA or DPP word is illegal")
    25232331    if ((arch & ARCH_RXVEGA)==0 && !src0Op.range.isVGPR())
    2524     {
    2525         asmr.printError(instrPlace, "SRC0 must be a vector register with "
    2526                     "SDWA or DPP word");
    2527         return false;
    2528     }
     2332        ASM_FAIL_BY_ERROR(instrPlace, "SRC0 must be a vector register with "
     2333                    "SDWA or DPP word")
    25292334    if ((arch & ARCH_RXVEGA)!=0 && extraMods.needDPP && !src0Op.range.isVGPR())
    2530     {
    2531         asmr.printError(instrPlace, "SRC0 must be a vector register with DPP word");
    2532         return false;
    2533     }
     2335        ASM_FAIL_BY_ERROR(instrPlace, "SRC0 must be a vector register with DPP word")
    25342336    if (vop3)
    2535     {   // if VOP3 and (VOP_DPP or VOP_SDWA)
    2536         asmr.printError(instrPlace, "Mixing VOP3 with SDWA or WORD is illegal");
    2537         return false;
    2538     }
     2337        // if VOP3 and (VOP_DPP or VOP_SDWA)
     2338        ASM_FAIL_BY_ERROR(instrPlace, "Mixing VOP3 with SDWA or WORD is illegal")
    25392339    if (sextFlags && extraMods.needDPP)
    2540     {
    2541         asmr.printError(instrPlace, "SEXT modifiers is unavailable for DPP word");
    2542         return false;
    2543     }
     2340        ASM_FAIL_BY_ERROR(instrPlace, "SEXT modifiers is unavailable for DPP word")
    25442341    if (!extraMods.needSDWA && !extraMods.needDPP)
    25452342    {
Note: See TracChangeset for help on using the changeset viewer.