source: CLRX/CLRadeonExtender/trunk/amdasm/AsmROCmFormat.cpp @ 2589

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

CLRadeonExtender: AsmROCm: Add setting of config values (majority). Create and use AsmROCmKernelConfig with additional fields.

File size: 30.6 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 <cstring>
22#include <string>
23#include <vector>
24#include <utility>
25#include <algorithm>
26#include <CLRX/utils/Utilities.h>
27#include <CLRX/amdasm/Assembler.h>
28#include "AsmInternals.h"
29
30using namespace CLRX;
31
32static const char* rocmPseudoOpNamesTbl[] =
33{
34    "call_convention", "codeversion", "config",
35    "control_directive", "debug_private_segment_buffer_sgpr",
36    "debug_wavefront_private_segment_offset_sgpr",
37    "debugmode", "dims", "dx10clamp",
38    "exceptions", "floatmode", "gds_segment_size",
39    "group_segment_align", "ieeemode", "kcode",
40    "kcodeend", "kernarg_segment_align",
41    "kernarg_segment_size", "kernel_code_entry_offset",
42    "kernel_code_prefetch_offset", "kernel_code_prefetch_size",
43    "localsize", "machine", "max_scratch_backing_memory",
44    "pgmrsrc1", "pgmrsrc2", "priority", "private_segment_align",
45    "privmode", "reserved_sgpr_count", "reserved_sgpr_first",
46    "reserved_vgpr_count", "reserved_vgpr_first",
47    "runtime_loader_kernel_symbol",
48    "scratchbuffer", "sgprsnum", "tgsize",
49    "use_debug_enabled", "use_dispatch_id",
50    "use_dispatch_ptr", "use_dynamic_call_stack",
51    "use_flat_scratch_init", "use_grid_workgroup_count",
52    "use_kernarg_segment_ptr", "use_ordered_append_gds",
53    "use_private_segment_size", "use_ptr64", "use_queue_ptr",
54    "use_private_segment_buffer", "use_xnack_enabled",
55    "userdatanum", "vgprsnum", "wavefront_sgpr_count",
56    "wavefront_size", "workitem_vgpr_count",
57    "workgroup_fbarrier_count", "workgroup_group_segment_size",
58    "workitem_private_segment_size"
59};
60
61enum
62{
63    ROCMOP_CALL_CONVENTION, ROCMOP_CODEVERSION, ROCMOP_CONFIG,
64    ROCMOP_CONTROL_DIRECTIVE, ROCMOP_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR,
65    ROCMOP_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR,
66    ROCMOP_DEBUGMODE, ROCMOP_DIMS, ROCMOP_DX10CLAMP,
67    ROCMOP_EXCEPTIONS, ROCMOP_FLOATMODE, ROCMOP_GDS_SEGMENT_SIZE,
68    ROCMOP_GROUP_SEGMENT_ALIGN, ROCMOP_IEEEMODE, ROCMOP_KCODE,
69    ROCMOP_KCODEEND, ROCMOP_KERNARG_SEGMENT_ALIGN,
70    ROCMOP_KERNARG_SEGMENT_SIZE, ROCMOP_KERNEL_CODE_ENTRY_OFFSET,
71    ROCMOP_KERNEL_CODE_PREFETCH_OFFSET, ROCMOP_KERNEL_CODE_PREFETCH_SIZE,
72    ROCMOP_LOCALSIZE, ROCMOP_MACHINE, ROCMOP_MAX_SCRATCH_BACKING_MEMORY,
73    ROCMOP_PGMRSRC1, ROCMOP_PGMRSRC2, ROCMOP_PRIORITY, ROCMOP_PRIVATE_SEGMENT_ALIGN,
74    ROCMOP_PRIVMODE, ROCMOP_RESERVED_SGPR_COUNT, ROCMOP_RESERVED_SGPR_FIRST,
75    ROCMOP_RESERVED_VGPR_COUNT, ROCMOP_RESERVED_VGPR_FIRST,
76    ROCMOP_RUNTIME_LOADER_KERNEL_SYMBOL,
77    ROCMOP_SCRATCHBUFFER, ROCMOP_SGPRSNUM, ROCMOP_TGSIZE,
78    ROCMOP_USE_DEBUG_ENABLED, ROCMOP_USE_DISPATCH_ID,
79    ROCMOP_USE_DISPATCH_PTR, ROCMOP_USE_DYNAMIC_CALL_STACK,
80    ROCMOP_USE_FLAT_SCRATCH_INIT, ROCMOP_USE_GRID_WORKGROUP_COUNT,
81    ROCMOP_USE_KERNARG_SEGMENT_PTR, ROCMOP_USE_ORDERED_APPEND_GDS,
82    ROCMOP_USE_PRIVATE_SEGMENT_SIZE, ROCMOP_USE_PTR64, ROCMOP_USE_QUEUE_PTR,
83    ROCMOP_USE_PRIVATE_SEGMENT_BUFFER, ROCMOP_USE_XNACK_ENABLED,
84    ROCMOP_USERDATANUM, ROCMOP_VGPRSNUM, ROCMOP_WAVEFRONT_SGPR_COUNT,
85    ROCMOP_WAVEFRONT_SIZE, ROCMOP_WORKITEM_VGPR_COUNT,
86    ROCMOP_WORKGROUP_FBARRIER_COUNT, ROCMOP_WORKGROUP_GROUP_SEGMENT_SIZE,
87    ROCMOP_WORKITEM_PRIVATE_SEGMENT_SIZE
88};
89
90/*
91 * ROCm format handler
92 */
93
94AsmROCmHandler::AsmROCmHandler(Assembler& assembler): AsmFormatHandler(assembler),
95             output{}, codeSection(0), commentSection(ASMSECT_NONE),
96             extraSectionCount(0)
97{
98    assembler.currentKernel = ASMKERN_GLOBAL;
99    assembler.currentSection = 0;
100    sections.push_back({ ASMKERN_GLOBAL, AsmSectionType::CODE,
101                ELFSECTID_TEXT, ".text" });
102    currentKcodeKernel = ASMKERN_GLOBAL;
103    savedSection = 0;
104}
105
106AsmROCmHandler::~AsmROCmHandler()
107{
108    for (Kernel* kernel: kernelStates)
109        delete kernel;
110}
111
112cxuint AsmROCmHandler::addKernel(const char* kernelName)
113{
114    cxuint thisKernel = output.symbols.size();
115    cxuint thisSection = sections.size();
116    output.addEmptyKernel(kernelName);
117    /// add kernel config section
118    sections.push_back({ thisKernel, AsmSectionType::CONFIG, ELFSECTID_UNDEF, nullptr });
119    kernelStates.push_back(new Kernel{ thisSection, nullptr, ASMSECT_NONE, thisSection });
120   
121    if (assembler.currentKernel == ASMKERN_GLOBAL)
122        savedSection = assembler.currentSection;
123   
124    assembler.currentKernel = thisKernel;
125    assembler.currentSection = thisSection;
126    return thisKernel;
127}
128
129cxuint AsmROCmHandler::addSection(const char* sectionName, cxuint kernelId)
130{
131    const cxuint thisSection = sections.size();
132    Section section;
133    section.kernelId = ASMKERN_GLOBAL;  // we ignore input kernelId, we go to main
134       
135    if (::strcmp(sectionName, ".text") == 0) // code
136    {
137        if (codeSection!=ASMSECT_NONE)
138            throw AsmFormatException("Only one section '.text' can be in binary");
139        codeSection = thisSection;
140        section.type = AsmSectionType::CODE;
141        section.elfBinSectId = ELFSECTID_TEXT;
142        section.name = ".text"; // set static name (available by whole lifecycle)
143    }
144    else if (::strcmp(sectionName, ".comment") == 0) // comment
145    {
146        if (commentSection!=ASMSECT_NONE)
147            throw AsmFormatException("Only one section '.comment' can be in binary");
148        commentSection = thisSection;
149        section.type = AsmSectionType::GALLIUM_COMMENT;
150        section.elfBinSectId = ELFSECTID_COMMENT;
151        section.name = ".comment"; // set static name (available by whole lifecycle)
152    }
153    else
154    {
155        auto out = extraSectionMap.insert(std::make_pair(CString(sectionName),
156                    thisSection));
157        if (!out.second)
158            throw AsmFormatException("Section already exists");
159        section.type = AsmSectionType::EXTRA_SECTION;
160        section.elfBinSectId = extraSectionCount++;
161        /// reference entry is available and unchangeable by whole lifecycle of section map
162        section.name = out.first->first.c_str();
163    }
164    sections.push_back(section);
165   
166    assembler.currentKernel = ASMKERN_GLOBAL;
167    assembler.currentSection = thisSection;
168    return thisSection;
169}
170
171cxuint AsmROCmHandler::getSectionId(const char* sectionName) const
172{
173    if (::strcmp(sectionName, ".text") == 0) // code
174        return codeSection;
175    else if (::strcmp(sectionName, ".comment") == 0) // comment
176        return commentSection;
177    else
178    {
179        SectionMap::const_iterator it = extraSectionMap.find(sectionName);
180        if (it != extraSectionMap.end())
181            return it->second;
182    }
183    return ASMSECT_NONE;
184}
185
186void AsmROCmHandler::setCurrentKernel(cxuint kernel)
187{
188    if (kernel != ASMKERN_GLOBAL && kernel >= kernelStates.size())
189        throw AsmFormatException("KernelId out of range");
190   
191    if (assembler.currentKernel == ASMKERN_GLOBAL)
192        savedSection = assembler.currentSection;
193    else // if kernel
194        kernelStates[assembler.currentKernel]->savedSection = assembler.currentSection;
195   
196    assembler.currentKernel = kernel;
197    if (kernel != ASMKERN_GLOBAL)
198        assembler.currentSection = kernelStates[kernel]->savedSection;
199    else // default main section
200        assembler.currentSection = savedSection;
201}
202
203void AsmROCmHandler::setCurrentSection(cxuint sectionId)
204{
205    if (sectionId >= sections.size())
206        throw AsmFormatException("SectionId out of range");
207   
208    if (assembler.currentKernel == ASMKERN_GLOBAL)
209        savedSection = assembler.currentSection;
210    else // if kernel
211        kernelStates[assembler.currentKernel]->savedSection = assembler.currentSection;
212   
213    assembler.currentSection = sectionId;
214    assembler.currentKernel = sections[sectionId].kernelId;
215}
216
217
218AsmFormatHandler::SectionInfo AsmROCmHandler::getSectionInfo(cxuint sectionId) const
219{
220    if (sectionId >= sections.size())
221        throw AsmFormatException("Section doesn't exists");
222   
223    AsmFormatHandler::SectionInfo info;
224    info.type = sections[sectionId].type;
225    info.flags = 0;
226    if (info.type == AsmSectionType::CODE)
227        info.flags = ASMSECT_ADDRESSABLE | ASMSECT_WRITEABLE;
228    else if (info.type != AsmSectionType::CONFIG)
229        info.flags = ASMSECT_ADDRESSABLE | ASMSECT_WRITEABLE | ASMSECT_ABS_ADDRESSABLE;
230   
231    info.name = sections[sectionId].name;
232    return info;
233}
234
235void AsmROCmHandler::restoreKcodeCurrentAllocRegs()
236{
237    if (currentKcodeKernel != ASMKERN_GLOBAL)
238    {
239        Kernel& newKernel = *kernelStates[currentKcodeKernel];
240        assembler.isaAssembler->setAllocatedRegisters(newKernel.allocRegs,
241                            newKernel.allocRegFlags);
242    }
243}
244
245void AsmROCmHandler::saveKcodeCurrentAllocRegs()
246{
247    if (currentKcodeKernel != ASMKERN_GLOBAL)
248    {   // save other state
249        size_t regTypesNum;
250        Kernel& oldKernel = *kernelStates[currentKcodeKernel];
251        const cxuint* regs = assembler.isaAssembler->getAllocatedRegisters(
252                            regTypesNum, oldKernel.allocRegFlags);
253        std::copy(regs, regs+2, oldKernel.allocRegs);
254    }
255}
256
257
258void AsmROCmHandler::handleLabel(const CString& label)
259{
260    if (assembler.sections[assembler.currentSection].type != AsmSectionType::CODE)
261        return;
262    auto kit = assembler.kernelMap.find(label);
263    if (kit == assembler.kernelMap.end())
264        return;
265    if (!kcodeSelection.empty())
266        return; // do not change if inside kcode
267    // save other state
268    saveKcodeCurrentAllocRegs();
269    // restore this state
270    currentKcodeKernel = kit->second;
271    restoreKcodeCurrentAllocRegs();
272}
273
274void AsmROCmHandler::Kernel::initializeKernelConfig()
275{
276    if (!config)
277    {
278        config.reset(new AsmROCmKernelConfig{});
279        ::memset(config.get(), 0, sizeof(AsmROCmKernelConfig));
280    }
281}
282
283namespace CLRX
284{
285
286bool AsmROCmPseudoOps::checkPseudoOpName(const CString& string)
287{
288    if (string.empty() || string[0] != '.')
289        return false;
290    const size_t pseudoOp = binaryFind(rocmPseudoOpNamesTbl, rocmPseudoOpNamesTbl +
291                sizeof(rocmPseudoOpNamesTbl)/sizeof(char*), string.c_str()+1,
292               CStringLess()) - rocmPseudoOpNamesTbl;
293    return pseudoOp < sizeof(rocmPseudoOpNamesTbl)/sizeof(char*);
294}
295   
296void AsmROCmPseudoOps::doConfig(AsmROCmHandler& handler, const char* pseudoOpPlace,
297                  const char* linePtr)
298{
299    Assembler& asmr = handler.assembler;
300    const char* end = asmr.line + asmr.lineSize;
301    if (asmr.currentKernel==ASMKERN_GLOBAL)
302    {
303        asmr.printError(pseudoOpPlace, "Kernel config can be defined only inside kernel");
304        return;
305    }
306   
307    if (handler.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
308    {
309        asmr.printError(pseudoOpPlace, "Configuration outside kernel definition");
310        return;
311    }
312    skipSpacesToEnd(linePtr, end);
313    if (!checkGarbagesAtEnd(asmr, linePtr))
314        return;
315    handler.kernelStates[asmr.currentKernel]->initializeKernelConfig();
316}
317
318void AsmROCmPseudoOps::doControlDirective(AsmROCmHandler& handler,
319              const char* pseudoOpPlace, const char* linePtr)
320{
321    Assembler& asmr = handler.assembler;
322    const char* end = asmr.line + asmr.lineSize;
323    if (asmr.currentKernel==ASMKERN_GLOBAL)
324    {
325        asmr.printError(pseudoOpPlace, "Kernel control directive can be defined "
326                    "only inside kernel");
327        return;
328    }
329    skipSpacesToEnd(linePtr, end);
330    if (!checkGarbagesAtEnd(asmr, linePtr))
331        return;
332   
333    AsmROCmHandler::Kernel& kernel = *handler.kernelStates[asmr.currentKernel];
334    if (kernel.ctrlDirSection == ASMSECT_NONE)
335    {
336        cxuint thisSection = handler.sections.size();
337        handler.sections.push_back({ asmr.currentKernel,
338            AsmSectionType::ROCM_CONFIG_CTRL_DIRECTIVE,
339            ELFSECTID_UNDEF, nullptr });
340        kernel.ctrlDirSection = thisSection;
341    }
342    asmr.goToSection(pseudoOpPlace, kernel.ctrlDirSection);
343    handler.kernelStates[asmr.currentKernel]->initializeKernelConfig();
344}
345
346void AsmROCmPseudoOps::setConfigValue(AsmROCmHandler& handler, const char* pseudoOpPlace,
347                  const char* linePtr, ROCmConfigValueTarget target)
348{
349    Assembler& asmr = handler.assembler;
350    const char* end = asmr.line + asmr.lineSize;
351   
352    if (asmr.currentKernel==ASMKERN_GLOBAL ||
353        asmr.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
354    {
355        asmr.printError(pseudoOpPlace, "Illegal place of configuration pseudo-op");
356        return;
357    }
358   
359    skipSpacesToEnd(linePtr, end);
360    const char* valuePlace = linePtr;
361    uint64_t value = BINGEN_NOTSUPPLIED;
362    bool good = getAbsoluteValueArg(asmr, value, linePtr, true);
363    /* ranges checking */
364    if (good)
365    {
366        switch(target)
367        {
368            case ROCMCVAL_SGPRSNUM:
369            {
370                const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
371                            asmr.deviceType);
372                cxuint maxSGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_SGPR, 0);
373                if (value > maxSGPRsNum)
374                {
375                    char buf[64];
376                    snprintf(buf, 64, "Used SGPRs number out of range (0-%u)", maxSGPRsNum);
377                    asmr.printError(valuePlace, buf);
378                    good = false;
379                }
380                break;
381            }
382            case ROCMCVAL_VGPRSNUM:
383            {
384                const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
385                            asmr.deviceType);
386                cxuint maxVGPRsNum = getGPUMaxRegistersNum(arch, REGTYPE_VGPR, 0);
387                if (value > maxVGPRsNum)
388                {
389                    char buf[64];
390                    snprintf(buf, 64, "Used VGPRs number out of range (0-%u)", maxVGPRsNum);
391                    asmr.printError(valuePlace, buf);
392                    good = false;
393                }
394                break;
395            }
396            case ROCMCVAL_EXCEPTIONS:
397                asmr.printWarningForRange(7, value,
398                                  asmr.getSourcePos(valuePlace), WS_UNSIGNED);
399                value &= 0x7f;
400                break;
401            case ROCMCVAL_FLOATMODE:
402                asmr.printWarningForRange(8, value,
403                                  asmr.getSourcePos(valuePlace), WS_UNSIGNED);
404                value &= 0xff;
405                break;
406            case ROCMCVAL_PRIORITY:
407                asmr.printWarningForRange(2, value,
408                                  asmr.getSourcePos(valuePlace), WS_UNSIGNED);
409                value &= 3;
410                break;
411            case ROCMCVAL_LOCALSIZE:
412            {
413                const GPUArchitecture arch = getGPUArchitectureFromDeviceType(
414                            asmr.deviceType);
415                const cxuint maxLocalSize = getGPUMaxLocalSize(arch);
416                if (value > maxLocalSize)
417                {
418                    char buf[64];
419                    snprintf(buf, 64, "LocalSize out of range (0-%u)", maxLocalSize);
420                    asmr.printError(valuePlace, buf);
421                    good = false;
422                }
423                break;
424            }
425            case ROCMCVAL_USERDATANUM:
426                if (value > 16)
427                {
428                    asmr.printError(valuePlace, "UserDataNum out of range (0-16)");
429                    good = false;
430                }
431                break;
432            default:
433                break;
434        }
435    }
436    if (!good || !checkGarbagesAtEnd(asmr, linePtr))
437        return;
438   
439    handler.kernelStates[asmr.currentKernel]->initializeKernelConfig();
440    AsmROCmKernelConfig& config = *(handler.kernelStates[asmr.currentKernel]->config);
441    // set value
442    switch(target)
443    {
444        case ROCMCVAL_SGPRSNUM:
445            config.usedSGPRsNum = value;
446            break;
447        case ROCMCVAL_VGPRSNUM:
448            config.usedVGPRsNum = value;
449            break;
450        case ROCMCVAL_PGMRSRC1:
451            config.computePgmRsrc1 = value;
452            break;
453        case ROCMCVAL_PGMRSRC2:
454            config.computePgmRsrc2 = value;
455            break;
456        case ROCMCVAL_FLOATMODE:
457            config.floatMode = value;
458            break;
459        case ROCMCVAL_LOCALSIZE:
460            config.localSize = value;
461            break;
462        case ROCMCVAL_SCRATCHBUFFER:
463            config.scratchBufferSize = value;
464            break;
465        case ROCMCVAL_PRIORITY:
466            config.priority = value;
467            break;
468        case ROCMCVAL_USERDATANUM:
469            config.userDataNum = value;
470            break;
471        case ROCMCVAL_EXCEPTIONS:
472            config.exceptions = value;
473            break;
474        case ROCMCVAL_KERNEL_CODE_ENTRY_OFFSET:
475            config.kernelCodeEntryOffset = value;
476            break;
477        case ROCMCVAL_KERNEL_CODE_PREFETCH_OFFSET:
478            config.kernelCodePrefetchOffset = value;
479            break;
480        case ROCMCVAL_KERNEL_CODE_PREFETCH_SIZE:
481            config.kernelCodePrefetchSize = value;
482            break;
483        case ROCMCVAL_MAX_SCRATCH_BACKING_MEMORY:
484            config.maxScrachBackingMemorySize = value;
485            break;
486        case ROCMCVAL_WORKITEM_PRIVATE_SEGMENT_SIZE:
487            config.workitemPrivateSegmentSize = value;
488            break;
489        case ROCMCVAL_WORKGROUP_GROUP_SEGMENT_SIZE:
490            config.workgroupGroupSegmentSize = value;
491            break;
492        case ROCMCVAL_GDS_SEGMENT_SIZE:
493            config.gdsSegmentSize = value;
494            break;
495        case ROCMCVAL_KERNARG_SEGMENT_SIZE:
496            config.kernargSegmentSize = value;
497            break;
498        case ROCMCVAL_WORKGROUP_FBARRIER_COUNT:
499            config.workgroupFbarrierCount = value;
500            break;
501        case ROCMCVAL_WAVEFRONT_SGPR_COUNT:
502            config.wavefrontSgprCount = value;
503            break;
504        case ROCMCVAL_WORKITEM_VGPR_COUNT:
505            config.workitemVgprCount = value;
506            break;
507        case ROCMCVAL_RESERVED_VGPR_FIRST:
508            config.reservedVgprFirst = value;
509            break;
510        case ROCMCVAL_RESERVED_VGPR_COUNT:
511            config.reservedVgprCount = value;
512            break;
513        case ROCMCVAL_RESERVED_SGPR_FIRST:
514            config.reservedSgprFirst = value;
515            break;
516        case ROCMCVAL_RESERVED_SGPR_COUNT:
517            config.reservedSgprCount = value;
518            break;
519        case ROCMCVAL_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR:
520            config.debugWavefrontPrivateSegmentOffsetSgpr = value;
521            break;
522        case ROCMCVAL_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR:
523            config.debugPrivateSegmentBufferSgpr = value;
524            break;
525        case ROCMCVAL_KERNARG_SEGMENT_ALIGN:
526            config.kernargSegmentAlignment = value;
527            break;
528        case ROCMCVAL_GROUP_SEGMENT_ALIGN:
529            config.groupSegmentAlignment = value;
530            break;
531        case ROCMCVAL_PRIVATE_SEGMENT_ALIGN:
532            config.privateSegmentAlignment = value;
533            break;
534        case ROCMCVAL_WAVEFRONT_SIZE:
535            config.wavefrontSize = value;
536            break;
537        case ROCMCVAL_CALL_CONVENTION:
538            config.callConvention = value;
539            break;
540        case ROCMCVAL_RUNTIME_LOADER_KERNEL_SYMBOL:
541            config.runtimeLoaderKernelSymbol = value;
542            break;
543        default:
544            break;
545    }
546}
547
548void AsmROCmPseudoOps::setConfigBoolValue(AsmROCmHandler& handler,
549          const char* pseudoOpPlace, const char* linePtr, ROCmConfigValueTarget target)
550{
551}
552
553void AsmROCmPseudoOps::setDimensions(AsmROCmHandler& handler, const char* pseudoOpPlace,
554                  const char* linePtr)
555{
556}
557
558void AsmROCmPseudoOps::doKCode(AsmROCmHandler& handler, const char* pseudoOpPlace,
559                  const char* linePtr)
560{
561}
562
563void AsmROCmPseudoOps::doKCodeEnd(AsmROCmHandler& handler, const char* pseudoOpPlace,
564                  const char* linePtr)
565{
566}
567
568void AsmROCmPseudoOps::updateKCodeSel(AsmROCmHandler& handler,
569                  const std::vector<cxuint>& oldset)
570{
571}
572
573}
574
575bool AsmROCmHandler::parsePseudoOp(const CString& firstName, const char* stmtPlace,
576               const char* linePtr)
577{
578    const size_t pseudoOp = binaryFind(rocmPseudoOpNamesTbl, rocmPseudoOpNamesTbl +
579                    sizeof(rocmPseudoOpNamesTbl)/sizeof(char*), firstName.c_str()+1,
580                   CStringLess()) - rocmPseudoOpNamesTbl;
581   
582    switch(pseudoOp)
583    {
584        case ROCMOP_CALL_CONVENTION:
585            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
586                             ROCMCVAL_CALL_CONVENTION);
587            break;
588        case ROCMOP_CODEVERSION:
589            break;
590        case ROCMOP_CONFIG:
591            break;
592        case ROCMOP_CONTROL_DIRECTIVE:
593            break;
594        case ROCMOP_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR:
595            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
596                             ROCMCVAL_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR);
597            break;
598        case ROCMOP_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR:
599            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
600                         ROCMCVAL_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR);
601            break;
602        case ROCMOP_DEBUGMODE:
603            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
604                             ROCMCVAL_DEBUGMODE);
605            break;
606        case ROCMOP_DIMS:
607            break;
608        case ROCMOP_DX10CLAMP:
609            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
610                             ROCMCVAL_DX10CLAMP);
611            break;
612        case ROCMOP_EXCEPTIONS:
613            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
614                             ROCMCVAL_EXCEPTIONS);
615            break;
616        case ROCMOP_FLOATMODE:
617            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
618                             ROCMCVAL_FLOATMODE);
619            break;
620        case ROCMOP_GDS_SEGMENT_SIZE:
621            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
622                             ROCMCVAL_GDS_SEGMENT_SIZE);
623            break;
624        case ROCMOP_GROUP_SEGMENT_ALIGN:
625            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
626                             ROCMCVAL_GROUP_SEGMENT_ALIGN);
627            break;
628        case ROCMOP_IEEEMODE:
629            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
630                             ROCMCVAL_IEEEMODE);
631            break;
632        case ROCMOP_KCODE:
633            break;
634        case ROCMOP_KCODEEND:
635            break;
636        case ROCMOP_KERNARG_SEGMENT_ALIGN:
637            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
638                             ROCMCVAL_KERNARG_SEGMENT_ALIGN);
639            break;
640        case ROCMOP_KERNARG_SEGMENT_SIZE:
641            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
642                             ROCMCVAL_KERNARG_SEGMENT_SIZE);
643            break;
644        case ROCMOP_KERNEL_CODE_ENTRY_OFFSET:
645            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
646                             ROCMCVAL_KERNEL_CODE_ENTRY_OFFSET);
647            break;
648        case ROCMOP_KERNEL_CODE_PREFETCH_OFFSET:
649            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
650                             ROCMCVAL_KERNEL_CODE_PREFETCH_OFFSET);
651            break;
652        case ROCMOP_KERNEL_CODE_PREFETCH_SIZE:
653            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
654                             ROCMCVAL_KERNEL_CODE_PREFETCH_SIZE);
655            break;
656        case ROCMOP_LOCALSIZE:
657            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
658                             ROCMCVAL_LOCALSIZE);
659            break;
660        case ROCMOP_MACHINE:
661            break;
662        case ROCMOP_MAX_SCRATCH_BACKING_MEMORY:
663            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
664                             ROCMCVAL_MAX_SCRATCH_BACKING_MEMORY);
665            break;
666        case ROCMOP_PGMRSRC1:
667            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr, ROCMCVAL_PGMRSRC1);
668            break;
669        case ROCMOP_PGMRSRC2:
670            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr, ROCMCVAL_PGMRSRC2);
671            break;
672        case ROCMOP_PRIORITY:
673            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr, ROCMCVAL_PRIORITY);
674            break;
675        case ROCMOP_PRIVATE_SEGMENT_ALIGN:
676            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
677                             ROCMCVAL_PRIVATE_SEGMENT_ALIGN);
678            break;
679        case ROCMOP_PRIVMODE:
680            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
681                             ROCMCVAL_PRIVMODE);
682            break;
683        case ROCMOP_RESERVED_SGPR_COUNT:
684            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
685                             ROCMCVAL_RESERVED_SGPR_COUNT);
686            break;
687        case ROCMOP_RESERVED_SGPR_FIRST:
688            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
689                             ROCMCVAL_RESERVED_SGPR_FIRST);
690            break;
691        case ROCMOP_RESERVED_VGPR_COUNT:
692            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
693                             ROCMCVAL_RESERVED_VGPR_COUNT);
694            break;
695        case ROCMOP_RESERVED_VGPR_FIRST:
696            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
697                             ROCMCVAL_RESERVED_VGPR_FIRST);
698            break;
699        case ROCMOP_RUNTIME_LOADER_KERNEL_SYMBOL:
700            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
701                             ROCMCVAL_RUNTIME_LOADER_KERNEL_SYMBOL);
702            break;
703        case ROCMOP_SCRATCHBUFFER:
704            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
705                             ROCMCVAL_SCRATCHBUFFER);
706            break;
707        case ROCMOP_SGPRSNUM:
708            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
709                             ROCMCVAL_SGPRSNUM);
710            break;
711        case ROCMOP_TGSIZE:
712            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
713                             ROCMCVAL_TGSIZE);
714            break;
715        case ROCMOP_USE_DEBUG_ENABLED:
716            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
717                             ROCMCVAL_USE_DEBUG_ENABLED);
718            break;
719        case ROCMOP_USE_DISPATCH_ID:
720            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
721                             ROCMCVAL_USE_DISPATCH_ID);
722            break;
723        case ROCMOP_USE_DISPATCH_PTR:
724            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
725                             ROCMCVAL_USE_DISPATCH_PTR);
726            break;
727        case ROCMOP_USE_DYNAMIC_CALL_STACK:
728            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
729                             ROCMCVAL_USE_DYNAMIC_CALL_STACK);
730            break;
731        case ROCMOP_USE_FLAT_SCRATCH_INIT:
732            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
733                             ROCMCVAL_USE_FLAT_SCRATCH_INIT);
734            break;
735        case ROCMOP_USE_GRID_WORKGROUP_COUNT:
736            break;
737        case ROCMOP_USE_KERNARG_SEGMENT_PTR:
738            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
739                             ROCMCVAL_USE_KERNARG_SEGMENT_PTR);
740            break;
741        case ROCMOP_USE_ORDERED_APPEND_GDS:
742            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
743                             ROCMCVAL_USE_ORDERED_APPEND_GDS);
744            break;
745        case ROCMOP_USE_PRIVATE_SEGMENT_SIZE:
746            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
747                             ROCMCVAL_USE_PRIVATE_SEGMENT_SIZE);
748            break;
749        case ROCMOP_USE_PTR64:
750            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
751                             ROCMCVAL_USE_PTR64);
752            break;
753        case ROCMOP_USE_QUEUE_PTR:
754            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
755                             ROCMCVAL_USE_QUEUE_PTR);
756            break;
757        case ROCMOP_USE_PRIVATE_SEGMENT_BUFFER:
758            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
759                             ROCMCVAL_USE_PRIVATE_SEGMENT_BUFFER);
760            break;
761        case ROCMOP_USE_XNACK_ENABLED:
762            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
763                             ROCMCVAL_USE_XNACK_ENABLED);
764            break;
765        case ROCMOP_USERDATANUM:
766            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
767                             ROCMCVAL_USERDATANUM);
768            break;
769        case ROCMOP_VGPRSNUM:
770            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr, ROCMCVAL_VGPRSNUM);
771            break;
772        case ROCMOP_WAVEFRONT_SGPR_COUNT:
773            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
774                             ROCMCVAL_WAVEFRONT_SGPR_COUNT);
775            break;
776        case ROCMOP_WAVEFRONT_SIZE:
777            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
778                             ROCMCVAL_WAVEFRONT_SIZE);
779            break;
780        case ROCMOP_WORKITEM_VGPR_COUNT:
781            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
782                             ROCMCVAL_WORKITEM_VGPR_COUNT);
783            break;
784        case ROCMOP_WORKGROUP_FBARRIER_COUNT:
785            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
786                             ROCMCVAL_WORKGROUP_FBARRIER_COUNT);
787            break;
788        case ROCMOP_WORKGROUP_GROUP_SEGMENT_SIZE:
789            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
790                             ROCMCVAL_WORKGROUP_GROUP_SEGMENT_SIZE);
791            break;
792        case ROCMOP_WORKITEM_PRIVATE_SEGMENT_SIZE:
793            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
794                             ROCMCVAL_WORKITEM_PRIVATE_SEGMENT_SIZE);
795            break;
796        default:
797            return false;
798    }
799    return true;
800}
801
802bool AsmROCmHandler::prepareBinary()
803{
804    return false;
805}
806
807void AsmROCmHandler::writeBinary(std::ostream& os) const
808{
809}
810
811void AsmROCmHandler::writeBinary(Array<cxbyte>& array) const
812{
813}
Note: See TracBrowser for help on using the repository browser.