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

Last change on this file since 3746 was 3746, checked in by matszpk, 2 years ago

CLRadeonExtender: Add includes to testcases.

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:8:15: Error: Expected expression
745test.s:13:20: Warning: Value 0x111da truncated to 0xda
746test.s:14:20: Error: LocalSize out of range (0-32768)
747test.s:15:19: Warning: Value 0x6 truncated to 0x2
748test.s:16:21: Warning: Value 0xd9 truncated to 0x59
749test.s:17:19: Error: Used SGPRs number out of range (0-104)
750test.s:18:22: Error: This is not 'unused' specifier
751test.s:23:9: Error: Illegal place of configuration pseudo-op
752test.s:24:9: Error: Illegal place of kernel argument
753test.s:25:9: Error: Illegal place of kernel argument
754test.s:26:9: Error: Illegal place of kernel argument
755test.s:27:9: Error: Illegal place of kernel argument
756test.s:28:9: Error: Illegal place of kernel argument
757test.s:29:9: Error: Illegal place of kernel argument
758test.s:30:9: Error: Illegal place of kernel argument
759test.s:31:9: Error: Illegal place of configuration pseudo-op
760test.s:32:9: Error: Illegal place of configuration pseudo-op
761test.s:33:9: Error: Illegal place of configuration pseudo-op
762test.s:34:9: Error: Illegal place of configuration pseudo-op
763test.s:35:9: Error: Illegal place of configuration pseudo-op
764test.s:36:9: Error: Illegal place of configuration pseudo-op
765test.s:37:9: Error: Illegal place of configuration pseudo-op
766test.s:38:9: Error: Illegal place of configuration pseudo-op
767test.s:39:9: Error: Illegal place of configuration pseudo-op
768test.s:40:9: Error: Illegal place of configuration pseudo-op
769test.s:41:9: Error: Illegal place of configuration pseudo-op
770test.s:45:5: Error: Config can't be defined if metadata,header,setup,stub section exists
771)ffDXD", false
772    },
773    /* AMD HSA config */
774    {
775        R"ffDXD(.amdcl2
776.gpu Bonaire
777.64bit
778.arch_minor 0
779.arch_stepping 0
780.driver_version 234800
781.kernel GenerateScramblerKernel
782    .hsaconfig
783        .dims xyz
784        .sgprsnum 22
785        .vgprsnum 16
786        .dx10clamp
787        .ieeemode
788        .floatmode 0xc0
789        .priority 0
790        .userdatanum 6
791        .codeversion 1, 1
792        .machine 1, 0, 0, 0
793        .kernel_code_entry_offset 0x100
794        .use_private_segment_buffer
795        .use_kernarg_segment_ptr
796        .private_elem_size 4
797        .use_ptr64
798        .kernarg_segment_align 16
799        .group_segment_align 16
800        .private_segment_align 16
801        .wavefront_size 64
802        .call_convention 0x0
803    .control_directive
804        .byte 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
805        .fill 120, 1, 0x00
806    .hsaconfig
807        .arg _.global_offset_0, "size_t", long
808        .arg _.global_offset_1, "size_t", long
809        .arg _.global_offset_2, "size_t", long
810        .arg _.printf_buffer, "size_t", void*, global, , rdonly
811        .arg _.vqueue_pointer, "size_t", long
812        .arg _.aqlwrap_pointer, "size_t", long
813        .arg d_wiring, "Wiring*", structure*, 1024, constant, const, rdonly
814        .arg d_key, "Key*", structure*, 64, constant, const, rdonly
815        .arg thblockShift, "uint", uint
816        .arg localShift, "uint", uint
817        .arg scramblerDataPitch, "uint", uint
818        .arg scramblerData, "int8_t*", char*, global,
819    .text
820        s_load_dwordx2  s[0:1], s[4:5], 0x10
821        s_waitcnt       lgkmcnt(0)
822        s_sub_u32       s1, s1, s0
823        v_bfe_u32       v1, v0, 0, s1
824        v_cmp_ge_u32    vcc, 25, v1
825        s_and_saveexec_b64 s[2:3], vcc
826        v_lshrrev_b32   v0, s1, v0
827        s_endpgm
828)ffDXD",
829        R"ffDXD(AmdCL2BinDump:
830  devType=Bonaire, aclVersion=, drvVersion=234800, compileOptions=""
831  Kernel: GenerateScramblerKernel
832    Code:
833    100540c07f008cbf01008180010090d20001050099028c7d6a2482be0100002c
834    000081bf
835    HSAConfig:
836      Arg: "_.global_offset_0", "size_t", long, void, none, 0, 0, 0, default, 3
837      Arg: "_.global_offset_1", "size_t", long, void, none, 0, 0, 0, default, 3
838      Arg: "_.global_offset_2", "size_t", long, void, none, 0, 0, 0, default, 3
839      Arg: "_.printf_buffer", "size_t", pointer, void, global, 0, 0, 0, default, 1
840      Arg: "_.vqueue_pointer", "size_t", long, void, none, 0, 0, 0, default, 3
841      Arg: "_.aqlwrap_pointer", "size_t", long, void, none, 0, 0, 0, default, 3
842      Arg: "d_wiring", "Wiring*", pointer, structure, constant, 4, 1024, 0, default, 1
843      Arg: "d_key", "Key*", pointer, structure, constant, 4, 64, 0, default, 1
844      Arg: "thblockShift", "uint", uint, void, none, 0, 0, 0, default, 3
845      Arg: "localShift", "uint", uint, void, none, 0, 0, 0, default, 3
846      Arg: "scramblerDataPitch", "uint", uint, void, none, 0, 0, 0, default, 3
847      Arg: "scramblerData", "int8_t*", pointer, char, global, 0, 0, 0, default, 3
848      amdCodeVersion=1.1
849      amdMachine=1:0:0:0
850      kernelCodeEntryOffset=256
851      kernelCodePrefetchOffset=0
852      kernelCodePrefetchSize=0
853      maxScrachBackingMemorySize=0
854      computePgmRsrc1=0xac0083
855      computePgmRsrc2=0x138c
856      enableSgprRegisterFlags=0x9
857      enableFeatureFlags=0xa
858      workitemPrivateSegmentSize=0
859      workgroupGroupSegmentSize=0
860      gdsSegmentSize=0
861      kernargSegmentSize=96
862      workgroupFbarrierCount=0
863      wavefrontSgprCount=22
864      workitemVgprCount=16
865      reservedVgprFirst=16
866      reservedVgprCount=0
867      reservedSgprFirst=20
868      reservedSgprCount=0
869      debugWavefrontPrivateSegmentOffsetSgpr=0
870      debugPrivateSegmentBufferSgpr=0
871      kernargSegmentAlignment=4
872      groupSegmentAlignment=4
873      privateSegmentAlignment=4
874      wavefrontSize=6
875      callConvention=0x0
876      runtimeLoaderKernelSymbol=0x0
877      ControlDirective:
878      0001000000000000000000000000000000000000000000000000000000000000
879      0000000000000000000000000000000000000000000000000000000000000000
880      0000000000000000000000000000000000000000000000000000000000000000
881      0000000000000000000000000000000000000000000000000000000000000000
882  GlobalData:
883  RwData:
884  nullptr
885  Bss size: 0, bssAlign: 0
886  SamplerInit:
887  nullptr
888)ffDXD", "", true
889    },
890    {
891        R"ffDXD(.amdcl2
892.gpu Bonaire
893.64bit
894.arch_minor 0
895.arch_stepping 0
896.driver_version 234800
897.kernel GenerateScramblerKernel
898    .hsaconfig
899        .dims xyz
900        .dx10clamp
901        .ieeemode
902        .floatmode 0xc0
903        .priority 0
904        .userdatanum 6
905        .codeversion 1, 1
906        .machine 1, 4, 6, 7
907        .kernel_code_entry_offset 0x100
908        .use_private_segment_buffer
909        .use_kernarg_segment_ptr
910        .private_elem_size 4
911        .use_ptr64
912        .call_convention 0x0
913        .workgroup_fbarrier_count 3324
914        .runtime_loader_kernel_symbol 0x4dc98b3a
915        .scratchbuffer 77222
916        .localsize 413
917    .control_directive
918        .byte 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
919    .hsaconfig
920        .arg _.global_offset_0, "size_t", long
921        .arg _.global_offset_1, "size_t", long
922        .arg _.global_offset_2, "size_t", long
923        .arg _.printf_buffer, "size_t", void*, global, , rdonly
924        .arg _.vqueue_pointer, "size_t", long
925        .arg _.aqlwrap_pointer, "size_t", long
926        .arg d_wiring, "Wiring*", structure*, 1024, constant, const, rdonly
927        .arg d_key, "Key*", structure*, 64, constant, const, rdonly
928        .arg thblockShift, "uint", uint
929        .arg localShift, "uint", uint
930        .arg scramblerDataPitch, "uint", uint
931        .arg scramblerData, "int8_t*", char*, global,
932    .control_directive
933        .fill 116, 1, 0x00
934    .text
935        s_mov_b32 s32, s14
936        v_mov_b32 v42, v11
937        s_endpgm
938    .control_directive
939        .int 2132
940)ffDXD",
941        R"ffDXD(AmdCL2BinDump:
942  devType=Bonaire, aclVersion=, drvVersion=234800, compileOptions=""
943  Kernel: GenerateScramblerKernel
944    Code:
945    0e03a0be0b03547e000081bf
946    HSAConfig:
947      Arg: "_.global_offset_0", "size_t", long, void, none, 0, 0, 0, default, 3
948      Arg: "_.global_offset_1", "size_t", long, void, none, 0, 0, 0, default, 3
949      Arg: "_.global_offset_2", "size_t", long, void, none, 0, 0, 0, default, 3
950      Arg: "_.printf_buffer", "size_t", pointer, void, global, 0, 0, 0, default, 1
951      Arg: "_.vqueue_pointer", "size_t", long, void, none, 0, 0, 0, default, 3
952      Arg: "_.aqlwrap_pointer", "size_t", long, void, none, 0, 0, 0, default, 3
953      Arg: "d_wiring", "Wiring*", pointer, structure, constant, 4, 1024, 0, default, 1
954      Arg: "d_key", "Key*", pointer, structure, constant, 4, 64, 0, default, 1
955      Arg: "thblockShift", "uint", uint, void, none, 0, 0, 0, default, 3
956      Arg: "localShift", "uint", uint, void, none, 0, 0, 0, default, 3
957      Arg: "scramblerDataPitch", "uint", uint, void, none, 0, 0, 0, default, 3
958      Arg: "scramblerData", "int8_t*", pointer, char, global, 0, 0, 0, default, 3
959      amdCodeVersion=1.1
960      amdMachine=1:4:6:7
961      kernelCodeEntryOffset=256
962      kernelCodePrefetchOffset=0
963      kernelCodePrefetchSize=0
964      maxScrachBackingMemorySize=0
965      computePgmRsrc1=0xac010a
966      computePgmRsrc2=0x138d
967      enableSgprRegisterFlags=0x9
968      enableFeatureFlags=0xa
969      workitemPrivateSegmentSize=77222
970      workgroupGroupSegmentSize=413
971      gdsSegmentSize=0
972      kernargSegmentSize=96
973      workgroupFbarrierCount=3324
974      wavefrontSgprCount=35
975      workitemVgprCount=43
976      reservedVgprFirst=43
977      reservedVgprCount=0
978      reservedSgprFirst=33
979      reservedSgprCount=0
980      debugWavefrontPrivateSegmentOffsetSgpr=0
981      debugPrivateSegmentBufferSgpr=0
982      kernargSegmentAlignment=4
983      groupSegmentAlignment=4
984      privateSegmentAlignment=4
985      wavefrontSize=6
986      callConvention=0x0
987      runtimeLoaderKernelSymbol=0x4dc98b3a
988      ControlDirective:
989      0001000000000000000000000000000000000000000000000000000000000000
990      0000000000000000000000000000000000000000000000000000000000000000
991      0000000000000000000000000000000000000000000000000000000000000000
992      0000000000000000000000000000000000000000000000000000000054080000
993  GlobalData:
994  RwData:
995  nullptr
996  Bss size: 0, bssAlign: 0
997  SamplerInit:
998  nullptr
999)ffDXD", "", true
1000    },
1001    {   // with vectypehint and work_group_size_hint
1002        R"ffDXD(.amdcl2
1003.64bit
1004.gpu Bonaire
1005.driver_version 191205
1006.kernel aaa1
1007    .config
1008        .dims x
1009        .setupargs
1010        .vectypehint float8
1011        .work_group_size_hint 44,112,5
1012        .arg n,uint
1013        .arg in,uint*,global,const
1014        .arg out,uint*,global
1015        .ieeemode
1016        .floatmode 0xda
1017        .localsize 1000
1018        .useargs
1019    .text
1020        s_and_b32 s9,s5,44
1021        s_and_b32 s10,s5,5
1022)ffDXD",
1023        R"ffDXD(AmdCL2BinDump:
1024  devType=Bonaire, aclVersion=, drvVersion=191205, compileOptions=""
1025  Kernel: aaa1
1026    Code:
1027    05ac098705850a87
1028    Config:
1029      Arg: "_.global_offset_0", "size_t", long, void, none, 0, 0, 0, 0, 0
1030      Arg: "_.global_offset_1", "size_t", long, void, none, 0, 0, 0, 0, 0
1031      Arg: "_.global_offset_2", "size_t", long, void, none, 0, 0, 0, 0, 0
1032      Arg: "_.printf_buffer", "size_t", pointer, void, global, 0, 3, 0, 0, 0
1033      Arg: "_.vqueue_pointer", "size_t", long, void, none, 0, 0, 0, 0, 0
1034      Arg: "_.aqlwrap_pointer", "size_t", long, void, none, 0, 0, 0, 0, 0
1035      Arg: "n", "uint", uint, void, none, 0, 0, 0, default, 3
1036      Arg: "in", "uint*", pointer, uint, global, 4, 0, 0, default, 3
1037      Arg: "out", "uint*", pointer, uint, global, 0, 0, 0, default, 3
1038      dims=1, cws=0 0 0, SGPRS=11, VGPRS=1
1039      pgmRSRC1=0x0, pgmRSRC2=0x0, ieeeMode=0x1, floatMode=0xda
1040      priority=0, exceptions=0, localSize=1000, scratchBuffer=0
1041      useArgs
1042      vectypehint=float8, workGroupSizeHint=44 112 5
1043  GlobalData:
1044  RwData:
1045  nullptr
1046  Bss size: 0, bssAlign: 0
1047  SamplerInit:
1048  nullptr
1049)ffDXD", "", true
1050    },
1051    {   // with vectypehint and work_group_size_hint
1052        // cws and work_group_size_hint defaults
1053        R"ffDXD(.amdcl2
1054.64bit
1055.gpu Bonaire
1056.driver_version 191205
1057.kernel aaa1
1058    .config
1059        .dims x
1060        .setupargs
1061        .vectypehint float8
1062        .cws 144,11
1063        .work_group_size_hint 44
1064        .arg n,uint
1065        .arg in,uint*,global,const
1066        .arg out,uint*,global
1067        .ieeemode
1068        .floatmode 0xda
1069        .localsize 1000
1070        .useargs
1071    .text
1072        s_and_b32 s9,s5,44
1073        s_and_b32 s10,s5,5
1074)ffDXD",
1075        R"ffDXD(AmdCL2BinDump:
1076  devType=Bonaire, aclVersion=, drvVersion=191205, compileOptions=""
1077  Kernel: aaa1
1078    Code:
1079    05ac098705850a87
1080    Config:
1081      Arg: "_.global_offset_0", "size_t", long, void, none, 0, 0, 0, 0, 0
1082      Arg: "_.global_offset_1", "size_t", long, void, none, 0, 0, 0, 0, 0
1083      Arg: "_.global_offset_2", "size_t", long, void, none, 0, 0, 0, 0, 0
1084      Arg: "_.printf_buffer", "size_t", pointer, void, global, 0, 3, 0, 0, 0
1085      Arg: "_.vqueue_pointer", "size_t", long, void, none, 0, 0, 0, 0, 0
1086      Arg: "_.aqlwrap_pointer", "size_t", long, void, none, 0, 0, 0, 0, 0
1087      Arg: "n", "uint", uint, void, none, 0, 0, 0, default, 3
1088      Arg: "in", "uint*", pointer, uint, global, 4, 0, 0, default, 3
1089      Arg: "out", "uint*", pointer, uint, global, 0, 0, 0, default, 3
1090      dims=1, cws=144 11 1, SGPRS=11, VGPRS=1
1091      pgmRSRC1=0x0, pgmRSRC2=0x0, ieeeMode=0x1, floatMode=0xda
1092      priority=0, exceptions=0, localSize=1000, scratchBuffer=0
1093      useArgs
1094      vectypehint=float8, workGroupSizeHint=44 1 1
1095  GlobalData:
1096  RwData:
1097  nullptr
1098  Bss size: 0, bssAlign: 0
1099  SamplerInit:
1100  nullptr
1101)ffDXD", "", true
1102    }
1103};
1104
1105static void testAssembler(cxuint testId, const AsmTestCase& testCase)
1106{
1107    std::istringstream input(testCase.input);
1108    std::ostringstream errorStream;
1109    std::ostringstream printStream;
1110   
1111    // create assembler with testcase's input and with ASM_TESTRUN flag
1112    Assembler assembler("test.s", input, (ASM_ALL|ASM_TESTRUN)&~ASM_ALTMACRO,
1113            BinaryFormat::AMD, GPUDeviceType::CAPE_VERDE, errorStream, printStream);
1114    bool good = assembler.assemble();
1115   
1116    std::ostringstream dumpOss;
1117    if (good && assembler.getFormatHandler()!=nullptr)
1118        // get format handler and their output
1119        printAmdCL2Output(dumpOss, static_cast<const AsmAmdCL2Handler*>(
1120                        assembler.getFormatHandler())->getOutput());
1121    /* compare result dump with expected dump */
1122    char testName[30];
1123    snprintf(testName, 30, "Test #%u", testId);
1124   
1125    assertValue(testName, "good", int(testCase.good), int(good));
1126    assertString(testName, "dump", testCase.dump, dumpOss.str());
1127    assertString(testName, "errorMessages", testCase.errors, errorStream.str());
1128}
1129
1130int main(int argc, const char** argv)
1131{
1132    int retVal = 0;
1133    for (size_t i = 0; i < sizeof(asmTestCases1Tbl)/sizeof(AsmTestCase); i++)
1134        try
1135        { testAssembler(i, asmTestCases1Tbl[i]); }
1136        catch(const std::exception& ex)
1137        {
1138            std::cerr << ex.what() << std::endl;
1139            retVal = 1;
1140        }
1141    return retVal;
1142}
Note: See TracBrowser for help on using the repository browser.