source: CLRX/CLRadeonExtender/trunk/tests/amdasm/AsmRegAlloc2.cpp @ 3999

Last change on this file since 3999 was 3999, checked in by matszpk, 12 months ago

CLRadeonExtender: AsmRegAlloc?: Fixed applySSAReplaces (propagation and minSSAId fill up). Working next more complex testcase.

File size: 23.7 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 <algorithm>
22#include <iostream>
23#include <sstream>
24#include <string>
25#include <vector>
26#include <cstring>
27#include <CLRX/utils/Utilities.h>
28#include <CLRX/amdasm/Assembler.h>
29#include <CLRX/utils/Containers.h>
30#include "../TestUtils.h"
31#include "AsmRegAlloc.h"
32
33using namespace CLRX;
34
35struct AsmApplySSAReplacesCase
36{
37    Array<CCodeBlock2> inCodeBlocks;
38    Array<std::pair<TestSingleVReg2, Array<SSAReplace> > > inSSAReplaces;
39    Array<CCodeBlock2> codeBlocks; // expected code blocks
40};
41
42static const AsmApplySSAReplacesCase ssaApplyReplacesCasesTbl[] =
43{
44    {   // 0 - first testcase
45        // 16 - trick - SSA replaces beyond visited point
46        {
47            // block 0 - start
48            { 0, 8,
49                { },
50                {
51                    { { "", 4 }, SSAInfo(0, 0, 0, 0, 0, true) },
52                    { { "", 5 }, SSAInfo(0, 0, 0, 0, 0, true) },
53                    { { "sa", 2 }, SSAInfo(0, 1, 1, 1, 1, false) },
54                    { { "sa", 3 }, SSAInfo(0, 1, 1, 1, 1, false) }
55                }, false, false, false },
56            // block 1 - loop
57            { 8, 16,
58                { { 2, false }, { 4, false } },
59                {
60                    { { "sa", 2 }, SSAInfo(1, 2, 2, 2, 1, true) },
61                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
62                }, false, false, false },
63            // block 2 - loop part 2
64            { 16, 24,
65                { { 1, false }, { 3, false } },
66                {
67                    { { "sa", 2 }, SSAInfo(2, SIZE_MAX, 3, SIZE_MAX, 0, true) },
68                    { { "sa", 3 }, SSAInfo(1, 2, 2, 2, 1, false) },
69                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
70                }, false, false, false },
71            // block 3 - end 2
72            { 24, 28,
73                { },
74                { }, false, false, true },
75            // block 4 - end
76            { 28, 36,
77                { },
78                {
79                    { { "sa", 3 }, SSAInfo(1, 3, 3, 3, 1, true) },
80                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
81                }, false, false, true }
82        },
83        {
84            { { "sa", 2 }, { { 2, 1 } } },
85            // must be
86            { { "sa", 3 }, { { 2, 1 } } }
87        },
88        // expected code blocks
89        {
90            // block 0 - start
91            { 0, 8,
92                { },
93                {
94                    { { "", 4 }, SSAInfo(0, 0, 0, 0, 0, true) },
95                    { { "", 5 }, SSAInfo(0, 0, 0, 0, 0, true) },
96                    { { "sa", 2 }, SSAInfo(0, 1, 1, 1, 1, false) },
97                    { { "sa", 3 }, SSAInfo(0, 1, 1, 1, 1, false) }
98                }, false, false, false },
99            // block 1 - loop
100            { 8, 16,
101                { { 2, false }, { 4, false } },
102                {
103                    { { "sa", 2 }, SSAInfo(1, 1, 2, 1, 1, true) },
104                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
105                }, false, false, false },
106            // block 2 - loop part 2
107            { 16, 24,
108                { { 1, false }, { 3, false } },
109                {
110                    { { "sa", 2 }, SSAInfo(1, SIZE_MAX, 3, SIZE_MAX, 0, true) },
111                    { { "sa", 3 }, SSAInfo(1, 1, 2, 1, 1, false) },
112                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
113                }, false, false, false },
114            // block 3 - end 2
115            { 24, 28,
116                { },
117                { }, false, false, true },
118            // block 4 - end
119            { 28, 36,
120                { },
121                {
122                    { { "sa", 3 }, SSAInfo(1, 3, 3, 3, 1, true) },
123                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
124                }, false, false, true }
125        }
126    },
127    {   // 1 - second testcase
128        // 13 - yet another branch example
129        {
130            // block 0
131            { 0, 12,
132                { { 1, false }, { 2, false }, { 4, false }, { 6, false } },
133                {
134                    { { "", 0 }, SSAInfo(0, 0, 0, 0, 0, true) },
135                    { { "", 1 }, SSAInfo(0, 0, 0, 0, 0, true) },
136                    { { "", 4 }, SSAInfo(0, 0, 0, 0, 0, true) },
137                    { { "", 5 }, SSAInfo(0, 0, 0, 0, 0, true) },
138                    { { "sa", 2 }, SSAInfo(0, 1, 1, 1, 1, false) },
139                    { { "sa", 3 }, SSAInfo(0, 1, 1, 1, 1, false) }
140                }, false, false, false },
141            // block 1 - b0
142            { 12, 24,
143                { },
144                {
145                    { { "sa", 2 }, SSAInfo(1, 2, 2, 2, 1, true) },
146                    { { "sa", 3 }, SSAInfo(1, 2, 2, 2, 1, true) },
147                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
148                }, false, false, true },
149            // block 2 - b1
150            { 24, 32,
151                { },
152                {
153                    { { "sa", 2 }, SSAInfo(1, 3, 3, 3, 1, true) },
154                    { { "sa", 3 }, SSAInfo(1, 3, 3, 3, 1, true) },
155                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
156                }, false, false, false },
157            // block 3 - b1x
158            { 32, 40,
159                { { 1, false } },
160                {
161                    { { "sa", 2 }, SSAInfo(3, 4, 4, 4, 1, true) },
162                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
163                }, false, false, true },
164            // block 4 - b2
165            { 40, 48,
166                { },
167                {
168                    { { "sa", 2 }, SSAInfo(1, 5, 5, 5, 1, true) },
169                    { { "sa", 3 }, SSAInfo(1, 4, 4, 4, 1, true) },
170                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
171                }, false, false, false },
172            // block 5 - b2x
173            { 48, 56,
174                { { 3, false } },
175                {
176                    { { "sa", 2 }, SSAInfo(5, 6, 6, 6, 1, true) },
177                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
178                }, false, false, true },
179            // block 6 - b3
180            { 56, 68,
181                { { 5, false } },
182                {
183                    { { "sa", 2 }, SSAInfo(1, 7, 7, 7, 1, true) },
184                    { { "sa", 3 }, SSAInfo(1, 5, 5, 5, 1, true) },
185                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
186                }, false, false, true }
187        },
188        {   // SSA replaces
189            { { "sa", 2 }, { { 4, 1 }, { 6, 3 }, { 7, 5 } } },
190            { { "sa", 3 }, { { 3, 1 }, { 4, 1 }, { 5, 1 } } }
191        },
192        // expected blocks
193        {
194            // block 0
195            { 0, 12,
196                { { 1, false }, { 2, false }, { 4, false }, { 6, false } },
197                {
198                    { { "", 0 }, SSAInfo(0, 0, 0, 0, 0, true) },
199                    { { "", 1 }, SSAInfo(0, 0, 0, 0, 0, true) },
200                    { { "", 4 }, SSAInfo(0, 0, 0, 0, 0, true) },
201                    { { "", 5 }, SSAInfo(0, 0, 0, 0, 0, true) },
202                    { { "sa", 2 }, SSAInfo(0, 1, 1, 1, 1, false) },
203                    { { "sa", 3 }, SSAInfo(0, 1, 1, 1, 1, false) }
204                }, false, false, false },
205            // block 1 - b0
206            { 12, 24,
207                { },
208                {
209                    { { "sa", 2 }, SSAInfo(1, 2, 2, 2, 1, true) },
210                    { { "sa", 3 }, SSAInfo(1, 2, 2, 2, 1, true) },
211                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
212                }, false, false, true },
213            // block 2 - b1
214            { 24, 32,
215                { },
216                {
217                    { { "sa", 2 }, SSAInfo(1, 3, 3, 3, 1, true) },
218                    { { "sa", 3 }, SSAInfo(1, 1, 3, 1, 1, true) },
219                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
220                }, false, false, false },
221            // block 3 - b1x
222            { 32, 40,
223                { { 1, false } },
224                {
225                    { { "sa", 2 }, SSAInfo(3, 1, 4, 1, 1, true) },
226                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
227                }, false, false, true },
228            // block 4 - b2
229            { 40, 48,
230                { },
231                {
232                    { { "sa", 2 }, SSAInfo(1, 5, 5, 5, 1, true) },
233                    { { "sa", 3 }, SSAInfo(1, 1, 4, 1, 1, true) },
234                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
235                }, false, false, false },
236            // block 5 - b2x
237            { 48, 56,
238                { { 3, false } },
239                {
240                    { { "sa", 2 }, SSAInfo(5, 3, 6, 3, 1, true) },
241                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
242                }, false, false, true },
243            // block 6 - b3
244            { 56, 68,
245                { { 5, false } },
246                {
247                    { { "sa", 2 }, SSAInfo(1, 5, 7, 5, 1, true) },
248                    { { "sa", 3 }, SSAInfo(1, 1, 5, 1, 1, true) },
249                    { { "sa", 4 }, SSAInfo(0, SIZE_MAX, 1, SIZE_MAX, 0, true) }
250                }, false, false, true }
251        }
252    },
253    {   // 2 - more complex dependencies
254        {
255            { 0, 4,
256                { },
257                {
258                    { { "sa", 2 }, SSAInfo(0, 1, 1, 1, 1, true) },
259                    { { "sa", 3 }, SSAInfo(0, 1, 1, 1, 1, true) }
260                }, false, false, false },
261            { 4, 8,
262                { },
263                {
264                    { { "sa", 2 }, SSAInfo(1, 2, 2, 2, 1, true) },
265                    { { "sa", 3 }, SSAInfo(1, 2, 2, 2, 1, true) }
266                }, false, false, false },
267            { 8, 12,
268                { },
269                {
270                    { { "sa", 2 }, SSAInfo(2, 3, 3, 3, 1, true) },
271                    { { "sa", 3 }, SSAInfo(2, 3, 3, 3, 1, true) }
272                }, false, false, false },
273            { 12, 16,
274                { },
275                {
276                    { { "sa", 2 }, SSAInfo(3, 4, 4, 4, 1, true) },
277                    { { "sa", 3 }, SSAInfo(3, 4, 4, 4, 1, true) }
278                }, false, false, false },
279            { 16, 20,
280                { },
281                {
282                    { { "sa", 2 }, SSAInfo(4, 5, 5, 5, 1, true) },
283                    { { "sa", 3 }, SSAInfo(4, 5, 5, 5, 1, true) }
284                }, false, false, false },
285            { 20, 24,
286                { },
287                {
288                    { { "sa", 2 }, SSAInfo(5, 6, 6, 6, 1, true) },
289                    { { "sa", 3 }, SSAInfo(5, 6, 6, 6, 1, true) }
290                }, false, false, false },
291            { 24, 28,
292                { },
293                {
294                    { { "sa", 2 }, SSAInfo(6, 7, 7, 7, 1, true) },
295                    { { "sa", 3 }, SSAInfo(6, 7, 7, 7, 1, true) }
296                }, false, false, false },
297            { 28, 32,
298                { },
299                {
300                    { { "sa", 2 }, SSAInfo(7, 8, 8, 8, 1, true) },
301                    { { "sa", 3 }, SSAInfo(7, 8, 8, 8, 1, true) }
302                }, false, false, false },
303            { 32, 36,
304                { },
305                {
306                    { { "sa", 2 }, SSAInfo(8, 9, 9, 9, 1, true) },
307                    { { "sa", 3 }, SSAInfo(8, 9, 9, 9, 1, true) }
308                }, false, false, false },
309            { 36, 40,
310                { },
311                {
312                    { { "sa", 2 }, SSAInfo(9, 10, 10, 10, 1, true) },
313                    { { "sa", 3 }, SSAInfo(9, 10, 10, 10, 1, true) }
314                }, false, false, false },
315            { 40, 44,
316                { },
317                {
318                    { { "sa", 2 }, SSAInfo(10, 11, 11, 11, 1, true) },
319                    { { "sa", 3 }, SSAInfo(10, 11, 11, 11, 1, true) }
320                }, false, false, false },
321            { 44, 48,
322                { },
323                {
324                    { { "sa", 2 }, SSAInfo(11, 12, 12, 12, 1, true) },
325                    { { "sa", 3 }, SSAInfo(11, 12, 12, 12, 1, true) }
326                }, false, false, false },
327            { 48, 52,
328                { },
329                {
330                    { { "sa", 2 }, SSAInfo(12, 13, 13, 13, 1, true) },
331                    { { "sa", 3 }, SSAInfo(12, 13, 13, 13, 1, true) }
332                }, false, false, false }
333        },
334        {   // SSA replaces
335            { { "sa", 2 }, { { 4, 1 }, { 4, 3 }, { 3, 2 }, { 7, 5 }, { 7, 6 },
336                        { 11, 7 }, { 12, 7 } } },
337            { { "sa", 3 }, { { 3, 2 }, { 5, 3 }, { 5, 4 }, { 4, 1 },
338                        { 13, 4 }, { 12, 5 }, { 10, 2 } } }
339        },
340        // expected blocks
341        {
342            { 0, 4,
343                { },
344                {
345                    { { "sa", 2 }, SSAInfo(0, 1, 1, 1, 1, true) },
346                    { { "sa", 3 }, SSAInfo(0, 1, 1, 1, 1, true) }
347                }, false, false, false },
348            { 4, 8,
349                { },
350                {
351                    { { "sa", 2 }, SSAInfo(1, 1, 2, 1, 1, true) },
352                    { { "sa", 3 }, SSAInfo(1, 1, 2, 1, 1, true) }
353                }, false, false, false },
354            { 8, 12,
355                { },
356                {
357                    { { "sa", 2 }, SSAInfo(1, 1, 3, 1, 1, true) },
358                    { { "sa", 3 }, SSAInfo(1, 1, 3, 1, 1, true) }
359                }, false, false, false },
360            { 12, 16,
361                { },
362                {
363                    { { "sa", 2 }, SSAInfo(1, 1, 4, 1, 1, true) },
364                    { { "sa", 3 }, SSAInfo(1, 1, 4, 1, 1, true) }
365                }, false, false, false },
366            { 16, 20,
367                { },
368                {
369                    { { "sa", 2 }, SSAInfo(1, 5, 5, 5, 1, true) },
370                    { { "sa", 3 }, SSAInfo(1, 1, 5, 1, 1, true) }
371                }, false, false, false },
372            { 20, 24,
373                { },
374                {
375                    { { "sa", 2 }, SSAInfo(5, 5, 6, 5, 1, true) },
376                    { { "sa", 3 }, SSAInfo(1, 6, 6, 6, 1, true) }
377                }, false, false, false },
378            { 24, 28,
379                { },
380                {
381                    { { "sa", 2 }, SSAInfo(5, 5, 7, 5, 1, true) },
382                    { { "sa", 3 }, SSAInfo(6, 7, 7, 7, 1, true) }
383                }, false, false, false },
384            { 28, 32,
385                { },
386                {
387                    { { "sa", 2 }, SSAInfo(5, 8, 8, 8, 1, true) },
388                    { { "sa", 3 }, SSAInfo(7, 8, 8, 8, 1, true) }
389                }, false, false, false },
390            { 32, 36,
391                { },
392                {
393                    { { "sa", 2 }, SSAInfo(8, 9, 9, 9, 1, true) },
394                    { { "sa", 3 }, SSAInfo(8, 9, 9, 9, 1, true) }
395                }, false, false, false },
396            { 36, 40,
397                { },
398                {
399                    { { "sa", 2 }, SSAInfo(9, 10, 10, 10, 1, true) },
400                    { { "sa", 3 }, SSAInfo(9, 1, 10, 1, 1, true) }
401                }, false, false, false },
402            { 40, 44,
403                { },
404                {
405                    { { "sa", 2 }, SSAInfo(10, 5, 11, 5, 1, true) },
406                    { { "sa", 3 }, SSAInfo(1, 11, 11, 11, 1, true) }
407                }, false, false, false },
408            { 44, 48,
409                { },
410                {
411                    { { "sa", 2 }, SSAInfo(5, 5, 12, 5, 1, true) },
412                    { { "sa", 3 }, SSAInfo(11, 1, 12, 1, 1, true) }
413                }, false, false, false },
414            { 48, 52,
415                { },
416                {
417                    { { "sa", 2 }, SSAInfo(5, 13, 13, 13, 1, true) },
418                    { { "sa", 3 }, SSAInfo(1, 1, 13, 1, 1, true) }
419                }, false, false, false }
420        }
421    }
422};
423
424std::ostream& operator<<(std::ostream& os, const TestSingleVReg& vreg)
425{
426    if (!vreg.name.empty())
427        os << vreg.name << "[" << vreg.index << "]";
428    else
429        os << "@REG[" << vreg.index << "]";
430    return os;
431}
432
433static TestSingleVReg getTestSingleVReg(const AsmSingleVReg& vr,
434        const std::unordered_map<const AsmRegVar*, CString>& rvMap)
435{
436    if (vr.regVar == nullptr)
437        return { "", vr.index };
438   
439    auto it = rvMap.find(vr.regVar);
440    if (it == rvMap.end())
441        throw Exception("getTestSingleVReg: RegVar not found!!");
442    return { it->second, vr.index };
443}
444
445static void testApplySSAReplaces(cxuint i, const AsmApplySSAReplacesCase& testCase)
446{
447    std::istringstream input("");
448    Assembler assembler("test.s", input, ASM_ALL&~ASM_ALTMACRO,
449                    BinaryFormat::RAWCODE, GPUDeviceType::CAPE_VERDE);
450   
451    std::unordered_map<CString, AsmRegVar> regVars;
452    std::vector<CodeBlock> inCodeBlocks;
453    // generate input code blocks
454    for (size_t i = 0; i < testCase.inCodeBlocks.size(); i++)
455    {
456        const CCodeBlock2& cc = testCase.inCodeBlocks[i];
457        CodeBlock inCodeBlock{ cc.start, cc.end,
458            std::vector<AsmRegAllocator::NextBlock>(cc.nexts.begin(), cc.nexts.end()),
459            cc.haveCalls, cc.haveReturn, cc.haveEnd };
460        for (const auto& v: cc.ssaInfos)
461        {
462            AsmSingleVReg vreg{ nullptr, v.first.index };
463            if (v.first.name != nullptr)
464            {
465                auto res = regVars.insert({ v.first.name , AsmRegVar{ 0, 100 } });
466                vreg.regVar = &res.first->second;
467            }
468            inCodeBlock.ssaInfoMap.insert({ vreg, v.second });
469        }
470        inCodeBlocks.push_back(inCodeBlock);
471    }
472    SSAReplacesMap inSSAReplaces;
473    // generate SSA replaces
474    for (const auto& replace: testCase.inSSAReplaces)
475    {
476        AsmSingleVReg vreg{ nullptr, replace.first.index };
477        if (replace.first.name != nullptr)
478        {
479            auto res = regVars.insert({ replace.first.name , AsmRegVar{ 0, 100 } });
480            vreg.regVar = &res.first->second;
481        }
482        inSSAReplaces.insert({ vreg, VectorSet<SSAReplace>(
483                    replace.second.begin(), replace.second.end()) });
484    }
485   
486    AsmRegAllocator regAlloc(assembler, inCodeBlocks, inSSAReplaces);
487    regAlloc.applySSAReplaces();
488   
489    const std::vector<CodeBlock>& resCodeBlocks = regAlloc.getCodeBlocks();
490    std::ostringstream oss;
491    oss << " testAsmSSAReplace case#" << i;
492    const std::string testCaseName = oss.str();
493   
494    assertValue("testAsmSSAReplace", testCaseName+".codeBlocks.size",
495                testCase.codeBlocks.size(), resCodeBlocks.size());
496   
497    std::unordered_map<const AsmRegVar*, CString> regVarNamesMap;
498    for (const auto& rvEntry: regVars)
499        regVarNamesMap.insert(std::make_pair(&rvEntry.second, rvEntry.first));
500   
501    for (size_t j = 0; j < resCodeBlocks.size(); j++)
502    {
503        const CCodeBlock2& expCBlock = testCase.codeBlocks[j];
504        const CodeBlock& resCBlock = resCodeBlocks[j];
505        std::ostringstream codeBlockOss;
506        codeBlockOss << ".codeBlock#" << j << ".";
507        codeBlockOss.flush();
508        std::string cbname(codeBlockOss.str());
509        assertValue("testAsmSSAReplace", testCaseName + cbname + "start",
510                    expCBlock.start, resCBlock.start);
511        assertValue("testAsmSSAReplace", testCaseName + cbname + "end",
512                    expCBlock.end, resCBlock.end);
513        assertValue("testAsmSSAReplace", testCaseName + cbname + "nextsSize",
514                    expCBlock.nexts.size(), resCBlock.nexts.size());
515       
516        for (size_t k = 0; k < expCBlock.nexts.size(); k++)
517        {
518            std::ostringstream nextOss;
519            nextOss << "next#" << k << ".";
520            nextOss.flush();
521            std::string nname(nextOss.str());
522           
523            assertValue("testAsmSSAReplace", testCaseName + cbname + nname + "block",
524                    expCBlock.nexts[k].block, resCBlock.nexts[k].block);
525            assertValue("testAsmSSAReplace", testCaseName + cbname + nname + "isCall",
526                    int(expCBlock.nexts[k].isCall), int(resCBlock.nexts[k].isCall));
527        }
528       
529        assertValue("testAsmSSAReplace", testCaseName + cbname + "ssaInfoSize",
530                    expCBlock.ssaInfos.size(), resCBlock.ssaInfoMap.size());
531       
532        Array<std::pair<TestSingleVReg, SSAInfo> > resSSAInfos(
533                        resCBlock.ssaInfoMap.size());
534        std::transform(resCBlock.ssaInfoMap.begin(), resCBlock.ssaInfoMap.end(),
535            resSSAInfos.begin(),
536            [&regVarNamesMap](const std::pair<AsmSingleVReg, SSAInfo>& a)
537            -> std::pair<TestSingleVReg, SSAInfo>
538            { return { getTestSingleVReg(a.first, regVarNamesMap), a.second }; });
539        mapSort(resSSAInfos.begin(), resSSAInfos.end());
540       
541        for (size_t k = 0; k < expCBlock.ssaInfos.size(); k++)
542        {
543            std::ostringstream ssaOss;
544            ssaOss << "ssaInfo#" << k << ".";
545            ssaOss.flush();
546            std::string ssaName(ssaOss.str());
547           
548            const TestSingleVReg expVReg = { expCBlock.ssaInfos[k].first.name,
549                    expCBlock.ssaInfos[k].first.index };
550           
551            assertValue("testAsmSSAReplace", testCaseName + cbname + ssaName + "svreg",
552                        expVReg, resSSAInfos[k].first);
553            const SSAInfo& expSInfo = expCBlock.ssaInfos[k].second;
554            const SSAInfo& resSInfo = resSSAInfos[k].second;
555            assertValue("testAsmSSAReplace",
556                        testCaseName + cbname + ssaName + "ssaIdBefore",
557                        expSInfo.ssaIdBefore, resSInfo.ssaIdBefore);
558            assertValue("testAsmSSAReplace", testCaseName + cbname + ssaName + "ssaId",
559                        expSInfo.ssaId, resSInfo.ssaId);
560            assertValue("testAsmSSAReplace",
561                        testCaseName + cbname + ssaName + "ssaIdChange",
562                        expSInfo.ssaIdChange, resSInfo.ssaIdChange);
563            assertValue("testAsmSSAReplace",
564                        testCaseName + cbname + ssaName + "ssaIdFirst",
565                        expSInfo.ssaIdFirst, resSInfo.ssaIdFirst);
566            assertValue("testAsmSSAReplace",
567                        testCaseName + cbname + ssaName + "ssaIdLast",
568                        expSInfo.ssaIdLast, resSInfo.ssaIdLast);
569            assertValue("testAsmSSAReplace", testCaseName + cbname + ssaName +
570                        "readBeforeWrite", int(expSInfo.readBeforeWrite),
571                        int(resSInfo.readBeforeWrite));
572        }
573       
574        assertValue("testAsmSSAReplace", testCaseName + cbname + "haveCalls",
575                    int(expCBlock.haveCalls), int(resCBlock.haveCalls));
576        assertValue("testAsmSSAReplace", testCaseName + cbname + "haveReturn",
577                    int(expCBlock.haveReturn), int(resCBlock.haveReturn));
578        assertValue("testAsmSSAReplace", testCaseName + cbname + "haveEnd",
579                    int(expCBlock.haveEnd), int(resCBlock.haveEnd));
580    }
581}
582
583int main(int argc, const char** argv)
584{
585    int retVal = 0;
586    for (size_t i = 0; i < sizeof(ssaApplyReplacesCasesTbl)/
587                        sizeof(AsmApplySSAReplacesCase); i++)
588        try
589        { testApplySSAReplaces(i, ssaApplyReplacesCasesTbl[i]); }
590        catch(const std::exception& ex)
591        {
592            std::cerr << ex.what() << std::endl;
593            retVal = 1;
594        }
595    return retVal;
596}
Note: See TracBrowser for help on using the repository browser.