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

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

CLRadeonExtender: AsmROCm: Update.

File size: 23.4 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
106cxuint AsmROCmHandler::addKernel(const char* kernelName)
107{
108    cxuint thisKernel = output.symbols.size();
109    cxuint thisSection = sections.size();
110    output.addEmptyKernel(kernelName);
111    /// add kernel config section
112    sections.push_back({ thisKernel, AsmSectionType::CONFIG, ELFSECTID_UNDEF, nullptr });
113    kernelStates.push_back({ thisSection, nullptr, ASMSECT_NONE, thisSection });
114   
115    if (assembler.currentKernel == ASMKERN_GLOBAL)
116        savedSection = assembler.currentSection;
117   
118    assembler.currentKernel = thisKernel;
119    assembler.currentSection = thisSection;
120    return thisKernel;
121}
122
123cxuint AsmROCmHandler::addSection(const char* sectionName, cxuint kernelId)
124{
125    const cxuint thisSection = sections.size();
126    Section section;
127    section.kernelId = ASMKERN_GLOBAL;  // we ignore input kernelId, we go to main
128       
129    if (::strcmp(sectionName, ".text") == 0) // code
130    {
131        if (codeSection!=ASMSECT_NONE)
132            throw AsmFormatException("Only one section '.text' can be in binary");
133        codeSection = thisSection;
134        section.type = AsmSectionType::CODE;
135        section.elfBinSectId = ELFSECTID_TEXT;
136        section.name = ".text"; // set static name (available by whole lifecycle)
137    }
138    else if (::strcmp(sectionName, ".comment") == 0) // comment
139    {
140        if (commentSection!=ASMSECT_NONE)
141            throw AsmFormatException("Only one section '.comment' can be in binary");
142        commentSection = thisSection;
143        section.type = AsmSectionType::GALLIUM_COMMENT;
144        section.elfBinSectId = ELFSECTID_COMMENT;
145        section.name = ".comment"; // set static name (available by whole lifecycle)
146    }
147    else
148    {
149        auto out = extraSectionMap.insert(std::make_pair(CString(sectionName),
150                    thisSection));
151        if (!out.second)
152            throw AsmFormatException("Section already exists");
153        section.type = AsmSectionType::EXTRA_SECTION;
154        section.elfBinSectId = extraSectionCount++;
155        /// reference entry is available and unchangeable by whole lifecycle of section map
156        section.name = out.first->first.c_str();
157    }
158    sections.push_back(section);
159   
160    assembler.currentKernel = ASMKERN_GLOBAL;
161    assembler.currentSection = thisSection;
162    return thisSection;
163}
164
165cxuint AsmROCmHandler::getSectionId(const char* sectionName) const
166{
167    if (::strcmp(sectionName, ".text") == 0) // code
168        return codeSection;
169    else if (::strcmp(sectionName, ".comment") == 0) // comment
170        return commentSection;
171    else
172    {
173        SectionMap::const_iterator it = extraSectionMap.find(sectionName);
174        if (it != extraSectionMap.end())
175            return it->second;
176    }
177    return ASMSECT_NONE;
178}
179
180void AsmROCmHandler::setCurrentKernel(cxuint kernel)
181{
182    if (kernel != ASMKERN_GLOBAL && kernel >= kernelStates.size())
183        throw AsmFormatException("KernelId out of range");
184   
185    if (assembler.currentKernel == ASMKERN_GLOBAL)
186        savedSection = assembler.currentSection;
187    else // if kernel
188        kernelStates[assembler.currentKernel].savedSection = assembler.currentSection;
189   
190    assembler.currentKernel = kernel;
191    if (kernel != ASMKERN_GLOBAL)
192        assembler.currentSection = kernelStates[kernel].savedSection;
193    else // default main section
194        assembler.currentSection = savedSection;
195}
196
197void AsmROCmHandler::setCurrentSection(cxuint sectionId)
198{
199    if (sectionId >= sections.size())
200        throw AsmFormatException("SectionId out of range");
201   
202    if (assembler.currentKernel == ASMKERN_GLOBAL)
203        savedSection = assembler.currentSection;
204    else // if kernel
205        kernelStates[assembler.currentKernel].savedSection = assembler.currentSection;
206   
207    assembler.currentSection = sectionId;
208    assembler.currentKernel = sections[sectionId].kernelId;
209}
210
211
212AsmFormatHandler::SectionInfo AsmROCmHandler::getSectionInfo(cxuint sectionId) const
213{
214    if (sectionId >= sections.size())
215        throw AsmFormatException("Section doesn't exists");
216   
217    AsmFormatHandler::SectionInfo info;
218    info.type = sections[sectionId].type;
219    info.flags = 0;
220    if (info.type == AsmSectionType::CODE)
221        info.flags = ASMSECT_ADDRESSABLE | ASMSECT_WRITEABLE;
222    else if (info.type != AsmSectionType::CONFIG)
223        info.flags = ASMSECT_ADDRESSABLE | ASMSECT_WRITEABLE | ASMSECT_ABS_ADDRESSABLE;
224   
225    info.name = sections[sectionId].name;
226    return info;
227}
228
229void AsmROCmHandler::restoreKcodeCurrentAllocRegs()
230{
231    if (currentKcodeKernel != ASMKERN_GLOBAL)
232    {
233        Kernel& newKernel = kernelStates[currentKcodeKernel];
234        assembler.isaAssembler->setAllocatedRegisters(newKernel.allocRegs,
235                            newKernel.allocRegFlags);
236    }
237}
238
239void AsmROCmHandler::saveKcodeCurrentAllocRegs()
240{
241    if (currentKcodeKernel != ASMKERN_GLOBAL)
242    {   // save other state
243        size_t regTypesNum;
244        Kernel& oldKernel = kernelStates[currentKcodeKernel];
245        const cxuint* regs = assembler.isaAssembler->getAllocatedRegisters(
246                            regTypesNum, oldKernel.allocRegFlags);
247        std::copy(regs, regs+2, oldKernel.allocRegs);
248    }
249}
250
251
252void AsmROCmHandler::handleLabel(const CString& label)
253{
254    if (assembler.sections[assembler.currentSection].type != AsmSectionType::CODE)
255        return;
256    auto kit = assembler.kernelMap.find(label);
257    if (kit == assembler.kernelMap.end())
258        return;
259    if (!kcodeSelection.empty())
260        return; // do not change if inside kcode
261    // save other state
262    saveKcodeCurrentAllocRegs();
263    // restore this state
264    currentKcodeKernel = kit->second;
265    restoreKcodeCurrentAllocRegs();
266}
267
268void AsmROCmHandler::Kernel::initializeKernelConfig()
269{
270    if (!config)
271    {
272        config.reset(new ROCmKernelConfig{});
273        ::memset(config.get(), 0, sizeof(ROCmKernelConfig));
274    }
275}
276
277namespace CLRX
278{
279
280bool AsmROCmPseudoOps::checkPseudoOpName(const CString& string)
281{
282    if (string.empty() || string[0] != '.')
283        return false;
284    const size_t pseudoOp = binaryFind(rocmPseudoOpNamesTbl, rocmPseudoOpNamesTbl +
285                sizeof(rocmPseudoOpNamesTbl)/sizeof(char*), string.c_str()+1,
286               CStringLess()) - rocmPseudoOpNamesTbl;
287    return pseudoOp < sizeof(rocmPseudoOpNamesTbl)/sizeof(char*);
288}
289   
290void AsmROCmPseudoOps::doConfig(AsmROCmHandler& handler, const char* pseudoOpPlace,
291                  const char* linePtr)
292{
293    Assembler& asmr = handler.assembler;
294    const char* end = asmr.line + asmr.lineSize;
295    if (asmr.currentKernel==ASMKERN_GLOBAL)
296    {
297        asmr.printError(pseudoOpPlace, "Kernel config can be defined only inside kernel");
298        return;
299    }
300   
301    if (handler.sections[asmr.currentSection].type != AsmSectionType::CONFIG)
302    {
303        asmr.printError(pseudoOpPlace, "Configuration outside kernel definition");
304        return;
305    }
306    skipSpacesToEnd(linePtr, end);
307    if (!checkGarbagesAtEnd(asmr, linePtr))
308        return;
309    handler.kernelStates[asmr.currentKernel].initializeKernelConfig();
310}
311
312void AsmROCmPseudoOps::doControlDirective(AsmROCmHandler& handler,
313              const char* pseudoOpPlace, const char* linePtr)
314{
315    Assembler& asmr = handler.assembler;
316    const char* end = asmr.line + asmr.lineSize;
317    if (asmr.currentKernel==ASMKERN_GLOBAL)
318    {
319        asmr.printError(pseudoOpPlace, "Kernel control directive can be defined "
320                    "only inside kernel");
321        return;
322    }
323    skipSpacesToEnd(linePtr, end);
324    if (!checkGarbagesAtEnd(asmr, linePtr))
325        return;
326   
327    AsmROCmHandler::Kernel& kernel = handler.kernelStates[asmr.currentKernel];
328    if (kernel.ctrlDirSection == ASMSECT_NONE)
329    {
330        cxuint thisSection = handler.sections.size();
331        handler.sections.push_back({ asmr.currentKernel,
332            AsmSectionType::ROCM_CONFIG_CTRL_DIRECTIVE,
333            ELFSECTID_UNDEF, nullptr });
334        kernel.ctrlDirSection = thisSection;
335    }
336    asmr.goToSection(pseudoOpPlace, kernel.ctrlDirSection);
337    handler.kernelStates[asmr.currentKernel].initializeKernelConfig();
338}
339
340void AsmROCmPseudoOps::setConfigValue(AsmROCmHandler& handler, const char* pseudoOpPlace,
341                  const char* linePtr, ROCmConfigValueTarget target)
342{
343}
344
345void AsmROCmPseudoOps::setConfigBoolValue(AsmROCmHandler& handler,
346          const char* pseudoOpPlace, const char* linePtr, ROCmConfigValueTarget target)
347{
348}
349
350void AsmROCmPseudoOps::setDimensions(AsmROCmHandler& handler, const char* pseudoOpPlace,
351                  const char* linePtr)
352{
353}
354
355void AsmROCmPseudoOps::doKCode(AsmROCmHandler& handler, const char* pseudoOpPlace,
356                  const char* linePtr)
357{
358}
359
360void AsmROCmPseudoOps::doKCodeEnd(AsmROCmHandler& handler, const char* pseudoOpPlace,
361                  const char* linePtr)
362{
363}
364
365void AsmROCmPseudoOps::updateKCodeSel(AsmROCmHandler& handler,
366                  const std::vector<cxuint>& oldset)
367{
368}
369
370}
371
372bool AsmROCmHandler::parsePseudoOp(const CString& firstName, const char* stmtPlace,
373               const char* linePtr)
374{
375    const size_t pseudoOp = binaryFind(rocmPseudoOpNamesTbl, rocmPseudoOpNamesTbl +
376                    sizeof(rocmPseudoOpNamesTbl)/sizeof(char*), firstName.c_str()+1,
377                   CStringLess()) - rocmPseudoOpNamesTbl;
378   
379    switch(pseudoOp)
380    {
381        case ROCMOP_CALL_CONVENTION:
382            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
383                             ROCMCVAL_CALL_CONVENTION);
384            break;
385        case ROCMOP_CODEVERSION:
386            break;
387        case ROCMOP_CONFIG:
388            break;
389        case ROCMOP_CONTROL_DIRECTIVE:
390            break;
391        case ROCMOP_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR:
392            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
393                             ROCMCVAL_DEBUG_PRIVATE_SEGMENT_BUFFER_SGPR);
394            break;
395        case ROCMOP_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR:
396            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
397                         ROCMCVAL_DEBUG_WAVEFRONT_PRIVATE_SEGMENT_OFFSET_SGPR);
398            break;
399        case ROCMOP_DEBUGMODE:
400            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
401                             ROCMCVAL_DEBUGMODE);
402            break;
403        case ROCMOP_DIMS:
404            break;
405        case ROCMOP_DX10CLAMP:
406            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
407                             ROCMCVAL_DX10CLAMP);
408            break;
409        case ROCMOP_EXCEPTIONS:
410            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
411                             ROCMCVAL_EXCEPTIONS);
412            break;
413        case ROCMOP_FLOATMODE:
414            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
415                             ROCMCVAL_FLOATMODE);
416            break;
417        case ROCMOP_GDS_SEGMENT_SIZE:
418            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
419                             ROCMCVAL_GDS_SEGMENT_SIZE);
420            break;
421        case ROCMOP_GROUP_SEGMENT_ALIGN:
422            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
423                             ROCMCVAL_GROUP_SEGMENT_ALIGN);
424            break;
425        case ROCMOP_IEEEMODE:
426            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
427                             ROCMCVAL_IEEEMODE);
428            break;
429        case ROCMOP_KCODE:
430            break;
431        case ROCMOP_KCODEEND:
432            break;
433        case ROCMOP_KERNARG_SEGMENT_ALIGN:
434            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
435                             ROCMCVAL_KERNARG_SEGMENT_ALIGN);
436            break;
437        case ROCMOP_KERNARG_SEGMENT_SIZE:
438            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
439                             ROCMCVAL_KERNARG_SEGMENT_SIZE);
440            break;
441        case ROCMOP_KERNEL_CODE_ENTRY_OFFSET:
442            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
443                             ROCMCVAL_KERNEL_CODE_ENTRY_OFFSET);
444            break;
445        case ROCMOP_KERNEL_CODE_PREFETCH_OFFSET:
446            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
447                             ROCMCVAL_KERNEL_CODE_PREFETCH_OFFSET);
448            break;
449        case ROCMOP_KERNEL_CODE_PREFETCH_SIZE:
450            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
451                             ROCMCVAL_KERNEL_CODE_PREFETCH_SIZE);
452            break;
453        case ROCMOP_LOCALSIZE:
454            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
455                             ROCMCVAL_LOCALSIZE);
456            break;
457        case ROCMOP_MACHINE:
458            break;
459        case ROCMOP_MAX_SCRATCH_BACKING_MEMORY:
460            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
461                             ROCMCVAL_MAX_SCRATCH_BACKING_MEMORY);
462            break;
463        case ROCMOP_PGMRSRC1:
464            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr, ROCMCVAL_PGMRSRC1);
465            break;
466        case ROCMOP_PGMRSRC2:
467            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr, ROCMCVAL_PGMRSRC2);
468            break;
469        case ROCMOP_PRIORITY:
470            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr, ROCMCVAL_PRIORITY);
471            break;
472        case ROCMOP_PRIVATE_SEGMENT_ALIGN:
473            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
474                             ROCMCVAL_PRIVATE_SEGMENT_ALIGN);
475            break;
476        case ROCMOP_PRIVMODE:
477            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
478                             ROCMCVAL_PRIVMODE);
479            break;
480        case ROCMOP_RESERVED_SGPR_COUNT:
481            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
482                             ROCMCVAL_RESERVED_SGPR_COUNT);
483            break;
484        case ROCMOP_RESERVED_SGPR_FIRST:
485            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
486                             ROCMCVAL_RESERVED_SGPR_FIRST);
487            break;
488        case ROCMOP_RESERVED_VGPR_COUNT:
489            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
490                             ROCMCVAL_RESERVED_VGPR_COUNT);
491            break;
492        case ROCMOP_RESERVED_VGPR_FIRST:
493            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
494                             ROCMCVAL_RESERVED_VGPR_FIRST);
495            break;
496        case ROCMOP_RUNTIME_LOADER_KERNEL_SYMBOL:
497            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
498                             ROCMCVAL_RUNTIME_LOADER_KERNEL_SYMBOL);
499            break;
500        case ROCMOP_SCRATCHBUFFER:
501            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
502                             ROCMCVAL_SCRATCHBUFFER);
503            break;
504        case ROCMOP_SGPRSNUM:
505            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
506                             ROCMCVAL_SGPRSNUM);
507            break;
508        case ROCMOP_TGSIZE:
509            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
510                             ROCMCVAL_TGSIZE);
511            break;
512        case ROCMOP_USE_DEBUG_ENABLED:
513            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
514                             ROCMCVAL_USE_DEBUG_ENABLED);
515            break;
516        case ROCMOP_USE_DISPATCH_ID:
517            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
518                             ROCMCVAL_USE_DISPATCH_ID);
519            break;
520        case ROCMOP_USE_DISPATCH_PTR:
521            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
522                             ROCMCVAL_USE_DISPATCH_PTR);
523            break;
524        case ROCMOP_USE_DYNAMIC_CALL_STACK:
525            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
526                             ROCMCVAL_USE_DYNAMIC_CALL_STACK);
527            break;
528        case ROCMOP_USE_FLAT_SCRATCH_INIT:
529            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
530                             ROCMCVAL_USE_FLAT_SCRATCH_INIT);
531            break;
532        case ROCMOP_USE_GRID_WORKGROUP_COUNT:
533            break;
534        case ROCMOP_USE_KERNARG_SEGMENT_PTR:
535            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
536                             ROCMCVAL_USE_KERNARG_SEGMENT_PTR);
537            break;
538        case ROCMOP_USE_ORDERED_APPEND_GDS:
539            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
540                             ROCMCVAL_USE_ORDERED_APPEND_GDS);
541            break;
542        case ROCMOP_USE_PRIVATE_SEGMENT_SIZE:
543            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
544                             ROCMCVAL_USE_PRIVATE_SEGMENT_SIZE);
545            break;
546        case ROCMOP_USE_PTR64:
547            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
548                             ROCMCVAL_USE_PTR64);
549            break;
550        case ROCMOP_USE_QUEUE_PTR:
551            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
552                             ROCMCVAL_USE_QUEUE_PTR);
553            break;
554        case ROCMOP_USE_PRIVATE_SEGMENT_BUFFER:
555            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
556                             ROCMCVAL_USE_PRIVATE_SEGMENT_BUFFER);
557            break;
558        case ROCMOP_USE_XNACK_ENABLED:
559            AsmROCmPseudoOps::setConfigBoolValue(*this, stmtPlace, linePtr,
560                             ROCMCVAL_USE_XNACK_ENABLED);
561            break;
562        case ROCMOP_USERDATANUM:
563            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
564                             ROCMCVAL_USERDATANUM);
565            break;
566        case ROCMOP_VGPRSNUM:
567            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr, ROCMCVAL_VGPRSNUM);
568            break;
569        case ROCMOP_WAVEFRONT_SGPR_COUNT:
570            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
571                             ROCMCVAL_WAVEFRONT_SGPR_COUNT);
572            break;
573        case ROCMOP_WAVEFRONT_SIZE:
574            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
575                             ROCMCVAL_WAVEFRONT_SIZE);
576            break;
577        case ROCMOP_WORKITEM_VGPR_COUNT:
578            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
579                             ROCMCVAL_WORKITEM_VGPR_COUNT);
580            break;
581        case ROCMOP_WORKGROUP_FBARRIER_COUNT:
582            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
583                             ROCMCVAL_WORKGROUP_FBARRIER_COUNT);
584            break;
585        case ROCMOP_WORKGROUP_GROUP_SEGMENT_SIZE:
586            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
587                             ROCMCVAL_WORKGROUP_GROUP_SEGMENT_SIZE);
588            break;
589        case ROCMOP_WORKITEM_PRIVATE_SEGMENT_SIZE:
590            AsmROCmPseudoOps::setConfigValue(*this, stmtPlace, linePtr,
591                             ROCMCVAL_WORKITEM_PRIVATE_SEGMENT_SIZE);
592            break;
593        default:
594            return false;
595    }
596    return true;
597}
598
599bool AsmROCmHandler::prepareBinary()
600{
601    return false;
602}
603
604void AsmROCmHandler::writeBinary(std::ostream& os) const
605{
606}
607
608void AsmROCmHandler::writeBinary(Array<cxbyte>& array) const
609{
610}
Note: See TracBrowser for help on using the repository browser.