Changeset 3342 in CLRX


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

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

File:
1 edited

Legend:

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

    r3302 r3342  
    622622            int64_t offset = (int64_t(value)-int64_t(output.size())-4);
    623623            if (offset & 3)
    624             {
    625                 asmr.printError(linePtr, "Jump is not aligned to word!");
    626                 good = false;
    627             }
     624                ASM_NOTGOOD_BY_ERROR(linePtr, "Jump is not aligned to word!")
    628625            offset >>= 2;
    629626            if (offset > INT16_MAX || offset < INT16_MIN)
    630             {
    631                 asmr.printError(linePtr, "Jump out of range");
    632                 good = false;
    633             }
     627                ASM_NOTGOOD_BY_ERROR(linePtr, "Jump out of range")
    634628            imm16 = offset;
    635629            // add codeflow entry
     
    651645        skipSpacesToEnd(linePtr, end);
    652646        if (::strcmp(name, "hwreg")!=0 || linePtr==end || *linePtr!='(')
    653         {
    654             asmr.printError(funcNamePlace, "Expected hwreg function");
    655             return false;
    656         }
     647            ASM_FAIL_BY_ERROR(funcNamePlace, "Expected hwreg function")
    657648        ++linePtr;
    658649        skipSpacesToEnd(linePtr, end);
     
    668659                        regMapSize, regMap, hwregId, "hwreg_");
    669660            if (good && (arch & ARCH_GCN_1_2_4) == 0 && hwregId == 13)
    670             {   // if ib_dgb1 in not GCN 1.2
    671                 asmr.printError(hwregNamePlace, "Unknown HWRegister");
    672                 good = false;
    673             }
     661                // if ib_dgb1 in not GCN 1.2
     662                ASM_NOTGOOD_BY_ERROR(hwregNamePlace, "Unknown HWRegister")
    674663        }
    675664        else
     
    707696        skipSpacesToEnd(linePtr, end);
    708697        if (linePtr==end || *linePtr!=')')
    709         {
    710             asmr.printError(linePtr, "Unterminated hwreg function");
    711             return false;
    712         }
     698            ASM_FAIL_BY_ERROR(linePtr, "Unterminated hwreg function")
    713699        ++linePtr;
    714700        imm16 = hwregId | (arg2Value<<6) | ((arg3Value-1)<<11);
     
    884870    const bool isGCN14 = (arch & ARCH_RXVEGA)!=0;
    885871    if (gcnEncSize==GCNEncSize::BIT64)
    886     {
    887         asmr.printError(instrPlace, "Only 32-bit size for SOPP encoding");
    888         return false;
    889     }
     872        ASM_FAIL_BY_ERROR(instrPlace, "Only 32-bit size for SOPP encoding")
    890873   
    891874    uint16_t imm16 = 0;
     
    902885                int64_t offset = (int64_t(value)-int64_t(output.size())-4);
    903886                if (offset & 3)
    904                 {
    905                     asmr.printError(linePtr, "Jump is not aligned to word!");
    906                     good = false;
    907                 }
     887                    ASM_NOTGOOD_BY_ERROR(linePtr, "Jump is not aligned to word!")
    908888                offset >>= 2;
    909889                if (offset > INT16_MAX || offset < INT16_MIN)
    910                 {
    911                     asmr.printError(linePtr, "Jump out of range");
    912                     good = false;
    913                 }
     890                    ASM_NOTGOOD_BY_ERROR(linePtr, "Jump out of range")
    914891                imm16 = offset;
    915892                Assembler& asmr = gcnAsm->assembler;
     
    966943                }
    967944                else
    968                 {
    969                     asmr.printError(funcNamePlace, "Expected vmcnt, lgkmcnt or expcnt");
    970                     goodCnt = good = false;
    971                 }
     945                    ASM_NOTGOOD_BY_ERROR1(goodCnt = good, funcNamePlace,
     946                                    "Expected vmcnt, lgkmcnt or expcnt");
    972947               
    973948                skipSpacesToEnd(linePtr, end);
     
    994969                skipSpacesToEnd(linePtr, end);
    995970                if (linePtr==end || *linePtr!=')')
    996                 {
    997                     asmr.printError(linePtr, "Unterminated function");
    998                     return false;
    999                 }
     971                    ASM_FAIL_BY_ERROR(linePtr, "Unterminated function")
    1000972                // ampersand
    1001973                skipCharAndSpacesToEnd(linePtr, end);
     
    1016988            skipSpacesToEnd(linePtr, end);
    1017989            if (::strcmp(name, "sendmsg")!=0 || linePtr==end || *linePtr!='(')
    1018             {
    1019                 asmr.printError(funcNamePlace, "Expected sendmsg function");
    1020                 return false;
    1021             }
     990                ASM_FAIL_BY_ERROR(funcNamePlace, "Expected sendmsg function")
    1022991            skipCharAndSpacesToEnd(linePtr, end);
    1023992           
     
    10411010                        sendMessage = msgMap[index].second;
    10421011                    else
    1043                     {
    1044                         asmr.printError(funcArg1Place, "Unknown message");
    1045                         good = false;
    1046                     }
     1012                        ASM_NOTGOOD_BY_ERROR(funcArg1Place, "Unknown message")
    10471013                }
    10481014                else
     
    10881054                        {   // not found
    10891055                            gsopIndex = 0;
    1090                             asmr.printError(funcArg2Place, "Unknown GSOP");
    1091                             good = false;
     1056                            ASM_NOTGOOD_BY_ERROR(funcArg2Place, "Unknown GSOP")
    10921057                        }
    10931058                    }
     
    11181083            skipSpacesToEnd(linePtr, end);
    11191084            if (linePtr==end || *linePtr!=')')
    1120             {
    1121                 asmr.printError(linePtr, "Unterminated sendmsg function");
    1122                 return false;
    1123             }
     1085                ASM_FAIL_BY_ERROR(linePtr, "Unterminated sendmsg function")
    11241086            ++linePtr;
    11251087            imm16 = sendMessage | (gsopIndex<<4) | (streamId<<8);
     
    11601122    bool good = true;
    11611123    if (gcnEncSize==GCNEncSize::BIT64)
    1162     {
    1163         asmr.printError(instrPlace, "Only 32-bit size for SMRD encoding");
    1164         return false;
    1165     }
     1124        ASM_FAIL_BY_ERROR(instrPlace, "Only 32-bit size for SMRD encoding")
    11661125    GCNAssembler* gcnAsm = static_cast<GCNAssembler*>(asmr.isaAssembler);
    11671126   
     
    12481207    bool good = true;
    12491208    if (gcnEncSize==GCNEncSize::BIT32)
    1250     {
    1251         asmr.printError(instrPlace, "Only 64-bit size for SMEM encoding");
    1252         return false;
    1253     }
     1209        ASM_FAIL_BY_ERROR(instrPlace, "Only 64-bit size for SMEM encoding")
    12541210   
    12551211    GCNAssembler* gcnAsm = static_cast<GCNAssembler*>(asmr.isaAssembler);
     
    13041260            if (good && (gcnInsn.mode & GCN_MLOAD) == 0 && soffsetReg &&
    13051261                    !soffsetReg.isVal(124))
    1306             {   // if no M0 register
    1307                 asmr.printError(soffsetPlace,
    1308                         "Store/Atomic SMEM instructions accepts only M0 register");
    1309                 good = false;
    1310             }
     1262                // if no M0 register
     1263                ASM_NOTGOOD_BY_ERROR(soffsetPlace,
     1264                        "Store/Atomic SMEM instructions accepts only M0 register")
    13111265        }
    13121266        else // '@' prefix
     
    13551309            }
    13561310            else
    1357             {
    1358                 asmr.printError(modPlace, "Unknown SMEM modifier");
    1359                 good = false;
    1360             }
     1311                ASM_NOTGOOD_BY_ERROR(modPlace, "Unknown SMEM modifier")
    13611312        }
    13621313        else
     
    15761527        (src0Op.range.isSGPR() || src0Op.range.isVal(124) ||
    15771528         src1Op.range.isSGPR() || src1Op.range.isVal(124)))
    1578     {
    1579         asmr.printError(instrPlace, "Literal with SGPR or M0 is illegal");
    1580         return false;
    1581     }
     1529        ASM_FAIL_BY_ERROR(instrPlace, "Literal with SGPR or M0 is illegal")
    15821530   
    15831531    if (vop3) // modify fields in reg usage
     
    16131561   
    16141562    if (sgprsReaded >= 2)
    1615     {   /* include VCCs (???) */
    1616         asmr.printError(instrPlace, "More than one SGPR to read in instruction");
    1617         return false;
    1618     }
     1563        /* include VCCs (???) */
     1564        ASM_FAIL_BY_ERROR(instrPlace, "More than one SGPR to read in instruction")
    16191565    const bool needImm = (src0Op.range.start==255 || src1Op.range.start==255 ||
    16201566             mode1 == GCN_ARG1_IMM || mode1 == GCN_ARG2_IMM);
     
    16441590   
    16451591    if (isGCN12 && vop3 && haveDstCC && ((src0Op.vopMods|src1Op.vopMods) & VOPOP_ABS) != 0)
    1646     {
    1647         asmr.printError(instrPlace, "Abs modifier is illegal for VOP3B encoding");
    1648         return false;
    1649     }
     1592        ASM_FAIL_BY_ERROR(instrPlace, "Abs modifier is illegal for VOP3B encoding")
    16501593    if (vop3 && needImm)
    1651     {
    1652         asmr.printError(instrPlace, "Literal in VOP3 encoding is illegal");
    1653         return false;
    1654     }
     1594        ASM_FAIL_BY_ERROR(instrPlace, "Literal in VOP3 encoding is illegal")
    16551595   
    16561596    if (!checkGCNVOPEncoding(asmr, instrPlace, gcnVOPEnc, &extraMods))
     
    18561796   
    18571797    if (vop3 && src0Op.range.isVal(255))
    1858     {
    1859         asmr.printError(instrPlace, "Literal in VOP3 encoding is illegal");
    1860         return false;
    1861     }
     1798        ASM_FAIL_BY_ERROR(instrPlace, "Literal in VOP3 encoding is illegal")
    18621799   
    18631800    if (!checkGCNVOPEncoding(asmr, instrPlace, gcnVOPEnc, &extraMods))
     
    20081945        (src0Op.range.isSGPR() || src0Op.range.isVal(124) ||
    20091946         src1Op.range.isSGPR() || src1Op.range.isVal(124)))
    2010     {
    2011         asmr.printError(instrPlace, "Literal with SGPR or M0 is illegal");
    2012         return false;
    2013     }
     1947        ASM_FAIL_BY_ERROR(instrPlace, "Literal with SGPR or M0 is illegal")
    20141948    if (src0Op.range.isSGPR() && src1Op.range.isSGPR() &&
    20151949        !regRangeCanEqual(src0Op.range, src1Op.range))
    2016     {   /* include VCCs (???) */
    2017         asmr.printError(instrPlace, "More than one SGPR to read in instruction");
    2018         return false;
    2019     }
     1950        /* include VCCs (???) */
     1951        ASM_FAIL_BY_ERROR(instrPlace, "More than one SGPR to read in instruction")
    20201952   
    20211953    if (vop3) // modify fields in reg usage
     
    20541986   
    20551987    if (vop3 && (src0Op.range.isVal(255) || src1Op.range.isVal(255)))
    2056     {
    2057         asmr.printError(instrPlace, "Literal in VOP3 encoding is illegal");
    2058         return false;
    2059     }
     1988        ASM_FAIL_BY_ERROR(instrPlace, "Literal in VOP3 encoding is illegal")
    20601989   
    20611990    if (!checkGCNVOPEncoding(asmr, instrPlace, gcnVOPEnc, &extraMods))
     
    20631992   
    20641993    if (isGCN14 && ((modifiers & VOP3_CLAMP)!=0 || (modifiers&3)!=0))
    2065     {
    2066         asmr.printError(instrPlace, "Modifiers CLAMP and OMOD is illegal in SDWAB");
    2067         return false;
    2068     }
     1994        ASM_FAIL_BY_ERROR(instrPlace, "Modifiers CLAMP and OMOD is illegal in SDWAB")
    20691995   
    20701996    if (src0OpExpr!=nullptr)
     
    21652091    const bool vop3p = (gcnInsn.mode & GCN_VOP3_VOP3P) != 0;
    21662092    if (gcnVOPEnc!=GCNVOPEnc::NORMAL)
    2167     {
    2168         asmr.printError(instrPlace, "DPP and SDWA encoding is illegal for VOP3");
    2169         return false;
    2170     }
     2093        ASM_FAIL_BY_ERROR(instrPlace, "DPP and SDWA encoding is illegal for VOP3")
    21712094   
    21722095    GCNAssembler* gcnAsm = static_cast<GCNAssembler*>(asmr.isaAssembler);
     
    22922215                }
    22932216                else
    2294                 {
    2295                     asmr.printError(modPlace, "Unknown VINTRP modifier");
    2296                     good = false;
    2297                 }
     2217                    ASM_NOTGOOD_BY_ERROR(modPlace, "Unknown VINTRP modifier")
    22982218            }
    22992219            if (modHigh)
     
    23802300       
    23812301        if (numSgprToRead>=2)
    2382         {
    2383             asmr.printError(instrPlace, "More than one SGPR to read in instruction");
    2384             return false;
    2385         }
     2302            ASM_FAIL_BY_ERROR(instrPlace, "More than one SGPR to read in instruction")
    23862303    }
    23872304   
     
    24772394    RegRange srcReg(0, 0);
    24782395    if (gcnEncSize==GCNEncSize::BIT64)
    2479     {
    2480         asmr.printError(instrPlace, "Only 32-bit size for VINTRP encoding");
    2481         return false;
    2482     }
     2396        ASM_FAIL_BY_ERROR(instrPlace, "Only 32-bit size for VINTRP encoding")
    24832397    if (gcnVOPEnc!=GCNVOPEnc::NORMAL)
    2484     {
    2485         asmr.printError(instrPlace, "DPP and SDWA encoding is illegal for VOP3");
    2486         return false;
    2487     }
     2398        ASM_FAIL_BY_ERROR(instrPlace, "DPP and SDWA encoding is illegal for VOP3")
    24882399   
    24892400    GCNAssembler* gcnAsm = static_cast<GCNAssembler*>(asmr.isaAssembler);
     
    25322443    bool good = true;
    25332444    if (gcnEncSize==GCNEncSize::BIT32)
    2534     {
    2535         asmr.printError(instrPlace, "Only 64-bit size for DS encoding");
    2536         return false;
    2537     }
     2445        ASM_FAIL_BY_ERROR(instrPlace, "Only 64-bit size for DS encoding")
    25382446    RegRange dstReg(0, 0);
    25392447    RegRange addrReg(0, 0);
     
    26322540            }
    26332541            else
    2634             {
    2635                 asmr.printError(modPlace, "Expected 'offset'");
    2636                 good = false;
    2637             }
     2542                ASM_NOTGOOD_BY_ERROR(modPlace, "Expected 'offset'")
    26382543        }
    26392544        else
     
    26702575                }
    26712576                else
    2672                 {
    2673                     asmr.printError(linePtr, "Expected ':' before offset");
    2674                     good = false;
    2675                 }
     2577                    ASM_NOTGOOD_BY_ERROR(linePtr, "Expected ':' before offset")
    26762578            }
    26772579            else
    2678             {
    2679                 asmr.printError(modPlace,
    2680                                 "Expected 'offset', 'offset0' or 'offset1'");
    2681                 good = false;
    2682             }
     2580                ASM_NOTGOOD_BY_ERROR(modPlace,
     2581                                "Expected 'offset', 'offset0' or 'offset1'")
    26832582        }
    26842583    }
     
    26912590   
    26922591    if ((gcnInsn.mode&GCN_ONLYGDS) != 0 && !haveGds)
    2693     {
    2694         asmr.printError(instrPlace, "Instruction requires GDS modifier");
    2695         return false;
    2696     }
     2592        ASM_FAIL_BY_ERROR(instrPlace, "Instruction requires GDS modifier")
    26972593   
    26982594    if (offsetExpr!=nullptr)
     
    27622658    bool good = true;
    27632659    if (gcnEncSize==GCNEncSize::BIT32)
    2764     {
    2765         asmr.printError(instrPlace, "Only 64-bit size for MUBUF/MTBUF encoding");
    2766         return false;
    2767     }
     2660        ASM_FAIL_BY_ERROR(instrPlace, "Only 64-bit size for MUBUF/MTBUF encoding")
    27682661    const uint16_t mode1 = (gcnInsn.mode & GCN_MASK1);
    27692662    RegRange vaddrReg(0, 0);
     
    28632756            }
    28642757            else
    2865             {
    2866                 asmr.printError(modPlace, (gcnInsn.encoding==GCNENC_MUBUF) ?
    2867                     "Unknown MUBUF modifier" : "Unknown MTBUF modifier");
    2868             }
     2758                ASM_NOTGOOD_BY_ERROR(modPlace, (gcnInsn.encoding==GCNENC_MUBUF) ?
     2759                    "Unknown MUBUF modifier" : "Unknown MTBUF modifier")
    28692760        }
    28702761        else if (gcnInsn.encoding==GCNENC_MTBUF && ::strcmp(name, "format")==0)
     
    28742765            if (linePtr==end || *linePtr!=':')
    28752766            {
    2876                 asmr.printError(linePtr, "Expected ':' before format");
    2877                 good = false;
     2767                ASM_NOTGOOD_BY_ERROR(linePtr, "Expected ':' before format")
    28782768                continue;
    28792769            }
    28802770            skipCharAndSpacesToEnd(linePtr, end);
    28812771            if (linePtr==end || *linePtr!='[')
    2882             {
    2883                 asmr.printError(modPlace, "Expected '[' before format");
    2884                 modGood = good = false;
    2885             }
     2772                ASM_NOTGOOD_BY_ERROR1(modGood = good, modPlace,
     2773                                "Expected '[' before format");
    28862774            if (modGood)
    28872775            {
     
    29192807                        }
    29202808                        else
    2921                         {
    2922                             asmr.printError(fmtPlace, "Unknown data/number format");
    2923                             modGood = good = false;
    2924                         }
     2809                            ASM_NOTGOOD_BY_ERROR1(modGood = good, fmtPlace,
     2810                                        "Unknown data/number format");
    29252811                    }
    29262812                }
     
    29492835                    linePtr++;
    29502836                else
    2951                 {
    2952                     asmr.printError(linePtr, "Unterminated format modifier");
    2953                     good = false;
    2954                 }
     2837                    ASM_NOTGOOD_BY_ERROR(linePtr, "Unterminated format modifier")
    29552838                if (modGood)
    29562839                {
     
    29752858            good &= parseModEnable(asmr, linePtr, haveIdxen, "idxen modifier");
    29762859        else
    2977         {
    2978             asmr.printError(modPlace, (gcnInsn.encoding==GCNENC_MUBUF) ?
    2979                     "Unknown MUBUF modifier" : "Unknown MTBUF modifier");
    2980             good = false;
    2981         }
     2860            ASM_NOTGOOD_BY_ERROR(modPlace, (gcnInsn.encoding==GCNENC_MUBUF) ?
     2861                    "Unknown MUBUF modifier" : "Unknown MTBUF modifier")
    29822862    }
    29832863   
     
    29972877            snprintf(errorMsg, 40, "Required %u vector register%s", dregsNum,
    29982878                     (dregsNum>1) ? "s" : "");
    2999             asmr.printError(vdataPlace, errorMsg);
    3000             good = false;
     2879            ASM_NOTGOOD_BY_ERROR(vdataPlace, errorMsg)
    30012880        }
    30022881    }
     
    30042883    {
    30052884        if (!parsedVaddr && (haveIdxen || haveOffen || haveAddr64))
    3006         {   // no vaddr in instruction
    3007             asmr.printError(vaddrPlace, "VADDR is required if idxen, offen "
    3008                     "or addr64 is enabled");
    3009             good = false;
    3010         }
     2885            // no vaddr in instruction
     2886            ASM_NOTGOOD_BY_ERROR(vaddrPlace, "VADDR is required if idxen, offen "
     2887                    "or addr64 is enabled")
    30112888        else
    30122889        {
    30132890            const cxuint vaddrSize = ((haveOffen&&haveIdxen) || haveAddr64) ? 2 : 1;
    30142891            if (!isXRegRange(vaddrReg, vaddrSize))
    3015             {
    3016                 asmr.printError(vaddrPlace, (vaddrSize==2) ? "Required 2 vector registers" :
    3017                             "Required 1 vector register");
    3018                 good = false;
    3019             }
     2892                ASM_NOTGOOD_BY_ERROR(vaddrPlace, (vaddrSize==2) ?
     2893                        "Required 2 vector registers" : "Required 1 vector register")
    30202894        }
    30212895    }
     
    30482922    /* checking modifiers conditions */
    30492923    if (haveAddr64 && (haveOffen || haveIdxen))
    3050     {
    3051         asmr.printError(instrPlace, "Idxen and offen must be zero in 64-bit address mode");
    3052         return false;
    3053     }
     2924        ASM_FAIL_BY_ERROR(instrPlace, "Idxen and offen must be zero in 64-bit address mode")
    30542925    if (haveTfe && haveLds)
    3055     {
    3056         asmr.printError(instrPlace, "Both LDS and TFE is illegal");
    3057         return false;
    3058     }
     2926        ASM_FAIL_BY_ERROR(instrPlace, "Both LDS and TFE is illegal")
    30592927   
    30602928    // ignore vdata if LDS
     
    31252993    const char* end = asmr.line+asmr.lineSize;
    31262994    if (gcnEncSize==GCNEncSize::BIT32)
    3127     {
    3128         asmr.printError(instrPlace, "Only 64-bit size for MIMG encoding");
    3129         return false;
    3130     }
     2995        ASM_FAIL_BY_ERROR(instrPlace, "Only 64-bit size for MIMG encoding")
    31312996    const bool isGCN14 = (arch & ARCH_RXVEGA)!=0;
    31322997    bool good = true;
     
    31583023        snprintf(buf, 60, "Required (%u-%u) vector registers", geRegRequired,
    31593024                 geRegRequired+vaddrMaxExtraRegs);
    3160         asmr.printError(vaddrPlace, buf);
    3161         good = false;
     3025        ASM_NOTGOOD_BY_ERROR(vaddrPlace, buf)
    31623026    }
    31633027   
     
    32233087                        dmask = value&0xf;
    32243088                        if (dmask == 0)
    3225                         {
    3226                             asmr.printError(valuePlace, "Zero in dmask is illegal");
    3227                             good = false;
    3228                         }
     3089                            ASM_NOTGOOD_BY_ERROR(valuePlace, "Zero in dmask is illegal")
    32293090                    }
    32303091                    else
     
    32323093                }
    32333094                else
    3234                 {
    3235                     asmr.printError(linePtr, "Expected ':' before dmask");
    3236                     good = false;
    3237                 }
     3095                    ASM_NOTGOOD_BY_ERROR(linePtr, "Expected ':' before dmask")
    32383096            }
    32393097            else
    3240             {
    3241                 asmr.printError(modPlace, "Unknown MIMG modifier");
    3242                 good = false;
    3243             }
     3098                ASM_NOTGOOD_BY_ERROR(modPlace, "Unknown MIMG modifier")
    32443099        }
    32453100        else if (name[0] < 's')
     
    32543109                good &= parseModEnable(asmr, linePtr, haveA16, "a16 modifier");
    32553110            else
    3256             {
    3257                 asmr.printError(modPlace, "Unknown MIMG modifier");
    3258                 good = false;
    3259             }
     3111                ASM_NOTGOOD_BY_ERROR(modPlace, "Unknown MIMG modifier")
    32603112        }
    32613113        // other modifiers
     
    32673119            good &= parseModEnable(asmr, linePtr, haveUnorm, "unorm modifier");
    32683120        else
    3269         {
    3270             asmr.printError(modPlace, "Unknown MIMG modifier");
    3271             good = false;
    3272         }
     3121            ASM_NOTGOOD_BY_ERROR(modPlace, "Unknown MIMG modifier")
    32733122    }
    32743123   
     
    32823131        snprintf(errorMsg, 40, "Required %u vector register%s", dregsNum,
    32833132                 (dregsNum>1) ? "s" : "");
    3284         asmr.printError(vdataPlace, errorMsg);
    3285         good = false;
     3133        ASM_NOTGOOD_BY_ERROR(vdataPlace, errorMsg)
    32863134    }
    32873135    if (!isXRegRange(srsrcReg, (haveR128)?4:8))
    3288     {
    3289         asmr.printError(srsrcPlace, (haveR128) ? "Required 4 scalar registers" :
    3290                     "Required 8 scalar registers");
    3291         good = false;
    3292     }
     3136        ASM_NOTGOOD_BY_ERROR(srsrcPlace, (haveR128) ? "Required 4 scalar registers" :
     3137                    "Required 8 scalar registers")
    32933138   
    32943139    const bool vdataToWrite = ((gcnInsn.mode&GCN_MLOAD) != 0 ||
     
    33453190    /* checking modifiers conditions */
    33463191    if (!haveUnorm && ((gcnInsn.mode&GCN_MLOAD) == 0 || (gcnInsn.mode&GCN_MATOMIC)!=0))
    3347     {   // unorm is not set for this instruction
    3348         asmr.printError(instrPlace, "Unorm is not set for store or atomic instruction");
    3349         return false;
    3350     }
     3192        // unorm is not set for this instruction
     3193        ASM_FAIL_BY_ERROR(instrPlace, "Unorm is not set for store or atomic instruction")
    33513194   
    33523195    uint32_t words[2];
     
    33753218    const char* end = asmr.line+asmr.lineSize;
    33763219    if (gcnEncSize==GCNEncSize::BIT32)
    3377     {
    3378         asmr.printError(instrPlace, "Only 64-bit size for EXP encoding");
    3379         return false;
    3380     }
     3220        ASM_FAIL_BY_ERROR(instrPlace, "Only 64-bit size for EXP encoding")
    33813221    bool good = true;
    33823222    cxbyte enMask = 0xf;
     
    34043244                target = cstrtobyte(nameStart, name+nameSize);
    34053245                if (target>=8)
    3406                 {
    3407                     asmr.printError(targetPlace, "MRT number out of range (0-7)");
    3408                     good = false;
    3409                 }
     3246                    ASM_NOTGOOD_BY_ERROR(targetPlace, "MRT number out of range (0-7)")
    34103247            }
    34113248            else
     
    34173254            cxbyte posNum = cstrtobyte(nameStart, name+nameSize);
    34183255            if (posNum>=4)
    3419             {
    3420                 asmr.printError(targetPlace, "Pos number out of range (0-3)");
    3421                 good = false;
    3422             }
     3256                ASM_NOTGOOD_BY_ERROR(targetPlace, "Pos number out of range (0-3)")
    34233257            else
    34243258                target = posNum+12;
     
    34313265            cxbyte posNum = cstrtobyte(nameStart, name+nameSize);
    34323266            if (posNum>=32)
    3433             {
    3434                 asmr.printError(targetPlace, "Param number out of range (0-31)");
    3435                 good = false;
    3436             }
     3267                ASM_NOTGOOD_BY_ERROR(targetPlace, "Param number out of range (0-31)")
    34373268            else
    34383269                target = posNum+32;
    34393270        }
    34403271        else
    3441         {
    3442             asmr.printError(targetPlace, "Unknown EXP target");
    3443             good = false;
    3444         }
     3272            ASM_NOTGOOD_BY_ERROR(targetPlace, "Unknown EXP target")
    34453273    }
    34463274    else
     
    34973325            good &= parseModEnable(asmr, linePtr, haveCompr, "compr modifier");
    34983326        else
    3499         {
    3500             asmr.printError(modPlace, "Unknown EXP modifier");
    3501             good = false;
    3502         }
     3327            ASM_NOTGOOD_BY_ERROR(modPlace, "Unknown EXP modifier")
    35033328    }
    35043329   
     
    35103335    {
    35113336        if (vsrcsReg[0].start!=vsrcsReg[1].start && (enMask&3)==3)
    3512         {   // error (vsrc1!=vsrc0)
    3513             asmr.printError(vsrcPlaces[1], "VSRC1 must be equal to VSRC0 in compr mode");
    3514             return false;
    3515         }
     3337            // error (vsrc1!=vsrc0)
     3338            ASM_FAIL_BY_ERROR(vsrcPlaces[1], "VSRC1 must be equal to VSRC0 in compr mode")
    35163339        if (vsrcsReg[2].start!=vsrcsReg[3].start && (enMask&12)==12)
    3517         {   // error (vsrc3!=vsrc2)
    3518             asmr.printError(vsrcPlaces[3], "VSRC3 must be equal to VSRC2 in compr mode");
    3519             return false;
    3520         }
     3340            // error (vsrc3!=vsrc2)
     3341            ASM_FAIL_BY_ERROR(vsrcPlaces[3], "VSRC3 must be equal to VSRC2 in compr mode")
    35213342        vsrcsReg[1] = vsrcsReg[2];
    35223343        vsrcsReg[2] = vsrcsReg[3] = { 0, 0 };
     
    35443365    const char* end = asmr.line+asmr.lineSize;
    35453366    if (gcnEncSize==GCNEncSize::BIT32)
    3546     {
    3547         asmr.printError(instrPlace, "Only 64-bit size for FLAT encoding");
    3548         return false;
    3549     }
     3367        ASM_FAIL_BY_ERROR(instrPlace, "Only 64-bit size for FLAT encoding")
    35503368    const bool isGCN14 = (arch & ARCH_RXVEGA)!=0;
    35513369    const cxuint flatMode = (gcnInsn.mode & GCN_FLAT_MODEMASK);
     
    36453463   
    36463464    if (flatMode == GCN_FLAT_SCRATCH && !saddrOff && !vaddrOff)
    3647     {
    3648         asmr.printError(instrPlace, "Only one of VADDR and SADDR can be set in "
    3649                     "SCRATCH mode");
    3650         good = false;
    3651     }
     3465        ASM_NOTGOOD_BY_ERROR(instrPlace, "Only one of VADDR and SADDR can be set in "
     3466                    "SCRATCH mode")
    36523467   
    36533468    if (saddrOff)
     
    36953510        }
    36963511        else
    3697         {
    3698             asmr.printError(modPlace, "Unknown FLAT modifier");
    3699             good = false;
    3700         }
     3512            ASM_NOTGOOD_BY_ERROR(modPlace, "Unknown FLAT modifier")
    37013513    }
    37023514    /* check register ranges */
     
    37113523            snprintf(errorMsg, 40, "Required %u vector register%s", dstRegsNum,
    37123524                     (dstRegsNum>1) ? "s" : "");
    3713             asmr.printError(vdstPlace, errorMsg);
    3714             good = false;
     3525            ASM_NOTGOOD_BY_ERROR(vdstPlace, errorMsg)
    37153526        }
    37163527       
     
    39033714}
    39043715
     3716#define GCN_FAIL_BY_ERROR(PLACE, STRING) \
     3717    { \
     3718        printError(PLACE, STRING); \
     3719        return false; \
     3720    }
     3721
    39053722bool GCNAssembler::resolveCode(const AsmSourcePos& sourcePos, cxuint targetSectionId,
    39063723             cxbyte* sectionData, size_t offset, AsmExprTargetType targetType,
     
    39113728        case GCNTGT_LITIMM:
    39123729            if (sectionId != ASMSECT_ABS)
    3913             {
    3914                 printError(sourcePos, "Relative value is illegal in literal expressions");
    3915                 return false;
    3916             }
     3730                GCN_FAIL_BY_ERROR(sourcePos,
     3731                        "Relative value is illegal in literal expressions")
    39173732            SULEV(*reinterpret_cast<uint32_t*>(sectionData+offset+4), value);
    39183733            printWarningForRange(32, value, sourcePos);
     
    39203735        case GCNTGT_SOPKSIMM16:
    39213736            if (sectionId != ASMSECT_ABS)
    3922             {
    3923                 printError(sourcePos, "Relative value is illegal in immediate expressions");
    3924                 return false;
    3925             }
     3737                GCN_FAIL_BY_ERROR(sourcePos,
     3738                        "Relative value is illegal in immediate expressions")
    39263739            SULEV(*reinterpret_cast<uint16_t*>(sectionData+offset), value);
    39273740            printWarningForRange(16, value, sourcePos);
     
    39303743        {
    39313744            if (sectionId != targetSectionId)
    3932             {   // if jump outside current section (.text)
    3933                 printError(sourcePos, "Jump over current section!");
    3934                 return false;
    3935             }
     3745                // if jump outside current section (.text)
     3746                GCN_FAIL_BY_ERROR(sourcePos, "Jump over current section!")
    39363747            int64_t outOffset = (int64_t(value)-int64_t(offset)-4);
    39373748            if (outOffset & 3)
    3938             {
    3939                 printError(sourcePos, "Jump is not aligned to word!");
    3940                 return false;
    3941             }
     3749                GCN_FAIL_BY_ERROR(sourcePos, "Jump is not aligned to word!")
    39423750            outOffset >>= 2;
    39433751            if (outOffset > INT16_MAX || outOffset < INT16_MIN)
    3944             {
    3945                 printError(sourcePos, "Jump out of range!");
    3946                 return false;
    3947             }
     3752                GCN_FAIL_BY_ERROR(sourcePos, "Jump out of range!")
    39483753            SULEV(*reinterpret_cast<uint16_t*>(sectionData+offset), outOffset);
    39493754            uint16_t insnCode = ULEV(*reinterpret_cast<uint16_t*>(sectionData+offset+2));
     
    39553760        case GCNTGT_SMRDOFFSET:
    39563761            if (sectionId != ASMSECT_ABS)
    3957             {
    3958                 printError(sourcePos, "Relative value is illegal in offset expressions");
    3959                 return false;
    3960             }
     3762                GCN_FAIL_BY_ERROR(sourcePos,
     3763                            "Relative value is illegal in offset expressions")
    39613764            sectionData[offset] = value;
    39623765            printWarningForRange(8, value, sourcePos, WS_UNSIGNED);
     
    39643767        case GCNTGT_DSOFFSET16:
    39653768            if (sectionId != ASMSECT_ABS)
    3966             {
    3967                 printError(sourcePos, "Relative value is illegal in offset expressions");
    3968                 return false;
    3969             }
     3769                GCN_FAIL_BY_ERROR(sourcePos,
     3770                            "Relative value is illegal in offset expressions")
    39703771            SULEV(*reinterpret_cast<uint16_t*>(sectionData+offset), value);
    39713772            printWarningForRange(16, value, sourcePos, WS_UNSIGNED);
     
    39753776        case GCNTGT_SOPCIMM8:
    39763777            if (sectionId != ASMSECT_ABS)
    3977             {
    3978                 printError(sourcePos, (targetType != GCNTGT_SOPCIMM8) ?
     3778                GCN_FAIL_BY_ERROR(sourcePos, (targetType != GCNTGT_SOPCIMM8) ?
    39793779                        "Relative value is illegal in offset expressions" :
    3980                         "Relative value is illegal in immediate expressions");
    3981                 return false;
    3982             }
     3780                        "Relative value is illegal in immediate expressions")
    39833781            if (targetType==GCNTGT_DSOFFSET8_0)
    39843782                sectionData[offset] = value;
     
    39893787        case GCNTGT_MXBUFOFFSET:
    39903788            if (sectionId != ASMSECT_ABS)
    3991             {
    3992                 printError(sourcePos, "Relative value is illegal in offset expressions");
    3993                 return false;
    3994             }
     3789                GCN_FAIL_BY_ERROR(sourcePos,
     3790                            "Relative value is illegal in offset expressions")
    39953791            sectionData[offset] = value&0xff;
    39963792            sectionData[offset+1] = (sectionData[offset+1]&0xf0) | ((value>>8)&0xf);
     
    40003796        case GCNTGT_SMEMOFFSETVEGA:
    40013797            if (sectionId != ASMSECT_ABS)
    4002             {
    4003                 printError(sourcePos, "Relative value is illegal in offset expressions");
    4004                 return false;
    4005             }
     3798                GCN_FAIL_BY_ERROR(sourcePos,
     3799                            "Relative value is illegal in offset expressions")
    40063800            if (targetType==GCNTGT_SMEMOFFSETVEGA)
    40073801            {
     
    40173811        case GCNTGT_SMEMOFFSET2:
    40183812            if (sectionId != ASMSECT_ABS)
    4019             {
    4020                 printError(sourcePos, "Relative value is illegal in offset expressions");
    4021                 return false;
    4022             }
     3813                GCN_FAIL_BY_ERROR(sourcePos,
     3814                        "Relative value is illegal in offset expressions")
    40233815            sectionData[offset+7] = value;
    40243816            printWarningForRange(8, value, sourcePos, WS_UNSIGNED);
     
    40263818        case GCNTGT_SMEMIMM:
    40273819            if (sectionId != ASMSECT_ABS)
    4028             {
    4029                 printError(sourcePos, "Relative value is illegal in immediate expressions");
    4030                 return false;
    4031             }
     3820                GCN_FAIL_BY_ERROR(sourcePos,
     3821                        "Relative value is illegal in immediate expressions");
    40323822            sectionData[offset] = (sectionData[offset]&0x3f) | ((value<<6)&0xff);
    40333823            sectionData[offset+1] = (sectionData[offset+1]&0xe0) | ((value>>2)&0x1f);
     
    40363826        case GCNTGT_INSTOFFSET:
    40373827            if (sectionId != ASMSECT_ABS)
    4038             {
    4039                 printError(sourcePos, "Relative value is illegal in offset expressions");
    4040                 return false;
    4041             }
     3828                GCN_FAIL_BY_ERROR(sourcePos,
     3829                        "Relative value is illegal in offset expressions")
    40423830            sectionData[offset] = value;
    40433831            sectionData[offset+1] = (sectionData[offset+1]&0xf0) | ((value&0xf00)>>8);
     
    40463834        case GCNTGT_INSTOFFSET_S:
    40473835            if (sectionId != ASMSECT_ABS)
    4048             {
    4049                 printError(sourcePos, "Relative value is illegal in offset expressions");
    4050                 return false;
    4051             }
     3836                GCN_FAIL_BY_ERROR(sourcePos,
     3837                        "Relative value is illegal in offset expressions");
    40523838            sectionData[offset] = value;
    40533839            sectionData[offset+1] = (sectionData[offset+1]&0xe0) |
Note: See TracChangeset for help on using the changeset viewer.