Changeset 3156 in CLRX


Ignore:
Timestamp:
Jun 15, 2017, 8:51:43 AM (2 years ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmGallium?: Hot fix for LLVM 4.0 (AMDHSA). update documentation (new pseudo-ops in AsmGallium? and new options in clrxasm).

Location:
CLRadeonExtender/trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/CLRX/amdbin/Commons.h

    r2682 r3156  
    3939};
    4040
     41enum {
     42    AMDHSAFLAG_USE_PRIVATE_SEGMENT_BUFFER = 1,
     43    AMDHSAFLAG_USE_DISPATCH_PTR = 2,
     44    AMDHSAFLAG_USE_QUEUE_PTR = 4,
     45    AMDHSAFLAG_USE_KERNARG_SEGMENT_PTR = 8,
     46    AMDHSAFLAG_USE_DISPATCH_ID = 16,
     47    AMDHSAFLAG_USE_FLAT_SCRATCH_INIT = 32,
     48    AMDHSAFLAG_USE_PRIVATE_SEGMENT_SIZE = 64,
     49    AMDHSAFLAG_USE_GRID_WORKGROUP_COUNT_BIT = 7,
     50    AMDHSAFLAG_USE_GRID_WORKGROUP_COUNT_X = 128,
     51    AMDHSAFLAG_USE_GRID_WORKGROUP_COUNT_Y = 256,
     52    AMDHSAFLAG_USE_GRID_WORKGROUP_COUNT_Z = 512,
     53   
     54    AMDHSAFLAG_USE_ORDERED_APPEND_GDS = 1,
     55    AMDHSAFLAG_PRIVATE_ELEM_SIZE_BIT = 1,
     56    AMDHSAFLAG_USE_PTR64 = 8,
     57    AMDHSAFLAG_USE_DYNAMIC_CALL_STACK = 16,
     58    AMDHSAFLAG_USE_DEBUG_ENABLED = 32,
     59    AMDHSAFLAG_USE_XNACK_ENABLED = 64
     60};
     61
     62
     63struct AmdHsaKernelConfig
     64{
     65    uint32_t amdCodeVersionMajor;
     66    uint32_t amdCodeVersionMinor;
     67    uint16_t amdMachineKind;
     68    uint16_t amdMachineMajor;
     69    uint16_t amdMachineMinor;
     70    uint16_t amdMachineStepping;
     71    uint64_t kernelCodeEntryOffset;
     72    uint64_t kernelCodePrefetchOffset;
     73    uint64_t kernelCodePrefetchSize;
     74    uint64_t maxScrachBackingMemorySize;
     75    uint32_t computePgmRsrc1;
     76    uint32_t computePgmRsrc2;
     77    uint16_t enableSpgrRegisterFlags;
     78    uint16_t enableFeatureFlags;
     79    uint32_t workitemPrivateSegmentSize;
     80    uint32_t workgroupGroupSegmentSize;
     81    uint32_t gdsSegmentSize;
     82    uint64_t kernargSegmentSize;
     83    uint32_t workgroupFbarrierCount;
     84    uint16_t wavefrontSgprCount;
     85    uint16_t workitemVgprCount;
     86    uint16_t reservedVgprFirst;
     87    uint16_t reservedVgprCount;
     88    uint16_t reservedSgprFirst;
     89    uint16_t reservedSgprCount;
     90    uint16_t debugWavefrontPrivateSegmentOffsetSgpr;
     91    uint16_t debugPrivateSegmentBufferSgpr;
     92    cxbyte kernargSegmentAlignment;
     93    cxbyte groupSegmentAlignment;
     94    cxbyte privateSegmentAlignment;
     95    cxbyte wavefrontSize;
     96    uint32_t callConvention;
     97    uint32_t reserved1[3];
     98    uint64_t runtimeLoaderKernelSymbol;
     99    cxbyte controlDirective[128];
     100};
     101
    41102};
    42103
  • CLRadeonExtender/trunk/CLRX/amdbin/ROCmBinaries.h

    r2710 r3156  
    3131#include <CLRX/amdbin/Elf.h>
    3232#include <CLRX/amdbin/ElfBinaries.h>
     33#include <CLRX/amdbin/Commons.h>
    3334#include <CLRX/utils/MemAccess.h>
    3435#include <CLRX/utils/Containers.h>
     
    111112
    112113enum {
    113     ROCMFLAG_USE_PRIVATE_SEGMENT_BUFFER = 1,
    114     ROCMFLAG_USE_DISPATCH_PTR = 2,
    115     ROCMFLAG_USE_QUEUE_PTR = 4,
    116     ROCMFLAG_USE_KERNARG_SEGMENT_PTR = 8,
    117     ROCMFLAG_USE_DISPATCH_ID = 16,
    118     ROCMFLAG_USE_FLAT_SCRATCH_INIT = 32,
    119     ROCMFLAG_USE_PRIVATE_SEGMENT_SIZE = 64,
    120     ROCMFLAG_USE_GRID_WORKGROUP_COUNT_BIT = 7,
    121     ROCMFLAG_USE_GRID_WORKGROUP_COUNT_X = 128,
    122     ROCMFLAG_USE_GRID_WORKGROUP_COUNT_Y = 256,
    123     ROCMFLAG_USE_GRID_WORKGROUP_COUNT_Z = 512,
    124    
    125     ROCMFLAG_USE_ORDERED_APPEND_GDS = 1,
    126     ROCMFLAG_PRIVATE_ELEM_SIZE_BIT = 1,
    127     ROCMFLAG_USE_PTR64 = 8,
    128     ROCMFLAG_USE_DYNAMIC_CALL_STACK = 16,
    129     ROCMFLAG_USE_DEBUG_ENABLED = 32,
    130     ROCMFLAG_USE_XNACK_ENABLED = 64
     114    ROCMFLAG_USE_PRIVATE_SEGMENT_BUFFER = AMDHSAFLAG_USE_PRIVATE_SEGMENT_BUFFER,
     115    ROCMFLAG_USE_DISPATCH_PTR = AMDHSAFLAG_USE_DISPATCH_PTR,
     116    ROCMFLAG_USE_QUEUE_PTR = AMDHSAFLAG_USE_QUEUE_PTR,
     117    ROCMFLAG_USE_KERNARG_SEGMENT_PTR = AMDHSAFLAG_USE_KERNARG_SEGMENT_PTR,
     118    ROCMFLAG_USE_DISPATCH_ID = AMDHSAFLAG_USE_DISPATCH_ID,
     119    ROCMFLAG_USE_FLAT_SCRATCH_INIT = AMDHSAFLAG_USE_FLAT_SCRATCH_INIT,
     120    ROCMFLAG_USE_PRIVATE_SEGMENT_SIZE = AMDHSAFLAG_USE_PRIVATE_SEGMENT_SIZE,
     121    ROCMFLAG_USE_GRID_WORKGROUP_COUNT_BIT = AMDHSAFLAG_USE_GRID_WORKGROUP_COUNT_BIT,
     122    ROCMFLAG_USE_GRID_WORKGROUP_COUNT_X = AMDHSAFLAG_USE_GRID_WORKGROUP_COUNT_X,
     123    ROCMFLAG_USE_GRID_WORKGROUP_COUNT_Y = AMDHSAFLAG_USE_GRID_WORKGROUP_COUNT_Y,
     124    ROCMFLAG_USE_GRID_WORKGROUP_COUNT_Z = AMDHSAFLAG_USE_GRID_WORKGROUP_COUNT_Z,
     125   
     126    ROCMFLAG_USE_ORDERED_APPEND_GDS = AMDHSAFLAG_USE_ORDERED_APPEND_GDS,
     127    ROCMFLAG_PRIVATE_ELEM_SIZE_BIT = AMDHSAFLAG_PRIVATE_ELEM_SIZE_BIT,
     128    ROCMFLAG_USE_PTR64 = AMDHSAFLAG_USE_PTR64,
     129    ROCMFLAG_USE_DYNAMIC_CALL_STACK = AMDHSAFLAG_USE_DYNAMIC_CALL_STACK,
     130    ROCMFLAG_USE_DEBUG_ENABLED = AMDHSAFLAG_USE_DEBUG_ENABLED,
     131    ROCMFLAG_USE_XNACK_ENABLED = AMDHSAFLAG_USE_XNACK_ENABLED
    131132};
    132133
    133134/// ROCm kernel configuration structure
    134 struct ROCmKernelConfig
    135 {
    136     uint32_t amdCodeVersionMajor;
    137     uint32_t amdCodeVersionMinor;
    138     uint16_t amdMachineKind;
    139     uint16_t amdMachineMajor;
    140     uint16_t amdMachineMinor;
    141     uint16_t amdMachineStepping;
    142     uint64_t kernelCodeEntryOffset;
    143     uint64_t kernelCodePrefetchOffset;
    144     uint64_t kernelCodePrefetchSize;
    145     uint64_t maxScrachBackingMemorySize;
    146     uint32_t computePgmRsrc1;
    147     uint32_t computePgmRsrc2;
    148     uint16_t enableSpgrRegisterFlags;
    149     uint16_t enableFeatureFlags;
    150     uint32_t workitemPrivateSegmentSize;
    151     uint32_t workgroupGroupSegmentSize;
    152     uint32_t gdsSegmentSize;
    153     uint64_t kernargSegmentSize;
    154     uint32_t workgroupFbarrierCount;
    155     uint16_t wavefrontSgprCount;
    156     uint16_t workitemVgprCount;
    157     uint16_t reservedVgprFirst;
    158     uint16_t reservedVgprCount;
    159     uint16_t reservedSgprFirst;
    160     uint16_t reservedSgprCount;
    161     uint16_t debugWavefrontPrivateSegmentOffsetSgpr;
    162     uint16_t debugPrivateSegmentBufferSgpr;
    163     cxbyte kernargSegmentAlignment;
    164     cxbyte groupSegmentAlignment;
    165     cxbyte privateSegmentAlignment;
    166     cxbyte wavefrontSize;
    167     uint32_t callConvention;
    168     uint32_t reserved1[3];
    169     uint64_t runtimeLoaderKernelSymbol;
    170     cxbyte controlDirective[128];
    171 };
     135typedef AmdHsaKernelConfig ROCmKernelConfig;
    172136
    173137/// check whether is Amd OpenCL 2.0 binary
  • CLRadeonExtender/trunk/amdasm/AsmGalliumFormat.cpp

    r3152 r3156  
    2424#include <utility>
    2525#include <algorithm>
     26#include <CLRX/utils/GPUId.h>
    2627#include <CLRX/utils/Utilities.h>
    2728#include <CLRX/amdasm/Assembler.h>
     
    3637    "debugmode", "dims", "driver_version", "dx10clamp",
    3738    "entry", "exceptions", "floatmode",
     39    "get_driver_version", "get_llvm_version",
    3840    "globaldata", "ieeemode",
    3941    "kcode", "kcodeend",
     
    5052    GALLIUMOP_DEBUGMODE, GALLIUMOP_DIMS, GALLIUMOP_DRIVER_VERSION, GALLIUMOP_DX10CLAMP,
    5153    GALLIUMOP_ENTRY, GALLIUMOP_EXCEPTIONS, GALLIUMOP_FLOATMODE,
     54    GALLIUMOP_GET_DRIVER_VERSION, GALLIUMOP_GET_LLVM_VERSION,
    5255    GALLIUMOP_GLOBALDATA, GALLIUMOP_IEEEMODE,
    5356    GALLIUMOP_KCODE, GALLIUMOP_KCODEEND,
     
    296299    asmr.llvmVersion = value;
    297300}
     301
     302void AsmGalliumPseudoOps::getXXXVersion(AsmGalliumHandler& handler, const char* linePtr,
     303            bool getLLVMVersion)
     304{
     305    Assembler& asmr = handler.assembler;
     306    const char* end = asmr.line + asmr.lineSize;
     307    skipSpacesToEnd(linePtr, end);
     308   
     309    const char* symNamePlace = linePtr;
     310    const CString symName = extractScopedSymName(linePtr, end, false);
     311    if (symName.empty())
     312    {
     313        asmr.printError(symNamePlace, "Illegal symbol name");
     314        return;
     315    }
     316    size_t symNameLength = symName.size();
     317    if (symNameLength >= 3 && symName.compare(symNameLength-3, 3, "::.")==0)
     318    {
     319        asmr.printError(symNamePlace, "Symbol '.' can be only in global scope");
     320        return;
     321    }
     322    if (!checkGarbagesAtEnd(asmr, linePtr))
     323        return;
     324   
     325    cxuint driverVersion = 0;
     326    if (getLLVMVersion)
     327        driverVersion = asmr.llvmVersion;
     328    else
     329        driverVersion = asmr.driverVersion;
     330   
     331    std::pair<AsmSymbolEntry*, bool> res = asmr.insertSymbolInScope(symName,
     332                AsmSymbol(ASMSECT_ABS, driverVersion));
     333    if (!res.second)
     334    {   // found
     335        if (res.first->second.onceDefined && res.first->second.isDefined()) // if label
     336            asmr.printError(symNamePlace, (std::string("Symbol '")+symName.c_str()+
     337                        "' is already defined").c_str());
     338        else
     339            asmr.setSymbol(*res.first, driverVersion, ASMSECT_ABS);
     340    }
     341}
     342
    298343
    299344
     
    10131058                                    GALLIUMCVAL_FLOATMODE);
    10141059            break;
     1060        case GALLIUMOP_GET_DRIVER_VERSION:
     1061            AsmGalliumPseudoOps::getXXXVersion(*this, linePtr, false);
     1062            break;
     1063        case GALLIUMOP_GET_LLVM_VERSION:
     1064            AsmGalliumPseudoOps::getXXXVersion(*this, linePtr, true);
     1065            break;
    10151066        case GALLIUMOP_GLOBALDATA:
    10161067            AsmGalliumPseudoOps::doGlobalData(*this, stmtPlace, linePtr);
     
    10851136    return true;
    10861137}
     1138
     1139static const AMDGPUArchValues galliumAmdGpuArchValuesTbl[] =
     1140{
     1141    { 0, 0, 0 }, // GPUDeviceType::CAPE_VERDE
     1142    { 0, 0, 0 }, // GPUDeviceType::PITCAIRN
     1143    { 0, 0, 0 }, // GPUDeviceType::TAHITI
     1144    { 0, 0, 0 }, // GPUDeviceType::OLAND
     1145    { 7, 0, 0 }, // GPUDeviceType::BONAIRE
     1146    { 7, 0, 0 }, // GPUDeviceType::SPECTRE
     1147    { 7, 0, 0 }, // GPUDeviceType::SPOOKY
     1148    { 7, 0, 0 }, // GPUDeviceType::KALINDI
     1149    { 0, 0, 0 }, // GPUDeviceType::HAINAN
     1150    { 7, 0, 1 }, // GPUDeviceType::HAWAII
     1151    { 8, 0, 0 }, // GPUDeviceType::ICELAND
     1152    { 8, 0, 0 }, // GPUDeviceType::TONGA
     1153    { 7, 0, 0 }, // GPUDeviceType::MULLINS
     1154    { 8, 0, 3 }, // GPUDeviceType::FIJI
     1155    { 8, 0, 1 }, // GPUDeviceType::CARRIZO
     1156    { 0, 0, 0 }, // GPUDeviceType::DUMMY
     1157    { 0, 0, 0 }, // GPUDeviceType::GOOSE
     1158    { 0, 0, 0 }, // GPUDeviceType::HORSE
     1159    { 8, 0, 1 }, // GPUDeviceType::STONEY
     1160    { 8, 0, 4 }, // GPUDeviceType::ELLESMERE
     1161    { 8, 0, 4 } // GPUDeviceType::BAFFIN
     1162};
    10871163
    10881164bool AsmGalliumHandler::prepareBinary()
     
    12191295   
    12201296    /// checking symbols and set offset for kernels
     1297    AMDGPUArchValues amdGpuArchValues = galliumAmdGpuArchValuesTbl[
     1298                    cxuint(assembler.deviceType)];
     1299    AsmSection& asmCSection = assembler.sections[codeSection];
    12211300    const AsmSymbolMap& symbolMap = assembler.getSymbolMap();
     1301   
     1302    const cxuint ldsShift = arch<GPUArchitecture::GCN1_1 ? 8 : 9;
     1303    const uint32_t ldsMask = (1U<<ldsShift)-1U;
     1304   
    12221305    for (size_t ki = 0; ki < output.kernels.size(); ki++)
    12231306    {
     
    12501333        }
    12511334        kinput.offset = symbol.value;
     1335        if (assembler.llvmVersion >= 40000U)
     1336        {   // requires amdhsa-gcn (with HSA header)
     1337            // hotfix
     1338            GalliumKernelConfig& config = output.kernels[ki].config;
     1339            AmdHsaKernelConfig outConfig;
     1340           
     1341            uint32_t dimValues = 0;
     1342            if (config.dimMask != BINGEN_DEFAULT)
     1343                dimValues = ((config.dimMask&7)<<7) |
     1344                        (((config.dimMask&4) ? 2 : (config.dimMask&2) ? 1 : 0)<<11);
     1345            else
     1346                dimValues |= (config.pgmRSRC2 & 0x1b80U);
     1347            cxuint sgprsNum = std::max(config.usedSGPRsNum, 1U);
     1348            cxuint vgprsNum = std::max(config.usedVGPRsNum, 1U);
     1349            uint32_t pgmRSRC1 =  (config.pgmRSRC1) | ((vgprsNum-1)>>2) |
     1350                (((sgprsNum-1)>>3)<<6) | ((uint32_t(config.floatMode)&0xff)<<12) |
     1351                (config.ieeeMode?1U<<23:0) | (uint32_t(config.priority&3)<<10) |
     1352                (config.privilegedMode?1U<<20:0) | (config.dx10Clamp?1U<<21:0) |
     1353                (config.debugMode?1U<<22:0);
     1354           
     1355            uint32_t pgmRSRC2 = (config.pgmRSRC2 & 0xffffe440U) |
     1356                        (config.userDataNum<<1) | ((config.tgSize) ? 0x400 : 0) |
     1357                        ((config.scratchBufferSize)?1:0) | dimValues |
     1358                        (((config.localSize+ldsMask)>>ldsShift)<<15) |
     1359                        ((uint32_t(config.exceptions)&0x7f)<<24);
     1360           
     1361            size_t argSegmentSize = 0;
     1362            for (GalliumArgInfo& argInfo: output.kernels[ki].argInfos)
     1363                argSegmentSize += (argInfo.targetSize+7) & ~size_t(7);
     1364            SULEV(outConfig.amdCodeVersionMajor, 1);
     1365            SULEV(outConfig.amdCodeVersionMinor, 0);
     1366            SULEV(outConfig.amdMachineKind, 1);
     1367            SULEV(outConfig.amdMachineMajor, amdGpuArchValues.major);
     1368            SULEV(outConfig.amdMachineMinor, amdGpuArchValues.minor);
     1369            SULEV(outConfig.amdMachineStepping, amdGpuArchValues.stepping);
     1370            SULEV(outConfig.kernelCodeEntryOffset, 256);
     1371            SULEV(outConfig.kernelCodePrefetchOffset, 0);
     1372            SULEV(outConfig.kernelCodePrefetchSize, 0);
     1373            SULEV(outConfig.maxScrachBackingMemorySize, 0);
     1374            SULEV(outConfig.computePgmRsrc1, pgmRSRC1);
     1375            SULEV(outConfig.computePgmRsrc2, pgmRSRC2);
     1376            SULEV(outConfig.enableSpgrRegisterFlags,
     1377                    uint16_t(AMDHSAFLAG_USE_PRIVATE_SEGMENT_BUFFER|
     1378                        AMDHSAFLAG_USE_DISPATCH_PTR|AMDHSAFLAG_USE_KERNARG_SEGMENT_PTR));
     1379            SULEV(outConfig.enableFeatureFlags, uint16_t(AMDHSAFLAG_USE_PTR64|2));
     1380            SULEV(outConfig.workitemPrivateSegmentSize, config.spilledVGPRs<<2);
     1381            SULEV(outConfig.workgroupGroupSegmentSize, config.spilledSGPRs<<2);
     1382            SULEV(outConfig.gdsSegmentSize, 0);
     1383            SULEV(outConfig.kernargSegmentSize, argSegmentSize);
     1384            SULEV(outConfig.workgroupFbarrierCount, 0);
     1385            SULEV(outConfig.wavefrontSgprCount, config.usedSGPRsNum);
     1386            SULEV(outConfig.workitemVgprCount, config.usedVGPRsNum);
     1387            SULEV(outConfig.reservedVgprFirst, 0);
     1388            SULEV(outConfig.reservedVgprCount, 0);
     1389            SULEV(outConfig.reservedSgprFirst, 0);
     1390            SULEV(outConfig.reservedSgprCount, 0);
     1391            SULEV(outConfig.debugWavefrontPrivateSegmentOffsetSgpr, 0);
     1392            SULEV(outConfig.debugPrivateSegmentBufferSgpr, 0);
     1393            outConfig.kernargSegmentAlignment = 4;
     1394            outConfig.groupSegmentAlignment = 4;
     1395            outConfig.privateSegmentAlignment = 4;
     1396            outConfig.wavefrontSize = 6;
     1397            SULEV(outConfig.callConvention, 0);
     1398            SULEV(outConfig.reserved1[0], 0);
     1399            SULEV(outConfig.reserved1[1], 0);
     1400            SULEV(outConfig.reserved1[2], 0);
     1401            SULEV(outConfig.runtimeLoaderKernelSymbol, 0);
     1402           
     1403            ::memset(outConfig.controlDirective, 0, 128);
     1404            ::memcpy(asmCSection.content.data() + symbol.value,
     1405                     &outConfig, sizeof(AmdHsaKernelConfig));
     1406        }
    12521407    }
    12531408    // set versions
  • CLRadeonExtender/trunk/amdasm/AsmInternals.h

    r3152 r3156  
    327327   
    328328    static void setLLVMVersion(AsmGalliumHandler& handler, const char* linePtr);
     329   
     330    static void getXXXVersion(AsmGalliumHandler& handler, const char* linePtr,
     331                              bool getLLVMVersion);
    329332   
    330333    /* user configuration pseudo-ops */
  • CLRadeonExtender/trunk/doc/ClrxAsmGallium.md

    r2628 r3156  
    127127(from list: x, y, z) will be used to determine space of the kernel execution.
    128128
     129### .driver_version
     130
     131Syntax: .driver_version VERSION
     132
     133Set driver (Mesa3D) version for this binary. Version in form: MajorVersion*100+MinorVersion.
     134This pseudo-op replaces driver info.
     135
    129136### .dx10clamp
    130137
     
    157164This pseudo-op must be inside kernel configuration (`.config`). Defines float-mode.
    158165Set floatmode (FP_ROUND and FP_DENORM fields of the MODE register). Default value is 0xc0.
     166
     167### .get_driver_version
     168
     169Syntax: .get_driver_version SYMBOL
     170
     171Store current driver version to SYMBOL.
     172
     173### .get_llvm_version
     174
     175Syntax: .get_llvm_version SYMBOL
     176
     177Store current LLVM compiler version to SYMBOL.
    159178
    160179### .globaldata
     
    194213
    195214Close `.kcode` clause. Refer to `.kcode`.
     215
     216### .llvm_version
     217
     218Syntax: .llvm_version VERSION
     219
     220Set LLVM compiler version for this binary. Version in form: MajorVersion*100+MinorVersion.
     221This pseudo-op replaces driver info.
    196222
    197223### .localsize
  • CLRadeonExtender/trunk/doc/ClrxAsmInvoke.md

    r3139 r3156  
    1414[-g GPUDEVICE] [-A ARCH] [-t VERSION] [--defsym=SYM[=VALUE]] [--includePath=PATH]
    1515[--output OUTFILE] [--binaryFormat=BINFORMAT] [--64bit] [--gpuType=GPUDEVICE]
    16 [--arch=ARCH] [--driverVersion=VERSION] [--forceAddSymbols] [--noWarnings]
    17 [--alternate] [--buggyFPLit] [--noMacroCase] [--help] [--usage] [--version] [file...]
     16[--arch=ARCH] [--driverVersion=VERSION] [--llvmVersion=VERSION] [--forceAddSymbols]
     17[--noWarnings] [--alternate] [--buggyFPLit] [--noMacroCase] [--help] [--usage]
     18[--version] [file...]
    1819
    1920### Input
     
    7071MajorVersion*100 + MinorVersion.
    7172
     73* **--llvmVersion=VERSION**
     74
     75    Choose LLVM compiler version. Version can be retrieved from clinfo program that display
     76field Version. Version is number in that form: MajorVersion*100 + MinorVersion.
     77
    7278* **-S**, **--forceAddSymbols**
    7379
  • CLRadeonExtender/trunk/programs/clrxasm.pod

    r3139 r3156  
    1010[-g GPUDEVICE] [-A ARCH] [-t VERSION] [--defsym=SYM[=VALUE]] [--includePath=PATH]
    1111[--output OUTFILE] [--binaryFormat=BINFORMAT] [--64bit] [--gpuType=GPUDEVICE]
    12 [--arch=ARCH] [--driverVersion=VERSION] [--forceAddSymbols] [--noWarnings]
    13 [--alternate] [--buggyFPLit] [--noMacroCase] [--help] [--usage] [--version] [file...]
     12[--arch=ARCH] [--driverVersion=VERSION] [--llvmVersion=VERSION]
     13[--forceAddSymbols] [--noWarnings] [--alternate] [--buggyFPLit] [--noMacroCase]
     14[--help] [--usage] [--version] [file...]
    1415
    1516=head1 DESCRIPTION
     
    7071=item B<-t VERSION>, B<--driverVersion=VERSION>
    7172
    72 Choose AMD Catalyst OpenCL driver version. Version can retrieved from clinfo program
     73Choose AMD Catalyst/GalliumCompute Mesa OpenCL driver version.
     74Version can retrieved from clinfo program
    7375that display field 'Driver version' where version is. Version is number in that form:
    7476MajorVersion*100 + MinorVersion.
     77
     78=item B<--llvmVersion=VERSION>
     79
     80Choose LLVM compiler version. Version can be retrieved from clinfo program that display
     81field Version. Version is number in that form: MajorVersion*100 + MinorVersion.
    7582
    7683=item B<-S>, B<--forceAddSymbols>
Note: See TracChangeset for help on using the changeset viewer.