source: CLRX/CLRadeonExtender/trunk/tests/amdasm/AsmAmdCL2Format.cpp @ 3755

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

CLRadeonExtender: Asm: Make first argument in CWS ('.cws', 'reqd_work_group_size' ...) as optional.
CLRXDocs: Update syntax for '.cws' and other pseudo-ops with group-size. Fixed formatting.

File size: 40.5 KB
Line 
1/*
2 *  CLRadeonExtender - Unofficial OpenCL Radeon Extensions Library
3 *  Copyright (C) 2014-2018 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 <iostream>
22#include <cstdio>
23#include <sstream>
24#include <string>
25#include <algorithm>
26#include <memory>
27#include <CLRX/amdbin/AmdCL2BinGen.h>
28#include <CLRX/amdasm/Assembler.h>
29#include <CLRX/amdasm/AsmFormats.h>
30#include "../TestUtils.h"
31
32using namespace CLRX;
33
34static const char* argTypeNameTbl[] =
35{
36    "void", "uchar", "char", "ushort", "short", "uint", "int",
37    "ulong", "long", "float", "double", "pointer",
38    "image", "image1d", "image1d_array", "image1d_buffer",
39    "image2d", "image2d_array", "image3d",
40    "uchar2", "uchar3", "uchar4", "uchar8", "uchar16",
41    "char2", "char3", "char4", "char8", "char16",
42    "ushort2", "ushort3", "ushort4", "ushort8", "ushort16",
43    "short2", "short3", "short4", "short8", "short16",
44    "uint2", "uint3", "uint4", "uint8", "uint16",
45    "int2", "int3", "int4", "int8", "int16",
46    "ulong2", "ulong3", "ulong4", "ulong8", "ulong16",
47    "long2", "long3", "long4", "long8", "long16",
48    "float2", "float3", "float4", "float8", "float16",
49    "double2", "double3", "double4", "double8", "double16",
50    "sampler", "structure", "counter32", "counter64",
51    "pipe", "cmdqueue", "clkevent"
52};
53
54static const char* ptrSpaceNameTbl[] =
55{ "none", "local", "constant", "global" };
56
57// print hex data or nullptr
58static void printHexData(std::ostream& os, cxuint indentLevel, size_t size,
59             const cxbyte* data)
60{
61    if (data==nullptr)
62    {
63        for (cxuint j = 0; j < indentLevel; j++)
64            os << "  ";
65        os << "nullptr\n";
66        return;
67    }
68    for (size_t i = 0; i < size; i++)
69    {
70        if ((i&31)==0)
71            for (cxuint j = 0; j < indentLevel; j++)
72                os << "  ";
73        char buf[10];
74        snprintf(buf, 10, "%02x", cxuint(data[i]));
75        os << buf;
76        if ((i&31)==31 || i+1 == size)
77            os << '\n';
78    }
79}
80
81// helper for printing value from kernel config (print default and notsupplied)
82static std::string confValueToString(uint32_t val)
83{
84    if (val == BINGEN_DEFAULT)
85        return "default";
86    if (val == BINGEN_NOTSUPPLIED)
87        return "notsup";
88    std::ostringstream oss;
89    oss << val;
90    return oss.str();
91}
92
93// print dump of AMD OpenCL2.0 output to stream for comparing with testcase
94static void printAmdCL2Output(std::ostream& os, const AmdCL2Input* output)
95{
96    os << "AmdCL2BinDump:" << std::endl;
97    os << "  devType=" << getGPUDeviceTypeName(output->deviceType) << ", "
98            "aclVersion=" << output->aclVersion << ", "
99            "drvVersion=" << output->driverVersion << ", "
100            "compileOptions=\"" << output->compileOptions << "\"\n";
101   
102    for (const AmdCL2KernelInput& kernel: output->kernels)
103    {
104        os << "  Kernel: " << kernel.kernelName << "\n";
105        os << "    Code:\n";
106        printHexData(os, 2, kernel.codeSize, kernel.code);
107        if (!kernel.useConfig)
108        {
109            // print metadata, setup and stub (if no config)
110            os << "    Metadata:\n";
111            printHexData(os, 2, kernel.metadataSize, (const cxbyte*)kernel.metadata);
112            os << "    Setup:\n";
113            printHexData(os, 2, kernel.setupSize, (const cxbyte*)kernel.setup);
114            if (kernel.stubSize!=0)
115            {
116                os << "    Stub:\n";
117                printHexData(os, 2, kernel.stubSize, (const cxbyte*)kernel.stub);
118            }
119            if (kernel.isaMetadataSize!=0)
120            {
121                os << "    ISAMetadata:\n";
122                printHexData(os, 2, kernel.metadataSize, (const cxbyte*)kernel.metadata);
123            }
124        }
125        else
126        {
127            // when config
128            const AmdCL2KernelConfig& config = kernel.config;
129            if (!kernel.hsaConfig)
130                os << "    Config:\n";
131            else
132                os << "    HSAConfig:\n";
133            for (AmdKernelArgInput arg: config.args)
134                os << "      Arg: \"" << arg.argName << "\", \"" <<
135                        arg.typeName << "\", " <<
136                        argTypeNameTbl[cxuint(arg.argType)] << ", " <<
137                        argTypeNameTbl[cxuint(arg.pointerType)] << ", " <<
138                        ptrSpaceNameTbl[cxuint(arg.ptrSpace)] << ", " <<
139                        cxuint(arg.ptrAccess) << ", " << arg.structSize << ", " <<
140                        arg.constSpaceSize << ", " <<
141                        confValueToString(arg.resId) << ", " <<
142                        cxuint(arg.used) << "\n";
143            if (!config.samplers.empty())
144            {
145                os << "      Sampler:";
146                for (cxuint sampler: config.samplers)
147                    os << " " << sampler;
148                os << '\n';
149            }
150            if (!kernel.hsaConfig)
151            {
152                // print kernel config in old style
153                os << "      dims=" << confValueToString(config.dimMask) << ", "
154                        "cws=" << config.reqdWorkGroupSize[0] << " " <<
155                            config.reqdWorkGroupSize[1] << " " <<
156                            config.reqdWorkGroupSize[2] << ", "
157                        "SGPRS=" << config.usedSGPRsNum << ", "
158                        "VGPRS=" << config.usedVGPRsNum << "\n      "
159                        "pgmRSRC1=" << std::hex << "0x" << config.pgmRSRC1 << ", "
160                        "pgmRSRC2=0x" << config.pgmRSRC2 << ", "
161                        "ieeeMode=0x" << std::dec << config.ieeeMode << std::hex << ", "
162                        "floatMode=0x" << config.floatMode<< std::dec << "\n      "
163                        "priority=" << config.priority << ", "
164                        "exceptions=" << cxuint(config.exceptions) << ", "
165                        "localSize=" << config.localSize << ", "
166                        "scratchBuffer=" << config.scratchBufferSize << "\n      " <<
167                        (config.tgSize?"tgsize ":"") <<
168                        (config.debugMode?"debug ":"") <<
169                        (config.privilegedMode?"priv ":"") <<
170                        (config.dx10Clamp?"dx10clamp ":"") <<
171                        (config.useSetup?"useSetup ":"") <<
172                        (config.useArgs?"useArgs ":"") <<
173                        (config.useEnqueue?"useEnqueue ":"") <<
174                        (config.useGeneric?"useGeneric ":"") << "\n";
175                if (!config.vecTypeHint.empty() ||
176                    config.workGroupSizeHint[0] != 0 ||
177                    config.workGroupSizeHint[1] != 0 ||
178                    config.workGroupSizeHint[1] != 0)
179                {
180                    os << "      vectypehint=" << config.vecTypeHint.c_str() << ", "
181                        "workGroupSizeHint=" << config.workGroupSizeHint[0] << " " <<
182                        config.workGroupSizeHint[1] << " " <<
183                        config.workGroupSizeHint[2] << "\n";
184                }
185            }
186            else
187            {
188                // print AMD HSA config
189                const AmdHsaKernelConfig& config =
190                        *reinterpret_cast<const AmdHsaKernelConfig*>(kernel.setup);
191                os <<
192                    "      amdCodeVersion=" << ULEV(config.amdCodeVersionMajor) << "." <<
193                        ULEV(config.amdCodeVersionMajor) << "\n"
194                    "      amdMachine=" << ULEV(config.amdMachineKind) << ":" <<
195                        ULEV(config.amdMachineMajor) << ":" <<
196                        ULEV(config.amdMachineMinor) << ":" <<
197                        ULEV(config.amdMachineStepping) << "\n"
198                    "      kernelCodeEntryOffset=" << 
199                            ULEV(config.kernelCodeEntryOffset) << "\n"
200                    "      kernelCodePrefetchOffset=" <<
201                        ULEV(config.kernelCodePrefetchOffset) << "\n"
202                    "      kernelCodePrefetchSize=" <<
203                        ULEV(config.kernelCodePrefetchSize) << "\n"
204                    "      maxScrachBackingMemorySize=" <<
205                        ULEV(config.maxScrachBackingMemorySize) << "\n"
206                    "      computePgmRsrc1=0x" <<
207                        std::hex << ULEV(config.computePgmRsrc1) << "\n"
208                    "      computePgmRsrc2=0x" << ULEV(config.computePgmRsrc2) << "\n"
209                    "      enableSgprRegisterFlags=0x" <<
210                        ULEV(config.enableSgprRegisterFlags) << "\n"
211                    "      enableFeatureFlags=0x" <<
212                        ULEV(config.enableFeatureFlags) << std::dec << "\n"
213                    "      workitemPrivateSegmentSize=" <<
214                        ULEV(config.workitemPrivateSegmentSize) << "\n"
215                    "      workgroupGroupSegmentSize=" <<
216                        ULEV(config.workgroupGroupSegmentSize) << "\n"
217                    "      gdsSegmentSize=" << ULEV(config.gdsSegmentSize) << "\n"
218                    "      kernargSegmentSize=" << ULEV(config.kernargSegmentSize) << "\n"
219                    "      workgroupFbarrierCount=" <<
220                        ULEV(config.workgroupFbarrierCount) << "\n"
221                    "      wavefrontSgprCount=" << ULEV(config.wavefrontSgprCount) << "\n"
222                    "      workitemVgprCount=" << ULEV(config.workitemVgprCount) << "\n"
223                    "      reservedVgprFirst=" << ULEV(config.reservedVgprFirst) << "\n"
224                    "      reservedVgprCount=" << ULEV(config.reservedVgprCount) << "\n"
225                    "      reservedSgprFirst=" << ULEV(config.reservedSgprFirst) << "\n"
226                    "      reservedSgprCount=" << ULEV(config.reservedSgprCount) << "\n"
227                    "      debugWavefrontPrivateSegmentOffsetSgpr=" <<
228                        ULEV(config.debugWavefrontPrivateSegmentOffsetSgpr) << "\n"
229                    "      debugPrivateSegmentBufferSgpr=" <<
230                        ULEV(config.debugPrivateSegmentBufferSgpr) << "\n"
231                    "      kernargSegmentAlignment=" << 
232                        cxuint(config.kernargSegmentAlignment) << "\n"
233                    "      groupSegmentAlignment=" <<
234                        cxuint(config.groupSegmentAlignment) << "\n"
235                    "      privateSegmentAlignment=" <<
236                        cxuint(config.privateSegmentAlignment) << "\n"
237                    "      wavefrontSize=" << cxuint(config.wavefrontSize) << "\n"
238                    "      callConvention=0x" <<
239                        std::hex << ULEV(config.callConvention) << "\n"
240                    "      runtimeLoaderKernelSymbol=0x" <<
241                        ULEV(config.runtimeLoaderKernelSymbol) << std::dec << "\n";
242                os << "      ControlDirective:\n";
243                printHexData(os, 3, 128, config.controlDirective);
244            }
245        }
246        // sort relocation before printing
247        std::vector<AmdCL2RelInput> relocs(kernel.relocations.begin(),
248                            kernel.relocations.end());
249        std::sort(relocs.begin(), relocs.end(),
250                  [] (const AmdCL2RelInput& a, const AmdCL2RelInput& b)
251                  { return a.offset < b.offset; });
252        // print relocations
253        for (const AmdCL2RelInput& rel: relocs)
254            os << "    Rel: offset=" << rel.offset << ", type=" << rel.type << ", "
255                "symbol=" << rel.symbol << ", addend=" << rel.addend << "\n";
256    }
257   
258    // print globaldata, rwdata, bss
259    os << "  GlobalData:\n";
260    printHexData(os,  1, output->globalDataSize, output->globalData);
261    os << "  RwData:\n";
262    printHexData(os,  1, output->rwDataSize, output->rwData);
263    os << "  Bss size: " << output->bssSize << ", bssAlign: " <<
264                output->bssAlignment << "\n";
265    os << "  SamplerInit:\n";
266    printHexData(os,  1, output->samplerInitSize, output->samplerInit);
267   
268    // print extra sections from inner binary if supplied
269    for (BinSection section: output->innerExtraSections)
270    {
271        os << "    ISection " << section.name << ", type=" << section.type <<
272                        ", flags=" << section.flags << ":\n";
273        printHexData(os, 2, section.size, section.data);
274    }
275    // print extra symbols from inner binary if supplied
276    for (BinSymbol symbol: output->innerExtraSymbols)
277        os << "    ISymbol: name=" << symbol.name << ", value=" << symbol.value <<
278                ", size=" << symbol.size << ", section=" << symbol.sectionId << "\n";
279   
280    // print extra sections from main binary if supplied
281    for (BinSection section: output->extraSections)
282    {
283        os << "  Section " << section.name << ", type=" << section.type <<
284                        ", flags=" << section.flags << ":\n";
285        printHexData(os, 1, section.size, section.data);
286    }
287    // print extra symbols from main binary if supplied
288    for (BinSymbol symbol: output->extraSymbols)
289        os << "  Symbol: name=" << symbol.name << ", value=" << symbol.value <<
290                ", size=" << symbol.size << ", section=" << symbol.sectionId << "\n";
291    os.flush();
292}
293
294struct AsmTestCase
295{
296    const char* input;
297    const char* dump;
298    const char* errors;
299    bool good;
300};
301
302static const AsmTestCase asmTestCases1Tbl[] =
303{
304/* AMD CL2 (no config) */
305    {
306R"ffDXD(            .amdcl2
307            .64bit
308            .gpu Bonaire
309            .driver_version 191205
310            .kernel aaa1
311                .metadata
312                    .byte 1,2,3,4,44
313                .setup
314                    .byte 0,6,0,3,4
315
316            .kernel aaa2
317                .setup
318                    .byte 0,6,0,3,4
319                .metadata
320                    .byte 1,2,3,4,44
321            .kernel aaa1
322                    .byte 0xc1,0xc4
323            .main
324            .globaldata
325                .byte 44,55,66
326            .bssdata align=8
327                .skip 50
328            .main
329            .section .ala
330                .string "ala"
331            .inner
332            .section .beta
333                .string "beta"
334            .main
335                .byte 0xa,0xba
336            .inner
337                .byte 0xff,0xfd
338            .main
339            .bssdata
340                .skip 10
341            .main
342            .section .xx
343                .byte 1,23
344            .inner
345            .section .xx
346                .byte 12,13
347            .kernel vu
348                .section aaaxx
349                .text
350                    s_endpgm
351            .inner
352                .section aaaxx
353                .byte 0xcd,0xdc)ffDXD",
354        R"ffDXD(AmdCL2BinDump:
355  devType=Bonaire, aclVersion=, drvVersion=191205, compileOptions=""
356  Kernel: aaa1
357    Code:
358    Metadata:
359    010203042c
360    Setup:
361    0006000304c1c4
362  Kernel: aaa2
363    Code:
364    Metadata:
365    010203042c
366    Setup:
367    0006000304
368  Kernel: vu
369    Code:
370    000081bf
371    Metadata:
372    nullptr
373    Setup:
374    nullptr
375  GlobalData:
376  2c3742
377  RwData:
378  nullptr
379  Bss size: 60, bssAlign: 8
380  SamplerInit:
381  nullptr
382    ISection .beta, type=1, flags=0:
383    6265746100fffd
384    ISection .xx, type=1, flags=0:
385    0c0d
386    ISection aaaxx, type=1, flags=0:
387    cddc
388  Section .ala, type=1, flags=0:
389  616c61000aba
390  Section .xx, type=1, flags=0:
391  0117
392)ffDXD", "", true
393    },
394    /* AMD CL2 (old format, no config) */
395    {
396        R"ffDXD(.amdcl2
397.64bit
398.gpu Bonaire
399.driver_version 180005
400.kernel aaa1
401    .metadata
402        .byte 1,2,3,4,44
403    .setup
404        .byte 0,6,0,3,4
405    .stub
406.kernel aaa2
407    .stub
408        .byte 0xf0,0xef,0xe1
409    .setup
410        .byte 0,6,0,3,4
411    .metadata
412        .byte 1,2,3,4,44
413    .isametadata
414        .byte 0xd0,0xd1,0xd4
415.kernel aaa1
416        .byte 0xc1,0xc4
417.main
418    .section .cc
419        .short 12,34,261)ffDXD",
420        R"ffDXD(AmdCL2BinDump:
421  devType=Bonaire, aclVersion=, drvVersion=180005, compileOptions=""
422  Kernel: aaa1
423    Code:
424    Metadata:
425    010203042c
426    Setup:
427    0006000304
428    Stub:
429    c1c4
430  Kernel: aaa2
431    Code:
432    Metadata:
433    010203042c
434    Setup:
435    0006000304
436    Stub:
437    f0efe1
438    ISAMetadata:
439    010203042c
440  GlobalData:
441  RwData:
442  nullptr
443  Bss size: 0, bssAlign: 0
444  SamplerInit:
445  nullptr
446  Section .cc, type=1, flags=0:
447  0c0022000501
448)ffDXD", "", true
449    },
450    /* AMDCL2 with configs */
451    {
452        R"ffDXD(.amdcl2
453.64bit
454.gpu Bonaire
455.driver_version 191205
456.kernel aaa1
457    .config
458        .dims x
459        .setupargs
460        .arg n,uint
461        .arg in,uint*,global,const
462        .arg out,uint*,global
463        .ieeemode
464        .floatmode 0xda
465        .localsize 1000
466        .useargs
467    .text
468        s_and_b32 s9,s5,44
469        s_and_b32 s10,s5,5
470.kernel aaa2
471    .config
472        .dims x
473        .setupargs
474        .arg n,uint
475        .arg in,float*,global,const
476        .arg out,float*,global
477        .arg q,queue
478        .arg piper,pipe
479        .arg ce,clkevent
480        .scratchbuffer 2342
481        .ieeemode
482        .floatmode 0xda
483        .localsize 1000
484        .useargs
485        .priority 2
486        .privmode
487        .debugmode
488        .dx10clamp
489        .exceptions 0x12
490        .useenqueue
491    .text
492        s_and_b32 s9,s5,44
493        s_endpgm
494.kernel aaa1
495        s_and_b32 s11,s5,5
496        s_endpgm
497.kernel gfd12
498    .config
499        .dims xyz
500        .cws 8,5,2
501        .sgprsnum 25
502        .vgprsnum 78
503        .setupargs
504        .arg n,uint
505        .arg in,double*,global,const
506        .arg out,double*,global
507        .arg v,uchar,rdonly
508        .arg v2,uchar,wronly
509        .localsize 656
510        .pgmrsrc1 0x1234000
511        .pgmrsrc2 0xfcdefd0
512        .useargs
513        .usesetup
514        .usegeneric
515    .text
516        v_mov_b32 v1,v2
517        v_add_i32 v1,vcc,55,v3
518        s_endpgm
519)ffDXD",
520        R"ffDXD(AmdCL2BinDump:
521  devType=Bonaire, aclVersion=, drvVersion=191205, compileOptions=""
522  Kernel: aaa1
523    Code:
524    05ac098705850a8705850b87000081bf
525    Config:
526      Arg: "_.global_offset_0", "size_t", long, void, none, 0, 0, 0, 0, 0
527      Arg: "_.global_offset_1", "size_t", long, void, none, 0, 0, 0, 0, 0
528      Arg: "_.global_offset_2", "size_t", long, void, none, 0, 0, 0, 0, 0
529      Arg: "_.printf_buffer", "size_t", pointer, void, global, 0, 3, 0, 0, 0
530      Arg: "_.vqueue_pointer", "size_t", long, void, none, 0, 0, 0, 0, 0
531      Arg: "_.aqlwrap_pointer", "size_t", long, void, none, 0, 0, 0, 0, 0
532      Arg: "n", "uint", uint, void, none, 0, 0, 0, default, 3
533      Arg: "in", "uint*", pointer, uint, global, 4, 0, 0, default, 3
534      Arg: "out", "uint*", pointer, uint, global, 0, 0, 0, default, 3
535      dims=1, cws=0 0 0, SGPRS=12, VGPRS=1
536      pgmRSRC1=0x0, pgmRSRC2=0x0, ieeeMode=0x1, floatMode=0xda
537      priority=0, exceptions=0, localSize=1000, scratchBuffer=0
538      useArgs
539  Kernel: aaa2
540    Code:
541    05ac0987000081bf
542    Config:
543      Arg: "_.global_offset_0", "size_t", long, void, none, 0, 0, 0, 0, 0
544      Arg: "_.global_offset_1", "size_t", long, void, none, 0, 0, 0, 0, 0
545      Arg: "_.global_offset_2", "size_t", long, void, none, 0, 0, 0, 0, 0
546      Arg: "_.printf_buffer", "size_t", pointer, void, global, 0, 3, 0, 0, 0
547      Arg: "_.vqueue_pointer", "size_t", long, void, none, 0, 0, 0, 0, 0
548      Arg: "_.aqlwrap_pointer", "size_t", long, void, none, 0, 0, 0, 0, 0
549      Arg: "n", "uint", uint, void, none, 0, 0, 0, default, 3
550      Arg: "in", "float*", pointer, float, global, 4, 0, 0, default, 3
551      Arg: "out", "float*", pointer, float, global, 0, 0, 0, default, 3
552      Arg: "q", "queue_t", cmdqueue, void, none, 0, 0, 0, default, 3
553      Arg: "piper", "pipe", pipe, void, none, 0, 0, 0, default, 3
554      Arg: "ce", "clk_event_t", clkevent, void, none, 0, 0, 0, default, 3
555      dims=1, cws=0 0 0, SGPRS=12, VGPRS=1
556      pgmRSRC1=0x0, pgmRSRC2=0x0, ieeeMode=0x1, floatMode=0xda
557      priority=2, exceptions=18, localSize=1000, scratchBuffer=2342
558      debug priv dx10clamp useArgs useEnqueue
559  Kernel: gfd12
560    Code:
561    0203027eb706024a000081bf
562    Config:
563      Arg: "_.global_offset_0", "size_t", long, void, none, 0, 0, 0, 0, 0
564      Arg: "_.global_offset_1", "size_t", long, void, none, 0, 0, 0, 0, 0
565      Arg: "_.global_offset_2", "size_t", long, void, none, 0, 0, 0, 0, 0
566      Arg: "_.printf_buffer", "size_t", pointer, void, global, 0, 3, 0, 0, 0
567      Arg: "_.vqueue_pointer", "size_t", long, void, none, 0, 0, 0, 0, 0
568      Arg: "_.aqlwrap_pointer", "size_t", long, void, none, 0, 0, 0, 0, 0
569      Arg: "n", "uint", uint, void, none, 0, 0, 0, default, 3
570      Arg: "in", "double*", pointer, double, global, 4, 0, 0, default, 3
571      Arg: "out", "double*", pointer, double, global, 0, 0, 0, default, 3
572      Arg: "v", "uchar", uchar, void, none, 0, 0, 0, default, 1
573      Arg: "v2", "uchar", uchar, void, none, 0, 0, 0, default, 2
574      dims=7, cws=8 5 2, SGPRS=25, VGPRS=78
575      pgmRSRC1=0x1234000, pgmRSRC2=0xfcdefd0, ieeeMode=0x0, floatMode=0xc0
576      priority=0, exceptions=0, localSize=656, scratchBuffer=0
577      useSetup useArgs useGeneric
578  GlobalData:
579  RwData:
580  nullptr
581  Bss size: 0, bssAlign: 0
582  SamplerInit:
583  nullptr
584)ffDXD", "", true
585    },
586    /* AMDCL2 - relocations */
587    {
588        R"ffDXD(.amdcl2
589.64bit
590.gpu Bonaire
591.driver_version 191205
592.globaldata
593gstart:
594        .int 1,2,3,4,5,6
595gstart2:
596.rwdata
597        .int 4,5
598rwdat1:
599.bssdata
600        .skip 10
601bsslabel:
602.kernel aaa1
603    .config
604        .dims x
605        .setupargs
606        .arg n,uint
607        .arg in,uint*,global,const
608        .arg out,uint*,global
609        .ieeemode
610        .useargs
611cc=gstart+10+x
612    .text
613        s_and_b32 s9,s5,44
614        s_and_b32 s10,s5,5
615        s_mov_b32 s1, gstart+77
616        s_mov_b32 s1, gstart+7*3
617        s_mov_b32 s1, (gstart+7*3)&(1<<32-1)
618        s_mov_b32 s1, ((gstart+7*3)*2-gstart)&(4096*4096*256-1)
619        s_mov_b32 s1, (-gstart+2*(gstart+7*3))%(4096*4096*256)
620        s_mov_b32 s1, (-gstart+2*(gstart2+7*3))%%(4096*4096*256)
621        s_mov_b32 s1, (-gstart+2*(gstart2+7*5))%%(4096*4096*256*9)
622        s_mov_b32 s1, (-gstart+2*(gstart2+7*5))%(4096*4096*256*9)
623        s_mov_b32 s1, (gstart+7*3)>>(31-5+6)
624        s_mov_b32 s1, (gstart+7*3)>>(234%101)
625        s_mov_b32 s1, (gstart+7*3)>>(235%101-1)
626        s_mov_b32 s1, (gstart+7*3)/(4096*4096*256)
627        s_mov_b32 s1, (gstart+7*3)//(4096*4096*256)
628        s_mov_b32 s1, aa>>32
629        s_mov_b32 s1, (aa-10)>>32
630        s_mov_b32 s1, (bb-10)>>32
631        s_mov_b32 s1, (cc+1)>>32
632        s_mov_b32 s1, gstart2+77
633        s_mov_b32 s1, rwdat1+33
634        s_mov_b32 s1, bsslabel+33
635        .byte 12
636        .int (gstart+22)>>32
637        s_endpgm
638aa = gstart2 + 100
639bb = aa + 3
640x=3*6)ffDXD",
641        R"ffDXD(AmdCL2BinDump:
642  devType=Bonaire, aclVersion=, drvVersion=191205, compileOptions=""
643  Kernel: aaa1
644    Code:
645    05ac098705850a87ff0381be55555555ff0381be55555555ff0381be55555555
646    ff0381be55555555ff0381be55555555ff0381be55555555ff0381be55555555
647    ff0381be55555555ff0381be55555555ff0381be55555555ff0381be55555555
648    ff0381be55555555ff0381be55555555ff0381be55555555ff0381be55555555
649    ff0381be55555555ff0381be55555555ff0381be55555555ff0381be55555555
650    ff0381be555555550c55555555000081bf
651    Config:
652      Arg: "_.global_offset_0", "size_t", long, void, none, 0, 0, 0, 0, 0
653      Arg: "_.global_offset_1", "size_t", long, void, none, 0, 0, 0, 0, 0
654      Arg: "_.global_offset_2", "size_t", long, void, none, 0, 0, 0, 0, 0
655      Arg: "_.printf_buffer", "size_t", pointer, void, global, 0, 3, 0, 0, 0
656      Arg: "_.vqueue_pointer", "size_t", long, void, none, 0, 0, 0, 0, 0
657      Arg: "_.aqlwrap_pointer", "size_t", long, void, none, 0, 0, 0, 0, 0
658      Arg: "n", "uint", uint, void, none, 0, 0, 0, default, 3
659      Arg: "in", "uint*", pointer, uint, global, 4, 0, 0, default, 3
660      Arg: "out", "uint*", pointer, uint, global, 0, 0, 0, default, 3
661      dims=1, cws=0 0 0, SGPRS=11, VGPRS=1
662      pgmRSRC1=0x0, pgmRSRC2=0x0, ieeeMode=0x1, floatMode=0xc0
663      priority=0, exceptions=0, localSize=0, scratchBuffer=0
664      useArgs
665    Rel: offset=12, type=1, symbol=0, addend=77
666    Rel: offset=20, type=1, symbol=0, addend=21
667    Rel: offset=28, type=1, symbol=0, addend=21
668    Rel: offset=36, type=1, symbol=0, addend=42
669    Rel: offset=44, type=1, symbol=0, addend=42
670    Rel: offset=52, type=1, symbol=0, addend=90
671    Rel: offset=60, type=1, symbol=0, addend=118
672    Rel: offset=68, type=1, symbol=0, addend=118
673    Rel: offset=76, type=2, symbol=0, addend=21
674    Rel: offset=84, type=2, symbol=0, addend=21
675    Rel: offset=92, type=2, symbol=0, addend=21
676    Rel: offset=100, type=2, symbol=0, addend=21
677    Rel: offset=108, type=2, symbol=0, addend=21
678    Rel: offset=116, type=2, symbol=0, addend=124
679    Rel: offset=124, type=2, symbol=0, addend=114
680    Rel: offset=132, type=2, symbol=0, addend=117
681    Rel: offset=140, type=2, symbol=0, addend=29
682    Rel: offset=148, type=1, symbol=0, addend=101
683    Rel: offset=156, type=1, symbol=1, addend=41
684    Rel: offset=164, type=1, symbol=2, addend=43
685    Rel: offset=169, type=2, symbol=0, addend=22
686  GlobalData:
687  010000000200000003000000040000000500000006000000
688  RwData:
689  0400000005000000
690  Bss size: 10, bssAlign: 0
691  SamplerInit:
692  nullptr
693)ffDXD", "", true
694    },
695    /* AMDCL2 - errors */
696    {
697        R"ffDXD(.amdcl2
698.gpu Bonaire
699.driver_version 191205
700.kernel aaa1
701    .config
702        .dims xyd
703        .setupargs
704        .cws 
705        .arg n,uint
706        .arg in,uint*,global,const
707        .arg out,uint*,global
708        .ieeemode
709        .floatmode 0x111da
710        .localsize 103000
711        .priority 6
712        .exceptions 0xd9
713        .sgprsnum 231
714        .arg vx,uint,dxdd
715        .useargs
716    .text
717        s_and_b32 s9,s5,44
718        s_and_b32 s10,s5,5
719        .dims x
720        .setupargs
721        .arg n,uint
722        .arg in,float*,global,const
723        .arg out,float*,global
724        .arg q,queue
725        .arg piper,pipe
726        .arg ce,clkevent
727        .scratchbuffer 2342
728        .ieeemode
729        .floatmode 0xda
730        .localsize 1000
731        .useargs
732        .priority 2
733        .privmode
734        .debugmode
735        .dx10clamp
736        .exceptions 0x12
737        .useenqueue
738.kernel aaa2
739    .metadata
740        .byte 1,234,4
741    .config)ffDXD",
742        "",
743        R"ffDXD(test.s:6:15: Error: Unknown dimension type
744test.s:13:20: Warning: Value 0x111da truncated to 0xda
745test.s:14:20: Error: LocalSize out of range (0-32768)
746test.s:15:19: Warning: Value 0x6 truncated to 0x2
747test.s:16:21: Warning: Value 0xd9 truncated to 0x59
748test.s:17:19: Error: Used SGPRs number out of range (0-104)
749test.s:18:22: Error: This is not 'unused' specifier
750test.s:23:9: Error: Illegal place of configuration pseudo-op
751test.s:24:9: Error: Illegal place of kernel argument
752test.s:25:9: Error: Illegal place of kernel argument
753test.s:26:9: Error: Illegal place of kernel argument
754test.s:27:9: Error: Illegal place of kernel argument
755test.s:28:9: Error: Illegal place of kernel argument
756test.s:29:9: Error: Illegal place of kernel argument
757test.s:30:9: Error: Illegal place of kernel argument
758test.s:31:9: Error: Illegal place of configuration pseudo-op
759test.s:32:9: Error: Illegal place of configuration pseudo-op
760test.s:33:9: Error: Illegal place of configuration pseudo-op
761test.s:34:9: Error: Illegal place of configuration pseudo-op
762test.s:35:9: Error: Illegal place of configuration pseudo-op
763test.s:36:9: Error: Illegal place of configuration pseudo-op
764test.s:37:9: Error: Illegal place of configuration pseudo-op
765test.s:38:9: Error: Illegal place of configuration pseudo-op
766test.s:39:9: Error: Illegal place of configuration pseudo-op
767test.s:40:9: Error: Illegal place of configuration pseudo-op
768test.s:41:9: Error: Illegal place of configuration pseudo-op
769test.s:45:5: Error: Config can't be defined if metadata,header,setup,stub section exists
770)ffDXD", false
771    },
772    /* AMD HSA config */
773    {
774        R"ffDXD(.amdcl2
775.gpu Bonaire
776.64bit
777.arch_minor 0
778.arch_stepping 0
779.driver_version 234800
780.kernel GenerateScramblerKernel
781    .hsaconfig
782        .dims xyz
783        .sgprsnum 22
784        .vgprsnum 16
785        .dx10clamp
786        .ieeemode
787        .floatmode 0xc0
788        .priority 0
789        .userdatanum 6
790        .codeversion 1, 1
791        .machine 1, 0, 0, 0
792        .kernel_code_entry_offset 0x100
793        .use_private_segment_buffer
794        .use_kernarg_segment_ptr
795        .private_elem_size 4
796        .use_ptr64
797        .kernarg_segment_align 16
798        .group_segment_align 16
799        .private_segment_align 16
800        .wavefront_size 64
801        .call_convention 0x0
802    .control_directive
803        .byte 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
804        .fill 120, 1, 0x00
805    .hsaconfig
806        .arg _.global_offset_0, "size_t", long
807        .arg _.global_offset_1, "size_t", long
808        .arg _.global_offset_2, "size_t", long
809        .arg _.printf_buffer, "size_t", void*, global, , rdonly
810        .arg _.vqueue_pointer, "size_t", long
811        .arg _.aqlwrap_pointer, "size_t", long
812        .arg d_wiring, "Wiring*", structure*, 1024, constant, const, rdonly
813        .arg d_key, "Key*", structure*, 64, constant, const, rdonly
814        .arg thblockShift, "uint", uint
815        .arg localShift, "uint", uint
816        .arg scramblerDataPitch, "uint", uint
817        .arg scramblerData, "int8_t*", char*, global,
818    .text
819        s_load_dwordx2  s[0:1], s[4:5], 0x10
820        s_waitcnt       lgkmcnt(0)
821        s_sub_u32       s1, s1, s0
822        v_bfe_u32       v1, v0, 0, s1
823        v_cmp_ge_u32    vcc, 25, v1
824        s_and_saveexec_b64 s[2:3], vcc
825        v_lshrrev_b32   v0, s1, v0
826        s_endpgm
827)ffDXD",
828        R"ffDXD(AmdCL2BinDump:
829  devType=Bonaire, aclVersion=, drvVersion=234800, compileOptions=""
830  Kernel: GenerateScramblerKernel
831    Code:
832    100540c07f008cbf01008180010090d20001050099028c7d6a2482be0100002c
833    000081bf
834    HSAConfig:
835      Arg: "_.global_offset_0", "size_t", long, void, none, 0, 0, 0, default, 3
836      Arg: "_.global_offset_1", "size_t", long, void, none, 0, 0, 0, default, 3
837      Arg: "_.global_offset_2", "size_t", long, void, none, 0, 0, 0, default, 3
838      Arg: "_.printf_buffer", "size_t", pointer, void, global, 0, 0, 0, default, 1
839      Arg: "_.vqueue_pointer", "size_t", long, void, none, 0, 0, 0, default, 3
840      Arg: "_.aqlwrap_pointer", "size_t", long, void, none, 0, 0, 0, default, 3
841      Arg: "d_wiring", "Wiring*", pointer, structure, constant, 4, 1024, 0, default, 1
842      Arg: "d_key", "Key*", pointer, structure, constant, 4, 64, 0, default, 1
843      Arg: "thblockShift", "uint", uint, void, none, 0, 0, 0, default, 3
844      Arg: "localShift", "uint", uint, void, none, 0, 0, 0, default, 3
845      Arg: "scramblerDataPitch", "uint", uint, void, none, 0, 0, 0, default, 3
846      Arg: "scramblerData", "int8_t*", pointer, char, global, 0, 0, 0, default, 3
847      amdCodeVersion=1.1
848      amdMachine=1:0:0:0
849      kernelCodeEntryOffset=256
850      kernelCodePrefetchOffset=0
851      kernelCodePrefetchSize=0
852      maxScrachBackingMemorySize=0
853      computePgmRsrc1=0xac0083
854      computePgmRsrc2=0x138c
855      enableSgprRegisterFlags=0x9
856      enableFeatureFlags=0xa
857      workitemPrivateSegmentSize=0
858      workgroupGroupSegmentSize=0
859      gdsSegmentSize=0
860      kernargSegmentSize=96
861      workgroupFbarrierCount=0
862      wavefrontSgprCount=22
863      workitemVgprCount=16
864      reservedVgprFirst=16
865      reservedVgprCount=0
866      reservedSgprFirst=20
867      reservedSgprCount=0
868      debugWavefrontPrivateSegmentOffsetSgpr=0
869      debugPrivateSegmentBufferSgpr=0
870      kernargSegmentAlignment=4
871      groupSegmentAlignment=4
872      privateSegmentAlignment=4
873      wavefrontSize=6
874      callConvention=0x0
875      runtimeLoaderKernelSymbol=0x0
876      ControlDirective:
877      0001000000000000000000000000000000000000000000000000000000000000
878      0000000000000000000000000000000000000000000000000000000000000000
879      0000000000000000000000000000000000000000000000000000000000000000
880      0000000000000000000000000000000000000000000000000000000000000000
881  GlobalData:
882  RwData:
883  nullptr
884  Bss size: 0, bssAlign: 0
885  SamplerInit:
886  nullptr
887)ffDXD", "", true
888    },
889    {
890        R"ffDXD(.amdcl2
891.gpu Bonaire
892.64bit
893.arch_minor 0
894.arch_stepping 0
895.driver_version 234800
896.kernel GenerateScramblerKernel
897    .hsaconfig
898        .dims xyz
899        .dx10clamp
900        .ieeemode
901        .floatmode 0xc0
902        .priority 0
903        .userdatanum 6
904        .codeversion 1, 1
905        .machine 1, 4, 6, 7
906        .kernel_code_entry_offset 0x100
907        .use_private_segment_buffer
908        .use_kernarg_segment_ptr
909        .private_elem_size 4
910        .use_ptr64
911        .call_convention 0x0
912        .workgroup_fbarrier_count 3324
913        .runtime_loader_kernel_symbol 0x4dc98b3a
914        .scratchbuffer 77222
915        .localsize 413
916    .control_directive
917        .byte 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
918    .hsaconfig
919        .arg _.global_offset_0, "size_t", long
920        .arg _.global_offset_1, "size_t", long
921        .arg _.global_offset_2, "size_t", long
922        .arg _.printf_buffer, "size_t", void*, global, , rdonly
923        .arg _.vqueue_pointer, "size_t", long
924        .arg _.aqlwrap_pointer, "size_t", long
925        .arg d_wiring, "Wiring*", structure*, 1024, constant, const, rdonly
926        .arg d_key, "Key*", structure*, 64, constant, const, rdonly
927        .arg thblockShift, "uint", uint
928        .arg localShift, "uint", uint
929        .arg scramblerDataPitch, "uint", uint
930        .arg scramblerData, "int8_t*", char*, global,
931    .control_directive
932        .fill 116, 1, 0x00
933    .text
934        s_mov_b32 s32, s14
935        v_mov_b32 v42, v11
936        s_endpgm
937    .control_directive
938        .int 2132
939)ffDXD",
940        R"ffDXD(AmdCL2BinDump:
941  devType=Bonaire, aclVersion=, drvVersion=234800, compileOptions=""
942  Kernel: GenerateScramblerKernel
943    Code:
944    0e03a0be0b03547e000081bf
945    HSAConfig:
946      Arg: "_.global_offset_0", "size_t", long, void, none, 0, 0, 0, default, 3
947      Arg: "_.global_offset_1", "size_t", long, void, none, 0, 0, 0, default, 3
948      Arg: "_.global_offset_2", "size_t", long, void, none, 0, 0, 0, default, 3
949      Arg: "_.printf_buffer", "size_t", pointer, void, global, 0, 0, 0, default, 1
950      Arg: "_.vqueue_pointer", "size_t", long, void, none, 0, 0, 0, default, 3
951      Arg: "_.aqlwrap_pointer", "size_t", long, void, none, 0, 0, 0, default, 3
952      Arg: "d_wiring", "Wiring*", pointer, structure, constant, 4, 1024, 0, default, 1
953      Arg: "d_key", "Key*", pointer, structure, constant, 4, 64, 0, default, 1
954      Arg: "thblockShift", "uint", uint, void, none, 0, 0, 0, default, 3
955      Arg: "localShift", "uint", uint, void, none, 0, 0, 0, default, 3
956      Arg: "scramblerDataPitch", "uint", uint, void, none, 0, 0, 0, default, 3
957      Arg: "scramblerData", "int8_t*", pointer, char, global, 0, 0, 0, default, 3
958      amdCodeVersion=1.1
959      amdMachine=1:4:6:7
960      kernelCodeEntryOffset=256
961      kernelCodePrefetchOffset=0
962      kernelCodePrefetchSize=0
963      maxScrachBackingMemorySize=0
964      computePgmRsrc1=0xac010a
965      computePgmRsrc2=0x138d
966      enableSgprRegisterFlags=0x9
967      enableFeatureFlags=0xa
968      workitemPrivateSegmentSize=77222
969      workgroupGroupSegmentSize=413
970      gdsSegmentSize=0
971      kernargSegmentSize=96
972      workgroupFbarrierCount=3324
973      wavefrontSgprCount=35
974      workitemVgprCount=43
975      reservedVgprFirst=43
976      reservedVgprCount=0
977      reservedSgprFirst=33
978      reservedSgprCount=0
979      debugWavefrontPrivateSegmentOffsetSgpr=0
980      debugPrivateSegmentBufferSgpr=0
981      kernargSegmentAlignment=4
982      groupSegmentAlignment=4
983      privateSegmentAlignment=4
984      wavefrontSize=6
985      callConvention=0x0
986      runtimeLoaderKernelSymbol=0x4dc98b3a
987      ControlDirective:
988      0001000000000000000000000000000000000000000000000000000000000000
989      0000000000000000000000000000000000000000000000000000000000000000
990      0000000000000000000000000000000000000000000000000000000000000000
991      0000000000000000000000000000000000000000000000000000000054080000
992  GlobalData:
993  RwData:
994  nullptr
995  Bss size: 0, bssAlign: 0
996  SamplerInit:
997  nullptr
998)ffDXD", "", true
999    },
1000    {   // with vectypehint and work_group_size_hint
1001        R"ffDXD(.amdcl2
1002.64bit
1003.gpu Bonaire
1004.driver_version 191205
1005.kernel aaa1
1006    .config
1007        .dims x
1008        .setupargs
1009        .vectypehint float8
1010        .work_group_size_hint 44,112,5
1011        .arg n,uint
1012        .arg in,uint*,global,const
1013        .arg out,uint*,global
1014        .ieeemode
1015        .floatmode 0xda
1016        .localsize 1000
1017        .useargs
1018    .text
1019        s_and_b32 s9,s5,44
1020        s_and_b32 s10,s5,5
1021)ffDXD",
1022        R"ffDXD(AmdCL2BinDump:
1023  devType=Bonaire, aclVersion=, drvVersion=191205, compileOptions=""
1024  Kernel: aaa1
1025    Code:
1026    05ac098705850a87
1027    Config:
1028      Arg: "_.global_offset_0", "size_t", long, void, none, 0, 0, 0, 0, 0
1029      Arg: "_.global_offset_1", "size_t", long, void, none, 0, 0, 0, 0, 0
1030      Arg: "_.global_offset_2", "size_t", long, void, none, 0, 0, 0, 0, 0
1031      Arg: "_.printf_buffer", "size_t", pointer, void, global, 0, 3, 0, 0, 0
1032      Arg: "_.vqueue_pointer", "size_t", long, void, none, 0, 0, 0, 0, 0
1033      Arg: "_.aqlwrap_pointer", "size_t", long, void, none, 0, 0, 0, 0, 0
1034      Arg: "n", "uint", uint, void, none, 0, 0, 0, default, 3
1035      Arg: "in", "uint*", pointer, uint, global, 4, 0, 0, default, 3
1036      Arg: "out", "uint*", pointer, uint, global, 0, 0, 0, default, 3
1037      dims=1, cws=0 0 0, SGPRS=11, VGPRS=1
1038      pgmRSRC1=0x0, pgmRSRC2=0x0, ieeeMode=0x1, floatMode=0xda
1039      priority=0, exceptions=0, localSize=1000, scratchBuffer=0
1040      useArgs
1041      vectypehint=float8, workGroupSizeHint=44 112 5
1042  GlobalData:
1043  RwData:
1044  nullptr
1045  Bss size: 0, bssAlign: 0
1046  SamplerInit:
1047  nullptr
1048)ffDXD", "", true
1049    },
1050    {   // with vectypehint and work_group_size_hint
1051        // cws and work_group_size_hint defaults
1052        R"ffDXD(.amdcl2
1053.64bit
1054.gpu Bonaire
1055.driver_version 191205
1056.kernel aaa1
1057    .config
1058        .dims x
1059        .setupargs
1060        .vectypehint float8
1061        .cws 144,11
1062        .work_group_size_hint 44
1063        .arg n,uint
1064        .arg in,uint*,global,const
1065        .arg out,uint*,global
1066        .ieeemode
1067        .floatmode 0xda
1068        .localsize 1000
1069        .useargs
1070    .text
1071        s_and_b32 s9,s5,44
1072        s_and_b32 s10,s5,5
1073)ffDXD",
1074        R"ffDXD(AmdCL2BinDump:
1075  devType=Bonaire, aclVersion=, drvVersion=191205, compileOptions=""
1076  Kernel: aaa1
1077    Code:
1078    05ac098705850a87
1079    Config:
1080      Arg: "_.global_offset_0", "size_t", long, void, none, 0, 0, 0, 0, 0
1081      Arg: "_.global_offset_1", "size_t", long, void, none, 0, 0, 0, 0, 0
1082      Arg: "_.global_offset_2", "size_t", long, void, none, 0, 0, 0, 0, 0
1083      Arg: "_.printf_buffer", "size_t", pointer, void, global, 0, 3, 0, 0, 0
1084      Arg: "_.vqueue_pointer", "size_t", long, void, none, 0, 0, 0, 0, 0
1085      Arg: "_.aqlwrap_pointer", "size_t", long, void, none, 0, 0, 0, 0, 0
1086      Arg: "n", "uint", uint, void, none, 0, 0, 0, default, 3
1087      Arg: "in", "uint*", pointer, uint, global, 4, 0, 0, default, 3
1088      Arg: "out", "uint*", pointer, uint, global, 0, 0, 0, default, 3
1089      dims=1, cws=144 11 1, SGPRS=11, VGPRS=1
1090      pgmRSRC1=0x0, pgmRSRC2=0x0, ieeeMode=0x1, floatMode=0xda
1091      priority=0, exceptions=0, localSize=1000, scratchBuffer=0
1092      useArgs
1093      vectypehint=float8, workGroupSizeHint=44 1 1
1094  GlobalData:
1095  RwData:
1096  nullptr
1097  Bss size: 0, bssAlign: 0
1098  SamplerInit:
1099  nullptr
1100)ffDXD", "", true
1101    }
1102};
1103
1104static void testAssembler(cxuint testId, const AsmTestCase& testCase)
1105{
1106    std::istringstream input(testCase.input);
1107    std::ostringstream errorStream;
1108    std::ostringstream printStream;
1109   
1110    // create assembler with testcase's input and with ASM_TESTRUN flag
1111    Assembler assembler("test.s", input, (ASM_ALL|ASM_TESTRUN)&~ASM_ALTMACRO,
1112            BinaryFormat::AMD, GPUDeviceType::CAPE_VERDE, errorStream, printStream);
1113    bool good = assembler.assemble();
1114   
1115    std::ostringstream dumpOss;
1116    if (good && assembler.getFormatHandler()!=nullptr)
1117        // get format handler and their output
1118        printAmdCL2Output(dumpOss, static_cast<const AsmAmdCL2Handler*>(
1119                        assembler.getFormatHandler())->getOutput());
1120    /* compare result dump with expected dump */
1121    char testName[30];
1122    snprintf(testName, 30, "Test #%u", testId);
1123   
1124    assertValue(testName, "good", int(testCase.good), int(good));
1125    assertString(testName, "dump", testCase.dump, dumpOss.str());
1126    assertString(testName, "errorMessages", testCase.errors, errorStream.str());
1127}
1128
1129int main(int argc, const char** argv)
1130{
1131    int retVal = 0;
1132    for (size_t i = 0; i < sizeof(asmTestCases1Tbl)/sizeof(AsmTestCase); i++)
1133        try
1134        { testAssembler(i, asmTestCases1Tbl[i]); }
1135        catch(const std::exception& ex)
1136        {
1137            std::cerr << ex.what() << std::endl;
1138            retVal = 1;
1139        }
1140    return retVal;
1141}
Note: See TracBrowser for help on using the repository browser.