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

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

CLRadeonExtender: Amd & AmdCL2: Add testcases with default CWS sizes.

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