Changeset 3784 in CLRX


Ignore:
Timestamp:
Feb 13, 2018, 6:53:11 PM (17 months ago)
Author:
matszpk
Message:

CLRadeonExtender: AsmROCm: First working version with resolving section diffs for global symbols which will be added to symbol table.

Location:
CLRadeonExtender/trunk
Files:
5 edited

Legend:

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

    r3772 r3784  
    538538    void saveKcodeCurrentAllocRegs();
    539539   
     540    void addSymbols(bool sectionDiffsPrepared);
    540541public:
    541542    /// construcror
  • CLRadeonExtender/trunk/CLRX/amdbin/ElfBinaries.h

    r3761 r3784  
    867867    void addProgramHeader(const ElfProgramHeaderTemplate<Types>& progHeader);
    868868   
     869    /// clear symbols
     870    void clearSymbols()
     871    { symbols.clear(); }
     872    /// clear dynamic symbols
     873    void clearDynSymbols()
     874    { dynSymbols.clear(); }
    869875    /// add symbol
    870876    void addSymbol(const ElfSymbolTemplate<Types>& symbol)
  • CLRadeonExtender/trunk/CLRX/amdbin/ROCmBinaries.h

    r3772 r3784  
    398398    size_t metadataSize;
    399399    const char* metadata;
     400    cxuint mainSectionsNum;
    400401    uint16_t mainBuiltinSectTable[ROCMSECTID_MAX-ELFSECTID_START+1];
    401402   
     
    434435    const ROCmInput* getInput() const
    435436    { return input; }
    436    
    437     // prepare binary generator (for section diffs)
     437    /// set input
     438    void setInput(const ROCmInput* input);
     439   
     440    /// prepare binary generator (for section diffs)
    438441    void prepareBinaryGen();
    439    
     442    /// get section offset (from main section)
    440443    size_t getSectionOffset(cxuint sectionId) const
    441444    { return elfBinGen64->getRegionOffset(
    442445                    mainBuiltinSectTable[sectionId - ELFSECTID_START]); }
    443    
    444     /// set input
    445     void setInput(const ROCmInput* input);
     446    /// update symbols
     447    void updateSymbols();
    446448   
    447449    /// generates binary to array of bytes
  • CLRadeonExtender/trunk/amdasm/AsmROCmFormat.cpp

    r3772 r3784  
    24822482    }
    24832483   
    2484     // if set adds symbols to binary
    2485     std::vector<ROCmSymbolInput> dataSymbols;
    2486     if (assembler.getFlags() & ASM_FORCE_ADD_SYMBOLS)
    2487         for (const AsmSymbolEntry& symEntry: assembler.globalScope.symbolMap)
    2488         {
    2489             if (!symEntry.second.hasValue)
    2490                 continue; // unresolved
    2491             if (ELF32_ST_BIND(symEntry.second.info) == STB_LOCAL)
    2492                 continue; // local
    2493             if (assembler.kernelMap.find(symEntry.first.c_str())!=assembler.kernelMap.end())
    2494                 continue; // if kernel name
    2495            
    2496             if (symEntry.second.sectionId==codeSection)
    2497             {
    2498                 // put data objects
    2499                 dataSymbols.push_back({symEntry.first, size_t(symEntry.second.value),
    2500                     size_t(symEntry.second.size), ROCmRegionType::DATA});
    2501                 continue;
    2502             }
    2503             cxbyte info = symEntry.second.info;
    2504             // object type for global symbol referring to global data
    2505             if (symEntry.second.sectionId==dataSection)
    2506                 info = ELF32_ST_INFO(ELF32_ST_BIND(symEntry.second.info), STT_OBJECT);
    2507            
    2508             cxuint binSectId = (symEntry.second.sectionId != ASMSECT_ABS) ?
    2509                     sections[symEntry.second.sectionId].elfBinSectId : ELFSECTID_ABS;
    2510             if (binSectId==ELFSECTID_UNDEF)
    2511                 continue; // no section
    2512            
    2513             output.extraSymbols.push_back({ symEntry.first, symEntry.second.value,
    2514                     symEntry.second.size, binSectId, false,
    2515                     info, symEntry.second.other });
    2516         }
    2517    
     2484    // check kernel symbols and setup kernel configs
    25182485    AsmSection& asmCSection = assembler.sections[codeSection];
    25192486    const AsmSymbolMap& symbolMap = assembler.getSymbolMap();
     
    25702537    }
    25712538   
    2572     // put data objects
    2573     dataSymbols.insert(dataSymbols.end(), output.symbols.begin(), output.symbols.end());
    2574     output.symbols = std::move(dataSymbols);
     2539    // add symbols before section diffs prepping
     2540    addSymbols(false);
     2541   
    25752542    if (good)
    25762543    {
     
    25962563}
    25972564
     2565void AsmROCmHandler::addSymbols(bool sectionDiffsPrepared)
     2566{
     2567    output.extraSymbols.clear();
     2568    // if set adds symbols to binary
     2569    std::vector<ROCmSymbolInput> dataSymbols;
     2570    if (assembler.getFlags() & ASM_FORCE_ADD_SYMBOLS)
     2571        for (const AsmSymbolEntry& symEntry: assembler.globalScope.symbolMap)
     2572        {
     2573            //if (!symEntry.second.hasValue)
     2574              //  continue; // unresolved
     2575            if (ELF32_ST_BIND(symEntry.second.info) == STB_LOCAL)
     2576                continue; // local
     2577            if (assembler.kernelMap.find(symEntry.first.c_str())!=assembler.kernelMap.end())
     2578                continue; // if kernel name
     2579           
     2580            if (symEntry.second.sectionId==codeSection)
     2581            {
     2582                // put data objects
     2583                dataSymbols.push_back({symEntry.first, size_t(symEntry.second.value),
     2584                    size_t(symEntry.second.size), ROCmRegionType::DATA});
     2585                continue;
     2586            }
     2587            cxbyte info = symEntry.second.info;
     2588            // object type for global symbol referring to global data
     2589            if (symEntry.second.sectionId==dataSection)
     2590                info = ELF32_ST_INFO(ELF32_ST_BIND(symEntry.second.info), STT_OBJECT);
     2591           
     2592            cxuint binSectId = (symEntry.second.sectionId != ASMSECT_ABS) ?
     2593                    sections[symEntry.second.sectionId].elfBinSectId : ELFSECTID_ABS;
     2594            if (binSectId==ELFSECTID_UNDEF)
     2595                continue; // no section
     2596           
     2597            output.extraSymbols.push_back({ symEntry.first, symEntry.second.value,
     2598                    symEntry.second.size, binSectId, false,
     2599                    info, symEntry.second.other });
     2600        }
     2601   
     2602    // put data objects
     2603    if (sectionDiffsPrepared)
     2604    {
     2605        // move kernels to start
     2606        for (size_t i = 0; i < kernelStates.size(); i++)
     2607            output.symbols[i] = output.symbols[output.symbols.size()-kernelStates.size()+i];
     2608        output.symbols.resize(kernelStates.size());
     2609    }
     2610    dataSymbols.insert(dataSymbols.end(), output.symbols.begin(), output.symbols.end());
     2611    output.symbols = std::move(dataSymbols);
     2612}
     2613
    25982614bool AsmROCmHandler::prepareBinary()
    25992615{
     2616    // add symbols after section diffs prepping
     2617    addSymbols(true);
     2618    binGen->updateSymbols();
    26002619    return good;
    26012620}
  • CLRadeonExtender/trunk/amdbin/ROCmBinaries.cpp

    r3776 r3784  
    20232023    std::fill(mainBuiltinSectTable,
    20242024              mainBuiltinSectTable + ROCMSECTID_MAX-ELFSECTID_START+1, SHN_UNDEF);
    2025     cxuint mainSectionsNum = 1;
     2025    mainSectionsNum = 1;
    20262026   
    20272027    // generate main builtin section table (for section id translation)
     
    20462046    addMainSectionToTable(mainSectionsNum, mainBuiltinSectTable, ELFSECTID_STRTAB);
    20472047   
     2048    static const int32_t dynTags[] = {
     2049        DT_SYMTAB, DT_SYMENT, DT_STRTAB, DT_STRSZ, DT_HASH };
     2050    elfBinGen64->addDynamics(sizeof(dynTags)/sizeof(int32_t), dynTags);
     2051   
     2052    // elf program headers
     2053    elfBinGen64->addProgramHeader({ PT_PHDR, PF_R, 0, 1,
     2054                    true, Elf64Types::nobase, Elf64Types::nobase, 0 });
     2055    elfBinGen64->addProgramHeader({ PT_LOAD, PF_R, PHREGION_FILESTART,
     2056                    execProgHeaderRegionIndex,
     2057                    true, Elf64Types::nobase, Elf64Types::nobase, 0, 0x1000 });
     2058    elfBinGen64->addProgramHeader({ PT_LOAD, PF_R|PF_X, execProgHeaderRegionIndex, 1,
     2059                    true, Elf64Types::nobase, Elf64Types::nobase, 0 });
     2060    elfBinGen64->addProgramHeader({ PT_LOAD, PF_R|PF_W, execProgHeaderRegionIndex+1, 1,
     2061                    true, Elf64Types::nobase, Elf64Types::nobase, 0 });
     2062    elfBinGen64->addProgramHeader({ PT_DYNAMIC, PF_R|PF_W, execProgHeaderRegionIndex+1, 1,
     2063                    true, Elf64Types::nobase, Elf64Types::nobase, 0, 8 });
     2064    elfBinGen64->addProgramHeader({ PT_GNU_RELRO, PF_R, execProgHeaderRegionIndex+1, 1,
     2065                    true, Elf64Types::nobase, Elf64Types::nobase, 0, 1 });
     2066    elfBinGen64->addProgramHeader({ PT_GNU_STACK, PF_R|PF_W, PHREGION_FILESTART, 0,
     2067                    true, 0, 0, 0 });
     2068   
     2069    if (input->newBinFormat)
     2070        // program header for note (new binary format)
     2071        elfBinGen64->addProgramHeader({ PT_NOTE, PF_R, 1, 1, true,
     2072                    Elf64Types::nobase, Elf64Types::nobase, 0, 4 });
     2073   
     2074    target = input->target.c_str();
     2075    if (target.empty() && !input->targetTripple.empty())
     2076    {
     2077        target = input->targetTripple.c_str();
     2078        char dbuf[20];
     2079        snprintf(dbuf, 20, "-gfx%u%u%u", amdGpuArchValues.major, amdGpuArchValues.minor,
     2080                 amdGpuArchValues.stepping);
     2081        target += dbuf;
     2082    }
     2083    // elf notes
     2084    elfBinGen64->addNote({"AMD", sizeof noteDescType1, noteDescType1, 1U});
     2085    noteBuf.reset(new cxbyte[0x1b]);
     2086    ::memcpy(noteBuf.get(), noteDescType3, 0x1b);
     2087    SULEV(*(uint32_t*)(noteBuf.get()+4), amdGpuArchValues.major);
     2088    SULEV(*(uint32_t*)(noteBuf.get()+8), amdGpuArchValues.minor);
     2089    SULEV(*(uint32_t*)(noteBuf.get()+12), amdGpuArchValues.stepping);
     2090    elfBinGen64->addNote({"AMD", 0x1b, noteBuf.get(), 3U});
     2091    if (!target.empty())
     2092        elfBinGen64->addNote({"AMD", target.size(), (const cxbyte*)target.c_str(), 0xbU});
     2093   
     2094    metadataSize = input->metadataSize;
     2095    metadata = input->metadata;
     2096    if (input->useMetadataInfo)
     2097    {
     2098        // generate ROCm metadata
     2099        std::vector<std::pair<CString, size_t> > symbolIndices(input->symbols.size());
     2100        // create sorted indices of symbols by its name
     2101        for (size_t k = 0; k < input->symbols.size(); k++)
     2102            symbolIndices[k] = std::make_pair(input->symbols[k].symbolName, k);
     2103        mapSort(symbolIndices.begin(), symbolIndices.end());
     2104       
     2105        const size_t mdKernelsNum = input->metadataInfo.kernels.size();
     2106        std::unique_ptr<const ROCmKernelConfig*[]> kernelConfigPtrs(
     2107                new const ROCmKernelConfig*[mdKernelsNum]);
     2108        // generate ROCm kernel config pointers
     2109        for (size_t k = 0; k < mdKernelsNum; k++)
     2110        {
     2111            auto it = binaryMapFind(symbolIndices.begin(), symbolIndices.end(),
     2112                        input->metadataInfo.kernels[k].name);
     2113            if (it == symbolIndices.end() ||
     2114                (input->symbols[it->second].type != ROCmRegionType::FKERNEL &&
     2115                 input->symbols[it->second].type != ROCmRegionType::KERNEL))
     2116                throw BinGenException("Kernel in metadata doesn't exists in code");
     2117            kernelConfigPtrs[k] = reinterpret_cast<const ROCmKernelConfig*>(
     2118                        input->code + input->symbols[it->second].offset);
     2119        }
     2120        // just generate ROCm metadata from info
     2121        generateROCmMetadata(input->metadataInfo, kernelConfigPtrs.get(), metadataStr);
     2122        metadataSize = metadataStr.size();
     2123        metadata = metadataStr.c_str();
     2124    }
     2125   
     2126    if (metadataSize != 0)
     2127        elfBinGen64->addNote({"AMD", metadataSize, (const cxbyte*)metadata, 0xaU});
     2128   
     2129    /// region and sections
     2130    elfBinGen64->addRegion(ElfRegion64::programHeaderTable());
     2131    if (input->newBinFormat)
     2132        elfBinGen64->addRegion(ElfRegion64::noteSection());
     2133    if (input->globalData != nullptr)
     2134        elfBinGen64->addRegion(ElfRegion64(input->globalDataSize, input->globalData, 4,
     2135                ".rodata", SHT_PROGBITS, SHF_ALLOC, 0, 0, Elf64Types::nobase));
     2136   
     2137    elfBinGen64->addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 8,
     2138                ".dynsym", SHT_DYNSYM, SHF_ALLOC, 0, BINGEN_DEFAULT, Elf64Types::nobase));
     2139    elfBinGen64->addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 4,
     2140                ".hash", SHT_HASH, SHF_ALLOC,
     2141                mainBuiltinSectTable[ELFSECTID_DYNSYM-ELFSECTID_START], 0,
     2142                Elf64Types::nobase));
     2143    elfBinGen64->addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 1, ".dynstr", SHT_STRTAB,
     2144                SHF_ALLOC, 0, 0, Elf64Types::nobase));
     2145    // '.text' with alignment=4096
     2146    elfBinGen64->addRegion(ElfRegion64(input->codeSize, (const cxbyte*)input->code,
     2147              0x1000, ".text", SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR, 0, 0,
     2148              Elf64Types::nobase, 0, false, 256));
     2149    elfBinGen64->addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 0x1000,
     2150                ".dynamic", SHT_DYNAMIC, SHF_ALLOC|SHF_WRITE,
     2151                mainBuiltinSectTable[ELFSECTID_DYNSTR-ELFSECTID_START], 0,
     2152                Elf64Types::nobase, 0, false, 8));
     2153    if (!input->newBinFormat)
     2154    {
     2155        elfBinGen64->addRegion(ElfRegion64::noteSection());
     2156        elfBinGen64->addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 1,
     2157                    ".AMDGPU.config", SHT_PROGBITS, 0));
     2158    }
     2159    elfBinGen64->addRegion(ElfRegion64(commentSize, (const cxbyte*)comment, 1, ".comment",
     2160              SHT_PROGBITS, SHF_MERGE|SHF_STRINGS, 0, 0, 0, 1));
     2161    elfBinGen64->addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 8,
     2162                ".symtab", SHT_SYMTAB, 0, 0, BINGEN_DEFAULT));
     2163    elfBinGen64->addRegion(ElfRegion64::shstrtabSection());
     2164    elfBinGen64->addRegion(ElfRegion64::strtabSection());
     2165    elfBinGen64->addRegion(ElfRegion64::sectionHeaderTable());
     2166   
     2167    /* extra sections */
     2168    for (const BinSection& section: input->extraSections)
     2169        elfBinGen64->addRegion(ElfRegion64(section, mainBuiltinSectTable,
     2170                         ROCMSECTID_MAX, mainSectionsNum));
     2171    updateSymbols();
     2172    binarySize = elfBinGen64->countSize();
     2173}
     2174
     2175void ROCmBinGenerator::updateSymbols()
     2176{
     2177    elfBinGen64->clearSymbols();
     2178    elfBinGen64->clearDynSymbols();
    20482179    // add symbols (kernels, function kernels and data symbols)
    20492180    elfBinGen64->addSymbol(ElfSymbol64("_DYNAMIC",
     
    20782209        elfBinGen64->addDynSymbol(elfsym);
    20792210    }
    2080    
    2081     static const int32_t dynTags[] = {
    2082         DT_SYMTAB, DT_SYMENT, DT_STRTAB, DT_STRSZ, DT_HASH };
    2083     elfBinGen64->addDynamics(sizeof(dynTags)/sizeof(int32_t), dynTags);
    2084    
    2085     // elf program headers
    2086     elfBinGen64->addProgramHeader({ PT_PHDR, PF_R, 0, 1,
    2087                     true, Elf64Types::nobase, Elf64Types::nobase, 0 });
    2088     elfBinGen64->addProgramHeader({ PT_LOAD, PF_R, PHREGION_FILESTART,
    2089                     execProgHeaderRegionIndex,
    2090                     true, Elf64Types::nobase, Elf64Types::nobase, 0, 0x1000 });
    2091     elfBinGen64->addProgramHeader({ PT_LOAD, PF_R|PF_X, execProgHeaderRegionIndex, 1,
    2092                     true, Elf64Types::nobase, Elf64Types::nobase, 0 });
    2093     elfBinGen64->addProgramHeader({ PT_LOAD, PF_R|PF_W, execProgHeaderRegionIndex+1, 1,
    2094                     true, Elf64Types::nobase, Elf64Types::nobase, 0 });
    2095     elfBinGen64->addProgramHeader({ PT_DYNAMIC, PF_R|PF_W, execProgHeaderRegionIndex+1, 1,
    2096                     true, Elf64Types::nobase, Elf64Types::nobase, 0, 8 });
    2097     elfBinGen64->addProgramHeader({ PT_GNU_RELRO, PF_R, execProgHeaderRegionIndex+1, 1,
    2098                     true, Elf64Types::nobase, Elf64Types::nobase, 0, 1 });
    2099     elfBinGen64->addProgramHeader({ PT_GNU_STACK, PF_R|PF_W, PHREGION_FILESTART, 0,
    2100                     true, 0, 0, 0 });
    2101    
    2102     if (input->newBinFormat)
    2103         // program header for note (new binary format)
    2104         elfBinGen64->addProgramHeader({ PT_NOTE, PF_R, 1, 1, true,
    2105                     Elf64Types::nobase, Elf64Types::nobase, 0, 4 });
    2106    
    2107     target = input->target.c_str();
    2108     if (target.empty() && !input->targetTripple.empty())
    2109     {
    2110         target = input->targetTripple.c_str();
    2111         char dbuf[20];
    2112         snprintf(dbuf, 20, "-gfx%u%u%u", amdGpuArchValues.major, amdGpuArchValues.minor,
    2113                  amdGpuArchValues.stepping);
    2114         target += dbuf;
    2115     }
    2116     // elf notes
    2117     elfBinGen64->addNote({"AMD", sizeof noteDescType1, noteDescType1, 1U});
    2118     noteBuf.reset(new cxbyte[0x1b]);
    2119     ::memcpy(noteBuf.get(), noteDescType3, 0x1b);
    2120     SULEV(*(uint32_t*)(noteBuf.get()+4), amdGpuArchValues.major);
    2121     SULEV(*(uint32_t*)(noteBuf.get()+8), amdGpuArchValues.minor);
    2122     SULEV(*(uint32_t*)(noteBuf.get()+12), amdGpuArchValues.stepping);
    2123     elfBinGen64->addNote({"AMD", 0x1b, noteBuf.get(), 3U});
    2124     if (!target.empty())
    2125         elfBinGen64->addNote({"AMD", target.size(), (const cxbyte*)target.c_str(), 0xbU});
    2126    
    2127     metadataSize = input->metadataSize;
    2128     metadata = input->metadata;
    2129     if (input->useMetadataInfo)
    2130     {
    2131         // generate ROCm metadata
    2132         std::vector<std::pair<CString, size_t> > symbolIndices(input->symbols.size());
    2133         // create sorted indices of symbols by its name
    2134         for (size_t k = 0; k < input->symbols.size(); k++)
    2135             symbolIndices[k] = std::make_pair(input->symbols[k].symbolName, k);
    2136         mapSort(symbolIndices.begin(), symbolIndices.end());
    2137        
    2138         const size_t mdKernelsNum = input->metadataInfo.kernels.size();
    2139         std::unique_ptr<const ROCmKernelConfig*[]> kernelConfigPtrs(
    2140                 new const ROCmKernelConfig*[mdKernelsNum]);
    2141         // generate ROCm kernel config pointers
    2142         for (size_t k = 0; k < mdKernelsNum; k++)
    2143         {
    2144             auto it = binaryMapFind(symbolIndices.begin(), symbolIndices.end(),
    2145                         input->metadataInfo.kernels[k].name);
    2146             if (it == symbolIndices.end() ||
    2147                 (input->symbols[it->second].type != ROCmRegionType::FKERNEL &&
    2148                  input->symbols[it->second].type != ROCmRegionType::KERNEL))
    2149                 throw BinGenException("Kernel in metadata doesn't exists in code");
    2150             kernelConfigPtrs[k] = reinterpret_cast<const ROCmKernelConfig*>(
    2151                         input->code + input->symbols[it->second].offset);
    2152         }
    2153         // just generate ROCm metadata from info
    2154         generateROCmMetadata(input->metadataInfo, kernelConfigPtrs.get(), metadataStr);
    2155         metadataSize = metadataStr.size();
    2156         metadata = metadataStr.c_str();
    2157     }
    2158    
    2159     if (metadataSize != 0)
    2160         elfBinGen64->addNote({"AMD", metadataSize, (const cxbyte*)metadata, 0xaU});
    2161    
    2162     /// region and sections
    2163     elfBinGen64->addRegion(ElfRegion64::programHeaderTable());
    2164     if (input->newBinFormat)
    2165         elfBinGen64->addRegion(ElfRegion64::noteSection());
    2166     if (input->globalData != nullptr)
    2167         elfBinGen64->addRegion(ElfRegion64(input->globalDataSize, input->globalData, 4,
    2168                 ".rodata", SHT_PROGBITS, SHF_ALLOC, 0, 0, Elf64Types::nobase));
    2169    
    2170     elfBinGen64->addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 8,
    2171                 ".dynsym", SHT_DYNSYM, SHF_ALLOC, 0, BINGEN_DEFAULT, Elf64Types::nobase));
    2172     elfBinGen64->addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 4,
    2173                 ".hash", SHT_HASH, SHF_ALLOC,
    2174                 mainBuiltinSectTable[ELFSECTID_DYNSYM-ELFSECTID_START], 0,
    2175                 Elf64Types::nobase));
    2176     elfBinGen64->addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 1, ".dynstr", SHT_STRTAB,
    2177                 SHF_ALLOC, 0, 0, Elf64Types::nobase));
    2178     // '.text' with alignment=4096
    2179     elfBinGen64->addRegion(ElfRegion64(input->codeSize, (const cxbyte*)input->code,
    2180               0x1000, ".text", SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR, 0, 0,
    2181               Elf64Types::nobase, 0, false, 256));
    2182     elfBinGen64->addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 0x1000,
    2183                 ".dynamic", SHT_DYNAMIC, SHF_ALLOC|SHF_WRITE,
    2184                 mainBuiltinSectTable[ELFSECTID_DYNSTR-ELFSECTID_START], 0,
    2185                 Elf64Types::nobase, 0, false, 8));
    2186     if (!input->newBinFormat)
    2187     {
    2188         elfBinGen64->addRegion(ElfRegion64::noteSection());
    2189         elfBinGen64->addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 1,
    2190                     ".AMDGPU.config", SHT_PROGBITS, 0));
    2191     }
    2192     elfBinGen64->addRegion(ElfRegion64(commentSize, (const cxbyte*)comment, 1, ".comment",
    2193               SHT_PROGBITS, SHF_MERGE|SHF_STRINGS, 0, 0, 0, 1));
    2194     elfBinGen64->addRegion(ElfRegion64(0, (const cxbyte*)nullptr, 8,
    2195                 ".symtab", SHT_SYMTAB, 0, 0, BINGEN_DEFAULT));
    2196     elfBinGen64->addRegion(ElfRegion64::shstrtabSection());
    2197     elfBinGen64->addRegion(ElfRegion64::strtabSection());
    2198     elfBinGen64->addRegion(ElfRegion64::sectionHeaderTable());
    2199    
    2200     /* extra sections */
    2201     for (const BinSection& section: input->extraSections)
    2202         elfBinGen64->addRegion(ElfRegion64(section, mainBuiltinSectTable,
    2203                          ROCMSECTID_MAX, mainSectionsNum));
    22042211    /* extra symbols */
    22052212    for (const BinSymbol& symbol: input->extraSymbols)
     
    22102217        elfBinGen64->addDynSymbol(sym);
    22112218    }
    2212     binarySize = elfBinGen64->countSize();
    22132219}
    22142220
Note: See TracChangeset for help on using the changeset viewer.