source: CLRX/CLRadeonExtender/trunk/amdbin/ROCmBinaries.cpp @ 2582

Last change on this file since 2582 was 2582, checked in by matszpk, 3 years ago

CLRadeonExtender: Comment typo in AsmGalliumFormat?. Code for AsmROCmFormat.
ROCmBinGen: Add addEmptyKernel to ROCmInput.

File size: 14.5 KB
Line 
1/*
2 *  CLRadeonExtender - Unofficial OpenCL Radeon Extensions Library
3 *  Copyright (C) 2014-2016 Mateusz Szpakowski
4 *
5 *  This library is free software; you can redistribute it and/or
6 *  modify it under the terms of the GNU Lesser General Public
7 *  License as published by the Free Software Foundation; either
8 *  version 2.1 of the License, or (at your option) any later version.
9 *
10 *  This library is distributed in the hope that it will be useful,
11 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 *  Lesser General Public License for more details.
14 *
15 *  You should have received a copy of the GNU Lesser General Public
16 *  License along with this library; if not, write to the Free Software
17 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
18 */
19
20#include <CLRX/Config.h>
21#include <cassert>
22#include <cstdint>
23#include <algorithm>
24#include <utility>
25#include <CLRX/amdbin/ElfBinaries.h>
26#include <CLRX/utils/Utilities.h>
27#include <CLRX/utils/MemAccess.h>
28#include <CLRX/utils/InputOutput.h>
29#include <CLRX/utils/Containers.h>
30#include <CLRX/amdbin/ROCmBinaries.h>
31
32using namespace CLRX;
33
34/* TODO: add support for various kernel code offset (now only 256 is supported) */
35
36ROCmBinary::ROCmBinary(size_t binaryCodeSize, cxbyte* binaryCode, Flags creationFlags)
37        : ElfBinary64(binaryCodeSize, binaryCode, creationFlags),
38          regionsNum(0), codeSize(0), code(nullptr)
39{
40    cxuint textIndex = SHN_UNDEF;
41    try
42    { textIndex = getSectionIndex(".text"); }
43    catch(const Exception& ex)
44    { } // ignore failed
45    uint64_t codeOffset = 0;
46    if (textIndex!=SHN_UNDEF)
47    {
48        code = getSectionContent(textIndex);
49        const Elf64_Shdr& textShdr = getSectionHeader(textIndex);
50        codeSize = ULEV(textShdr.sh_size);
51        codeOffset = ULEV(textShdr.sh_offset);
52    }
53   
54    regionsNum = 0;
55    const size_t symbolsNum = getSymbolsNum();
56    for (size_t i = 0; i < symbolsNum; i++)
57    {   // count regions number
58        const Elf64_Sym& sym = getSymbol(i);
59        const cxbyte symType = ELF64_ST_TYPE(sym.st_info);
60        const cxbyte bind = ELF64_ST_BIND(sym.st_info);
61        if (ULEV(sym.st_shndx)==textIndex &&
62            (symType==STT_GNU_IFUNC || (bind==STB_GLOBAL && symType==STT_OBJECT)))
63            regionsNum++;
64    }
65    if (code==nullptr && regionsNum!=0)
66        throw Exception("No code if regions number is not zero");
67    regions.reset(new ROCmRegion[regionsNum]);
68    size_t j = 0;
69    typedef std::pair<uint64_t, size_t> RegionOffsetEntry;
70    std::unique_ptr<RegionOffsetEntry[]> symOffsets(new RegionOffsetEntry[regionsNum]);
71   
72    for (size_t i = 0; i < symbolsNum; i++)
73    {
74        const Elf64_Sym& sym = getSymbol(i);
75        if (ULEV(sym.st_shndx)!=textIndex)
76            continue;   // if not in '.text' section
77        const size_t value = ULEV(sym.st_value);
78        if (value < codeOffset)
79            throw Exception("Region offset is too small!");
80        const size_t size = ULEV(sym.st_size);
81       
82        const cxbyte symType = ELF64_ST_TYPE(sym.st_info);
83        const cxbyte bind = ELF64_ST_BIND(sym.st_info);
84        if (symType==STT_GNU_IFUNC || (bind==STB_GLOBAL && symType==STT_OBJECT))
85        {
86            const bool isKernel = (symType==STT_GNU_IFUNC);
87            symOffsets[j] = std::make_pair(value, j);
88            if (isKernel && value+0x100 > codeOffset+codeSize)
89                throw Exception("Kernel offset is too big!");
90            regions[j++] = { getSymbolName(i), size, value, isKernel };
91        }
92    }
93    std::sort(symOffsets.get(), symOffsets.get()+regionsNum,
94            [](const RegionOffsetEntry& a, const RegionOffsetEntry& b)
95            { return a.first < b.first; });
96    // checking distance between regions
97    for (size_t i = 1; i <= regionsNum; i++)
98    {
99        size_t end = (i<regionsNum) ? symOffsets[i].first : codeOffset+codeSize;
100        ROCmRegion& region = regions[symOffsets[i-1].second];
101        if (region.isKernel && symOffsets[i-1].first+0x100 > end)
102            throw Exception("Kernel size is too small!");
103       
104        const size_t regSize = end - symOffsets[i-1].first;
105        if (region.size==0)
106            region.size = regSize;
107        else
108            region.size = std::min(regSize, region.size);
109    }
110   
111    if (hasRegionMap())
112    {   // create region map
113        regionsMap.resize(regionsNum);
114        for (size_t i = 0; i < regionsNum; i++)
115            regionsMap[i] = std::make_pair(regions[i].regionName, i);
116        mapSort(regionsMap.begin(), regionsMap.end());
117    }
118}
119
120const ROCmRegion& ROCmBinary::getRegion(const char* name) const
121{
122    RegionMap::const_iterator it = binaryMapFind(regionsMap.begin(),
123                             regionsMap.end(), name);
124    if (it == regionsMap.end())
125        throw Exception("Can't find region name");
126    return regions[it->second];
127}
128
129bool CLRX::isROCmBinary(size_t binarySize, const cxbyte* binary)
130{
131    if (!isElfBinary(binarySize, binary))
132        return false;
133    if (binary[EI_CLASS] != ELFCLASS64)
134        return false;
135    const Elf64_Ehdr* ehdr = reinterpret_cast<const Elf64_Ehdr*>(binary);
136    if (ULEV(ehdr->e_machine) != 0xe0 || ULEV(ehdr->e_flags)!=0)
137        return false;
138    return true;
139}
140
141
142void ROCmInput::addEmptyKernel(const char* kernelName)
143{
144    symbols.push_back({ kernelName, 0, 0, true });
145}
146/*
147 * ROCm Binary Generator
148 */
149
150ROCmBinGenerator::ROCmBinGenerator() : manageable(false), input(nullptr)
151{ }
152
153ROCmBinGenerator::ROCmBinGenerator(const ROCmInput* rocmInput)
154        : manageable(false), input(rocmInput)
155{ }
156
157ROCmBinGenerator::ROCmBinGenerator(GPUDeviceType deviceType,
158        uint32_t archMinor, uint32_t archStepping, size_t codeSize, const cxbyte* code,
159        const std::vector<ROCmSymbolInput>& symbols)
160{
161    input = new ROCmInput{ deviceType, archMinor, archStepping, symbols, codeSize, code };
162}
163
164ROCmBinGenerator::ROCmBinGenerator(GPUDeviceType deviceType,
165        uint32_t archMinor, uint32_t archStepping, size_t codeSize, const cxbyte* code,
166        std::vector<ROCmSymbolInput>&& symbols)
167{
168    input = new ROCmInput{ deviceType, archMinor, archStepping, std::move(symbols),
169                codeSize, code };
170}
171
172ROCmBinGenerator::~ROCmBinGenerator()
173{
174    if (manageable)
175        delete input;
176}
177
178void ROCmBinGenerator::setInput(const ROCmInput* input)
179{
180    if (manageable)
181        delete input;
182    manageable = false;
183    this->input = input;
184}
185
186static const cxbyte noteDescType1[8] =
187{ 2, 0, 0, 0, 1, 0, 0, 0 };
188
189static const cxbyte noteDescType3[27] =
190{ 4, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
191  'A', 'M', 'D', 0, 'A', 'M', 'D', 'G', 'P', 'U', 0 };
192
193struct AMDGPUArchValues
194{
195    uint32_t major;
196    uint32_t minor;
197    uint32_t stepping;
198};
199
200// section index for symbol binding
201static const uint16_t mainBuiltinSectionTable[] =
202{
203    10, // ELFSECTID_SHSTRTAB
204    11, // ELFSECTID_STRTAB
205    9, // ELFSECTID_SYMTAB
206    3, // ELFSECTID_DYNSTR
207    1, // ELFSECTID_DYNSYM
208    4, // ELFSECTID_TEXT
209    SHN_UNDEF, // ELFSECTID_RODATA
210    SHN_UNDEF, // ELFSECTID_DATA
211    SHN_UNDEF, // ELFSECTID_BSS
212    8, // ELFSECTID_COMMENT
213    2, // ROCMSECTID_HASH
214    5, // ROCMSECTID_DYNAMIC
215    6, // ROCMSECTID_NOTE
216    7 // ROCMSECTID_GPUCONFIG
217};
218
219static const AMDGPUArchValues amdGpuArchValuesTbl[] =
220{
221    { 0, 0, 0 }, // GPUDeviceType::CAPE_VERDE
222    { 0, 0, 0 }, // GPUDeviceType::PITCAIRN
223    { 0, 0, 0 }, // GPUDeviceType::TAHITI
224    { 0, 0, 0 }, // GPUDeviceType::OLAND
225    { 7, 0, 0 }, // GPUDeviceType::BONAIRE
226    { 7, 0, 0 }, // GPUDeviceType::SPECTRE
227    { 7, 0, 0 }, // GPUDeviceType::SPOOKY
228    { 7, 0, 0 }, // GPUDeviceType::KALINDI
229    { 0, 0, 0 }, // GPUDeviceType::HAINAN
230    { 7, 0, 1 }, // GPUDeviceType::HAWAII
231    { 8, 0, 0 }, // GPUDeviceType::ICELAND
232    { 8, 0, 0 }, // GPUDeviceType::TONGA
233    { 7, 0, 0 }, // GPUDeviceType::MULLINS
234    { 8, 0, 3 }, // GPUDeviceType::FIJI
235    { 8, 0, 1 }, // GPUDeviceType::CARRIZO
236    { 0, 0, 0 }, // GPUDeviceType::DUMMY
237    { 0, 0, 0 }, // GPUDeviceType::GOOSE
238    { 0, 0, 0 }, // GPUDeviceType::HORSE
239    { 8, 0, 1 }, // GPUDeviceType::STONEY
240    { 8, 0, 4 }, // GPUDeviceType::ELLESMERE
241    { 8, 0, 4 } // GPUDeviceType::BAFFIN
242};
243
244void ROCmBinGenerator::generateInternal(std::ostream* osPtr, std::vector<char>* vPtr,
245             Array<cxbyte>* aPtr) const
246{
247    AMDGPUArchValues amdGpuArchValues = amdGpuArchValuesTbl[cxuint(input->deviceType)];
248    if (input->archMinor!=UINT32_MAX)
249        amdGpuArchValues.minor = input->archMinor;
250    if (input->archStepping!=UINT32_MAX)
251        amdGpuArchValues.stepping = input->archStepping;
252   
253    const char* comment = "CLRX ROCmBinGenerator " CLRX_VERSION;
254    uint32_t commentSize = ::strlen(comment);
255    if (input->comment!=nullptr)
256    {   // if comment, store comment section
257        comment = input->comment;
258        commentSize = input->commentSize;
259        if (commentSize==0)
260            commentSize = ::strlen(comment);
261    }
262   
263    ElfBinaryGen64 elfBinGen64({ 0U, 0U, 0x40, 0, ET_DYN,
264        0xe0, EV_CURRENT, UINT_MAX, 0, 0 }, true, true, true, PHREGION_FILESTART);
265    // add symbols
266    elfBinGen64.addSymbol(ElfSymbol64("_DYNAMIC", 5,
267                  ELF64_ST_INFO(STB_LOCAL, STT_NOTYPE), STV_HIDDEN, true, 0, 0));
268    for (const ROCmSymbolInput& symbol: input->symbols)
269    {
270        ElfSymbol64 elfsym;
271        if (symbol.isKernel)
272            elfsym = ElfSymbol64(symbol.symbolName.c_str(), 4,
273                  ELF64_ST_INFO(STB_GLOBAL, STT_GNU_IFUNC), 0, true,
274                  symbol.offset, symbol.size);
275        else
276            elfsym = ElfSymbol64(symbol.symbolName.c_str(), 4,
277                  ELF64_ST_INFO(STB_GLOBAL, STT_OBJECT), 0, true,
278                  symbol.offset, symbol.size);
279        elfBinGen64.addSymbol(elfsym);
280        elfBinGen64.addDynSymbol(elfsym);
281    }
282   
283    static const int32_t dynTags[] = {
284        DT_SYMTAB, DT_SYMENT, DT_STRTAB, DT_STRSZ, DT_HASH };
285    elfBinGen64.addDynamics(sizeof(dynTags)/sizeof(int32_t), dynTags);
286    // elf program headers
287    elfBinGen64.addProgramHeader({ PT_PHDR, PF_R, 0, 1,
288                    true, Elf64Types::nobase, Elf64Types::nobase, 0 });
289    elfBinGen64.addProgramHeader({ PT_LOAD, PF_R, PHREGION_FILESTART, 4,
290                    true, Elf64Types::nobase, Elf64Types::nobase, 0, 0x1000 });
291    elfBinGen64.addProgramHeader({ PT_LOAD, PF_R|PF_X, 4, 1,
292                    true, Elf64Types::nobase, Elf64Types::nobase, 0 });
293    elfBinGen64.addProgramHeader({ PT_LOAD, PF_R|PF_W, 5, 1,
294                    true, Elf64Types::nobase, Elf64Types::nobase, 0 });
295    elfBinGen64.addProgramHeader({ PT_DYNAMIC, PF_R|PF_W, 5, 1,
296                    true, Elf64Types::nobase, Elf64Types::nobase, 0, 8 });
297    elfBinGen64.addProgramHeader({ PT_GNU_RELRO, PF_R, 5, 1,
298                    true, Elf64Types::nobase, Elf64Types::nobase, 0, 1 });
299    elfBinGen64.addProgramHeader({ PT_GNU_STACK, PF_R|PF_W, PHREGION_FILESTART, 0,
300                    true, 0, 0, 0 });
301   
302    // elf notes
303    elfBinGen64.addNote({"AMD", sizeof noteDescType1, noteDescType1, 1U});
304    std::unique_ptr<cxbyte[]> noteBuf(new cxbyte[0x1b]);
305    ::memcpy(noteBuf.get(), noteDescType3, 0x1b);
306    SULEV(*(uint32_t*)(noteBuf.get()+4), amdGpuArchValues.major);
307    SULEV(*(uint32_t*)(noteBuf.get()+8), amdGpuArchValues.minor);
308    SULEV(*(uint32_t*)(noteBuf.get()+12), amdGpuArchValues.stepping);
309    elfBinGen64.addNote({"AMD", 0x1b, noteBuf.get(), 3U});
310   
311    /// region and sections
312    elfBinGen64.addRegion(ElfRegion64::programHeaderTable());
313    elfBinGen64.addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 8,
314                ".dynsym", SHT_DYNSYM, SHF_ALLOC, 0, 1, Elf64Types::nobase));
315    elfBinGen64.addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 4,
316                ".hash", SHT_HASH, SHF_ALLOC, 1, 0, Elf64Types::nobase));
317    elfBinGen64.addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 1, ".dynstr", SHT_STRTAB,
318                SHF_ALLOC, 0, 0, Elf64Types::nobase));
319    elfBinGen64.addRegion(ElfRegion64(input->codeSize, (const cxbyte*)input->code, 
320              0x1000, ".text", SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR, 0, 0,
321              Elf64Types::nobase, 0, false, 256));
322    elfBinGen64.addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 0x1000,
323                ".dynamic", SHT_DYNAMIC, SHF_ALLOC|SHF_WRITE, 3, 0,
324                Elf64Types::nobase, 0, false, 8));
325    elfBinGen64.addRegion(ElfRegion64::noteSection());
326    elfBinGen64.addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 1,
327                ".AMDGPU.config", SHT_PROGBITS, 0));
328    elfBinGen64.addRegion(ElfRegion64(commentSize, (const cxbyte*)comment, 1, ".comment",
329              SHT_PROGBITS, SHF_MERGE|SHF_STRINGS, 0, 0, 0, 1));
330    elfBinGen64.addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 8,
331                ".symtab", SHT_SYMTAB, 0, 0, 1));
332    elfBinGen64.addRegion(ElfRegion64::shstrtabSection());
333    elfBinGen64.addRegion(ElfRegion64::strtabSection());
334    elfBinGen64.addRegion(ElfRegion64::sectionHeaderTable());
335   
336    /* extra sections */
337    for (const BinSection& section: input->extraSections)
338        elfBinGen64.addRegion(ElfRegion64(section, mainBuiltinSectionTable,
339                         ROCMSECTID_MAX, 12));
340    /* extra symbols */
341    for (const BinSymbol& symbol: input->extraSymbols)
342        elfBinGen64.addSymbol(ElfSymbol64(symbol, mainBuiltinSectionTable,
343                         ROCMSECTID_MAX, 12));
344   
345    size_t binarySize = elfBinGen64.countSize();
346    /****
347     * prepare for write binary to output
348     ****/
349    std::unique_ptr<std::ostream> outStreamHolder;
350    std::ostream* os = nullptr;
351    if (aPtr != nullptr)
352    {
353        aPtr->resize(binarySize);
354        outStreamHolder.reset(
355                new ArrayOStream(binarySize, reinterpret_cast<char*>(aPtr->data())));
356        os = outStreamHolder.get();
357    }
358    else if (vPtr != nullptr)
359    {
360        vPtr->resize(binarySize);
361        outStreamHolder.reset(new VectorOStream(*vPtr));
362        os = outStreamHolder.get();
363    }
364    else // from argument
365        os = osPtr;
366   
367    const std::ios::iostate oldExceptions = os->exceptions();
368    try
369    {
370    os->exceptions(std::ios::failbit | std::ios::badbit);
371    /****
372     * write binary to output
373     ****/
374    FastOutputBuffer bos(256, *os);
375    elfBinGen64.generate(bos);
376    assert(bos.getWritten() == binarySize);
377    }
378    catch(...)
379    {
380        os->exceptions(oldExceptions);
381        throw;
382    }
383    os->exceptions(oldExceptions);
384}
385
386void ROCmBinGenerator::generate(Array<cxbyte>& array) const
387{
388    generateInternal(nullptr, nullptr, &array);
389}
390
391void ROCmBinGenerator::generate(std::ostream& os) const
392{
393    generateInternal(&os, nullptr, nullptr);
394}
395
396void ROCmBinGenerator::generate(std::vector<char>& v) const
397{
398    generateInternal(nullptr, &v, nullptr);
399}
Note: See TracBrowser for help on using the repository browser.