Changeset 3457 in CLRX


Ignore:
Timestamp:
Oct 7, 2017, 12:21:39 PM (17 months ago)
Author:
matszpk
Message:

CLRadeonExtender: Add new exception class to distinguish errors in GPUId, assembler, disassembler, binary readers and binary generators.

Location:
CLRadeonExtender/trunk
Files:
20 edited

Legend:

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

    r3195 r3457  
    3838namespace CLRX
    3939{
     40
     41/// Assembler exception class
     42class AsmException: public Exception
     43{
     44public:
     45    /// empty constructor
     46    AsmException() = default;
     47    /// constructor with messasge
     48    explicit AsmException(const std::string& message);
     49    /// destructor
     50    virtual ~AsmException() noexcept = default;
     51};
    4052
    4153enum: cxbyte {
  • CLRadeonExtender/trunk/CLRX/amdasm/Disassembler.h

    r3312 r3457  
    4343namespace CLRX
    4444{
     45
     46/// Disassembler exception class
     47class DisasmException: public Exception
     48{
     49public:
     50    /// empty constructor
     51    DisasmException() = default;
     52    /// constructor with messasge
     53    explicit DisasmException(const std::string& message);
     54    /// destructor
     55    virtual ~DisasmException() noexcept = default;
     56};
    4557
    4658class Disassembler;
  • CLRadeonExtender/trunk/CLRX/amdbin/ElfBinaries.h

    r3194 r3457  
    7474};
    7575
     76/// Bin exception class
     77class BinException: public Exception
     78{
     79public:
     80    /// empty constructor
     81    BinException() = default;
     82    /// constructor with messasge
     83    explicit BinException(const std::string& message);
     84    /// destructor
     85    virtual ~BinException() noexcept = default;
     86};
     87
     88/// Binary generator exception class
     89class BinGenException: public Exception
     90{
     91public:
     92    /// empty constructor
     93    BinGenException() = default;
     94    /// constructor with messasge
     95    explicit BinGenException(const std::string& message);
     96    /// destructor
     97    virtual ~BinGenException() noexcept = default;
     98};
     99
    76100/// ELF 32-bit types
    77101struct Elf32Types
     
    310334                    sectionIndexMap.begin(), sectionIndexMap.end(), name, CStringLess());
    311335        if (it == sectionIndexMap.end())
    312             throw Exception(std::string("Can't find Elf")+Types::bitName+" Section");
     336            throw BinException(std::string("Can't find Elf")+Types::bitName+" Section");
    313337        return it;
    314338    }
     
    337361                    symbolIndexMap.begin(), symbolIndexMap.end(), name, CStringLess());
    338362        if (it == symbolIndexMap.end())
    339             throw Exception(std::string("Can't find Elf")+Types::bitName+" Symbol");
     363            throw BinException(std::string("Can't find Elf")+Types::bitName+" Symbol");
    340364        return it;
    341365    }
     
    347371                    dynSymIndexMap.begin(), dynSymIndexMap.end(), name, CStringLess());
    348372        if (it == dynSymIndexMap.end())
    349             throw Exception(std::string("Can't find Elf")+Types::bitName+" DynSymbol");
     373            throw BinException(std::string("Can't find Elf")+Types::bitName+" DynSymbol");
    350374        return it;
    351375    }
  • CLRadeonExtender/trunk/CLRX/utils/GPUId.h

    r3444 r3457  
    3131namespace CLRX
    3232{
     33
     34/// GPUId exception class
     35class GPUIdException: public Exception
     36{
     37public:
     38    /// empty constructor
     39    GPUIdException() = default;
     40    /// constructor with messasge
     41    explicit GPUIdException(const std::string& message);
     42    /// destructor
     43    virtual ~GPUIdException() noexcept = default;
     44};
     45
    3346/*
    3447 * GPU identification utilities
  • CLRadeonExtender/trunk/amdasm/AsmExpression.cpp

    r3436 r3457  
    117117{
    118118    if (symOccursNum != 0)
    119         throw Exception("Expression can't be evaluated if symbols still are unresolved!");
     119        throw AsmException("Expression can't be evaluated if "
     120                    "symbols still are unresolved!");
    120121   
    121122    bool failed = false;
  • CLRadeonExtender/trunk/amdasm/AsmRegAlloc.cpp

    r3398 r3457  
    7777        size_t defaultInstrSize = (!useRegMode ? this->defaultInstrSize : 0);
    7878        if (lastOffset > offset)
    79             throw Exception("Offset before previous instruction");
     79            throw AsmException("Offset before previous instruction");
    8080        if (!instrStruct.empty() && offset - lastOffset < defaultInstrSize)
    81             throw Exception("Offset between previous instruction");
     81            throw AsmException("Offset between previous instruction");
    8282        size_t toSkip = !instrStruct.empty() ?
    8383                offset - lastOffset - defaultInstrSize : offset;
     
    170170{
    171171    if (!isNext)
    172         throw Exception("No reg usage in this code");
     172        throw AsmException("No reg usage in this code");
    173173    AsmRegVarUsage rvu;
    174174    // get regvarusage
     
    18721872            {
    18731873                if (colorsNum >= maxColorsNum)
    1874                     throw Exception("Too many register is needed");
     1874                    throw AsmException("Too many register is needed");
    18751875                colorsNum++;
    18761876            }
  • CLRadeonExtender/trunk/amdasm/AsmSource.cpp

    r3424 r3457  
    161161        stream = new std::ifstream(filename.c_str(), std::ios::binary);
    162162        if (!*stream)
    163             throw Exception(std::string("Can't open source file '")+filename.c_str()+"'");
     163            throw AsmException(std::string("Can't open source file '")+
     164                    filename.c_str()+"'");
    164165        stream->exceptions(std::ios::badbit);
    165166        buffer.reserve(AsmParserLineMaxSize);
     
    199200        stream = new std::ifstream(filename.c_str(), std::ios::binary);
    200201        if (!*stream)
    201             throw Exception(std::string("Can't open source file '")+filename.c_str()+"'");
     202            throw AsmException(std::string("Can't open source file '")+
     203                        filename.c_str()+"'");
    202204        stream->exceptions(std::ios::badbit);
    203205        buffer.reserve(AsmParserLineMaxSize);
  • CLRadeonExtender/trunk/amdasm/Assembler.cpp

    r3423 r3457  
    4646
    4747using namespace CLRX;
     48
     49// Assembler Exception costuctor
     50AsmException::AsmException(const std::string& message) : Exception(message)
     51{ }
    4852
    4953// copy constructor - includes usageHandler copying
     
    27072711                formatHandler->writeBinary(ofs);
    27082712            else
    2709                 throw Exception(std::string("Can't open output file '")+filename+"'");
     2713                throw AsmException(std::string("Can't open output file '")+filename+"'");
    27102714        }
    27112715        else
    2712             throw Exception("No output binary");
     2716            throw AsmException("No output binary");
    27132717    }
    27142718    else // failed
    2715         throw Exception("Assembler failed!");
     2719        throw AsmException("Assembler failed!");
    27162720}
    27172721
     
    27242728            formatHandler->writeBinary(outStream);
    27252729        else
    2726             throw Exception("No output binary");
     2730            throw AsmException("No output binary");
    27272731    }
    27282732    else // failed
    2729         throw Exception("Assembler failed!");
     2733        throw AsmException("Assembler failed!");
    27302734}
    27312735
     
    27382742            formatHandler->writeBinary(array);
    27392743        else
    2740             throw Exception("No output binary");
     2744            throw AsmException("No output binary");
    27412745    }
    27422746    else // failed
    2743         throw Exception("Assembler failed!");
    2744 }
     2747        throw AsmException("Assembler failed!");
     2748}
  • CLRadeonExtender/trunk/amdasm/DisasmAmd.cpp

    r3429 r3457  
    733733            cxuint argNo = cstrtovCStyle<cxuint>(linePtr+12, lineEnd, outEnd);
    734734            if (argNo >= config.args.size())
    735                 throw Exception("ArgNo out of range");
     735                throw DisasmException("ArgNo out of range");
    736736            const char* ptr = strechr(linePtr+12, lineEnd, ':');
    737737            if (ptr==nullptr)
     
    791791            config.args[argIdx].argType = KernelArgType::SAMPLER;
    792792        else
    793             throw Exception("Sampler arg index out of range");
     793            throw DisasmException("Sampler arg index out of range");
    794794   
    795795    // apply const qualifier to some pointer arguments
     
    798798            config.args[argIdx].ptrAccess |= KARG_PTR_CONST;
    799799        else
    800             throw Exception("Const arg index out of range");
     800            throw DisasmException("Const arg index out of range");
    801801   
    802802    /* from ATI CAL NOTES */
  • CLRadeonExtender/trunk/amdasm/DisasmAmdCL2.cpp

    r3430 r3457  
    145145            // check symbol type, section and value
    146146            if (ELF64_ST_TYPE(sym.st_info) != 12)
    147                 throw Exception("Wrong sampler symbol");
     147                throw DisasmException("Wrong sampler symbol");
    148148            uint64_t value = ULEV(sym.st_value);
    149149            if (ULEV(sym.st_shndx) != samplerInitSecIndex)
    150                 throw Exception("Wrong section for sampler symbol");
     150                throw DisasmException("Wrong section for sampler symbol");
    151151            if ((value&7) != 0)
    152                 throw Exception("Wrong value of sampler symbol");
     152                throw DisasmException("Wrong value of sampler symbol");
    153153            input->samplerRelocs.push_back({ size_t(ULEV(rel.r_offset)),
    154154                size_t(value>>3) });
     
    238238            if (sortedRelocIter != sortedRelocs.end() &&
    239239                    sortedRelocIter->first < size_t(kinput.code-textPtr))
    240                 throw Exception("Code relocation offset outside kernel code");
     240                throw DisasmException("Code relocation offset outside kernel code");
    241241           
    242242            if (sortedRelocIter != sortedRelocs.end())
     
    257257                    if (symShndx!=gDataSectionIdx && symShndx!=rwDataSectionIdx &&
    258258                        symShndx!=bssDataSectionIdx)
    259                         throw Exception("Symbol is not placed in global or "
     259                        throw DisasmException("Symbol is not placed in global or "
    260260                                "rwdata data or bss is illegal");
    261261                    addend += ULEV(sym.st_value);
     
    270270                        relocType = RELTYPE_HIGH_32BIT;
    271271                    else
    272                         throw Exception("Unknown relocation type");
     272                        throw DisasmException("Unknown relocation type");
    273273                    // put text relocs. compute offset by subtracting current code offset
    274274                    kinput.textRelocs.push_back(AmdCL2RelaEntry{sortedRelocIter->first-
     
    279279    }
    280280    if (sortedRelocIter != sortedRelocs.end())
    281         throw Exception("Code relocation offset outside kernel code");
     281        throw DisasmException("Code relocation offset outside kernel code");
    282282    return input.release();
    283283}
     
    474474                case 0:
    475475                    if (kindOfType!=1) // not sampler
    476                         throw Exception("Wrong kernel argument type");
     476                        throw DisasmException("Wrong kernel argument type");
    477477                    arg.argType = KernelArgType::SAMPLER;
    478478                    break;
     
    490490                    {
    491491                        if (kindOfType!=4) // not scalar
    492                             throw Exception("Wrong kernel argument type");
     492                            throw DisasmException("Wrong kernel argument type");
    493493                        arg.argType = (argType==3) ?
    494494                            KernelArgType::SHORT : KernelArgType::CHAR;
    495495                    }
    496496                    else
    497                         throw Exception("Wrong kernel argument type");
     497                        throw DisasmException("Wrong kernel argument type");
    498498                    break;
    499499                case 4: // int
    500500                case 5: // long
    501501                    if (kindOfType!=4) // not scalar
    502                         throw Exception("Wrong kernel argument type");
     502                        throw DisasmException("Wrong kernel argument type");
    503503                    arg.argType = (argType==5) ?
    504504                        KernelArgType::LONG : KernelArgType::INT;
     
    512512                {
    513513                    if (kindOfType!=4) // not scalar
    514                         throw Exception("Wrong kernel argument type");
     514                        throw DisasmException("Wrong kernel argument type");
    515515                    const cxuint vectorId = vectorIdTable[vectorSize];
    516516                    if (vectorId == UINT_MAX)
    517                         throw Exception("Wrong vector size");
     517                        throw DisasmException("Wrong vector size");
    518518                    arg.argType = cl20ArgTypeVectorTable[(argType-6)*6 + vectorId];
    519519                    break;
     
    521521                case 15:
    522522                    if (kindOfType!=4) // not scalar
    523                         throw Exception("Wrong kernel argument type");
     523                        throw DisasmException("Wrong kernel argument type");
    524524                    arg.argType = KernelArgType::STRUCTURE;
    525525                    break;
    526526                case 18:
    527527                    if (kindOfType!=7) // not scalar
    528                         throw Exception("Wrong kernel argument type");
     528                        throw DisasmException("Wrong kernel argument type");
    529529                    arg.argType = KernelArgType::CMDQUEUE;
    530530                    break;
    531531                default:
    532                     throw Exception("Wrong kernel argument type");
     532                    throw DisasmException("Wrong kernel argument type");
    533533                    break;
    534534            }
     
    569569                    arg.ptrSpace = KernelPtrSpace::CONSTANT;
    570570                else
    571                     throw Exception("Illegal pointer space");
     571                    throw DisasmException("Illegal pointer space");
    572572                // set access qualifiers (volatile, restrict, const)
    573573                arg.ptrAccess |= KARG_PTR_NORMAL;
     
    581581                // pointer space for pipe
    582582                if (ptrSpace!=4)
    583                     throw Exception("Illegal pipe space");
     583                    throw DisasmException("Illegal pipe space");
    584584                arg.ptrSpace = KernelPtrSpace::GLOBAL;
    585585            }
  • CLRadeonExtender/trunk/amdasm/Disassembler.cpp

    r3429 r3457  
    3535
    3636using namespace CLRX;
     37
     38DisasmException::DisasmException(const std::string& message) : Exception(message)
     39{ }
    3740
    3841ISADisassembler::ISADisassembler(Disassembler& _disassembler, cxuint outBufSize)
  • CLRadeonExtender/trunk/amdasm/GCNAssembler.cpp

    r3434 r3457  
    301301            break;
    302302        default:
    303             throw Exception("Unknown GCNField");
     303            throw AsmException("Unknown GCNField");
    304304    }
    305305    return { rstart, rstart+regSize };
  • CLRadeonExtender/trunk/amdbin/AmdBinGen.cpp

    r3417 r3457  
    689689        {
    690690            if (kinput.metadata == nullptr || kinput.metadataSize == 0)
    691                 throw Exception("No metadata for kernel");
     691                throw BinGenException("No metadata for kernel");
    692692            if (kinput.header == nullptr || kinput.headerSize == 0)
    693                 throw Exception("No header for kernel");
     693                throw BinGenException("No header for kernel");
    694694            if (kinput.code == nullptr)
    695                 throw Exception("No code for kernel");
     695                throw BinGenException("No code for kernel");
    696696            continue; // and skip
    697697        }
     
    700700        TempAmdKernelConfig& tempConfig = tempAmdKernelConfigs[i];
    701701        if (config.userDatas.size() > 16)
    702             throw Exception("UserDataElemsNum must not be greater than 16");
     702            throw BinGenException("UserDataElemsNum must not be greater than 16");
    703703        if (config.usedVGPRsNum > maxVGPRSNum)
    704             throw Exception("Used VGPRs number out of range");
     704            throw BinGenException("Used VGPRs number out of range");
    705705        if (config.usedSGPRsNum > maxSGPRSNum)
    706             throw Exception("Used SGPRs number out of range");
     706            throw BinGenException("Used SGPRs number out of range");
    707707        if (config.hwLocalSize > 32768)
    708             throw Exception("HWLocalSize out of range");
     708            throw BinGenException("HWLocalSize out of range");
    709709        if (config.floatMode >= 256)
    710             throw Exception("FloatMode out of range");
     710            throw BinGenException("FloatMode out of range");
    711711       
    712712        /* filling input */
     
    719719        for (const AmdKernelArgInput& arg: config.args)
    720720            if (arg.argType > KernelArgType::MAX_VALUE)
    721                 throw Exception("Unknown argument type");
     721                throw BinGenException("Unknown argument type");
    722722            else if (arg.argType == KernelArgType::POINTER)
    723723            {
    724724                if (arg.pointerType > KernelArgType::MAX_VALUE)
    725                     throw Exception("Unknown argument's pointer type");
     725                    throw BinGenException("Unknown argument's pointer type");
    726726                if (arg.ptrSpace > KernelPtrSpace::MAX_VALUE ||
    727727                    arg.ptrSpace == KernelPtrSpace::NONE)
    728                     throw Exception("Wrong pointer space type");
     728                    throw BinGenException("Wrong pointer space type");
    729729            }
    730730            else if (isKernelArgImage(arg.argType))
    731731            {
    732732                if ((arg.ptrAccess & KARG_PTR_ACCESS_MASK) == 0)
    733                     throw Exception("Invalid access qualifier for image");
     733                    throw BinGenException("Invalid access qualifier for image");
    734734            }
    735735       
     
    806806       
    807807        if (tempConfig.uavId != BINGEN_NOTSUPPLIED && tempConfig.uavId >= 1024)
    808             throw Exception("UavId out of range");
     808            throw BinGenException("UavId out of range");
    809809        if (tempConfig.constBufferId != BINGEN_NOTSUPPLIED &&
    810810            tempConfig.constBufferId >= 1024)
    811             throw Exception("ConstBufferId out of range");
     811            throw BinGenException("ConstBufferId out of range");
    812812        if (tempConfig.printfId != BINGEN_NOTSUPPLIED && tempConfig.printfId >= 1024)
    813             throw Exception("PrintfId out of range");
     813            throw BinGenException("PrintfId out of range");
    814814        if (tempConfig.privateId != BINGEN_NOTSUPPLIED && tempConfig.privateId >= 1024)
    815             throw Exception("PrivateId out of range");
     815            throw BinGenException("PrivateId out of range");
    816816       
    817817        /* fill argUavIds for global/constant pointers */
     
    838838                if ((arg.resId < 9 && arg.used) ||
    839839                    (!arg.used && arg.resId != tempConfig.uavId) || arg.resId >= 1024)
    840                     throw Exception("UavId out of range!");
     840                    throw BinGenException("UavId out of range!");
    841841                if (puavMask[arg.resId] && arg.resId != tempConfig.uavId)
    842                     throw Exception("UavId already used!");
     842                    throw BinGenException("UavId already used!");
    843843                puavMask.set(arg.resId);
    844844                tempConfig.argResIds[k] = arg.resId;
     
    849849                // old constant buffers
    850850                if (arg.resId < 2 || arg.resId >= 160)
    851                     throw Exception("CbId out of range!");
     851                    throw BinGenException("CbId out of range!");
    852852                if (cbIdMask[arg.resId])
    853                     throw Exception("CbId already used!");
     853                    throw BinGenException("CbId already used!");
    854854                cbIdMask.set(arg.resId);
    855855                tempConfig.argResIds[k] = arg.resId;
     
    861861                {
    862862                    if (arg.resId >= 128)
    863                         throw Exception("RdImgId out of range!");
     863                        throw BinGenException("RdImgId out of range!");
    864864                    if (rdImgMask[arg.resId])
    865                         throw Exception("RdImgId already used!");
     865                        throw BinGenException("RdImgId already used!");
    866866                    rdImgMask.set(arg.resId);
    867867                    tempConfig.argResIds[k] = arg.resId;
     
    870870                {
    871871                    if (arg.resId >= 8)
    872                         throw Exception("WrImgId out of range!");
     872                        throw BinGenException("WrImgId out of range!");
    873873                    if (wrImgMask[arg.resId])
    874                         throw Exception("WrImgId already used!");
     874                        throw BinGenException("WrImgId already used!");
    875875                    wrImgMask.set(arg.resId);
    876876                    tempConfig.argResIds[k] = arg.resId;
     
    880880            {
    881881                if (arg.resId >= 8)
    882                     throw Exception("CounterId out of range!");
     882                    throw BinGenException("CounterId out of range!");
    883883                if (cntIdMask[arg.resId])
    884                     throw Exception("CounterId already used!");
     884                    throw BinGenException("CounterId already used!");
    885885                cntIdMask.set(arg.resId);
    886886                tempConfig.argResIds[k] = arg.resId;
     
    902902                         puavIdsCount++);
    903903                    if (puavIdsCount == 1024)
    904                         throw Exception("UavId out of range!");
     904                        throw BinGenException("UavId out of range!");
    905905                    tempConfig.argResIds[k] = puavIdsCount++;
    906906                }
     
    914914                for (; cbIdsCount < 160 && cbIdMask[cbIdsCount]; cbIdsCount++);
    915915                if (cbIdsCount == 160)
    916                     throw Exception("CbId out of range!");
     916                    throw BinGenException("CbId out of range!");
    917917                tempConfig.argResIds[k] = cbIdsCount++;
    918918            }
     
    924924                    for (; rdImgsCount < 128 && rdImgMask[rdImgsCount]; rdImgsCount++);
    925925                    if (rdImgsCount == 128)
    926                         throw Exception("RdImgId out of range!");
     926                        throw BinGenException("RdImgId out of range!");
    927927                    tempConfig.argResIds[k] = rdImgsCount++;
    928928                }
     
    931931                    for (; wrImgsCount < 8 && wrImgMask[wrImgsCount]; wrImgsCount++);
    932932                    if (wrImgsCount == 8)
    933                         throw Exception("WrImgId out of range!");
     933                        throw BinGenException("WrImgId out of range!");
    934934                    tempConfig.argResIds[k] = wrImgsCount++;
    935935                }
     
    939939                for (; cntIdsCount < 8 && cntIdMask[cntIdsCount]; cntIdsCount++);
    940940                if (cntIdsCount == 8)
    941                     throw Exception("CounterId out of range!");
     941                    throw BinGenException("CounterId out of range!");
    942942                tempConfig.argResIds[k] = cntIdsCount++;
    943943            }
     
    10261026            const TypeNameVecSize& tp = argTypeNamesTable[cxuint(arg.pointerType)];
    10271027            if (tp.kindOfType == KT_UNKNOWN)
    1028                 throw Exception("Type not supported!");
     1028                throw BinGenException("Type not supported!");
    10291029            const cxuint typeSize =
    10301030                cxuint((tp.vecSize==3) ? 4 : tp.vecSize)*tp.elemSize;
     
    10541054            }
    10551055            else
    1056                 throw Exception("Other memory spaces are not supported");
     1056                throw BinGenException("Other memory spaces are not supported");
    10571057            metadata += ':';
    10581058            const size_t elemSize = (arg.pointerType==KernelArgType::STRUCTURE)?
     
    10871087                metadata += "RW";
    10881088            else
    1089                 throw Exception("Invalid image access qualifier!");
     1089                throw BinGenException("Invalid image access qualifier!");
    10901090            metadata += ':';
    10911091            itocstrCStyle(tempConfig.argResIds[k], numBuf, 21);
     
    11191119            const TypeNameVecSize& tp = argTypeNamesTable[cxuint(arg.argType)];
    11201120            if (tp.kindOfType == KT_UNKNOWN)
    1121                 throw Exception("Type not supported!");
     1121                throw BinGenException("Type not supported!");
    11221122            // type size is aligned (fix for 3 length vectors)
    11231123            const cxuint typeSize =
     
    16001600    /* checking input */
    16011601    if (input->deviceType > GPUDeviceType::GPUDEVICE_MAX)
    1602         throw Exception("Unknown GPU device type");
     1602        throw BinGenException("Unknown GPU device type");
    16031603   
    16041604    Array<TempAmdKernelConfig> tempAmdKernelConfigs(kernelsNum);
     
    16091609   
    16101610    if (gpuDeviceCodeTable[cxuint(input->deviceType)] == 0xffff)
    1611         throw Exception("Unsupported GPU device type by OpenCL 1.2 binary format");
     1611        throw BinGenException("Unsupported GPU device type by OpenCL 1.2 binary format");
    16121612   
    16131613    if (input->is64Bit)
     
    16581658                        writeOnlyImages++;
    16591659                        if (writeOnlyImages > 8)
    1660                             throw Exception("Too many write only images");
     1660                            throw BinGenException("Too many write only images");
    16611661                    }
    16621662                }
     
    17601760        const uint64_t innerBinSize = kelfBinGen.countSize();
    17611761        if (innerBinSize > UINT32_MAX)
    1762             throw Exception("Inner binary size is too big!");
     1762            throw BinGenException("Inner binary size is too big!");
    17631763        allInnerBinSize += tempAmdKernelDatas[i].innerBinSize = innerBinSize;
    17641764       
     
    17941794#endif
    17951795        binarySize > UINT32_MAX)
    1796         throw Exception("Binary size is too big!");
     1796        throw BinGenException("Binary size is too big!");
    17971797    /****
    17981798     * prepare for write binary to output
  • CLRadeonExtender/trunk/amdbin/AmdBinaries.cpp

    r3417 r3457  
    176176        const size_t encTableSize = ULEV(ephdr.p_filesz);
    177177        if (ULEV(ephdr.p_type) != 0x70000002)
    178             throw Exception("Missing encodings table");
     178            throw BinException("Missing encodings table");
    179179        if (encTableSize%sizeof(CALEncodingEntry) != 0)
    180             throw Exception("Wrong size of encodings table");
     180            throw BinException("Wrong size of encodings table");
    181181        if (usumGt(encTableOffset, encTableSize, binaryCodeSize))
    182             throw Exception("Offset+Size of encodings table out of range");
     182            throw BinException("Offset+Size of encodings table out of range");
    183183       
    184184        encodingEntriesNum = encTableSize/sizeof(CALEncodingEntry);
     
    192192            const size_t size = ULEV(entry.size);
    193193            if (offset >= binaryCodeSize)
    194                 throw Exception("Encoding entry offset out of range");
     194                throw BinException("Encoding entry offset out of range");
    195195            if (usumGt(offset, size, binaryCodeSize))
    196                 throw Exception("Encoding entry offset+size out of range");
     196                throw BinException("Encoding entry offset+size out of range");
    197197        }
    198198       
     
    211211            // check offset and ranges of program header
    212212            if (offset < encEntryOffset)
    213                 throw Exception("Kernel program offset out of encoding");
     213                throw BinException("Kernel program offset out of encoding");
    214214            if (usumGt(offset, size, encEntryOffset+encEntrySize))
    215                 throw Exception("Kernel program offset+size out of encoding");
     215                throw BinException("Kernel program offset+size out of encoding");
    216216           
    217217            if ((creationFlags & AMDBIN_CREATE_CALNOTES) != 0 &&
     
    226226                        *reinterpret_cast<const CALNoteHeader*>(binaryCode+offset+pos);
    227227                    if (ULEV(nhdr.nameSize) != 8)
    228                         throw Exception("Wrong name size in Note header!");
     228                        throw BinException("Wrong name size in Note header!");
    229229                    if (::memcmp(nhdr.name, "ATI CAL", 8) != 0)
    230                         throw Exception("Wrong name in Note header!");
     230                        throw BinException("Wrong name in Note header!");
    231231                    if (usumGt(uint32_t(pos + sizeof(CALNoteHeader)),
    232232                                ULEV(nhdr.descSize), size))
    233                         throw Exception("CAL Note desc size out of range");
     233                        throw BinException("CAL Note desc size out of range");
    234234                    pos += sizeof(CALNoteHeader) + ULEV(nhdr.descSize);
    235235                }
     
    254254                // if program headers table is not exhausted, but no encoding entries
    255255                if (i+1 < getProgramHeadersNum() && encodingIndex >= encodingEntriesNum)
    256                     throw Exception("ProgramHeaders out of encodings!");
     256                    throw BinException("ProgramHeaders out of encodings!");
    257257            }
    258258        }
     
    311311    }
    312312    if (encEntryIndex == encodingEntriesNum)
    313         throw Exception("Can't find suitable CALEncodingEntry!");
     313        throw BinException("Can't find suitable CALEncodingEntry!");
    314314    return encEntryIndex;
    315315}
     
    329329    } while (nestedLevel != 0 && pos < argDescsNum);
    330330    if (nestedLevel != 0)
    331         throw Exception("Unfinished kernel argument structure");
     331        throw BinException("Unfinished kernel argument structure");
    332332    return pos;
    333333}
     
    419419                    index = cstrtovCStyle<size_t>(symName+4, nullptr, outend);
    420420                    if (*outend != 0)
    421                         throw Exception("Garbages in .str symbol name!");
     421                        throw BinException("Garbages in .str symbol name!");
    422422                }
    423423                if (argTypeNamesSyms.size() <= index)
     
    426426                const typename Types::Sym& sym = elf.getSymbol(i);
    427427                if (ULEV(sym.st_shndx) >= elf.getSectionHeadersNum())
    428                     throw Exception("ArgTypeNameSymStr section index out of range");
     428                    throw BinException("ArgTypeNameSymStr section index out of range");
    429429                const typename Types::Shdr& secHdr =
    430430                        elf.getSectionHeader(ULEV(sym.st_shndx)); // from symbol
    431431               
    432432                if (ULEV(sym.st_value) >= ULEV(secHdr.sh_size))
    433                     throw Exception("ArgTypeNameSymStr value out of range");
     433                    throw BinException("ArgTypeNameSymStr value out of range");
    434434                if (usumGt(ULEV(sym.st_value), ULEV(sym.st_size), ULEV(secHdr.sh_size)))
    435                     throw Exception("ArgTypeNameSymStr value+size out of range");
     435                    throw BinException("ArgTypeNameSymStr value+size out of range");
    436436               
    437437                argTypeNamesSyms[index] = ULEV(secHdr.sh_offset) + ULEV(sym.st_value);
     
    439439                {
    440440                    if (ULEV(sym.st_value) >= unfinishedRegion)
    441                         throw Exception("Arg name/type is unfinished!");
     441                        throw BinException("Arg name/type is unfinished!");
    442442                }
    443443                else // is not roData
     
    448448                   
    449449                    if (ULEV(sym.st_value) >= unfinishedRegionArgNameSym)
    450                         throw Exception("Arg name/type is unfinished!");
     450                        throw BinException("Arg name/type is unfinished!");
    451451                }
    452452                continue;
     
    469469                elf.getSymbol(i);
    470470        if (ULEV(sym.st_shndx) >= elf.getSectionHeadersNum())
    471             throw Exception("Metadata section index out of range");
     471            throw BinException("Metadata section index out of range");
    472472       
    473473        const typename Types::Shdr& dataHdr =
     
    479479        if (fileOffset < ULEV(dataHdr.sh_offset) ||
    480480            fileOffset >= ULEV(dataHdr.sh_offset) + ULEV(dataHdr.sh_size))
    481             throw Exception("File offset of kernelMetadata out of range!");
     481            throw BinException("File offset of kernelMetadata out of range!");
    482482        const cxbyte* data = binaryCode + fileOffset;
    483483       
     
    514514           
    515515            if (realArgsNum >= kernelInfo.argInfos.size())
    516                 throw Exception("Kernel ArgInfo index out of range");
     516                throw BinException("Kernel ArgInfo index out of range");
    517517            AmdKernelArg& karg = kernelInfo.argInfos[realArgsNum++];
    518518            const size_t rodataHdrOffset = ULEV(rodataHdr.sh_offset);
     
    525525                if (argNameSym.getNameOffset() < rodataHdrOffset ||
    526526                    argNameSym.getNameOffset() >= rodataHdrOffset+rodataHdrSize)
    527                     throw Exception("Kernel arg name offset out of range!");
     527                    throw BinException("Kernel arg name offset out of range!");
    528528               
    529529                if (argNameSym.getNameOffset()-rodataHdrOffset >= unfinishedRegion)
    530                     throw Exception("Arg name is unfinished!");
     530                    throw BinException("Arg name is unfinished!");
    531531               
    532532                karg.argName = reinterpret_cast<const char*>(
     
    536536            {
    537537                if (argNameTypeNameIdx >= argTypeNamesSyms.size())
    538                     throw Exception("ArgName sym index out of range");
     538                    throw BinException("ArgName sym index out of range");
    539539                const typename Types::Size value = argTypeNamesSyms[argNameTypeNameIdx++];
    540540                if (value >= elf.getSize())
    541                     throw Exception("ArgName sym offset out of range");
     541                    throw BinException("ArgName sym offset out of range");
    542542               
    543543                karg.argName = reinterpret_cast<const char*>(binaryCode + value);
     
    549549                if (argTypeSym.getNameOffset() < rodataHdrOffset ||
    550550                    argTypeSym.getNameOffset() >= rodataHdrOffset+rodataHdrSize)
    551                     throw Exception("Kernel arg type offset out of range!");
     551                    throw BinException("Kernel arg type offset out of range!");
    552552               
    553553                if (argTypeSym.getNameOffset()-rodataHdrOffset >= unfinishedRegion)
    554                     throw Exception("Type name is unfinished!");
     554                    throw BinException("Type name is unfinished!");
    555555               
    556556                karg.typeName = reinterpret_cast<const char*>(
     
    560560            {
    561561                if (argNameTypeNameIdx >= argTypeNamesSyms.size())
    562                     throw Exception("ArgType sym index out of range");
     562                    throw BinException("ArgType sym index out of range");
    563563                const typename Types::Size value = argTypeNamesSyms[argNameTypeNameIdx++];
    564564                if (value >= elf.getSize())
    565                     throw Exception("ArgType sym offset out of range");
     565                    throw BinException("ArgType sym offset out of range");
    566566               
    567567                karg.typeName = reinterpret_cast<const char*>(binaryCode + value);
     
    571571            {
    572572                if (argType > 0x26)
    573                     throw Exception("Unknown kernel arg type");
     573                    throw BinException("Unknown kernel arg type");
    574574                karg.argType = x86ArgTypeTable[argType];
    575575                if (karg.argType == KernelArgType::POINTER &&
     
    622622        kernelInfosMap.begin(), kernelInfosMap.end(), name);
    623623    if (it == kernelInfosMap.end())
    624         throw Exception("Can't find kernel name");
     624        throw BinException("Can't find kernel name");
    625625    return kernelInfos[it->second];
    626626}
     
    11401140            compileOptionShIndex = ULEV(sym.st_shndx);
    11411141            if (compileOptionShIndex >= mainElf.getSectionHeadersNum())
    1142                 throw Exception("CompileOptions section index out of range");
     1142                throw BinException("CompileOptions section index out of range");
    11431143            const typename Types::Shdr& shdr =
    11441144                    mainElf.getSectionHeader(compileOptionShIndex);
     
    11471147                        mainElf.getSectionContent(compileOptionShIndex));
    11481148            if (ULEV(sym.st_value) >= ULEV(shdr.sh_size))
    1149                 throw Exception("CompileOptions value out of range");
     1149                throw BinException("CompileOptions value out of range");
    11501150            // compileOptionsEnd used later for setting offset for driver info
    11511151            // compile options precedes driver info
    11521152            compileOptionsEnd = ULEV(sym.st_value) + ULEV(sym.st_size);
    11531153            if (usumGt(ULEV(sym.st_value), ULEV(sym.st_size), ULEV(shdr.sh_size)))
    1154                 throw Exception("CompileOptions value+size out of range");
     1154                throw BinException("CompileOptions value+size out of range");
    11551155            compileOptions.assign(sectionContent + ULEV(sym.st_value), ULEV(sym.st_size));
    11561156        }
     
    11631163            const typename Types::Shdr& shdr = mainElf.getSectionHeader(shindex);
    11641164            if (ULEV(sym.st_value) >= ULEV(shdr.sh_size))
    1165                 throw Exception("globalData value out of range");
     1165                throw BinException("globalData value out of range");
    11661166            if (usumGt(ULEV(sym.st_value), ULEV(sym.st_size), ULEV(shdr.sh_size)))
    1167                 throw Exception("globalData value+size out of range");
     1167                throw BinException("globalData value+size out of range");
    11681168            globalDataSize = ULEV(sym.st_size);
    11691169            globalData = mainElf.getSectionContent(shindex) + ULEV(sym.st_value);
     
    12141214            const typename Types::Word symsize = ULEV(sym.st_size);
    12151215            if (symvalue > ULEV(textHdr.sh_size))
    1216                 throw Exception("Inner binary offset out of range!");
     1216                throw BinException("Inner binary offset out of range!");
    12171217            if (usumGt(symvalue, symsize, ULEV(textHdr.sh_size)))
    1218                 throw Exception("Inner binary offset+size out of range!");
     1218                throw BinException("Inner binary offset+size out of range!");
    12191219           
    12201220            innerBinaries[ki++] = AmdInnerGPUBinary32(CString(symName+9, len-16),
     
    12431243            const char* symName = mainElf.getSymbolName(it);
    12441244            if (ULEV(sym.st_shndx) >= mainElf.getSectionHeadersNum())
    1245                 throw Exception("Metadata section index out of range");
     1245                throw BinException("Metadata section index out of range");
    12461246           
    12471247            const typename Types::Shdr& rodataHdr =
     
    12521252            const typename Types::Word symsize = ULEV(sym.st_size);
    12531253            if (symvalue > ULEV(rodataHdr.sh_size))
    1254                 throw Exception("Metadata offset out of range");
     1254                throw BinException("Metadata offset out of range");
    12551255            if (usumGt(symvalue, symsize, ULEV(rodataHdr.sh_size)))
    1256                 throw Exception("Metadata offset+size out of range");
     1256                throw BinException("Metadata offset+size out of range");
    12571257           
    12581258            // parse AMDGPU kernel metadata
     
    12851285            const size_t symNameLen = ::strlen(symName);
    12861286            if (ULEV(sym.st_shndx) >= mainElf.getSectionHeadersNum())
    1287                 throw Exception("KernelHeader section index out of range");
     1287                throw BinException("KernelHeader section index out of range");
    12881288           
    12891289            const typename Types::Shdr& rodataHdr =
     
    12941294            const typename Types::Word symsize = ULEV(sym.st_size);
    12951295            if (symvalue > ULEV(rodataHdr.sh_size))
    1296                 throw Exception("KernelHeader offset out of range");
     1296                throw BinException("KernelHeader offset out of range");
    12971297            if (usumGt(symvalue, symsize, ULEV(rodataHdr.sh_size)))
    1298                 throw Exception("KernelHeader offset+size out of range");
     1298                throw BinException("KernelHeader offset+size out of range");
    12991299           
    13001300            // kernel name preceded by '__OpenCL_' and precedes '_kernel'
     
    13201320                  innerBinaryMap.end(), name);
    13211321    if (it == innerBinaryMap.end())
    1322         throw Exception("Can't find inner binary");
     1322        throw BinException("Can't find inner binary");
    13231323    return innerBinaries[it->second];
    13241324}
     
    13301330                   kernelHeaderMap.end(), name);
    13311331    if (it == kernelHeaderMap.end())
    1332         throw Exception("Can't find kernel header");
     1332        throw BinException("Can't find kernel header");
    13331333    return kernelHeaders[it->second];
    13341334}
     
    13831383        { return l.elfMachine < r.elfMachine;}) - gpuDeviceCodeTable;
    13841384    if (gpuDeviceCodeTableSize == index)
    1385         throw Exception("Can't determine GPU device type");
     1385        throw BinException("Can't determine GPU device type");
    13861386    return gpuDeviceCodeTable[index].deviceType;
    13871387}
     
    14531453                compileOptionShIndex = ULEV(sym.st_shndx);
    14541454                if (compileOptionShIndex >= getSectionHeadersNum())
    1455                     throw Exception("CompileOptions section index out of range");
     1455                    throw BinException("CompileOptions section index out of range");
    14561456                const Elf32_Shdr& shdr = getSectionHeader(compileOptionShIndex);
    14571457                const char* sectionContent = reinterpret_cast<char*>(
    14581458                            getSectionContent(compileOptionShIndex));
    14591459                if (ULEV(sym.st_value) >= ULEV(shdr.sh_size))
    1460                     throw Exception("CompileOptions value out of range");
     1460                    throw BinException("CompileOptions value out of range");
    14611461                // compileOptionsEnd used later for setting offset for driver info
    14621462                // compile options precedes driver info
    14631463                compileOptionsEnd = ULEV(sym.st_value) + ULEV(sym.st_size);
    14641464                if (usumGt(ULEV(sym.st_value), ULEV(sym.st_size), ULEV(shdr.sh_size)))
    1465                     throw Exception("CompileOptions value+size out of range");
     1465                    throw BinException("CompileOptions value+size out of range");
    14661466                compileOptions.assign(sectionContent + ULEV(sym.st_value),
    14671467                                      ULEV(sym.st_size));
     
    15371537                compileOptionShIndex = ULEV(sym.st_shndx);
    15381538                if (compileOptionShIndex >= getSectionHeadersNum())
    1539                     throw Exception("CompileOptions section index out of range");
     1539                    throw BinException("CompileOptions section index out of range");
    15401540                const Elf64_Shdr& shdr = getSectionHeader(compileOptionShIndex);
    15411541                const char* sectionContent = reinterpret_cast<char*>(
    15421542                            getSectionContent(compileOptionShIndex));
    15431543                if (ULEV(sym.st_value) >= ULEV(shdr.sh_size))
    1544                     throw Exception("CompileOptions value out of range");
     1544                    throw BinException("CompileOptions value out of range");
    15451545                // compileOptionsEnd used later for setting offset for driver info
    15461546                // compile options precedes driver info
    15471547                compileOptionsEnd = ULEV(sym.st_value) + ULEV(sym.st_size);
    15481548                if (usumGt(ULEV(sym.st_value), ULEV(sym.st_size), ULEV(shdr.sh_size)))
    1549                     throw Exception("CompileOptions value+size out of range");
     1549                    throw BinException("CompileOptions value+size out of range");
    15501550                compileOptions.assign(sectionContent + ULEV(sym.st_value),
    15511551                                      ULEV(sym.st_size));
     
    16071607    if (binaryCodeSize < sizeof(Elf32_Ehdr) ||
    16081608        ULEV(*reinterpret_cast<const uint32_t*>(binaryCode)) != elfMagicValue)
    1609         throw Exception("This is not ELF binary");
     1609        throw BinException("This is not ELF binary");
    16101610    if (binaryCode[EI_DATA] != ELFDATA2LSB)
    1611         throw Exception("Other than little-endian binaries are not supported!");
     1611        throw BinException("Other than little-endian binaries are not supported!");
    16121612   
    16131613    // checking binary class
     
    16271627    }
    16281628    else // fatal error
    1629         throw Exception("Unsupported ELF class");
    1630 }
     1629        throw BinException("Unsupported ELF class");
     1630}
  • CLRadeonExtender/trunk/amdbin/AmdCL2BinGen.cpp

    r3444 r3457  
    427427        TempAmdCL2KernelData& tempData = tempDatas[i];
    428428        if (newBinaries && (kernel.isaMetadataSize!=0 || kernel.isaMetadata!=nullptr))
    429             throw Exception("ISA metadata allowed for old driver binaries");
     429            throw BinGenException("ISA metadata allowed for old driver binaries");
    430430        if (newBinaries && (kernel.stubSize!=0 || kernel.stub!=nullptr))
    431             throw Exception("Kernel stub allowed for old driver binaries");
     431            throw BinGenException("Kernel stub allowed for old driver binaries");
    432432        /* check relocations */
    433433        if (newBinaries)
     
    435435            {
    436436                if (rel.type > RELTYPE_HIGH_32BIT || rel.symbol > 2)
    437                     throw Exception("Wrong relocation symbol or type");
     437                    throw BinGenException("Wrong relocation symbol or type");
    438438                if (rel.offset+4 > kernel.codeSize)
    439                     throw Exception("Relocation offset outside code size");
     439                    throw BinGenException("Relocation offset outside code size");
    440440            }
    441441       
     
    505505                    {
    506506                        if (inarg.resId >= 16)
    507                             throw Exception("SamplerId out of range!");
     507                            throw BinGenException("SamplerId out of range!");
    508508                        if (samplerMask[inarg.resId])
    509                             throw Exception("SamplerId already used!");
     509                            throw BinGenException("SamplerId already used!");
    510510                        samplerMask.set(inarg.resId);
    511511                        tempData.argResIds[k] = inarg.resId;
     
    518518                        {
    519519                            if (inarg.resId >= 128)
    520                                 throw Exception("RdOnlyImgId out of range!");
     520                                throw BinGenException("RdOnlyImgId out of range!");
    521521                            if (imgRoMask[inarg.resId])
    522                                 throw Exception("RdOnlyImgId already used!");
     522                                throw BinGenException("RdOnlyImgId already used!");
    523523                            imgRoMask.set(inarg.resId);
    524524                            tempData.argResIds[k] = inarg.resId;
     
    527527                        {
    528528                            if (inarg.resId >= 64)
    529                                 throw Exception("WrOnlyImgId out of range!");
     529                                throw BinGenException("WrOnlyImgId out of range!");
    530530                            if (imgWoMask[inarg.resId])
    531                                 throw Exception("WrOnlyImgId already used!");
     531                                throw BinGenException("WrOnlyImgId already used!");
    532532                            imgWoMask.set(inarg.resId);
    533533                            tempData.argResIds[k] = inarg.resId;
     
    537537                            // read-write images
    538538                            if (inarg.resId >= 64)
    539                                 throw Exception("RdWrImgId out of range!");
     539                                throw BinGenException("RdWrImgId out of range!");
    540540                            if (imgRWMask[inarg.resId])
    541                                 throw Exception("RdWrImgId already used!");
     541                                throw BinGenException("RdWrImgId already used!");
    542542                            imgRWMask.set(inarg.resId);
    543543                            tempData.argResIds[k] = inarg.resId;
     
    562562                             samplerCount++);
    563563                        if (samplerCount == 16)
    564                             throw Exception("SamplerId out of range!");
     564                            throw BinGenException("SamplerId out of range!");
    565565                        tempData.argResIds[k] = samplerCount++;
    566566                    }
     
    573573                            for (; imgRoCount < 128 && imgRoMask[imgRoCount]; imgRoCount++);
    574574                            if (imgRoCount == 128)
    575                                 throw Exception("RdOnlyImgId out of range!");
     575                                throw BinGenException("RdOnlyImgId out of range!");
    576576                            tempData.argResIds[k] = imgRoCount++;
    577577                        }
     
    580580                            for (; imgWoCount < 64 && imgWoMask[imgWoCount]; imgWoCount++);
    581581                            if (imgWoCount == 64)
    582                                 throw Exception("WrOnlyImgId out of range!");
     582                                throw BinGenException("WrOnlyImgId out of range!");
    583583                            tempData.argResIds[k] = imgWoCount++;
    584584                        }
     
    587587                            for (; imgRWCount < 64 && imgRWMask[imgRWCount]; imgRWCount++);
    588588                            if (imgRWCount == 128)
    589                                 throw Exception("RdWrImgId out of range!");
     589                                throw BinGenException("RdWrImgId out of range!");
    590590                            tempData.argResIds[k] = imgRWCount++;
    591591                        }
     
    597597            for (cxuint sampler: kernel.config.samplers)
    598598                if (sampler >= samplersNum)
    599                     throw Exception("SamplerId out of range");
     599                    throw BinGenException("SamplerId out of range");
    600600           
    601601            tempData.metadataSize = out;
     
    20562056    const GPUArchitecture arch = getGPUArchitectureFromDeviceType(input->deviceType);
    20572057    if (arch == GPUArchitecture::GCN1_0)
    2058         throw Exception("OpenCL 2.0 supported only for GCN1.1 or later");
     2058        throw BinGenException("OpenCL 2.0 supported only for GCN1.1 or later");
    20592059   
    20602060    const bool is16_3Ver = (input->driverVersion>=200406);
     
    20712071   
    20722072    if ((hasGlobalData || hasRWData || hasSamplers) && !newBinaries)
    2073         throw Exception("Old driver binaries doesn't support "
     2073        throw BinGenException("Old driver binaries doesn't support "
    20742074                        "global/atomic data or samplers");
    20752075   
     
    20772077    {
    20782078        if (!hasGlobalData && hasSamplers)
    2079             throw Exception("Global data must be defined if samplers present");
     2079            throw BinGenException("Global data must be defined if samplers present");
    20802080        // check sampler offset range
    20812081        for (size_t sampOffset: input->samplerOffsets)
    20822082            if (sampOffset+8 > input->globalDataSize)
    2083                 throw Exception("Sampler offset outside global data");
     2083                throw BinGenException("Sampler offset outside global data");
    20842084    }
    20852085    /* check samplers */
     
    20872087                (input->samplerInitSize>>3);
    20882088    if (!input->samplerOffsets.empty() && input->samplerOffsets.size() != samplersNum)
    2089         throw Exception("SamplerOffset number doesn't match to samplers number");
     2089        throw BinGenException("SamplerOffset number doesn't match to samplers number");
    20902090   
    20912091    for (size_t sampOffset: input->samplerOffsets)
    20922092        if ((sampOffset&7) != 0 && sampOffset >= input->globalDataSize)
    2093             throw Exception("Wrong sampler offset (out of range of unaligned)");
     2093            throw BinGenException("Wrong sampler offset (out of range of unaligned)");
    20942094   
    20952095    const bool gpuProDriver = (input->driverVersion == 203603 ||
     
    21082108    // if GPU type is not supported by driver version
    21092109    if (deviceCodeTable[cxuint(input->deviceType)] == UINT_MAX)
    2110         throw Exception("Unsupported GPU device type by driver version");
     2110        throw BinGenException("Unsupported GPU device type by driver version");
    21112111   
    21122112    std::unique_ptr<ElfBinaryGen32> elfBinGen32;
     
    21982198            for (const AmdCL2RelInput& rel: kernel.relocations)
    21992199                if (rel.offset >= kernel.codeSize)
    2200                     throw Exception("Kernel text relocation offset outside kernel code");
     2200                    throw BinGenException("Kernel text relocation offset outside kernel code");
    22012201       
    22022202        std::fill(innerBinSectionTable,
     
    24622462#endif
    24632463        binarySize > UINT32_MAX)
    2464         throw Exception("Binary size is too big!");
     2464        throw BinGenException("Binary size is too big!");
    24652465    /****
    24662466     * prepare for write binary to output
  • CLRadeonExtender/trunk/amdbin/AmdCL2Binaries.cpp

    r3419 r3457  
    4343            kernelDataMap.begin(), kernelDataMap.end(), name);
    4444    if (it == kernelDataMap.end())
    45         throw Exception("Can't find kernel name");
     45        throw BinException("Can't find kernel name");
    4646    return kernels[it->second];
    4747}
     
    9191        /// check conditions for symbol
    9292        if (textIndex != ULEV(sym.st_shndx))
    93             throw Exception("Kernel symbol outside text section");
     93            throw BinException("Kernel symbol outside text section");
    9494        if (binOffset >= binaryCodeSize)
    95             throw Exception("Kernel binary code offset out of range");
     95            throw BinException("Kernel binary code offset out of range");
    9696        if (usumGt(binOffset, binSize, binaryCodeSize))
    97             throw Exception("Kernel binary code offset and size out of range");
     97            throw BinException("Kernel binary code offset and size out of range");
    9898        if (binSize < 256+192)
    99             throw Exception("Kernel binary code size is too short");
     99            throw BinException("Kernel binary code size is too short");
    100100       
    101101        AmdCL2GPUKernelStub kernelStub;
     
    105105        const size_t setupOffset = ULEV(*reinterpret_cast<uint32_t*>(kernelStub.data));
    106106        if (setupOffset >= binSize)
    107             throw Exception("Kernel setup offset out of range");
     107            throw BinException("Kernel setup offset out of range");
    108108        // get size of setup (offset 16 of setup)
    109109        kernelStub.size = setupOffset;
     
    112112        const size_t textOffset = ULEV(*reinterpret_cast<uint32_t*>(kernelData.setup+16));
    113113        if (usumGe(textOffset, setupOffset, binSize))
    114             throw Exception("Kernel text offset out of range");
     114            throw BinException("Kernel text offset out of range");
    115115        kernelData.setupSize = textOffset;
    116116        kernelData.code = kernelData.setup + textOffset;
     
    140140            kernelDataMap.begin(), kernelDataMap.end(), name);
    141141    if (it == kernelDataMap.end())
    142         throw Exception("Can't find kernel name");
     142        throw BinException("Can't find kernel name");
    143143    return kernelStubs[it->second];
    144144}
     
    180180            const Elf64_Shdr& dataShdr = getSectionHeader(ULEV(sym.st_shndx));
    181181            if (ULEV(sym.st_shndx) >= getSectionHeadersNum())
    182                 throw Exception("Kernel section index out of range");
     182                throw BinException("Kernel section index out of range");
    183183            const char* symName = getSymbolName(index);
    184184            const size_t binOffset = ULEV(sym.st_value);
     
    186186            /// check conditions for symbol
    187187            if (binOffset >= ULEV(dataShdr.sh_size))
    188                 throw Exception("Kernel binary code offset out of range");
     188                throw BinException("Kernel binary code offset out of range");
    189189            if (usumGt(binOffset, binSize, ULEV(dataShdr.sh_size)))
    190                 throw Exception("Kernel binary code offset and size out of range");
     190                throw BinException("Kernel binary code offset and size out of range");
    191191            if (binSize < 192)
    192                 throw Exception("Kernel binary code size is too short");
     192                throw BinException("Kernel binary code size is too short");
    193193           
    194194            kernels[ki].setup = binaryCode + ULEV(dataShdr.sh_offset) + binOffset;
     
    198198           
    199199            if (textOffset >= binSize)
    200                 throw Exception("Kernel text offset out of range");
     200                throw BinException("Kernel text offset out of range");
    201201            kernels[ki].setupSize = textOffset;
    202202            kernels[ki].code = kernels[ki].setup + textOffset;
     
    339339    crimson16 = false;
    340340    if (metadataSize < 8+32+32)
    341         throw Exception("Kernel metadata is too short");
     341        throw BinException("Kernel metadata is too short");
    342342   
    343343    const typename Types::MetadataHeader* hdrStruc =
     
    346346    // checking kernel header size in metadata region
    347347    if (kernelHeader.size >= metadataSize)
    348         throw Exception("Metadata header size out of range");
     348        throw BinException("Metadata header size out of range");
    349349    if (kernelHeader.size < sizeof(typename Types::MetadataHeader))
    350         throw Exception("Metadata header is too short");
     350        throw BinException("Metadata header is too short");
    351351    kernelHeader.data = metadata;
    352352    const uint32_t argsNum = ULEV(hdrStruc->argsNum);
     
    354354    if (usumGt(ULEV(hdrStruc->firstNameLength), ULEV(hdrStruc->secondNameLength),
    355355                metadataSize-kernelHeader.size-2))
    356         throw Exception("KernelArgEntries offset out of range");
     356        throw BinException("KernelArgEntries offset out of range");
    357357   
    358358    size_t argOffset = kernelHeader.size +
     
    369369   
    370370    if(usumGt(argOffset, sizeof(typename Types::KernelArgEntry)*(argsNum+1), metadataSize))
    371         throw Exception("Number of arguments out of range");
     371        throw BinException("Number of arguments out of range");
    372372   
    373373    const char* strBase = (const char*)metadata;
     
    379379        AmdKernelArg& arg = kernelInfo.argInfos[i];
    380380        if (ULEV(argPtr->size)!=sizeof(typename Types::KernelArgEntry))
    381             throw Exception("Kernel ArgEntry size doesn't match");
     381            throw BinException("Kernel ArgEntry size doesn't match");
    382382        // get name of argument
    383383        size_t nameSize = ULEV(argPtr->argNameSize);
    384384        if (usumGt(strOffset, nameSize+1, metadataSize))
    385             throw Exception("Kernel ArgEntry name size out of range");
     385            throw BinException("Kernel ArgEntry name size out of range");
    386386        arg.argName.assign(strBase+strOffset, nameSize);
    387387        // get name of type of argument
     
    389389        nameSize = ULEV(argPtr->typeNameSize);
    390390        if (usumGt(strOffset, nameSize+1, metadataSize))
    391             throw Exception("Kernel ArgEntry typename size out of range");
     391            throw BinException("Kernel ArgEntry typename size out of range");
    392392        arg.typeName.assign(strBase+strOffset, nameSize);
    393393        strOffset += nameSize+1;
     
    407407                case 0:
    408408                    if (kindOfType!=1) // not sampler
    409                         throw Exception("Wrong kernel argument type");
     409                        throw BinException("Wrong kernel argument type");
    410410                    arg.argType = KernelArgType::SAMPLER;
    411411                    break;
     
    423423                    {
    424424                        if (kindOfType!=4) // not scalar
    425                             throw Exception("Wrong kernel argument type");
     425                            throw BinException("Wrong kernel argument type");
    426426                        arg.argType = (argType==3) ?
    427427                            KernelArgType::SHORT : KernelArgType::CHAR;
    428428                    }
    429429                    else
    430                         throw Exception("Wrong kernel argument type");
     430                        throw BinException("Wrong kernel argument type");
    431431                    break;
    432432                case 4: // int
    433433                case 5: // long
    434434                    if (kindOfType!=4) // not scalar
    435                         throw Exception("Wrong kernel argument type");
     435                        throw BinException("Wrong kernel argument type");
    436436                    arg.argType = (argType==5) ?
    437437                        KernelArgType::LONG : KernelArgType::INT;
     
    445445                {
    446446                    if (kindOfType!=4) // not scalar
    447                         throw Exception("Wrong kernel argument type");
     447                        throw BinException("Wrong kernel argument type");
    448448                    const cxuint vectorId = vectorIdTable[vectorSize];
    449449                    if (vectorId == UINT_MAX)
    450                         throw Exception("Wrong vector size");
     450                        throw BinException("Wrong vector size");
    451451                    arg.argType = cl20ArgTypeVectorTable[(argType-6)*6 + vectorId];
    452452                    break;
     
    454454                case 15:
    455455                    if (kindOfType!=4) // not scalar
    456                         throw Exception("Wrong kernel argument type");
     456                        throw BinException("Wrong kernel argument type");
    457457                    arg.argType = KernelArgType::STRUCTURE;
    458458                    break;
    459459                case 18:
    460460                    if (kindOfType!=7) // not scalar
    461                         throw Exception("Wrong kernel argument type");
     461                        throw BinException("Wrong kernel argument type");
    462462                    arg.argType = KernelArgType::CMDQUEUE;
    463463                    break;
    464464                default:
    465                     throw Exception("Wrong kernel argument type");
     465                    throw BinException("Wrong kernel argument type");
    466466                    break;
    467467            }
     
    484484                    arg.ptrSpace = KernelPtrSpace::CONSTANT;
    485485                else
    486                     throw Exception("Illegal pointer space");
     486                    throw BinException("Illegal pointer space");
    487487                // set access qualifiers (volatile, restrict, const)
    488488                arg.ptrAccess = KARG_PTR_NORMAL;
     
    498498                // global space for pipe
    499499                if (ptrSpace!=4)
    500                     throw Exception("Illegal pipe space");
     500                    throw BinException("Illegal pipe space");
    501501                arg.ptrSpace = KernelPtrSpace::GLOBAL;
    502502            }
     
    531531    auto it = binaryMapFind(kernelInfosMap.begin(), kernelInfosMap.end(), name);
    532532    if (it == kernelInfosMap.end())
    533         throw Exception("Can't find kernel metadata by name");
     533        throw BinException("Can't find kernel metadata by name");
    534534    return metadatas[it->second];
    535535}
     
    540540    auto it = binaryMapFind(isaMetadataMap.begin(), isaMetadataMap.end(), name);
    541541    if (it == isaMetadataMap.end())
    542         throw Exception("Can't find kernel ISA metadata by name");
     542        throw BinException("Can't find kernel ISA metadata by name");
    543543    return isaMetadatas[it->second];
    544544}
     
    566566                const typename Types::Sym& sym = elfBin.getSymbol(i);
    567567                if (ULEV(sym.st_shndx) >= elfBin.getSectionHeadersNum())
    568                     throw Exception("Compiler options section header out of range");
     568                    throw BinException("Compiler options section header out of range");
    569569                const typename Types::Shdr& shdr =
    570570                            elfBin.getSectionHeader(ULEV(sym.st_shndx));
     
    573573                // checking compile options offset and size
    574574                if (coOffset >= ULEV(shdr.sh_size))
    575                     throw Exception("Compiler options offset out of range");
     575                    throw BinException("Compiler options offset out of range");
    576576                if (usumGt(coOffset, coSize, ULEV(shdr.sh_size)))
    577                     throw Exception("Compiler options offset and size out of range");
     577                    throw BinException("Compiler options offset and size out of range");
    578578               
    579579                const char* coData = reinterpret_cast<const char*>(binaryCode) +
     
    586586                const typename Types::Sym& sym = elfBin.getSymbol(i);
    587587                if (ULEV(sym.st_shndx) >= elfBin.getSectionHeadersNum())
    588                     throw Exception("AclVersionString section header out of range");
     588                    throw BinException("AclVersionString section header out of range");
    589589                const typename Types::Shdr& shdr =
    590590                        elfBin.getSectionHeader(ULEV(sym.st_shndx));
     
    593593                // checking acl offset and acl size
    594594                if (aclOffset >= ULEV(shdr.sh_size))
    595                     throw Exception("AclVersionString offset out of range");
     595                    throw BinException("AclVersionString offset out of range");
    596596                if (usumGt(aclOffset, aclSize, ULEV(shdr.sh_size)))
    597                     throw Exception("AclVersionString offset and size out of range");
     597                    throw BinException("AclVersionString offset and size out of range");
    598598               
    599599                const char* aclVersionData = reinterpret_cast<const char*>(binaryCode) +
     
    681681            const char* mtName = elfBin.getSymbolName(index);
    682682            if (ULEV(mtsym.st_shndx) >= elfBin.getSectionHeadersNum())
    683                 throw Exception("Kernel Metadata section header out of range");
     683                throw BinException("Kernel Metadata section header out of range");
    684684            const typename Types::Shdr& shdr =
    685685                    elfBin.getSectionHeader(ULEV(mtsym.st_shndx));
     
    688688            /// offset and size verifying
    689689            if (mtOffset >= ULEV(shdr.sh_size))
    690                 throw Exception("Kernel Metadata offset out of range");
     690                throw BinException("Kernel Metadata offset out of range");
    691691            if (usumGt(mtOffset, mtSize, ULEV(shdr.sh_size)))
    692                 throw Exception("Kernel Metadata offset and size out of range");
     692                throw BinException("Kernel Metadata offset and size out of range");
    693693           
    694694            cxbyte* metadata = binaryCode + ULEV(shdr.sh_offset) + mtOffset;
     
    715715            const char* mtName = elfBin.getSymbolName(index);
    716716            if (ULEV(mtsym.st_shndx) >= elfBin.getSectionHeadersNum())
    717                 throw Exception("Kernel ISAMetadata section header out of range");
     717                throw BinException("Kernel ISAMetadata section header out of range");
    718718            const typename Types::Shdr& shdr =
    719719                        elfBin.getSectionHeader(ULEV(mtsym.st_shndx));
     
    722722            /// offset and size verifying
    723723            if (mtOffset >= ULEV(shdr.sh_size))
    724                 throw Exception("Kernel ISAMetadata offset out of range");
     724                throw BinException("Kernel ISAMetadata offset out of range");
    725725            if (usumGt(mtOffset, mtSize, ULEV(shdr.sh_size)))
    726                 throw Exception("Kernel ISAMetadata offset and size out of range");
     726                throw BinException("Kernel ISAMetadata offset and size out of range");
    727727           
    728728            cxbyte* metadata = binaryCode + ULEV(shdr.sh_offset) + mtOffset;
     
    956956        const cxbyte* noteContent = (const cxbyte*)innerBin.getNotes();
    957957        if (noteContent==nullptr)
    958             throw Exception("Missing notes in inner binary!");
     958            throw BinException("Missing notes in inner binary!");
    959959        size_t notesSize = innerBin.getNotesSize();
    960960        // find note about AMDGPU
     
    966966            size_t descsz = ULEV(nhdr->n_descsz);
    967967            if (usumGt(offset, namesz+descsz, notesSize))
    968                 throw Exception("Note offset+size out of range");
     968                throw BinException("Note offset+size out of range");
    969969            if (ULEV(nhdr->n_type) == 0x3 && namesz==4 && descsz>=0x1a &&
    970970                ::strcmp((const char*)noteContent+offset+
     
    979979                    if ((arch==GPUArchitecture::GCN1_2 && major<8) ||
    980980                        (arch==GPUArchitecture::GCN1_1 && major!=7))
    981                         throw Exception("Wrong arch major for GPU architecture");
     981                        throw BinException("Wrong arch major for GPU architecture");
    982982                    // fix for GFX900 - we don't know what is type of device
    983983                    if (arch==GPUArchitecture::GCN1_2 && major!=8)
     
    985985                }
    986986                else if (major != 9 && major != 8 && major != 7)
    987                     throw Exception("Unknown arch major");
     987                    throw BinException("Unknown arch major");
    988988               
    989989                archMinor = ULEV(content[2]);
     
    10091009   
    10101010    if (!knownGPUType)
    1011         throw Exception("Can't determine GPU device type");
     1011        throw BinException("Can't determine GPU device type");
    10121012   
    10131013    outArchMinor = archMinor;
  • CLRadeonExtender/trunk/amdbin/ElfBinaries.cpp

    r3418 r3457  
    4141using namespace CLRX;
    4242
     43// BinException costuctor
     44BinException::BinException(const std::string& message) : Exception(message)
     45{ }
     46
     47// BinGenException costuctor
     48BinGenException::BinGenException(const std::string& message) : Exception(message)
     49{ }
     50
    4351/* determine unfinished strings region in string table for checking further consistency */
    4452static size_t unfinishedRegionOfStringTable(const cxbyte* table, size_t size)
     
    9098{
    9199    if (binaryCodeSize < sizeof(typename Types::Ehdr))
    92         throw Exception("Binary is too small!!!");
     100        throw BinException("Binary is too small!!!");
    93101   
    94102    const typename Types::Ehdr* ehdr =
     
    97105    // checking ELF magic, ELFCLASS and endian (only little-endian accepted)
    98106    if (ULEV(*reinterpret_cast<const uint32_t*>(binaryCode)) != elfMagicValue)
    99         throw Exception("This is not ELF binary");
     107        throw BinException("This is not ELF binary");
    100108    if (ehdr->e_ident[EI_CLASS] != Types::ELFCLASS)
    101         throw Exception(std::string("This is not ")+Types::bitName+"bit ELF binary");
     109        throw BinException(std::string("This is not ")+Types::bitName+"bit ELF binary");
    102110    if (ehdr->e_ident[EI_DATA] != ELFDATA2LSB)
    103         throw Exception("Other than little-endian binaries are not supported!");
     111        throw BinException("Other than little-endian binaries are not supported!");
    104112   
    105113    if ((ULEV(ehdr->e_phoff) == 0 && ULEV(ehdr->e_phnum) != 0))
    106         throw Exception("Elf invalid phoff and phnum combination");
     114        throw BinException("Elf invalid phoff and phnum combination");
    107115    if (ULEV(ehdr->e_phoff) != 0)
    108116    {
    109117        /* reading and checking program headers */
    110118        if (ULEV(ehdr->e_phoff) > binaryCodeSize)
    111             throw Exception("ProgramHeaders offset out of range!");
     119            throw BinException("ProgramHeaders offset out of range!");
    112120        if (usumGt(ULEV(ehdr->e_phoff),
    113121                   ((typename Types::Word)ULEV(ehdr->e_phentsize))*ULEV(ehdr->e_phnum),
    114122                   binaryCodeSize))
    115             throw Exception("ProgramHeaders offset+size out of range!");
     123            throw BinException("ProgramHeaders offset+size out of range!");
    116124       
    117125        cxuint phnum = ULEV(ehdr->e_phnum);
     
    121129            const typename Types::Phdr& phdr = getProgramHeader(i);
    122130            if (ULEV(phdr.p_offset) > binaryCodeSize)
    123                 throw Exception("Segment offset out of range!");
     131                throw BinException("Segment offset out of range!");
    124132            if (usumGt(ULEV(phdr.p_offset), ULEV(phdr.p_filesz), binaryCodeSize))
    125                 throw Exception("Segment offset+size out of range!");
     133                throw BinException("Segment offset+size out of range!");
    126134        }
    127135    }
    128136   
    129137    if ((ULEV(ehdr->e_shoff) == 0 && ULEV(ehdr->e_shnum) != 0))
    130         throw Exception("Elf invalid shoff and shnum combination");
     138        throw BinException("Elf invalid shoff and shnum combination");
    131139    if (ULEV(ehdr->e_shoff) != 0 && ULEV(ehdr->e_shstrndx) != SHN_UNDEF)
    132140    {
    133141        /* indexing of sections */
    134142        if (ULEV(ehdr->e_shoff) > binaryCodeSize)
    135             throw Exception("SectionHeaders offset out of range!");
     143            throw BinException("SectionHeaders offset out of range!");
    136144        if (usumGt(ULEV(ehdr->e_shoff),
    137145                  ((typename Types::Word)ULEV(ehdr->e_shentsize))*ULEV(ehdr->e_shnum),
    138146                  binaryCodeSize))
    139             throw Exception("SectionHeaders offset+size out of range!");
     147            throw BinException("SectionHeaders offset+size out of range!");
    140148        if (ULEV(ehdr->e_shstrndx) >= ULEV(ehdr->e_shnum))
    141             throw Exception("Shstrndx out of range!");
     149            throw BinException("Shstrndx out of range!");
    142150       
    143151        typename Types::Shdr& shstrShdr = getSectionHeader(ULEV(ehdr->e_shstrndx));
     
    159167            /// checking section offset ranges
    160168            if (ULEV(shdr.sh_offset) > binaryCodeSize)
    161                 throw Exception("Section offset out of range!");
     169                throw BinException("Section offset out of range!");
    162170            if (ULEV(shdr.sh_type) != SHT_NOBITS)
    163171                if (usumGt(ULEV(shdr.sh_offset), ULEV(shdr.sh_size), binaryCodeSize))
    164                     throw Exception("Section offset+size out of range!");
     172                    throw BinException("Section offset+size out of range!");
    165173            if (ULEV(shdr.sh_link) >= ULEV(ehdr->e_shnum))
    166                 throw Exception("Section link out of range!");
     174                throw BinException("Section link out of range!");
    167175           
    168176            const typename Types::Size sh_nameindx = ULEV(shdr.sh_name);
    169177            if (sh_nameindx >= ULEV(shstrShdr.sh_size))
    170                 throw Exception("Section name index out of range!");
     178                throw BinException("Section name index out of range!");
    171179           
    172180            if (sh_nameindx >= unfinishedShstrPos)
    173                 throw Exception("Unfinished section name!");
     181                throw BinException("Unfinished section name!");
    174182           
    175183            const char* shname =
     
    196204            // indexing symbols
    197205            if (ULEV(symTableHdr->sh_entsize) < sizeof(typename Types::Sym))
    198                 throw Exception("SymTable entry size is too small!");
     206                throw BinException("SymTable entry size is too small!");
    199207           
    200208            symbolEntSize = ULEV(symTableHdr->sh_entsize);
    201209            symbolTable = binaryCode + ULEV(symTableHdr->sh_offset);
    202210            if (ULEV(symTableHdr->sh_link) == SHN_UNDEF)
    203                 throw Exception("Symbol table doesn't have string table");
     211                throw BinException("Symbol table doesn't have string table");
    204212           
    205213            typename Types::Shdr& symstrShdr = getSectionHeader(ULEV(symTableHdr->sh_link));
     
    218226                const typename Types::Size symnameindx = ULEV(sym.st_name);
    219227                if (symnameindx >= ULEV(symstrShdr.sh_size))
    220                     throw Exception("Symbol name index out of range!");
     228                    throw BinException("Symbol name index out of range!");
    221229                // check whether name is finished in string section content
    222230                if (symnameindx >= unfinishedSymstrPos)
    223                     throw Exception("Unfinished symbol name!");
     231                    throw BinException("Unfinished symbol name!");
    224232               
    225233                const char* symname =
     
    237245            // indexing dynamic symbols
    238246            if (ULEV(dynSymTableHdr->sh_entsize) < sizeof(typename Types::Sym))
    239                 throw Exception("DynSymTable entry size is too small!");
     247                throw BinException("DynSymTable entry size is too small!");
    240248           
    241249            dynSymEntSize = ULEV(dynSymTableHdr->sh_entsize);
    242250            dynSymTable = binaryCode + ULEV(dynSymTableHdr->sh_offset);
    243251            if (ULEV(dynSymTableHdr->sh_link) == SHN_UNDEF)
    244                 throw Exception("DynSymbol table doesn't have string table");
     252                throw BinException("DynSymbol table doesn't have string table");
    245253           
    246254            typename Types::Shdr& dynSymstrShdr =
     
    261269                const typename Types::Size symnameindx = ULEV(sym.st_name);
    262270                if (symnameindx >= ULEV(dynSymstrShdr.sh_size))
    263                     throw Exception("DynSymbol name index out of range!");
     271                    throw BinException("DynSymbol name index out of range!");
    264272                // check whether name is finished in string section content
    265273                if (symnameindx >= unfinishedSymstrPos)
    266                     throw Exception("Unfinished dynsymbol name!");
     274                    throw BinException("Unfinished dynsymbol name!");
    267275               
    268276                const char* symname =
     
    287295            const typename Types::Size size = ULEV(dynamicTableHdr->sh_size);
    288296            if (entSize < sizeof(typename Types::Dyn))
    289                 throw Exception("Size of dynamic entry is too small!");
     297                throw BinException("Size of dynamic entry is too small!");
    290298            if (size % entSize != 0)
    291                 throw Exception("Size of dynamic section is not match!");
     299                throw BinException("Size of dynamic section is not match!");
    292300            dynamicsNum = entSize / size;
    293301            dynamicEntSize = entSize;
     
    305313                    sectionIndexMap.begin(), sectionIndexMap.end(), name, CStringLess());
    306314        if (it == sectionIndexMap.end())
    307             throw Exception(std::string("Can't find Elf")+Types::bitName+" Section");
     315            throw BinException(std::string("Can't find Elf")+Types::bitName+" Section");
    308316        return it->second;
    309317    }
     
    316324                return i;
    317325        }
    318         throw Exception(std::string("Can't find Elf")+Types::bitName+" Section");
     326        throw BinException(std::string("Can't find Elf")+Types::bitName+" Section");
    319327    }
    320328}
     
    326334                    symbolIndexMap.begin(), symbolIndexMap.end(), name, CStringLess());
    327335    if (it == symbolIndexMap.end())
    328         throw Exception(std::string("Can't find Elf")+Types::bitName+" Symbol");
     336        throw BinException(std::string("Can't find Elf")+Types::bitName+" Symbol");
    329337    return it->second;
    330338}
     
    336344                    dynSymIndexMap.begin(), dynSymIndexMap.end(), name, CStringLess());
    337345    if (it == dynSymIndexMap.end())
    338         throw Exception(std::string("Can't find Elf")+Types::bitName+" DynSymbol");
     346        throw BinException(std::string("Can't find Elf")+Types::bitName+" DynSymbol");
    339347    return it->second;
    340348}
     
    379387        const uint16_t shndx = builtinSections[sectionIndex-ELFSECTID_START];
    380388        if (shndx == SHN_UNDEF) // if table entry for sectionIndex is not defined
    381             throw Exception("Wrong BinSection:sectionId");
     389            throw BinGenException("Wrong BinSection:sectionId");
    382390        return builtinSections[sectionIndex-ELFSECTID_START];
    383391    }
    384392    else // failed
    385         throw Exception("Wrong BinSection:sectionId");
     393        throw BinGenException("Wrong BinSection:sectionId");
    386394}
    387395
     
    499507    /* verify data */
    500508    if (header.entryRegion != UINT_MAX && header.entryRegion >= regions.size())
    501         throw Exception("Header entry region out of range");
     509        throw BinGenException("Header entry region out of range");
    502510   
    503511    regionOffsets.reset(new typename Types::Word[regions.size()]);
     
    541549                    }
    542550                    else
    543                         throw Exception("Wrong Hash Sym section!");
     551                        throw BinGenException("Wrong Hash Sym section!");
    544552                }
    545553                sectionCount++;
    546554            }
    547555        if (!hashSymDetected)
    548             throw Exception("Wrong Hash Sym is not detected!");
     556            throw BinGenException("Wrong Hash Sym is not detected!");
    549557    }
    550558   
     
    567575        if (sym.sectionIndex >= sectionsNum && sym.sectionIndex!=SHN_ABS &&
    568576                    sym.sectionIndex!=SHN_UNDEF)
    569             throw Exception("Symbol section index out of range");
     577            throw BinGenException("Symbol section index out of range");
    570578    for (const auto& sym: dynSymbols)
    571579        if (sym.sectionIndex >= sectionsNum && sym.sectionIndex!=SHN_ABS &&
    572580                    sym.sectionIndex!=SHN_UNDEF)
    573             throw Exception("DynSymbol section index out of range");
     581            throw BinGenException("DynSymbol section index out of range");
    574582   
    575583    for (size_t i = 0; i < regions.size(); i++)
     
    598606                if (progHdr.regionStart!=PHREGION_FILESTART &&
    599607                            progHdr.regionStart >= regions.size())
    600                     throw Exception("Region start out of range");
     608                    throw BinGenException("Region start out of range");
    601609                if ((progHdr.regionStart==PHREGION_FILESTART &&
    602610                     progHdr.regionsNum > regions.size()) ||
    603611                    (progHdr.regionStart!=PHREGION_FILESTART &&
    604612                     uint64_t(progHdr.regionStart) + progHdr.regionsNum > regions.size()))
    605                     throw Exception("Region end out of range");
     613                    throw BinGenException("Region end out of range");
    606614            }
    607615            if (addrStartRegion==PHREGION_FILESTART)
     
    626634            // if section
    627635            if (region.section.link >= sectionsNum)
    628                 throw Exception("Section link out of range");
     636                throw BinGenException("Section link out of range");
    629637           
    630638            if (haveDynamic)
  • CLRadeonExtender/trunk/amdbin/GalliumBinaries.cpp

    r3447 r3457  
    8282    if (amdGPUConfigSize != 24 && amdGPUConfigSize != 40 &&
    8383        shdrSize % amdGPUConfigSize != 0)
    84         throw Exception("Wrong size of .AMDGPU.config section!");
     84        throw BinException("Wrong size of .AMDGPU.config section!");
    8585    // detect whether is binary generated for LLVM >= 3.9.0 by amdGPUConfig size
    8686    llvm390 = amdGPUConfigSize==40;
     
    102102        {
    103103            if (ULEV(sym.st_value) >= textSize)
    104                 throw Exception("kernel symbol offset out of range");
     104                throw BinException("kernel symbol offset out of range");
    105105            if (hasProgInfoMap)
    106106                progInfoEntryMap[progInfosNum] = std::make_pair(symName,
     
    110110    }
    111111    if (progInfosNum*amdGPUConfigSize != ULEV(shdr.sh_size))
    112         throw Exception("Number of symbol kernels doesn't match progInfos number!");
     112        throw BinException("Number of symbol kernels doesn't match progInfos number!");
    113113    cxbyte* binaryCode = (cxbyte*)elfBinary.getBinaryCode();
    114114    progInfoEntries = reinterpret_cast<GalliumProgInfoEntry*>(binaryCode +
     
    161161                         progInfoEntryMap.end(), name, CStringLess());
    162162    if (it == progInfoEntryMap.end())
    163         throw Exception("Can't find GalliumElf ProgInfoEntry");
     163        throw BinException("Can't find GalliumElf ProgInfoEntry");
    164164    return it->second;
    165165}
     
    189189        { symIndex = elfBinary.getSymbolIndex(kernel.kernelName.c_str()); }
    190190        catch(const Exception& ex)
    191         { throw Exception("Kernel symbol not found"); }
     191        { throw BinException("Kernel symbol not found"); }
    192192        const auto& sym = elfBinary.getSymbol(symIndex);
    193193        const char* symName = elfBinary.getSymbolName(symIndex);
     
    198198            // names must be stored in order
    199199            if (kernel.kernelName != symName)
    200                 throw Exception("Kernel symbols out of order!");
     200                throw BinException("Kernel symbols out of order!");
    201201            if (ULEV(sym.st_value) != kernel.offset)
    202                 throw Exception("Kernel symbol value and Kernel "
     202                throw BinException("Kernel symbol value and Kernel "
    203203                            "offset doesn't match");
    204204        }
    205205        else
    206             throw Exception("Wrong section or binding for kernel symbol");
     206            throw BinException("Wrong section or binding for kernel symbol");
    207207    }
    208208}
     
    215215{
    216216    if (binaryCodeSize < 4)
    217         throw Exception("GalliumBinary is too small!!!");
     217        throw BinException("GalliumBinary is too small!!!");
    218218    uint32_t* data32 = reinterpret_cast<uint32_t*>(binaryCode);
    219219    kernelsNum = ULEV(*data32);
    220220    if (binaryCodeSize < uint64_t(kernelsNum)*16U)
    221         throw Exception("Kernels number is too big!");
     221        throw BinException("Kernels number is too big!");
    222222    kernels.reset(new GalliumKernel[kernelsNum]);
    223223    cxbyte* data = binaryCode + 4;
     
    227227        GalliumKernel& kernel = kernels[i];
    228228        if (usumGt(uint32_t(data-binaryCode), 4U, binaryCodeSize))
    229             throw Exception("GalliumBinary is too small!!!");
     229            throw BinException("GalliumBinary is too small!!!");
    230230       
    231231        const cxuint symNameLen = ULEV(*reinterpret_cast<const uint32_t*>(data));
    232232        data+=4;
    233233        if (usumGt(uint32_t(data-binaryCode), symNameLen, binaryCodeSize))
    234             throw Exception("Kernel name length is too long!");
     234            throw BinException("Kernel name length is too long!");
    235235       
    236236        kernel.kernelName.assign((const char*)data, symNameLen);
     
    238238        data += symNameLen;
    239239        if (usumGt(uint32_t(data-binaryCode), 12U, binaryCodeSize))
    240             throw Exception("GalliumBinary is too small!!!");
     240            throw BinException("GalliumBinary is too small!!!");
    241241       
    242242        data32 = reinterpret_cast<uint32_t*>(data);
     
    248248       
    249249        if (UINT32_MAX/24U < argsNum)
    250             throw Exception("Number of arguments number is too high!");
     250            throw BinException("Number of arguments number is too high!");
    251251        if (usumGt(uint32_t(data-binaryCode), 24U*argsNum, binaryCodeSize))
    252             throw Exception("GalliumBinary is too small!!!");
     252            throw BinException("GalliumBinary is too small!!!");
    253253       
    254254        kernel.argInfos.resize(argsNum);
     
    259259            // accept not known arg type by this CLRadeonExtender
    260260            if (type > 255)
    261                 throw Exception("Type of kernel argument out of handled range");
     261                throw BinException("Type of kernel argument out of handled range");
    262262            argInfo.type = GalliumArgType(type);
    263263            argInfo.size = ULEV(data32[1]);
     
    268268            // accept not known semantic type by this CLRadeonExtender
    269269            if (semType > 255)
    270                 throw Exception("Semantic of kernel argument out of handled range");
     270                throw BinException("Semantic of kernel argument out of handled range");
    271271            argInfo.semantic = GalliumArgSemantic(semType);
    272272            data32 += 6;
     
    276276   
    277277    if (usumGt(uint32_t(data-binaryCode), 4U, binaryCodeSize))
    278         throw Exception("GalliumBinary is too small!!!");
     278        throw BinException("GalliumBinary is too small!!!");
    279279   
    280280    sectionsNum = ULEV(data32[0]);
    281281    if (binaryCodeSize-(data-binaryCode) < uint64_t(sectionsNum)*20U)
    282         throw Exception("Sections number is too big!");
     282        throw BinException("Sections number is too big!");
    283283    sections.reset(new GalliumSection[sectionsNum]);
    284284    // parse sections and their content
     
    291291        GalliumSection& section = sections[i];
    292292        if (usumGt(uint32_t(data-binaryCode), 20U, binaryCodeSize))
    293             throw Exception("GalliumBinary is too small!!!");
     293            throw BinException("GalliumBinary is too small!!!");
    294294       
    295295        section.sectionId = ULEV(data32[0]);
     
    297297        // section type must be lower than 256
    298298        if (secType > 255)
    299             throw Exception("Type of section out of range");
     299            throw BinException("Type of section out of range");
    300300        section.type = GalliumSectionType(secType);
    301301        section.size = ULEV(data32[2]);
     
    303303        const uint32_t sizeFromHeader = ULEV(data32[4]); // from LLVM binary
    304304        if (section.size != sizeOfData-4 || section.size != sizeFromHeader)
    305             throw Exception("Section size fields doesn't match itself!");
     305            throw BinException("Section size fields doesn't match itself!");
    306306       
    307307        data = reinterpret_cast<cxbyte*>(data32+5);
    308308        if (usumGt(uint32_t(data-binaryCode), section.size, binaryCodeSize))
    309             throw Exception("Section size is too big!!!");
     309            throw BinException("Section size is too big!!!");
    310310       
    311311        section.offset = data-binaryCode;
     
    317317            mesa170 = (section.type == GalliumSectionType::TEXT_EXECUTABLE_170);
    318318            if (section.size < sizeof(Elf32_Ehdr))
    319                 throw Exception("Wrong GalliumElfBinary size");
     319                throw BinException("Wrong GalliumElfBinary size");
    320320            const Elf32_Ehdr& ehdr = *reinterpret_cast<const Elf32_Ehdr*>(data);
    321321            if (ehdr.e_ident[EI_CLASS] == ELFCLASS32)
     
    335335            }
    336336            else // wrong class
    337                 throw Exception("Wrong GalliumElfBinary class");
     337                throw BinException("Wrong GalliumElfBinary class");
    338338        }
    339339        data += section.size;
     
    342342   
    343343    if (!elfBinary)
    344         throw Exception("Gallium Elf binary not found!");
     344        throw BinException("Gallium Elf binary not found!");
    345345    for (uint32_t i = 0; i < kernelsNum; i++)
    346346        if (kernels[i].sectionId != elfSectionId)
    347             throw Exception("Kernel not in text section!");
     347            throw BinException("Kernel not in text section!");
    348348    // verify kernel offsets
    349349    if (!elf64BitBinary)
     
    360360       { return k1.kernelName < k2.kernelName; });
    361361    if (it == kernels.get()+kernelsNum || it->kernelName != name)
    362         throw Exception("Can't find Gallium Kernel Index");
     362        throw BinException("Can't find Gallium Kernel Index");
    363363    return it-kernels.get();
    364364}
     
    619619            const GalliumKernelConfig& config = kernel.config;
    620620            if (config.usedVGPRsNum > maxVGPRSNum)
    621                 throw Exception("Used VGPRs number out of range");
     621                throw BinGenException("Used VGPRs number out of range");
    622622            if (config.usedSGPRsNum > maxSGPRSNum)
    623                 throw Exception("Used SGPRs number out of range");
     623                throw BinGenException("Used SGPRs number out of range");
    624624            if (config.localSize > 32768)
    625                 throw Exception("LocalSize out of range");
     625                throw BinGenException("LocalSize out of range");
    626626            if (config.priority >= 4)
    627                 throw Exception("Priority out of range");
     627                throw BinGenException("Priority out of range");
    628628            if (config.userDataNum > 16)
    629                 throw Exception("UserDataNum out of range");
     629                throw BinGenException("UserDataNum out of range");
    630630        }
    631631   
     
    666666#endif
    667667        elfSize > UINT32_MAX)
    668         throw Exception("Elf binary size is too big!");
     668        throw BinGenException("Elf binary size is too big!");
    669669   
    670670#ifdef HAVE_32BIT
    671671    if (binarySize > UINT32_MAX)
    672         throw Exception("Binary size is too big!");
     672        throw BinGenException("Binary size is too big!");
    673673#endif
    674674    /****
     
    707707        const GalliumKernelInput& kernel = input->kernels[korder];
    708708        if (kernel.offset >= input->codeSize)
    709             throw Exception("Kernel offset out of range");
     709            throw BinGenException("Kernel offset out of range");
    710710       
    711711        bos.writeObject<uint32_t>(LEV(uint32_t(kernel.kernelName.size())));
  • CLRadeonExtender/trunk/amdbin/ROCmBinaries.cpp

    r3444 r3457  
    6868    }
    6969    if (code==nullptr && regionsNum!=0)
    70         throw Exception("No code if regions number is not zero");
     70        throw BinException("No code if regions number is not zero");
    7171    regions.reset(new ROCmRegion[regionsNum]);
    7272    size_t j = 0;
     
    8282        const size_t value = ULEV(sym.st_value);
    8383        if (value < codeOffset)
    84             throw Exception("Region offset is too small!");
     84            throw BinException("Region offset is too small!");
    8585        const size_t size = ULEV(sym.st_size);
    8686       
     
    9999            symOffsets[j] = std::make_pair(value, j);
    100100            if (type!=ROCmRegionType::DATA && value+0x100 > codeOffset+codeSize)
    101                 throw Exception("Kernel or code offset is too big!");
     101                throw BinException("Kernel or code offset is too big!");
    102102            regions[j++] = { getSymbolName(i), size, value, type };
    103103        }
     
    113113        ROCmRegion& region = regions[symOffsets[i-1].second];
    114114        if (region.type==ROCmRegionType::KERNEL && symOffsets[i-1].first+0x100 > end)
    115             throw Exception("Kernel size is too small!");
     115            throw BinException("Kernel size is too small!");
    116116       
    117117        const size_t regSize = end - symOffsets[i-1].first;
     
    144144        const cxbyte* noteContent = (const cxbyte*)getNotes();
    145145        if (noteContent==nullptr)
    146             throw Exception("Missing notes in inner binary!");
     146            throw BinException("Missing notes in inner binary!");
    147147        size_t notesSize = getNotesSize();
    148148        // find note about AMDGPU
     
    153153            size_t descsz = ULEV(nhdr->n_descsz);
    154154            if (usumGt(offset, namesz+descsz, notesSize))
    155                 throw Exception("Note offset+size out of range");
     155                throw BinException("Note offset+size out of range");
    156156            if (ULEV(nhdr->n_type) == 0x3 && namesz==4 && descsz>=0x1a &&
    157157                ::strcmp((const char*)noteContent+offset+sizeof(Elf64_Nhdr), "AMD")==0)
     
    180180                             regionsMap.end(), name);
    181181    if (it == regionsMap.end())
    182         throw Exception("Can't find region name");
     182        throw BinException("Can't find region name");
    183183    return regions[it->second];
    184184}
  • CLRadeonExtender/trunk/utils/GPUId.cpp

    r3445 r3457  
    2727
    2828using namespace CLRX;
     29
     30GPUIdException::GPUIdException(const std::string& message) : Exception(message)
     31{ }
    2932
    3033// length of GPU device table (number of recognized GPU devices)
     
    164167                 name, CStringCaseLess());
    165168    if (it == lowerCaseGpuDeviceEntryTable+lowerCaseGpuDeviceEntryTableSize)
    166         throw Exception("Unknown GPU device type");
     169        throw GPUIdException("Unknown GPU device type");
    167170    return it->second;
    168171}
     
    176179            break;
    177180    if (found == sizeof(gpuArchitectureNameTable2) / sizeof(const char*))
    178         throw Exception("Unknown GPU architecture");
     181        throw GPUIdException("Unknown GPU architecture");
    179182    return GPUArchitecture(found/3);
    180183}
     
    183186{
    184187    if (deviceType > GPUDeviceType::GPUDEVICE_MAX)
    185         throw Exception("Unknown GPU device type");
     188        throw GPUIdException("Unknown GPU device type");
    186189    return gpuDeviceArchTable[cxuint(deviceType)];
    187190}
     
    190193{
    191194    if (architecture > GPUArchitecture::GPUARCH_MAX)
    192         throw Exception("Unknown GPU architecture");
     195        throw GPUIdException("Unknown GPU architecture");
    193196    return gpuLowestDeviceFromArchTable[cxuint(architecture)];
    194197}
     
    197200{
    198201    if (deviceType > GPUDeviceType::GPUDEVICE_MAX)
    199         throw Exception("Unknown GPU device type");
     202        throw GPUIdException("Unknown GPU device type");
    200203    return gpuDeviceNameTable[cxuint(deviceType)];
    201204}
     
    204207{
    205208    if (architecture > GPUArchitecture::GPUARCH_MAX)
    206         throw Exception("Unknown GPU architecture");
     209        throw GPUIdException("Unknown GPU architecture");
    207210    return gpuArchitectureNameTable[cxuint(architecture)];
    208211}
     
    212215{
    213216    if (architecture > GPUArchitecture::GPUARCH_MAX)
    214         throw Exception("Unknown GPU architecture");
     217        throw GPUIdException("Unknown GPU architecture");
    215218    if (regType == REGTYPE_VGPR)
    216219        return 256; // VGPRS
     
    360363{
    361364    if (deviceType > GPUDeviceType::GPUDEVICE_MAX)
    362         throw Exception("Unknown GPU device type");
     365        throw GPUIdException("Unknown GPU device type");
    363366    // choose correct GPU arch values table
    364367    const AMDGPUArchVersion* archValuesTable = (table == GPUArchVersionTable::AMDCL2) ?
Note: See TracChangeset for help on using the changeset viewer.