Changeset 3152 in CLRX


Ignore:
Timestamp:
Jun 14, 2017, 7:35:33 PM (2 years ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmGallium?: Add spilled gprs, driver version and llvm version. Write binary for new mesa and llvm.
add new option '--llvmVersion' to clrxasm.

Location:
CLRadeonExtender/trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/CLRX/amdasm/Assembler.h

    r3040 r3152  
    423423    GPUDeviceType deviceType;
    424424    uint32_t driverVersion;
     425    uint32_t llvmVersion; // GalliumCompute
    425426    bool _64bit;    ///
    426427    bool good;
     
    683684    void setDriverVersion(uint32_t driverVersion)
    684685    { this->driverVersion = driverVersion; }
     686   
     687    /// get LLVM version
     688    uint32_t getLLVMVersion() const
     689    { return llvmVersion; }
     690    /// set LLVM version
     691    void setLLVMVersion(uint32_t llvmVersion)
     692    { this->llvmVersion = llvmVersion; }
    685693   
    686694    /// get GPU device type
  • CLRadeonExtender/trunk/CLRX/amdbin/GalliumBinaries.h

    r3151 r3152  
    386386{
    387387    CString kernelName;   ///< kernel's name
    388     GalliumProgInfoEntry progInfo[3];   ///< program info for kernel
     388    GalliumProgInfoEntry progInfo[5];   ///< program info for kernel
    389389    bool useConfig;         ///< true if configuration has been used to generate binary
    390390    GalliumKernelConfig config; ///< kernel's configuration
  • CLRadeonExtender/trunk/amdasm/AsmGalliumFormat.cpp

    r3026 r3152  
    3434{
    3535    "arg", "args", "config",
    36     "debugmode", "dims", "dx10clamp",
     36    "debugmode", "dims", "driver_version", "dx10clamp",
    3737    "entry", "exceptions", "floatmode",
    3838    "globaldata", "ieeemode",
    3939    "kcode", "kcodeend",
    40     "localsize", "pgmrsrc1", "pgmrsrc2", "priority",
     40    "llvm_version", "localsize",
     41    "pgmrsrc1", "pgmrsrc2", "priority",
    4142    "privmode", "proginfo",
    42     "scratchbuffer", "sgprsnum", "tgsize",
    43     "userdatanum", "vgprsnum"
     43    "scratchbuffer", "sgprsnum", "spilledsgprs", "spilledvgprs",
     44    "tgsize", "userdatanum", "vgprsnum"
    4445};
    4546
     
    4748{
    4849    GALLIUMOP_ARG = 0, GALLIUMOP_ARGS, GALLIUMOP_CONFIG,
    49     GALLIUMOP_DEBUGMODE, GALLIUMOP_DIMS, GALLIUMOP_DX10CLAMP,
     50    GALLIUMOP_DEBUGMODE, GALLIUMOP_DIMS, GALLIUMOP_DRIVER_VERSION, GALLIUMOP_DX10CLAMP,
    5051    GALLIUMOP_ENTRY, GALLIUMOP_EXCEPTIONS, GALLIUMOP_FLOATMODE,
    5152    GALLIUMOP_GLOBALDATA, GALLIUMOP_IEEEMODE,
    5253    GALLIUMOP_KCODE, GALLIUMOP_KCODEEND,
    53     GALLIUMOP_LOCALSIZE, GALLIUMOP_PGMRSRC1, GALLIUMOP_PGMRSRC2, GALLIUMOP_PRIORITY,
     54    GALLIUMOP_LLVM_VERSION, GALLIUMOP_LOCALSIZE,
     55    GALLIUMOP_PGMRSRC1, GALLIUMOP_PGMRSRC2, GALLIUMOP_PRIORITY,
    5456    GALLIUMOP_PRIVMODE, GALLIUMOP_PROGINFO,
    55     GALLIUMOP_SCRATCHBUFFER, GALLIUMOP_SGPRSNUM, GALLIUMOP_TGSIZE,
    56     GALLIUMOP_USERDATANUM, GALLIUMOP_VGPRSNUM
     57    GALLIUMOP_SCRATCHBUFFER, GALLIUMOP_SGPRSNUM,
     58    GALLIUMOP_SPILLEDSGPRS, GALLIUMOP_SPILLEDVGPRS,
     59    GALLIUMOP_TGSIZE, GALLIUMOP_USERDATANUM, GALLIUMOP_VGPRSNUM
    5760};
    5861
     
    268271}
    269272
     273void AsmGalliumPseudoOps::setDriverVersion(AsmGalliumHandler& handler, const char* linePtr)
     274{
     275    Assembler& asmr = handler.assembler;
     276    const char* end = asmr.line + asmr.lineSize;
     277    skipSpacesToEnd(linePtr, end);
     278    uint64_t value;
     279    if (!getAbsoluteValueArg(asmr, value, linePtr, true))
     280        return;
     281    if (!checkGarbagesAtEnd(asmr, linePtr))
     282        return;
     283    asmr.driverVersion = value;
     284}
     285
     286void AsmGalliumPseudoOps::setLLVMVersion(AsmGalliumHandler& handler, const char* linePtr)
     287{
     288    Assembler& asmr = handler.assembler;
     289    const char* end = asmr.line + asmr.lineSize;
     290    skipSpacesToEnd(linePtr, end);
     291    uint64_t value;
     292    if (!getAbsoluteValueArg(asmr, value, linePtr, true))
     293        return;
     294    if (!checkGarbagesAtEnd(asmr, linePtr))
     295        return;
     296    asmr.llvmVersion = value;
     297}
     298
     299
    270300void AsmGalliumPseudoOps::doConfig(AsmGalliumHandler& handler, const char* pseudoOpPlace,
    271301                      const char* linePtr)
     
    372402                break;
    373403            }
     404            case GALLIUMCVAL_SPILLEDSGPRS:
     405            {
     406                const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     407                            asmr.deviceType);
     408                cxuint maxSGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_SGPR, 0);
     409                if (value > maxSGPRsNum)
     410                {
     411                    char buf[64];
     412                    snprintf(buf, 64, "Spilled SGPRs number out of range (0-%u)",
     413                             maxSGPRsNum);
     414                    asmr.printError(valuePlace, buf);
     415                    good = false;
     416                }
     417                break;
     418            }
     419            case GALLIUMCVAL_SPILLEDVGPRS:
     420            {
     421                const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
     422                            asmr.deviceType);
     423                cxuint maxVGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_VGPR, 0);
     424                if (value > maxVGPRsNum)
     425                {
     426                    char buf[64];
     427                    snprintf(buf, 64, "Spilled VGPRs number out of range (0-%u)",
     428                             maxVGPRsNum);
     429                    asmr.printError(valuePlace, buf);
     430                    good = false;
     431                }
     432                break;
     433            }
    374434            case GALLIUMCVAL_EXCEPTIONS:
    375435                asmr.printWarningForRange(7, value,
     
    430490        case GALLIUMCVAL_VGPRSNUM:
    431491            config.usedVGPRsNum = value;
     492            break;
     493        case GALLIUMCVAL_SPILLEDSGPRS:
     494            config.spilledSGPRs = value;
     495            break;
     496        case GALLIUMCVAL_SPILLEDVGPRS:
     497            config.spilledVGPRs = value;
    432498            break;
    433499        case GALLIUMCVAL_PGMRSRC1:
     
    929995            AsmGalliumPseudoOps::setDimensions(*this, stmtPlace, linePtr);
    930996            break;
     997        case GALLIUMOP_DRIVER_VERSION:
     998            AsmGalliumPseudoOps::setDriverVersion(*this, linePtr);
     999            break;
    9311000        case GALLIUMOP_DX10CLAMP:
    9321001            AsmGalliumPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
     
    9571026            AsmGalliumPseudoOps::doKCodeEnd(*this, stmtPlace, linePtr);
    9581027            break;
     1028        case GALLIUMOP_LLVM_VERSION:
     1029            AsmGalliumPseudoOps::setLLVMVersion(*this, linePtr);
     1030            break;
    9591031        case GALLIUMOP_LOCALSIZE:
    9601032            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     
    9871059            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
    9881060                                    GALLIUMCVAL_SGPRSNUM);
     1061            break;
     1062        case GALLIUMOP_SPILLEDSGPRS:
     1063            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1064                                    GALLIUMCVAL_SPILLEDSGPRS);
     1065            break;
     1066        case GALLIUMOP_SPILLEDVGPRS:
     1067            AsmGalliumPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
     1068                                    GALLIUMCVAL_SPILLEDVGPRS);
    9891069            break;
    9901070        case GALLIUMOP_TGSIZE:
     
    11711251        kinput.offset = symbol.value;
    11721252    }
     1253    // set versions
     1254    output.isMesa170 = assembler.driverVersion >= 170000U;
     1255    output.isLLVM390 = assembler.llvmVersion >= 30900U;
    11731256    return good;
    11741257}
  • CLRadeonExtender/trunk/amdasm/AsmInternals.h

    r3085 r3152  
    315315    GALLIUMCVAL_DX10CLAMP,
    316316    GALLIUMCVAL_PRIVMODE,
    317     GALLIUMCVAL_EXCEPTIONS
     317    GALLIUMCVAL_EXCEPTIONS,
     318    GALLIUMCVAL_SPILLEDSGPRS,
     319    GALLIUMCVAL_SPILLEDVGPRS
    318320};
    319321
     
    321323{
    322324    static bool checkPseudoOpName(const CString& string);
     325   
     326    static void setDriverVersion(AsmGalliumHandler& handler, const char* linePtr);
     327   
     328    static void setLLVMVersion(AsmGalliumHandler& handler, const char* linePtr);
    323329   
    324330    /* user configuration pseudo-ops */
  • CLRadeonExtender/trunk/amdasm/Assembler.cpp

    r3069 r3152  
    598598        : format(_format),
    599599          deviceType(_deviceType),
    600           driverVersion(0),
     600          driverVersion(0), llvmVersion(0),
    601601          _64bit(false),
    602602          isaAssembler(nullptr),
     
    634634        : format(_format),
    635635          deviceType(_deviceType),
    636           driverVersion(0),
     636          driverVersion(0), llvmVersion(0),
    637637          _64bit(false),
    638638          isaAssembler(nullptr),
  • CLRadeonExtender/trunk/amdasm/DisasmGallium.cpp

    r3151 r3152  
    206206        printDisasmData(galliumInput->globalDataSize, galliumInput->globalData, output);
    207207    }
     208    if (galliumInput->isMesa170)
     209        output.write(".driver_version 170000\n", 23);
    208210    if (galliumInput->isLLVM390)
    209         output.write(".llvm390\n", 9);
    210     if (galliumInput->isMesa170)
    211         output.write(".mesa170\n", 9);
     211        output.write(".llvm_version 30900\n", 20);
    212212   
    213213    const GPUArchitecture arch = getGPUArchitectureFromDeviceType(galliumInput->deviceType);
  • CLRadeonExtender/trunk/amdbin/GalliumBinaries.cpp

    r3151 r3152  
    472472        const cxuint ldsShift = arch<GPUArchitecture::GCN1_1 ? 8 : 9;
    473473        const uint32_t ldsMask = (1U<<ldsShift)-1U;
     474       
     475        const cxuint progInfoEntriesNum = input.isLLVM390 ? 5 : 3;
     476       
    474477        for (uint32_t korder: kernelsOrder)
    475478        {
    476479            const GalliumKernelInput& kernel = input.kernels[korder];
    477             GalliumProgInfoEntry outEntries[3];
     480            GalliumProgInfoEntry outEntries[5];
    478481            if (kernel.useConfig)
    479482            {
     
    482485                outEntries[1].address = ULEV(0x0000b84cU);
    483486                outEntries[2].address = ULEV(0x0000b860U);
     487                outEntries[3].address = ULEV(0x00000004U);
     488                outEntries[4].address = ULEV(0x00000008U);
    484489               
    485490                uint32_t scratchBlocks = ((config.scratchBufferSize<<6) + 1023)>>10;
     
    505510                        ((uint32_t(config.exceptions)&0x7f)<<24);
    506511                outEntries[2].value = (scratchBlocks)<<12;
    507                 for (cxuint k = 0; k < 3; k++)
     512                if (input.isLLVM390)
     513                {
     514                    outEntries[4].value = config.spilledSGPRs;
     515                    outEntries[5].value = config.spilledVGPRs;
     516                }
     517                for (cxuint k = 0; k < progInfoEntriesNum; k++)
    508518                    outEntries[k].value = ULEV(outEntries[k].value);
    509519            }
    510520            else
    511                 for (cxuint k = 0; k < 3; k++)
     521            {
     522                for (cxuint k = 0; k < progInfoEntriesNum; k++)
    512523                {
    513524                    outEntries[k].address = ULEV(kernel.progInfo[k].address);
    514525                    outEntries[k].value = ULEV(kernel.progInfo[k].value);
    515526                }
     527            }
    516528            fob.writeArray(3, outEntries);
    517529        }
     
    711723    /* section */
    712724    {
    713         const uint32_t section[6] = { LEV(1U), LEV(0U), LEV(0U), LEV(uint32_t(elfSize)),
    714             LEV(uint32_t(elfSize+4)), LEV(uint32_t(elfSize)) };
     725        const uint32_t secType = uint32_t(input->isMesa170 ?
     726                GalliumSectionType::TEXT_EXECUTABLE_170 : GalliumSectionType::TEXT);
     727        const uint32_t section[6] = { LEV(1U), LEV(0U), LEV(secType),
     728            LEV(uint32_t(elfSize)), LEV(uint32_t(elfSize+4)), LEV(uint32_t(elfSize)) };
    715729        bos.writeArray(6, section);
    716730    }
  • CLRadeonExtender/trunk/programs/clrxasm.cpp

    r2830 r3152  
    4747        "set GPU architecture for Gallium/raw binaries", "ARCH" },
    4848    { "driverVersion", 't', CLIArgType::UINT, false, false,
    49         "set driver version (for AmdCatalyst)", nullptr },
     49        "set driver version (for Amd/GalliumCompute)", nullptr },
     50    { "llvmVersion", 0, CLIArgType::UINT, false, false,
     51        "set LLVM version (for GalliumCompute)", nullptr },
    5052    { "forceAddSymbols", 'S', CLIArgType::NONE, false, false,
    5153        "force add symbols to binaries", nullptr },
     
    8486    GPUDeviceType deviceType = GPUDeviceType::CAPE_VERDE;
    8587    uint32_t driverVersion = 0;
     88    uint32_t llvmVersion = 0;
    8689    Flags flags = 0;
    8790    if (cli.hasShortOption('b'))
     
    110113    if (cli.hasShortOption('t'))
    111114        driverVersion = cli.getShortOptArg<cxuint>('t');
     115    if (cli.hasLongOption("llvmVersion"))
     116        llvmVersion = cli.getLongOptArg<cxuint>("llvmVersion");
    112117    if (cli.hasShortOption('S'))
    113118        flags |= ASM_FORCE_ADD_SYMBOLS;
     
    133138    assembler->set64Bit(is64Bit);
    134139    assembler->setDriverVersion(driverVersion);
     140    assembler->setLLVMVersion(llvmVersion);
    135141   
    136142    size_t defSymsNum = 0;
Note: See TracChangeset for help on using the changeset viewer.