Changeset 3293 in CLRX


Ignore:
Timestamp:
Sep 2, 2017, 5:27:00 PM (13 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmGallium?/ROCm: Reuse code to checking config values.

Location:
CLRadeonExtender/trunk/amdasm
Files:
3 edited

Legend:

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

    r3292 r3293  
    609609        {
    610610            case GALLIUMCVAL_SGPRSNUM:
    611             case GALLIUMCVAL_HSA_SGPRSNUM:
    612611            {
    613612                const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     
    624623            }
    625624            case GALLIUMCVAL_VGPRSNUM:
    626             case GALLIUMCVAL_HSA_VGPRSNUM:
    627625            {
    628626                const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     
    669667            }
    670668            case GALLIUMCVAL_EXCEPTIONS:
    671             case GALLIUMCVAL_HSA_EXCEPTIONS:
    672669                asmr.printWarningForRange(7, value,
    673670                                  asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     
    675672                break;
    676673            case GALLIUMCVAL_FLOATMODE:
    677             case GALLIUMCVAL_HSA_FLOATMODE:
    678674                asmr.printWarningForRange(8, value,
    679675                                  asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     
    681677                break;
    682678            case GALLIUMCVAL_PRIORITY:
    683             case GALLIUMCVAL_HSA_PRIORITY:
    684679                asmr.printWarningForRange(2, value,
    685680                                  asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     
    687682                break;
    688683            case GALLIUMCVAL_LOCALSIZE:
    689             case GALLIUMCVAL_WORKGROUP_GROUP_SEGMENT_SIZE:
    690684            {
    691685                const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     
    702696            }
    703697            case GALLIUMCVAL_USERDATANUM:
    704             case GALLIUMCVAL_HSA_USERDATANUM:
    705698                if (value > 16)
    706699                {
     
    711704            case GALLIUMCVAL_PGMRSRC1:
    712705            case GALLIUMCVAL_PGMRSRC2:
    713             case GALLIUMCVAL_HSA_PGMRSRC1:
    714             case GALLIUMCVAL_HSA_PGMRSRC2:
    715706                asmr.printWarningForRange(32, value,
    716707                                  asmr.getSourcePos(valuePlace), WS_UNSIGNED);
    717708                break;
    718            
    719             case GALLIUMCVAL_PRIVATE_ELEM_SIZE:
    720                 if (value==0 || 1ULL<<(63-CLZ64(value)) != value)
    721                 {
    722                     asmr.printError(valuePlace,
    723                                     "Private element size must be power of two");
    724                     good = false;
    725                 }
    726                 else if (value < 2 || value > 16)
    727                 {
    728                     asmr.printError(valuePlace, "Private element size out of range");
    729                     good = false;
    730                 }
    731                 break;
    732             case GALLIUMCVAL_KERNARG_SEGMENT_ALIGN:
    733             case GALLIUMCVAL_GROUP_SEGMENT_ALIGN:
    734             case GALLIUMCVAL_PRIVATE_SEGMENT_ALIGN:
    735                 if (value==0 || 1ULL<<(63-CLZ64(value)) != value)
    736                 {
    737                     asmr.printError(valuePlace, "Alignment must be power of two");
    738                     good = false;
    739                 }
    740                 else if (value < 16)
    741                 {
    742                     asmr.printError(valuePlace, "Alignment must be not smaller than 16");
    743                     good = false;
    744                 }
    745                 break;
    746             case GALLIUMCVAL_WAVEFRONT_SIZE:
    747                 if (value==0 || 1ULL<<(63-CLZ64(value)) != value)
    748                 {
    749                     asmr.printError(valuePlace, "Wavefront size must be power of two");
    750                     good = false;
    751                 }
    752                 else if (value > 256)
    753                 {
    754                     asmr.printError(valuePlace,
    755                                 "Wavefront size must be not greater than 256");
    756                     good = false;
    757                 }
    758                 break;
    759             case GALLIUMCVAL_WORKITEM_PRIVATE_SEGMENT_SIZE:
    760             case GALLIUMCVAL_GDS_SEGMENT_SIZE:
    761             case GALLIUMCVAL_WORKGROUP_FBARRIER_COUNT:
    762             case GALLIUMCVAL_CALL_CONVENTION:
    763                 asmr.printWarningForRange(32, value,
    764                                   asmr.getSourcePos(valuePlace), WS_UNSIGNED);
    765                 break;
    766             case GALLIUMCVAL_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR:
    767             case GALLIUMCVAL_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR:
    768             {
    769                 const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
    770                             asmr.deviceType);
    771                 cxuint maxSGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_SGPR, 0);
    772                 if (value >= maxSGPRsNum)
    773                 {
    774                     asmr.printError(valuePlace, "SGPR register out of range");
    775                     good = false;
    776                 }
    777                 break;
    778             }
    779709            default:
    780710                break;
    781711        }
     712       
     713        if (good && target >= GALLIUMCVAL_HSA_FIRST_PARAM)
     714            good = AsmROCmPseudoOps::checkConfigValue(asmr, valuePlace,
     715                ROCmConfigValueTarget(target-GALLIUMCVAL_HSA_FIRST_PARAM), value);
    782716    }
    783717   
  • CLRadeonExtender/trunk/amdasm/AsmInternals.h

    r3292 r3293  
    668668                      const char* linePtr);
    669669   
     670    static bool checkConfigValue(Assembler& asmr, const char* valuePlace,
     671                    ROCmConfigValueTarget target, uint64_t value);
    670672    static void setConfigValueMain(AsmAmdHsaKernelConfig& config,
    671673                        ROCmConfigValueTarget target, uint64_t value);
  • CLRadeonExtender/trunk/amdasm/AsmROCmFormat.cpp

    r3292 r3293  
    419419}
    420420
     421bool AsmROCmPseudoOps::checkConfigValue(Assembler& asmr, const char* valuePlace,
     422                ROCmConfigValueTarget target, uint64_t value)
     423{
     424    bool good = true;
     425    switch(target)
     426    {
     427        case ROCMCVAL_SGPRSNUM:
     428        {
     429            const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     430                        asmr.deviceType);
     431            cxuint maxSGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_SGPR, 0);
     432            if (value > maxSGPRsNum)
     433            {
     434                char buf[64];
     435                snprintf(buf, 64, "Used SGPRs number out of range (0-%u)", maxSGPRsNum);
     436                asmr.printError(valuePlace, buf);
     437                good = false;
     438            }
     439            break;
     440        }
     441        case ROCMCVAL_VGPRSNUM:
     442        {
     443            const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     444                        asmr.deviceType);
     445            cxuint maxVGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_VGPR, 0);
     446            if (value > maxVGPRsNum)
     447            {
     448                char buf[64];
     449                snprintf(buf, 64, "Used VGPRs number out of range (0-%u)", maxVGPRsNum);
     450                asmr.printError(valuePlace, buf);
     451                good = false;
     452            }
     453            break;
     454        }
     455        case ROCMCVAL_EXCEPTIONS:
     456            asmr.printWarningForRange(7, value,
     457                                asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     458            value &= 0x7f;
     459            break;
     460        case ROCMCVAL_FLOATMODE:
     461            asmr.printWarningForRange(8, value,
     462                                asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     463            value &= 0xff;
     464            break;
     465        case ROCMCVAL_PRIORITY:
     466            asmr.printWarningForRange(2, value,
     467                                asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     468            value &= 3;
     469            break;
     470        case ROCMCVAL_WORKGROUP_GROUP_SEGMENT_SIZE: // local size
     471        {
     472            asmr.printWarningForRange(32, value,
     473                        asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     474           
     475            const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     476                        asmr.deviceType);
     477            const cxuint maxLocalSize = getGPUMaxLocalSize(arch);
     478            if (value > maxLocalSize)
     479            {
     480                char buf[64];
     481                snprintf(buf, 64, "LocalSize out of range (0-%u)", maxLocalSize);
     482                asmr.printError(valuePlace, buf);
     483                good = false;
     484            }
     485            break;
     486        }
     487        case ROCMCVAL_USERDATANUM:
     488            if (value > 16)
     489            {
     490                asmr.printError(valuePlace, "UserDataNum out of range (0-16)");
     491                good = false;
     492            }
     493            break;
     494        case ROCMCVAL_PRIVATE_ELEM_SIZE:
     495            if (value==0 || 1ULL<<(63-CLZ64(value)) != value)
     496            {
     497                asmr.printError(valuePlace,
     498                                "Private element size must be power of two");
     499                good = false;
     500            }
     501            else if (value < 2 || value > 16)
     502            {
     503                asmr.printError(valuePlace, "Private element size out of range");
     504                good = false;
     505            }
     506            break;
     507        case ROCMCVAL_KERNARG_SEGMENT_ALIGN:
     508        case ROCMCVAL_GROUP_SEGMENT_ALIGN:
     509        case ROCMCVAL_PRIVATE_SEGMENT_ALIGN:
     510            if (value==0 || 1ULL<<(63-CLZ64(value)) != value)
     511            {
     512                asmr.printError(valuePlace, "Alignment must be power of two");
     513                good = false;
     514            }
     515            else if (value < 16)
     516            {
     517                asmr.printError(valuePlace, "Alignment must be not smaller than 16");
     518                good = false;
     519            }
     520            break;
     521        case ROCMCVAL_WAVEFRONT_SIZE:
     522            if (value==0 || 1ULL<<(63-CLZ64(value)) != value)
     523            {
     524                asmr.printError(valuePlace, "Wavefront size must be power of two");
     525                good = false;
     526            }
     527            else if (value > 256)
     528            {
     529                asmr.printError(valuePlace,
     530                            "Wavefront size must be not greater than 256");
     531                good = false;
     532            }
     533            break;
     534        case ROCMCVAL_WORKITEM_PRIVATE_SEGMENT_SIZE:
     535        case ROCMCVAL_GDS_SEGMENT_SIZE:
     536        case ROCMCVAL_WORKGROUP_FBARRIER_COUNT:
     537        case ROCMCVAL_CALL_CONVENTION:
     538        case ROCMCVAL_PGMRSRC1:
     539        case ROCMCVAL_PGMRSRC2:
     540            asmr.printWarningForRange(32, value,
     541                                asmr.getSourcePos(valuePlace), WS_UNSIGNED);
     542            break;
     543        case ROCMCVAL_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR:
     544        case ROCMCVAL_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR:
     545        {
     546            const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     547                        asmr.deviceType);
     548            cxuint maxSGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_SGPR, 0);
     549            if (value >= maxSGPRsNum)
     550            {
     551                asmr.printError(valuePlace, "SGPR register out of range");
     552                good = false;
     553            }
     554            break;
     555        }
     556        default:
     557            break;
     558    }
     559    return good;
     560}
     561
    421562void AsmROCmPseudoOps::setConfigValueMain(AsmAmdHsaKernelConfig& config,
    422563                ROCmConfigValueTarget target, uint64_t value)
     
    533674    /* ranges checking */
    534675    if (good)
    535     {
    536         switch(target)
    537         {
    538             case ROCMCVAL_SGPRSNUM:
    539             {
    540                 const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
    541                             asmr.deviceType);
    542                 cxuint maxSGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_SGPR, 0);
    543                 if (value > maxSGPRsNum)
    544                 {
    545                     char buf[64];
    546                     snprintf(buf, 64, "Used SGPRs number out of range (0-%u)", maxSGPRsNum);
    547                     asmr.printError(valuePlace, buf);
    548                     good = false;
    549                 }
    550                 break;
    551             }
    552             case ROCMCVAL_VGPRSNUM:
    553             {
    554                 const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
    555                             asmr.deviceType);
    556                 cxuint maxVGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_VGPR, 0);
    557                 if (value > maxVGPRsNum)
    558                 {
    559                     char buf[64];
    560                     snprintf(buf, 64, "Used VGPRs number out of range (0-%u)", maxVGPRsNum);
    561                     asmr.printError(valuePlace, buf);
    562                     good = false;
    563                 }
    564                 break;
    565             }
    566             case ROCMCVAL_EXCEPTIONS:
    567                 asmr.printWarningForRange(7, value,
    568                                   asmr.getSourcePos(valuePlace), WS_UNSIGNED);
    569                 value &= 0x7f;
    570                 break;
    571             case ROCMCVAL_FLOATMODE:
    572                 asmr.printWarningForRange(8, value,
    573                                   asmr.getSourcePos(valuePlace), WS_UNSIGNED);
    574                 value &= 0xff;
    575                 break;
    576             case ROCMCVAL_PRIORITY:
    577                 asmr.printWarningForRange(2, value,
    578                                   asmr.getSourcePos(valuePlace), WS_UNSIGNED);
    579                 value &= 3;
    580                 break;
    581             case ROCMCVAL_WORKGROUP_GROUP_SEGMENT_SIZE: // local size
    582             {
    583                 asmr.printWarningForRange(32, value,
    584                           asmr.getSourcePos(valuePlace), WS_UNSIGNED);
    585                
    586                 const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
    587                             asmr.deviceType);
    588                 const cxuint maxLocalSize = getGPUMaxLocalSize(arch);
    589                 if (value > maxLocalSize)
    590                 {
    591                     char buf[64];
    592                     snprintf(buf, 64, "LocalSize out of range (0-%u)", maxLocalSize);
    593                     asmr.printError(valuePlace, buf);
    594                     good = false;
    595                 }
    596                 break;
    597             }
    598             case ROCMCVAL_USERDATANUM:
    599                 if (value > 16)
    600                 {
    601                     asmr.printError(valuePlace, "UserDataNum out of range (0-16)");
    602                     good = false;
    603                 }
    604                 break;
    605             case ROCMCVAL_PRIVATE_ELEM_SIZE:
    606                 if (value==0 || 1ULL<<(63-CLZ64(value)) != value)
    607                 {
    608                     asmr.printError(valuePlace,
    609                                     "Private element size must be power of two");
    610                     good = false;
    611                 }
    612                 else if (value < 2 || value > 16)
    613                 {
    614                     asmr.printError(valuePlace, "Private element size out of range");
    615                     good = false;
    616                 }
    617                 break;
    618             case ROCMCVAL_KERNARG_SEGMENT_ALIGN:
    619             case ROCMCVAL_GROUP_SEGMENT_ALIGN:
    620             case ROCMCVAL_PRIVATE_SEGMENT_ALIGN:
    621                 if (value==0 || 1ULL<<(63-CLZ64(value)) != value)
    622                 {
    623                     asmr.printError(valuePlace, "Alignment must be power of two");
    624                     good = false;
    625                 }
    626                 else if (value < 16)
    627                 {
    628                     asmr.printError(valuePlace, "Alignment must be not smaller than 16");
    629                     good = false;
    630                 }
    631                 break;
    632             case ROCMCVAL_WAVEFRONT_SIZE:
    633                 if (value==0 || 1ULL<<(63-CLZ64(value)) != value)
    634                 {
    635                     asmr.printError(valuePlace, "Wavefront size must be power of two");
    636                     good = false;
    637                 }
    638                 else if (value > 256)
    639                 {
    640                     asmr.printError(valuePlace,
    641                                 "Wavefront size must be not greater than 256");
    642                     good = false;
    643                 }
    644                 break;
    645             case ROCMCVAL_WORKITEM_PRIVATE_SEGMENT_SIZE:
    646             case ROCMCVAL_GDS_SEGMENT_SIZE:
    647             case ROCMCVAL_WORKGROUP_FBARRIER_COUNT:
    648             case ROCMCVAL_CALL_CONVENTION:
    649             case ROCMCVAL_PGMRSRC1:
    650             case ROCMCVAL_PGMRSRC2:
    651                 asmr.printWarningForRange(32, value,
    652                                   asmr.getSourcePos(valuePlace), WS_UNSIGNED);
    653                 break;
    654             case ROCMCVAL_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR:
    655             case ROCMCVAL_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR:
    656             {
    657                 const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
    658                             asmr.deviceType);
    659                 cxuint maxSGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_SGPR, 0);
    660                 if (value >= maxSGPRsNum)
    661                 {
    662                     asmr.printError(valuePlace, "SGPR register out of range");
    663                     good = false;
    664                 }
    665                 break;
    666             }
    667             default:
    668                 break;
    669         }
    670     }
     676        good = checkConfigValue(asmr, valuePlace, target, value);
    671677    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
    672678        return;
Note: See TracChangeset for help on using the changeset viewer.