source/slang/slang-ir-specialize-target-switch.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

#include "slang-ir-specialize-target-switch.h"
#include "slang-ir.h"
#include "slang-ir-insts.h"
#include "slang-compiler.h"
#include "slang-capability.h"
#include "slang-ir-dce.h"

namespace Slang
{
    void specializeTargetSwitch(TargetRequest* target, IRGlobalValueWithCode* code)
    {
        bool changed = false;
        for (auto block : code->getBlocks())
        {
            if (auto targetSwitch = as<IRTargetSwitch>(block->getTerminator()))
            {
                CapabilitySet bestCapSet = CapabilitySet::makeInvalid();
                IRBlock* targetBlock = nullptr;
                for (UInt i = 0; i < targetSwitch->getCaseCount(); i++)
                {
                    auto cap = (CapabilityAtom)getIntVal(targetSwitch->getCaseValue(i));
                    CapabilitySet capSet;
                    if (cap == CapabilityAtom::Invalid)
                        capSet = CapabilitySet::makeEmpty();
                    else
                        capSet = CapabilitySet(cap);
                    if (capSet.isBetterForTarget(bestCapSet, target->getTargetCaps()))
                    {
                        targetBlock = targetSwitch->getCaseBlock(i);
                        bestCapSet = capSet;
                    }
                }
                IRBuilder builder(targetSwitch);
                builder.setInsertBefore(targetSwitch);
                if (targetBlock)
                {
                    builder.emitBranch(targetBlock);
                }
                else
                {
                    builder.emitMissingReturn();
                }
                targetSwitch->removeAndDeallocate();
                changed = true;
            }
        }
        if (changed)
        {
            // Remove unreachable blocks after specialization.
            eliminateDeadCode(code);
        }
    }

    void specializeTargetSwitch(TargetRequest* target, IRModule* module)
    {
        for (auto globalInst : module->getGlobalInsts())
        {
            if (auto code = as<IRGlobalValueWithCode>(globalInst))
            {
                specializeTargetSwitch(target, code);
                if (auto gen = as<IRGeneric>(code))
                {
                    auto retVal = findGenericReturnVal(gen);
                    if (auto innerCode = as<IRGlobalValueWithCode>(retVal))
                    {
                        specializeTargetSwitch(target, innerCode);
                    }
                }
            }
        }
    }

}